ruby_pager 0.1.1

data/lib/ruby_pager/application_logger.rb

@@ -0,0 +1,15 @@
+require 'logger'
+require 'singleton'
+
+module Utils
+  class ApplicationLogger < Logger
+    include Singleton
+    
+    def initialize
+      
+      super(STDOUT)
+      
+    end
+    
+  end
+end

data/lib/ruby_pager/coord.rb

@@ -0,0 +1,50 @@
+
+module RubyPager
+  class Coord
+
+    attr_reader :id, :x , :y
+    def initialize(ex_index,ex_data)
+      @data = ex_data
+      @id = ex_index
+      load_coords()
+    end
+    def id=(ex_id)
+      raise(StandardError, "Got passed a negative value to update the x coord") if ex_id.to_i < 0
+      @id=ex_id.to_i
+    end
+
+    def x=(x_coord)
+      raise(StandardError, "Got passed a negative value to update the x coord") if x_coord.to_i < 0
+      @x=x_coord.to_i
+    end
+
+    def y=(y_coord)
+      raise(StandardError, "Got passed a negative value to update the y coord") if y_coord.to_i < 0
+      @y=y_coord.to_i
+    end
+
+    def get_consolidated_data
+      consolidate_data()
+      return @data
+    end
+
+    def vertical_noise(ex_std_dev)
+      noise_generator=GaussianNoise.new(@y,ex_std_dev)
+      @y=noise_generator.rand.to_i
+    end
+
+    private
+
+    def load_coords()
+      separate = @data.split(",")
+      raise(StandardError,"Got passed coord data that doesn't have exactly two dimensions")if separate.size !=2
+      @x = separate[0].to_i
+      @y = separate[1].to_i
+    end
+
+    def consolidate_data
+      @data="#{@x},#{@y}"
+    end
+
+  end
+end

data/lib/ruby_pager/coords.rb

@@ -0,0 +1,81 @@
+
+module RubyPager
+
+  class Coords
+    def initialize(ex_coords_string)
+      @data = ex_coords_string
+      @points=Array.new
+      load_points()
+    end
+
+    def self.blank
+      return Coords.new(Coords.blank_data)
+    end
+
+    def size
+      return @points.size
+    end
+
+    def [](ex_index)
+      raise(RangeError, "Index #{ex_index} is out of range") unless ex_index.between?(0,@points.size-1)
+      return @points[ex_index]
+    end
+
+    def get_consolidated_data
+      consolidate_data()
+      return @data
+    end
+
+    def push(ex_coord)
+      raise(ArgumentError, "Got passed a non coord object") if ex_coord.class != RubyPager::Coord
+      ex_coord.id=@points.size
+      @points.push(ex_coord)
+    end
+
+    def clear
+      @points.clear
+    end
+
+    def reload(ex_coord_string)
+      clear
+      @data=ex_coord_string
+      load_points
+    end
+
+    def delete(ex_delete_index)
+      @points.delete_at(ex_delete_index)
+      review_points_index()
+    end
+
+    def vertical_noise(ex_std_dev)
+      @points.each {|point| point.vertical_noise(ex_std_dev)}
+    end
+
+    def self.blank_data
+      res = ""
+      return res
+    end
+    private
+
+    def load_points()
+      coord_string_array= @data.split
+      coord_string_array.each_with_index {|string_coord,index|
+        @points.push(Coord.new(index,string_coord))
+      }
+    end
+
+    def consolidate_data
+      @data=""
+      @points.each {|point|
+        @data+=" " if @data.size() > 0
+        @data+= point.get_consolidated_data}
+    end
+
+    def review_points_index
+      @points.each_with_index {|point,index |
+        point.id=index}
+    end
+
+  end
+
+end

data/lib/ruby_pager/extendmatrix2.rb

