pulo 0.1.1 → 0.1.2

data/lib/pulo/quantity/quantity.rb

@@ -0,0 +1,285 @@
+# encoding: utf-8
+
+module Pulo
+#Module instance variables to store global settings
+  class << self
+    attr_accessor :precision
+    attr_accessor :significant_figures
+    attr_accessor :supress_quantity_names
+
+    def quantities; @quantities||={};end #hash with dimension_spec as the key
+
+    def help
+      @quantities.each do |dim|
+
+        dim[1].each do |quan|
+          names=quan.quantity_name
+          if quan.synonyms.length>0
+            names += ', ' + quan.synonyms.join(', ')
+          end
+
+          puts names
+          puts '---------------------------------------------------------------------------------------'
+          puts '[' + dim[0].to_s + ']'
+          puts quan.units_sorted
+          puts ''
+        end
+      end
+    end
+  end
+end
+Pulo.precision = 2
+Pulo.significant_figures = false
+Pulo.supress_quantity_names = false
+
+
+module Pulo
+  class Quantity
+    include Comparable
+    #=====================================
+    #Quantity: Class variables and methods - For child quantity classes
+    #=====================================
+    class << self
+      def units; @units ||={}; end
+      def si_unit_scales; @si_unit_scales ||={};end
+      def synonyms; @synonyms ||=[]; end
+
+      attr_accessor :base_unit
+      attr_accessor :dimensions
+
+      def best_si_unit(scale)
+        @si_unit_scales.min_by do |unit|
+          (scale-unit[0]).abs
+        end[1]
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        puts "#{quantity_name} doesn't have a unit #{method_sym}."
+        puts "Available units are: " + units.map{|unt| unt[1].name }.join(', ')
+      end
+
+      def quantity_name
+        self.name.split('::')[1]
+      end
+
+      def units_sorted
+        self.units.values.sort do |a,b|
+          next -1 if a.is_si? && !b.is_si?
+
+          next 1 if !a.is_si? && b.is_si?
+
+          if a.is_si?
+            next -1 if a.scale<b.scale
+            next 1
+          else
+            if a.si_convert_unit==b.si_convert_unit
+              next a.si_convert_factor<=>b.si_convert_factor
+            else
+              a.si_convert_unit<=>b.si_convert_unit
+            end
+          end
+        end
+      end
+    end
+
+    #=====================================
+    #Instance variables and methods - Child Quantities
+    #=====================================
+    attr_accessor :value, :unit
+
+    def initialize(value=nil, unit=nil)
+      value ||= 1.0
+      if unit
+        if unit.is_a?(Symbol)
+          raise "Unit #{unit.to_s} not defined for #{self.class.quantity_name}." unless self.class.units[unit]
+
+          self.unit=self.class.units[unit]
+        else
+          self.unit=unit
+        end
+      else
+        self.unit=self.class.base_unit
+      end
+      self.value=Float(value) unless self.value.is_a?(Float)
+      self
+    end
+
+    def dimensions
+      self.class.dimensions
+    end
+
+    def to_s(precision=nil, supress_quantity_names=false)
+      "#{self.class.quantity_name + ': ' unless Pulo.supress_quantity_names || supress_quantity_names || self.class==Dimensionless}#{NumberToRoundedConverter.convert(@value,precision)} #{@unit.abbreviation}"
+    end
+
+    def to; self; end
+    def in; self; end
+
+    #Pass unknown methods through to the underlying value (Float) if it responds. eg floor and modulo methods
+    def method_missing(method_sym, *arguments, &block)
+      if self.value.respond_to?(method_sym)
+        self.value.send(method_sym,*arguments,&block)
+      end
+    end
+
+    def inverse
+      Dimensionless.new/self
+    end
+    def -@
+      self.class.new -self.value,self.unit
+    end
+    def +(other)
+      case
+        when other.is_a?(Numeric)
+          self.class.new self.value+other,self.unit
+        when other.class.dimensions==self.class.dimensions
+          if self.unit==other.unit
+            self.class.new self.value+other.value,self.unit
+          else
+            self.class.new self.value+other.send(self.unit.name).value,self.unit
+          end
+        else
+          raise  QuantitiesException.new("Cannot add a #{other.class.name} to a #{self.class.name}")
+      end
+    end
+    def -(other)
+      case
+        when other.is_a?(Numeric)
+          self.class.new self.value-other,self.unit
+        when other.class.dimensions==self.class.dimensions
+          if self.unit==other.unit
+            self.class.new self.value-other.value,self.unit
+          else
+            self.class.new self.value-other.send(self.unit.name).value,self.unit
+          end
+        else
+          raise  QuantitiesException.new("Cannot minus a #{other.class.name} from a #{self.class.name}")
+      end
+    end
+    def *(other)
+      case
+        when other.is_a?(Numeric)
+          self.class.new self.value*other,self.unit
+        when other.is_a?(Quantity)
+          new_dims=self.class.dimensions+other.class.dimensions
+
+          #get both quantities to their equivalent SI if needed
+          q1=self; q1=q1.to_si unless q1.is_si?
+          q2=other; q2=q2.to_si unless q2.is_si?
+
+          target_scale=q1.unit.scale+q2.unit.scale
+          target_value=q1.value*q2.value
+          existing_or_new_quantity new_dims,target_scale,target_value
+        else
+          raise  QuantitiesException.new("Cannot multiply a #{other.class.name} and a #{self.class.name}")
+      end
+    end
+    def /(other)
+      case
+        when other.is_a?(Numeric)
+          self.class.new self.value/other,self.unit
+        when other.is_a?(Quantity)
+          new_dims=self.class.dimensions-other.class.dimensions
+
+          q1=self; q1=q1.to_si unless q1.is_si?
+          q2=other; q2=q2.to_si unless q2.is_si?
+
+          target_scale=q1.unit.scale-q2.unit.scale
+          target_value=q1.value/q2.value
+          existing_or_new_quantity new_dims,target_scale,target_value
+        else
+          raise  QuantitiesException.new("Cannot divide a #{self.class.name} by a #{other.class.name}")
+      end
+    end
+    def **(power)
+      raise  QuantitiesException.new('Can only raise a quantity to an integer power') unless power.is_a?(Integer)
+
+      new_dims=self.class.dimensions*power
+      q1=self; q1=q1.to_si unless q1.is_si?
+
+      target_scale=q1.unit.scale*power
+      target_value=q1.value**power
+
+      existing_or_new_quantity new_dims,target_scale,target_value
+    end
+    def rt(power)
+      raise  QuantitiesException.new('Can only do integer roots') unless power.is_a?(Integer)
+
+      self.class.dimensions.spec.each do |dim|
+        if dim[1]/power.to_f % 1 != 0
+          raise  QuantitiesException.new('Root would lead to non-integer dimensions')
+        end
+      end
+      new_dims=self.class.dimensions/power
+
+      q1=self; q1=q1.to_si unless q1.is_si?
+
+      target_scale=q1.unit.scale/power
+      target_value=q1.value**(1.0/power)
+      existing_or_new_quantity new_dims,target_scale,target_value
+    end
+    def <=>(other)
+      unless (other.is_a?(Quantity) && self.class.dimensions==other.class.dimensions) || (other.is_a?(Numeric) && self.class==Dimensionless)
+        raise  QuantitiesException.new("Can only compare quantities with same dimensions (given: #{self.class} and #{other.class}).")
+      end
+      if other.is_a?(Numeric)
+        other=Dimensionless.n(other)
+      end
+      to_base_unit.value<=>other.to_base_unit.value
+    end
+
+    def existing_or_new_quantity(new_dims, target_scale, target_value)
+      if Pulo.quantities[new_dims]
+        klass=Pulo.quantities[new_dims][0]
+        unit=klass.best_si_unit Math.log10(target_value.abs) + target_scale
+        klass.new(target_value*10**(target_scale-unit.scale), unit)
+      else
+        qname=new_dims.to_s(true).gsub(/-/, '_')
+        QuantityBuilder.build(qname) do
+          # noinspection RubyArgCount
+          dimensions new_dims.spec
+          si_unit '0.0'+qname, '', new_dims.to_s, 1.0
+          unless target_scale==0
+            si_unit target_scale.to_s+qname, '', new_dims.to_s+'*10^'+target_scale.to_s, 1.0*10**target_scale
+          end
+        end.klass.send(target_scale.to_s+qname, target_value)
+      end
+    end
+
+    def to_base_unit
+      self.send(self.class.base_unit.name)
+    end
+
+    def is_si?
+      @unit.is_si?
+    end
+
+    def to_si
+      return self if self.is_si?
+      self.send(self.unit.si_convert_unit)
+    end
+
+    #Converts to SI and most 'natural' scale
+    def rescale
+      unless self.is_si?
+        return self.to_base_unit.rescale
+      end
+      scale=Math.log10(self.value)+self.unit.scale
+
+      unit_scales=self.class.si_unit_scales.sort
+
+      if scale<unit_scales[0][0]
+        return self.send unit_scales[0][1].name
+      end
+      if scale>=unit_scales.last[0]
+        return self.send unit_scales.last[1].name
+      end
+      unit_scales.each_cons(2) do |us|
+        if us[0][0]<=scale && us[1][0]>scale
+          return self.send us[0][1].name
+        end
+      end
+    end
+
+  end
+end

