pulo 0.1.1 → 0.1.2

data/lib/pulo/formatting.rb

@@ -0,0 +1,140 @@
+# encoding: utf-8
+
+module Pulo
+  class << self
+
+    def stats_format stats
+      ret=''
+      stats.each do |stat|
+        if stat[0]==:number
+          ret+='Count: ' + stat[1].to_s + "\n"
+        else
+          ret+=stat[0].to_s.capitalize + ': ' + stat[1].to_s + "\n"
+        end
+      end
+      ret
+    end
+
+    def super_digit(val)
+      val.to_s.chars.inject('') do |res, chr|
+        res+= case chr
+                when '.'
+                  "\u207B".encode('utf-8')
+                when '-'
+                  "\u207B".encode('utf-8')
+                when '1'
+                  "\u00B9".encode('utf-8')
+                when '2'
+                  "\u00B2".encode('utf-8')
+                when '3'
+                  "\u00B3".encode('utf-8')
+                when '0'
+                  "\u2070".encode('utf-8')
+                when '4'
+                  "\u2074".encode('utf-8')
+                when '5'
+                  "\u2075".encode('utf-8')
+                when '6'
+                  "\u2076".encode('utf-8')
+                when '7'
+                  "\u2077".encode('utf-8')
+                when '8'
+                  "\u2078".encode('utf-8')
+                when '9'
+                  "\u2079".encode('utf-8')
+                else
+                  ''
+              end
+      end
+    end
+  end
+
+  class NumberToRoundedConverter
+    def self.convert(number, precision)
+
+      precision ||= Pulo.precision
+
+      if Pulo.significant_figures && precision > 0
+        digits, rounded_number = digits_and_rounded_number(number, precision)
+        precision -= digits
+        precision = 0 if precision < 0 # don't let it be negative
+      else
+        rounded_number = number.round(precision)
+        rounded_number = rounded_number.to_i if precision == 0
+        rounded_number = rounded_number.abs if rounded_number.zero? # prevent showing negative zeros
+      end
+      formatted_string = "%00.#{precision}f" % rounded_number
+
+      delimited_number = NumberToDelimitedConverter.convert(formatted_string)
+      format_number(delimited_number)
+    end
+
+    private
+
+    def self.digits_and_rounded_number(number,precision)
+      if zero?(number)
+        [1, 0]
+      else
+        digits = digit_count(number)
+        multiplier = 10 ** (digits - precision)
+        rounded_number = calculate_rounded_number(number,multiplier)
+        digits = digit_count(rounded_number) # After rounding, the number of digits may have changed
+        [digits, rounded_number]
+      end
+    end
+
+    def self.calculate_rounded_number(number,multiplier)
+      (number / BigDecimal.new(multiplier.to_f.to_s)).round * multiplier
+    end
+
+    def self.digit_count(number)
+      number.zero? ? 1 : (Math.log10(absolute_number(number)) + 1).floor
+    end
+
+    def self.format_number(number)
+      escaped_separator = Regexp.escape('.')
+      number.sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
+    end
+
+    def self.absolute_number(number)
+      number.respond_to?(:abs) ? number.abs : number.to_d.abs
+    end
+
+    def self.zero?(number)
+      number.respond_to?(:zero?) ? number.zero? : number.to_d.zero?
+    end
+  end
+
+  class NumberToDelimitedConverter
+    DELIMITED_REGEX = /(\d)(?=(\d\d\d)+(?!\d))/
+
+    def self.convert(number)
+      parts(number).join('.')
+    end
+
+    private
+
+    def self.parts(number)
+      left, right = number.to_s.split('.')
+      left.gsub!(DELIMITED_REGEX) do |digit_to_delimit|
+        "#{digit_to_delimit},"
+      end
+      [left, right].compact
+    end
+  end
+
+end
+
+#class BigDecimal
+#  DEFAULT_STRING_FORMAT = 'F'
+#  def to_formatted_s(*args)
+#    if args[0].is_a?(Symbol)
+#      super
+#    else
+#      format = args[0] || DEFAULT_STRING_FORMAT
+#      _original_to_s(format)
+#    end
+#  end
+#  alias_method :_original_to_s, :to_s
+#  alias_method :to_s, :to_formatted_s
+#end

data/lib/pulo/frames/frame.rb