@@ -0,0 +1,138 @@
+require 'extendmatrix'
+
+class Matrix
+
+  def normalize!(avg)   
+     square=0.0
+#     require 'ruby-debug'; debugger
+     @rows.each do |row|
+           row.each {|val| square+=(val-avg)**2}
+      end
+     deviation = Math.sqrt(square/(@rows.size*column_size).to_f)
+     deviation = 1.0 if deviation == 0.0
+     @rows.each_with_index do |row, row_index|
+           row.each_with_index do |e, col_index|
+             @rows[row_index][col_index] = (e - avg) / deviation
+           end
+     end
+     return self
+  end
+  
+  def to_histogram
+    histogram = Hash.new
+    histogram.default = 0
+    @rows.each_with_index do |row, row_index|
+      row.each_with_index do |e, col_index|
+        histogram[e]+=1
+      end
+    end
+    return histogram
+  end
+  
+  def to_normalized_histogram
+    histogram = Hash.new
+    histogram.default = 0.0
+    @rows.each_with_index do |row, row_index|
+      row.each_with_index do |e, col_index|
+        histogram[e]+=1.0
+      end
+    end
+    num_elements = (row_size * column_size).to_f
+    histogram.each do |index,value|
+      histogram[index]/=num_elements
+    end
+    
+    return histogram
+  end
+  
+  def row_vector_accumulation!(row_index,v)
+    @rows[row_index].size.times{|i| @rows[row_index][i] += v[i] }
+    return self
+  end
+  
+  def row_vector_decrement!(row_index,v)
+    @rows[row_index].size.times{|i| @rows[row_index][i] -= v[i] }
+    return self
+  end
+  def row_vector_scalar_division!(row_index,val)
+    @rows[row_index].size.times{|i| @rows[row_index][i] /= val }
+    return self
+  end
+  
+  def row_vector_distance(row_index,v2)
+    dist = 0.0
+    @rows[row_index].size.times{|i|dist += (@rows[row_index][i]-v2[i])**2}
+    return Math.sqrt(dist)
+  end
+  
+  def to_elements
+    elements = Array.new
+    
+    @rows.each_with_index do |row, row_index|
+             elements.concat(@rows[row_index])
+    end  
+    return elements
+  end
+  
+  
+  def minor_to_elements(*param)
+    case param.size
+    when 2
+      row_range, col_range = param
+      from_row = row_range.first
+      from_row += row_size if from_row < 0
+      to_row = row_range.end
+      to_row += row_size if to_row < 0
+      to_row += 1 unless row_range.exclude_end?
+      size_row = to_row - from_row
+
+      from_col = col_range.first
+      from_col += column_size if from_col < 0
+      to_col = col_range.end
+      to_col += column_size if to_col < 0
+      to_col += 1 unless col_range.exclude_end?
+      size_col = to_col - from_col
+    when 4
+      from_row, size_row, from_col, size_col = param
+      return nil if size_row < 0 || size_col < 0
+      from_row += row_size if from_row < 0
+      from_col += column_size if from_col < 0
+    else
+      Matrix.Raise ArgumentError, param.inspect
+    end
+
+    return nil if from_row > row_size || from_col > column_size || from_row < 0 || from_col < 0
+    
+    elements = Array.new
+    
+    rows = @rows[from_row, size_row].each{|row|
+      elements.concat(row[from_col, size_col])
+    }
+    return elements
+  end
+  
+end
+
+class Vector
+      def calculate_distance(v2)
+        dist = 0.0
+        @elements.size.times{|i|dist += (@elements[i]-v2[i])**2}
+        return Math.sqrt(dist)
+      end
+      
+      def scalar_division!(val)
+        (0...size).each{|i| @elements[i]/=val}
+        return self
+      end
+      
+      def minus_vector!(v)
+        Vector.Raise ErrDimensionMismatch if size != v.size
+        (0...size).each{|i| @elements[i]-=v[i]}
+        return self
+      end
+      
+      def minus_scalar!(val)
+        (0...size).each{|i| @elements[i]-=val}
+        return self
+      end
+end

data/lib/ruby_pager/gaussian_noise.rb