data/lib/pulo/quantity/quantity_builder.rb

@@ -0,0 +1,185 @@
+# encoding: utf-8
+
+module Pulo
+  class QuantityBuilder
+
+    @unit_group_name
+
+    def self.build(name,&block)
+      klass=Class.new(Quantity)
+      Pulo.const_set(name,klass)
+      QuantityBuilder.new(klass,&block)
+    end
+
+    def initialize(klass,&block)
+      @klass=klass
+      instance_eval(&block)
+    end
+
+    def klass
+      @klass
+    end
+
+    private
+
+    def define_method_on_klass(klass,method, &block)
+      klass.send :define_method, method, &block
+    end
+
+    def dimensions(*dims)
+      #Create a dimensions object based on the supplied specification and set it on the new class
+      spec=Dimension.new(dims[0])
+      @klass.dimensions=spec
+
+      if Pulo.quantities[spec]
+        #If a quantity has already been defined with this set of dimensions
+
+        Pulo.quantities[spec].each do |quan_klass|
+          #for each of the other quantities with the same dimensions
+          # define a method on them with the name of this quantity
+          quan_klass.instance_exec(@klass) do |other_klass|
+            define_method other_klass.quantity_name.downcase do
+              other_unit=other_klass.si_unit_scales[self.unit.scale]
+              other_unit=other_klass.best_si_unit(Math.log10(self.value)+self.unit.scale) unless other_unit
+              return other_klass.new(self.value*10**(self.unit.scale-other_unit.scale),other_unit)
+            end
+          end
+
+          #and define a method on us for the reverse
+          define_method_on_klass @klass, quan_klass.quantity_name.downcase do
+            other_unit=quan_klass.si_unit_scales[self.unit.scale]
+            other_unit=quan_klass.best_si_unit(Math.log10(self.value)+self.unit.scale) unless other_unit
+            return quan_klass.new(self.value*10**(self.unit.scale-other_unit.scale),other_unit)
+          end
+        end
+        Pulo.quantities[spec] << @klass
+      else
+        Pulo.quantities.merge!({spec=>[@klass]})
+      end
+    end
+
+    def synonyms(*synonyms)
+      synonyms.each do |synonym|
+        @klass.synonyms << synonym
+        Pulo.const_set(synonym,@klass.clone)
+      end
+    end
+
+    def constant(name,symbol,unit,value)
+      @klass.define_singleton_method(name) do
+        # noinspection RubyArgCount
+        self.new value, self.units[unit]
+      end
+      unless symbol==''
+        @klass.define_singleton_method(symbol) do
+          # noinspection RubyArgCount
+          self.new value, self.units[unit]
+        end
+      end
+    end
+
+    def si_unit(name,plural,abbreviation,scale)
+      scale=Math.log10(scale)
+      unit=SI_Unit.new(name,plural, abbreviation,scale)
+      if scale==0
+        @klass.base_unit=unit
+      end
+      define_unit_methods unit
+      @klass.si_unit_scales.merge!({scale=>unit})
+    end
+
+    def non_si_unit(name,plural,abbreviation,si_convert_unit,si_convert_factor)
+      unit=NonSI_Unit.new(name,plural, abbreviation, si_convert_unit, si_convert_factor)
+      define_unit_methods unit
+    end
+
+    def define_unit_methods(unit)
+      @klass.units.merge!({unit.name=>unit})
+
+      #Class method for creating by unit name
+      @klass.define_singleton_method("#{unit.name}") do |val|
+        # noinspection RubyArgCount
+        self.new val,unit
+      end
+
+      #Class method for creating by unit plural name
+      unless unit.name.to_s==unit.plural
+        @klass.define_singleton_method("#{unit.plural}") do |val|
+          self.send(unit.name,val) #Could also be done as a method alias?
+        end
+      end
+
+      #Class method for creating by unit abbreviated name
+      unless unit.name.to_s==unit.abbreviation || unit.abbreviation==''
+        @klass.define_singleton_method("#{unit.abbreviation}") do |val|
+          self.send(unit.name,val) #Could also be done as a method alias?
+        end
+      end
+
+      #Instance method for conversion to this unit by plural
+      unless unit.name.to_s==unit.plural
+        define_method_on_klass(@klass,"#{unit.plural}") do
+          self.send(unit.name) #Could also be done as a method alias?
+        end
+      end
+
+      #Instance method for conversion to this unit by abbreviation
+      unless unit.name.to_s==unit.abbreviation || unit.abbreviation==''
+        define_method_on_klass(@klass,"#{unit.abbreviation}") do
+          self.send(unit.name) #Could also be done as a method alias?
+        end
+      end
+
+      define_method_on_klass(@klass,"#{unit.name}") do
+        #If its conversion to and from the same unit then just return self
+        if self.unit.name==unit.name  ##TODO: Make == work for units
+          return self
+        end
+
+        #Actual conversions depending on si or non-si from and to units
+        case
+
+          #si to si
+          when self.unit.is_si? && unit.is_si?
+            # noinspection RubyArgCount
+            self.class.new self.value*10**(self.unit.scale-unit.scale),unit
+
+          #si to non-si
+          when self.unit.is_si? && !unit.is_si?
+            to_unit=self.class.units[unit.name]
+            if to_unit.si_convert_unit==self.unit.name
+              intermediate_si=self
+            else
+              intermediate_si=self.send(to_unit.si_convert_unit)
+            end
+            # noinspection RubyArgCount
+            self.class.new intermediate_si.value*to_unit.si_convert_factor,unit
+
+          #non-si to si
+          when !self.unit.is_si? && unit.is_si?
+            # noinspection RubyArgCount
+            intermediate_si=self.class.new self.value/self.unit.si_convert_factor,self.class.units[self.unit.si_convert_unit]
+            if intermediate_si.unit==unit
+              intermediate_si
+            else
+              intermediate_si.send(unit.name)
+            end
+
+          #non-si to non-si
+          else
+            #get the destination non-si unit definition
+            to_unit=self.class.units[unit.name]
+
+            #first convert self to si
+            intermediate_si=self.send(self.unit.si_convert_unit)
+
+            #then convert this si to the si 'partner' of the destination unit
+            intermediate_si2=intermediate_si.send(to_unit.si_convert_unit)
+
+            #lastly convert this to the final required non-si
+            intermediate_si2.send(to_unit.name)
+        end
+      end
+    end
+  end
+end