@@ -0,0 +1,289 @@
+require 'csv'
+require 'descriptive_statistics'
+require_relative 'frame_cell'
+require_relative 'frame_row'
+require_relative 'frame_column'
+
+module Pulo
+
+  class Frame
+
+    attr_reader :column_count,:row_count,:rows, :columns, :column_names
+
+    def initialize
+      @rows=[]
+      @columns=[]
+      @column_names={}
+      @column_count=0
+      @row_count=0
+    end
+
+    def export_csv(path)
+
+      CSV.open(path, 'wb') do |csv|
+        csv << @columns.map {|col| col.name}
+        csv << @columns.map {|col|
+          if col.column_class.respond_to?(:quantity_name)
+            col.column_class.quantity_name
+          else
+            col.column_class.name
+          end
+        }
+        csv << @columns.map {|col|
+          if col.column_class.respond_to?(:quantity_name)
+            col.column_unit.abbreviation
+          else
+            ''
+          end
+        }
+        @rows.each do |row|
+          csv<<row.to_a.map{|cell|
+            if cell.class.respond_to?(:quantity_name)
+              cell.value
+            else
+              cell
+            end
+          }
+        end
+      end
+    end
+
+    #applies the given function to each row
+    #returns a hash where each element (keyed by the group) is a frame containing the group
+    def group(group_function)
+      #t=Time.now
+      groups={}
+      @rows.each do |row|
+        res=group_function.call(row)
+        if groups[res]
+          groups[res].append_row(row.to_a)
+        else
+          frm=self.copy_definition
+          frm.append_row(row.to_a)
+          groups.merge!({res=>frm})
+        end
+      end
+      #puts "Groups in #{((Time.now-t)*1000).to_i} ms."
+      groups
+    end
+
+    def group_reduce(group_function,column_defns)
+      #get groups
+      groups=group(group_function)
+
+      #t=Time.now
+      output=Frame.new
+      output.append_column 'Group'
+
+      #setup the columns
+      column_defns.keys.each do |col|
+        output.append_column(col)
+      end
+
+      #add a row to the output for each group produced in the earlier stage
+      groups.each do |group|
+        row=column_defns.map do |defn|
+          if defn[1].class==Proc
+            defn[1].call group[1]
+          else
+            #assume an array with method for descriptive statistics and a column name
+            c=group[1][defn[1][1]]
+            v=case defn[1][0]
+                when :min
+                  c.to_a.min
+                when :max
+                  c.to_a.max
+                else
+                  DescriptiveStatistics.send(defn[1][0],c.to_a)
+              end
+            if c.column_class.respond_to?(:quantity_name) && defn[1][0]!=:number
+              c.column_class.send(c.column_unit.name,v)
+            else
+              v
+            end
+          end
+        end
+        row.insert 0,group[0]
+        output.append_row row
+      end
+      #puts "Reduce in #{((Time.now-t)*1000).to_i} ms."
+      output
+
+    end
+
+    def sort(&sort_function)
+      int=@rows.map do |row|
+        [row.row_number,sort_function.call(row)]
+      end.sort_by {|elm| elm[1]}.map{|elm| elm[0]}
+      frm=self.copy_definition
+      int.each do |row_no|
+        frm.append_row self.rows[row_no].to_a_values
+      end
+      frm
+    end
+
+    def clone
+      frame=copy_definition
+      @rows.each do |row|
+          frame.append_row row.to_a
+      end
+      frame
+    end
+
+    def copy_definition
+      frame=Frame.new
+      @columns.each do |col|
+        frame.append_column(col.name,col.hidden?,&col.formula)
+      end
+      frame
+    end
+
+    def delete_column(name_or_index)
+      if name_or_index.is_a?(Integer)
+        raise IndexError,"No column number #{name_or_index} defined." unless @columns[name_or_index]
+        index=name_or_index
+        name=@columns[index].name
+      else
+        index=@column_names[name_or_index]
+        raise IndexError,"Column with name '#{name_or_index}' not found." unless index
+        name=name_or_index
+      end
+      @rows.each {|row| row.delete_column(index)}
+      @column_names.delete(name)
+      @column_names.each do |item|
+        @column_names[item[0]]-=1 if @column_names[item[0]]>=index
+      end
+      @columns.delete_at(index)
+      @column_count-=1
+    end
+
+    def rename_column(old_name,new_name)
+      col=self[old_name]
+      col_no=@column_names[old_name]
+      @column_names.delete(old_name)
+      @column_names.merge!({new_name=>col_no})
+      col.name=new_name
+    end
+
+    def append_column(name,hidden=false,&formula)
+      col=FrameColumn.new(name,self, hidden, &formula)
+
+      @columns << col
+      @column_names.merge!({name=>@column_count})
+
+      @rows.each do |rw|
+        cell=FrameCell.new(col,rw)
+        col.append_row(cell)
+        rw.append_column(cell)
+      end
+      @column_count+=1
+      col
+    end
+
+    def append_row(values)
+      if values.is_a?(Array)
+        vals=values.each
+        row=FrameRow.new(self,@row_count)
+        @columns.each do |col|
+          if values.length==column_count
+            v = vals.next
+          else
+            v = col.value_column? ? vals.next : nil
+          end
+          cell=FrameCell.new(col,row,v)
+          col.append_row(cell)
+          row.append_column(cell)
+        end
+        @rows<<row
+        @row_count+=1
+        row
+      else
+        raise 'Expecting an array of values as the append row.'
+      end
+    end
+    def insert_row(previous_row,values)
+      if values.is_a?(Array)
+        row_no=previous_row.row_number+1
+        vals=values.each
+        row=FrameRow.new(self,row_no)
+        @columns.each do |col|
+          if values.length==column_count
+            v = vals.next
+          else
+            v = col.value_column? ? vals.next : nil
+          end
+          cell=FrameCell.new(col,row,v)
+          col.insert_row(row_no,cell)
+          row.append_column(cell)
+        end
+        @rows.insert(row_no,row)
+        @row_count+=1
+        @rows.drop(row_no+1).each {|r| r.row_number+=1}
+      else
+        raise 'Expecting an array of values as the append row.'
+      end
+    end
+
+    def recalc_all(with_timing=false)
+      formula_columns.each { |col| col.recalc with_timing }
+    end
+
+    def [](column)
+      if column.is_a?(Integer)
+        raise IndexError,"No column number #{column} defined." unless @columns[column]
+        @columns[column]
+      else
+        column_no=@column_names[column]
+        raise IndexError,"Column with name '#{column}' not found." unless column_no
+        @columns[column_no]
+      end
+    end
+
+    def first_row
+      @rows.first
+    end
+    def last_row
+      @rows.last
+    end
+
+    def lookup(value,column)
+      self[column].lookup(value)
+    end
+
+    def to_s(&filter)
+      @columns.each {|c| c.recalc_width}
+      ret="\n          "
+      ret+=@columns.select {|c| !c.hidden?}.map{|s| s.name.ljust(s.width,' ')}.join('  ') + "\n"
+      ret+='========= '
+      ret+=@columns.select {|c| !c.hidden?}.map{|s| ''.ljust(s.width,'=')}.join('= ') + "\n"
+      ret+='          '
+      ret+=@columns.select {|c| !c.hidden?}.map{|s|
+        if s.column_class.respond_to?(:quantity_name)
+          (s.column_class.quantity_name + (s.value_column? ? '' : '*')).ljust(s.width,' ')
+        else
+          (s.column_class.to_s + (s.value_column? ? '' : '*')).ljust(s.width,' ')
+        end
+      }.join('  ') + "\n"
+      ret+='--------- '
+      ret+=@columns.select {|c| !c.hidden?}.map{|s| ''.ljust(s.width,'-')}.join('- ') + "\n"
+
+      ret+=(@rows.select{|row| !block_given? || filter.call(row)}.map { |row| row.to_s}).join("\n")
+
+      ret+="\n" + @rows.length.to_s + " rows\n"
+      ret
+    end
+
+    def inspect
+      "Frame Object"
+    end
+
+    def value_columns
+      @columns.find_all { |col| col.value_column?}
+    end
+
+    def formula_columns
+      @columns.find_all { |col| !col.value_column?}
+    end
+
+  end
+end