@@ -0,0 +1,36 @@
+
+module RubyPager
+
+  class GaussianNoise
+    def initialize(ex_mean, ex_stddev, ex_rand_helper = lambda { Kernel.rand })
+      @rand_helper = ex_rand_helper
+      @mean = ex_mean
+      @stddev = ex_stddev
+      @valid = false
+      @next = 0
+    end
+
+    def rand
+      if @valid then
+        @valid = false
+        return @next
+      else
+        @valid = true
+        x, y = self.class.gaussian(@mean, @stddev, @rand_helper)
+        @next = y
+        return x
+      end
+    end
+
+    private
+    def self.gaussian(mean, stddev, rand)
+      theta = 2 * Math::PI * rand.call
+      rho = Math.sqrt(-2 * Math.log(1 - rand.call))
+      scale = stddev * rho
+      x = mean + scale * Math.cos(theta)
+      y = mean + scale * Math.sin(theta)
+      return x, y
+    end
+  end
+
+end

data/lib/ruby_pager/histogram.rb

@@ -0,0 +1,102 @@
+require 'ap'
+#require 'ruby-debug'
+
+
+module Utils
+  class Histogram
+	def initialize(file_path,ex_type)
+      @logger = Utils::ApplicationLogger.instance
+      @logger.level = Logger::INFO
+	  @limits= []
+	  @type = ex_type.to_sym
+	  @histogram= Hash.new{|h,key|h[key]=Array.new}
+	  @derivate= Hash.new{|h,key|h[key]=Array.new}
+      @logger.info("Loading histogram")
+	  load_file(file_path)
+	end
+
+	def load_file(file_path)
+		
+		File.open(file_path, "r") do |file|
+			while (line = file.gets)
+				process_line(line)	
+			end
+		end
+		puts "BUCKETS ARE  #{@buckets}"
+		puts "HISTOGRAMS ARE #{@histogram.size}"
+		puts "HISTOGRAMS ARE #{@histogram[0].size}"
+	end
+
+	def process_line(line)
+		
+		values = line.split
+		@buckets = values[1].to_i if values[0] == "NumVect"
+		
+		if values[0]== "NumParam"
+			@num_histograms = values[1].to_i
+			@num_histograms/=2 if @type == :derivate
+		end
+		
+		process_limit(values[1..2].map{|val| val.to_i}) if values[0] == "Limit"
+      	@logger.info("Processing data") if values[0] == "Data"
+
+		process_data_line(values.map{|val| val.to_f})if values[0] =~ /\d/  
+		
+	end
+
+	def process_limit(values)
+	
+		@limits.push({:start => values[0],:end => values[1]})	
+	end
+	
+	def process_data_line(values)
+		if @type == :basic
+			values.each_index{|i| @histogram[i].push(values[i])}
+		else
+			values.each_index do |i|
+				if i.even?
+					@histogram[i/2].push(values[i])
+				else
+					@derivate[(i-1)/2].push(values[i])	
+				end
+			end
+
+		end
+	end
+
+	def to_line(hist_index,row_index)
+#return [@limits[hist_index][:start],((@limits[hist_index][:end] - @limits[hist_index][:start])*@histogram[hist_index][row_index]*100).to_i+ @limits[hist_index][:start]]
+	    
+		return [@limits[hist_index][:start],((@limits[hist_index][:end] - @limits[hist_index][:start])*(@histogram[hist_index][row_index])/100).to_i+ @limits[hist_index][:start]] if hist_index < 3
+	   return [@limits[hist_index][:start],((@limits[hist_index][:end] - @limits[hist_index][:start])*@histogram[hist_index][row_index]*200).to_i+ @limits[hist_index][:start]] if hist_index == 3
+	   return [@limits[hist_index][:start],((@limits[hist_index][:end] - @limits[hist_index][:start])*@histogram[hist_index][row_index]*2000).to_i+ @limits[hist_index][:start]] if hist_index > 3
+
+	end
+
+
+	def derivate_to_line(hist_index,row_index)
+		return [@limits[hist_index][:start],((@limits[hist_index][:end] - @limits[hist_index][:start])*@derivate[hist_index][row_index]*2000).to_i+ @limits[hist_index][:start]]
+	end
+
+	def each_line
+		@buckets.times do |r|
+			temp = []
+			@num_histograms.times do |h|
+				temp.push(to_line(h,r))
+			end
+			yield r,temp
+		end
+	end
+
+	def each_derivate
+		@buckets.times do |r|
+			temp = []
+			@num_histograms.times do |h|
+				temp.push(derivate_to_line(h,r))
+			end
+			yield r,temp
+		end
+	end
+  end
+end
+