data/lib/pulo/frames/frame_cell.rb

@@ -0,0 +1,83 @@
+module Pulo
+  class FrameCell
+
+    def initialize(parent_column,parent_row,value=nil)
+      @parent_column=parent_column
+      @parent_row=parent_row
+      @error=false
+      self.value=value
+    end
+
+    def column
+      @parent_column
+    end
+
+    def row
+      @parent_row
+    end
+
+    def empty?
+      @value.nil?
+    end
+
+    def value_column?
+      @parent_column.value_column?
+    end
+
+    def set_error
+      @error=true
+    end
+    def unset_error
+      @error=false
+    end
+    def error?
+      @error
+    end
+
+    def value
+      #raise "Column (#{@parent_column.name}) requires re-calc, value not available." if @parent_column.recalc_required
+      return "ERR" if error?
+      #return "UNK" if @parent_column.recalc_required
+      #return "NIL" if empty?
+      @value
+    end
+
+    def value=(val)
+
+      if @parent_column.column_class==NilClass
+        @parent_column.column_class=val.class
+        if val.class.respond_to?(:quantity_name)
+          @parent_column.column_unit=val.unit
+        end
+      end
+
+      if val.class.respond_to?(:quantity_name)
+        if val.unit.name!=@parent_column.column_unit.name
+          val=val.send(@parent_column.column_unit.name)
+        end
+      end
+
+      if @parent_column.column_class!=NilClass && val.class!=NilClass
+        if val.class.respond_to?(:quantity_name)
+          unless val.class.dimensions==@parent_column.column_class.dimensions
+            raise "Tried to set a value (#{val.to_s}) of class #{val.class} with dimensions #{val.class.dimensions} on column #{@parent_column.name} which already has a defined class of #{@parent_column.column_class}."
+          end
+        else
+          unless val.class==@parent_column.column_class
+            raise "Tried to set a value (#{val.to_s}) of class #{val.class} on column #{@parent_column.name} which already has a defined class of #{@parent_column.column_class}."
+          end
+        end
+      end
+      @value=val
+    end
+
+    def to_s
+      begin
+        @parent_column.formatter.call(value).ljust(@parent_column.width,' ')
+      rescue Exception => e
+        value.to_s
+      end
+    end
+
+  end
+end