quantitymanager 0.2.0

data/lib/unitmanager/simple_unit.rb

@@ -0,0 +1,155 @@
+#Extension to standard Array class. 
+#Added functionality to compare array content regardless element order.
+class Array
+    def contains?(other_array)
+      copy = dup
+      other_array.each {|item| 
+        return false unless i = copy.index(item)
+        copy[i] = nil
+      }
+      true
+    end
+    
+    def same?(other_array)
+      length == other_array.length &&
+      contains?(other_array)
+    end
+
+end
+
+module Unit
+  
+  class BaseUnit
+
+    class << self
+
+      def once (*methods) #:nodoc:
+        methods.each {|method| 
+         
+          module_eval <<-"end;"
+            alias_method :__#{method.to_i}__ , :#{method.to_s}
+
+            def #{method.to_s}(*args, &block)
+              if defined? @__#{method.to_i}__ 
+                @__#{method.to_i}__ 
+              else
+                @__#{method.to_i}__ ||= __#{method.to_i}__(*args, &block)
+              end  
+            end
+            private :__#{method.to_i}__
+            
+          end;
+          
+        }
+      end
+      
+      private :once
+    end
+ 
+    # This method allows to retrieve symbolic portions of the unit definition.
+    # Supported values are:
+    # 	:dividends - returns an array of symbols representing dividend part of 
+    #                  unit definition.
+    # 	:divisors - returns an array of symbols representing divisor part of 
+    #                  unit definition.
+    # 	:string - string representation of the unit of measure. 
+    def [] (symbol)
+      unit_sym[symbol]
+    end
+  end
+  
+  # Adds comparing capabilities to  unit implementations
+  module Comparable
+
+     #Two units are compatible if they have same hierarchy base
+     #Example :cm is compatible with :in, since they both based on :mm   
+     def compatible? (other)
+      return false if other == nil
+      return false unless other.respond_to?(:h_base)
+
+      h_base[:dividends].same?(other.h_base[:dividends]) &&
+      h_base[:divisors].same?(other.h_base[:divisors])
+    end
+    
+    def contains? (other)
+      return false if other == nil
+      return false unless other.respond_to?(:h_base)
+
+      h_base[:dividends].contains?(other.h_base[:dividends]) &&
+      h_base[:divisors].contains?(other.h_base[:divisors])
+    end
+  end
+  
+
+  # Implementation of what is called ‘simple unit of measure’. 
+  # This is a linear unit which is optionally based on some other 
+  # simple unit with linear coefficient.
+  # Example:  :cm is based on :mm with coefficient equal 10.
+  # In other words X cm = 10 * Y mm. 
+  class SimpleUnit < BaseUnit
+  
+      include Unit::Comparable
+#      include Unit::Singleton
+  
+      attr_reader :unit, :coefficient, :based_on
+  
+      @@EMPTY_UNIT = SimpleUnit.new()
+ 
+  	  def initialize (args = {})
+        @unit = args[:unit]
+        @based_on = args[:based_on] || nil
+        @coefficient = args[:coefficient] || 1
+      end
+  
+      def to_base(value)
+        value = @based_on.to_base(value) if derived?
+        
+        value *= @coefficient
+      end
+  
+      def from_base(value)
+        value = @based_on.from_base(value) if derived?
+        
+        value /= @coefficient
+      end
+      
+      # Returns unit representing hierarchy base for the given unit.
+      # The Hierarchy is the "based on" chain.
+      def h_base
+        derived? ? @based_on.h_base : self
+      end
+      
+      def dividend
+        @unit
+      end
+      
+      def divisor
+        @@EMPTY_UNIT
+      end
+      
+      # Two Simple units are equal if they have same symbol, 
+      # based on the same unit with the same coefficient
+      def ==(other)
+        return false if other == nil
+        return false unless other.kind_of?(self.class)
+        
+        unit == other.unit && based_on == other.based_on && coefficient == other.coefficient     
+      end
+      
+      def eql?(other)
+        self == other
+      end
+
+  private        
+      def derived?
+        @based_on != nil
+      end
+  
+      def unit_sym
+        {:dividends => [@unit], :divisors => [], :string => @unit.to_s}
+      end
+  
+  once :unit_sym    
+  end
+
+end

data/lib/unitmanager/unit_composition.rb

@@ -0,0 +1,217 @@
+module Unit
+
+  module SymbolConverter
+
+    def convert(symbols)
+      units = []
+      symbols.each {|symbol| 
+        unit = @units[symbol]
+        raise "Invalid Unit Name: #{symbol.to_s}" if unit.nil?
+        units << unit
+      }
+      return units
+    end
+  
+  end
+
+
+  # Implementation of what is called ‘composed unit of measure’. 
+  # This is a result of performing multiplication or division of
+  # quantities with simple units.
+  # Example:  1 lb per in or 70 mi per hour
+  class ComposedUnit < BaseUnit
+  
+    include Unit::Comparable
+  
+    attr_reader :dividends, :divisors, :coefficient
+  
+    def initialize(params)
+      params = Optimizer.process(params)
+    
+      @coefficient = params[:coefficient] || 1
+      @dividends = params[:dividends] || []
+      @divisors = params[:divisors] || [] 
+    end
+    
+    def to_base(value)
+      value * to_base_coef
+    end
+    
+    def from_base(value)
+      value * from_base_coef
+    end
+    
+    # Returns unit representing hierarchy base for the given unit.
+    # The Hierarchy is the "based on" chain.
+    def h_base
+      ComposedUnit.new({ :coefficient => 1.0,
+            :dividends => Optimizer.base(@dividends),
+            :divisors => Optimizer.base(@divisors) })
+    end
+    
+    def dividend
+      ComposedUnit.new({:dividends => @dividends})
+    end
+    
+    def divisor
+      ComposedUnit.new({:divisors => @divisors})
+    end
+    
+    def reverse
+      ComposedUnit.new({
+        :coefficient => 1.0 / coefficient,
+        :dividends => @divisors.collect{|unit| unit },
+        :divisors => @dividends.collect{|unit| unit }
+      })
+    end
+  
+    # Two composed units are equal if their coefficients are the same 
+    # and units contain same set of dividends and divisors.
+    def ==(other)
+      return false if other == nil
+      return false unless other.kind_of?(self.class)
+      
+      result = (coefficient == other.coefficient) &&
+       dividends.same?(other.dividends) &&
+       divisors.same?(other.divisors)
+      
+      return result
+    end
+    
+    def eql?(other)
+      self == other
+    end
+    
+  private    
+    
+    def collect(array)
+      result = []
+      
+      array.each {|item| result += (yield(item) || []) }
+      
+      return result
+    end
+ 
+    def to_base_coef 
+      coef = @coefficient
+      @dividends.each {|unit| coef *= unit.to_base(1.0) }
+      @divisors.each {|unit| coef /= unit.to_base(1.0) }
+      coef
+    end
+ 
+    def from_base_coef
+      coef = @coefficient
+      @dividends.each {|unit| coef *= unit.from_base(1.0) }
+      @divisors.each {|unit| coef /= unit.from_base(1.0) }
+      coef
+    end
+ 
+    def unit_string
+      buffer = {:dividends => [], :divisors => []}
+        
+      @dividends.each{|unit|
+        if unit[:string]
+          strings = unit[:string].split(/\//)
+          buffer[:dividends] << strings[0]
+          buffer[:divisors] << strings[1]
+        end
+      }        
+        
+      @divisors.each{|unit|
+        if unit[:string]
+          strings = unit[:string].split(/\//)
+          buffer[:dividends] << strings[1]
+          buffer[:divisors] << strings[0]
+        end
+      }        
+        
+      unit_string = buffer[:dividends].empty? ? '' : buffer[:dividends].compact.join('*')
+
+      buffer[:divisors].compact!
+      unit_string << "/" << buffer[:divisors].join('*') unless buffer[:divisors].empty?
+      
+      unit_string
+    end
+    
+ 
+    def unit_sym
+      {
+        :dividends => 
+          collect(@dividends){|unit| unit[:dividends]} +
+          collect(@divisors){|unit| unit[:divisors]},
+        :divisors => 
+          collect(@divisors){|unit| unit[:dividends]} +
+          collect(@dividends){|unit| unit[:divisors]},
+        :string => unit_string          
+      }
+    end
+    
+    once :unit_sym, :to_base_coef, :from_base_coef, :h_base, :dividend, :divisor, :reverse, :unit_string
+  end
+
+
+  class Parser 
+    include SymbolConverter
+  
+    def initialize(units)
+      @units = units
+    end
+  
+    def to_units(unit_spec)
+  
+       operands = unit_spec.split(/\//)
+       raise "Invalid Number of Operands in : #{unit_spec}" if operands.size > 2
+       
+       {
+          :dividends => convert(parse_operand_symbols(operands[0])),
+          :divisors => convert(parse_operand_symbols(operands[1]))
+       }   
+    end
+    
+    def parse_operand_symbols(string)
+      operands = string.nil? ? [] : string.split(/\*/)
+      operands.collect{|name| name.to_sym}
+    end
+    
+  end
+
+
+  class Optimizer
+  
+    def Optimizer.process(params)
+      raise "Incoming parameter has to respond to [] method" unless params.respond_to?(:[])
+      
+      #initialize local values
+      coefficient = params[:coefficient] || 1
+      dividends = [] + (params[:dividends] || [])
+      divisors =  [] + (params[:divisors] || [])
+
+      #create arrays of unit hierarchy bases..  
+      base_dividends = base(dividends)
+      base_divisors = base(divisors)
+
+      #try to find matching units and optimize them
+      base_dividends.each_index { | i |
+        if index = base_divisors.index(base_dividends[i])
+          coefficient *= dividends[i].to_base(1.0)
+          coefficient /= divisors[index].to_base(1.0)
+            
+          #set 'used' units to nil, so they won't be used again  
+          dividends[i] = divisors[index] = base_divisors[index] = nil
+        end
+      }          
+         
+      return {
+        :coefficient => coefficient,
+        :dividends => dividends.compact,
+        :divisors => divisors.compact
+      }
+    end
+ 
+    def Optimizer.base(units)
+      units.collect {| item | item.h_base}
+    end
+    
+  end
+  
+end  

data/test/all_tests.rb

@@ -0,0 +1,8 @@
+dir = File.dirname(__FILE__)
+
+require dir + "/test_helper"
+
+unit_tests = Dir[dir + "/../test/*test.rb"]
+unit_tests.each{|test|
+ require test
+}

data/test/calculator_test.rb

@@ -0,0 +1,194 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+include Unit
+include Quantity
+
+class CalculatorTest < Test::Unit::TestCase
+
+  def setup
+
+    @units = {}
+    @units[:mm] = SimpleUnit.new(:unit => :mm)
+    @units[:cm] = SimpleUnit.new(:unit => :cm, :based_on => @units[:mm], :coefficient => 10)  
+    @units[:m] = SimpleUnit.new(:unit => :m, :based_on => @units[:cm], :coefficient => 100)
+
+    @units[:g] = SimpleUnit.new(:unit => :g)
+    @units[:kg] = SimpleUnit.new(:unit => :kg, :based_on => @units[:g], :coefficient => 1000.0)
+    @units[:oz] = SimpleUnit.new(:unit => :oz, :based_on => @units[:g], :coefficient => 28.349523125)
+    @units[:lb] = SimpleUnit.new(:unit => :lb, :based_on => @units[:oz], :coefficient => 16)
+    @units[:mg] = SimpleUnit.new(:unit => :mg, :based_on => @units[:g], :coefficient => 0.001)
+
+    @units[:sec] = SimpleUnit.new(:unit => :sec)
+    
+    @calc = Calculator.new(@units)
+  
+  end
+
+
+  def test_quantity_creation
+    qty = @calc.quantity(45.897, :mm)
+    
+    assert_in_delta(45.897, qty.value, 0.0001)
+    assert_equal([:mm], qty[:dividends])
+    assert_equal([], qty[:divisors])
+    
+    
+    qty = @calc.quantity(57.345, "mm/lb")
+    assert_in_delta(57.345, qty.value, 0.0001)
+    assert_equal([:mm], qty[:dividends])
+    assert_equal([:lb], qty[:divisors])
+  end
+  
+  def test_calculator_expression_method
+    qty = @calc.exp {5.lb}
+    assert(qty.kind_of?(Quantity))
+    
+    qty = @calc.exp {12.mm + 34.7.cm}
+    assert(qty.kind_of?(Quantity))
+    
+    qty = @calc.quantity(45, :cm)
+    assert_equal(qty, @calc.exp(:cm) {qty})
+  end
+ 
+  def test_convert_to
+
+    qty = @calc.quantity(45, :cm)
+ 
+    base = @calc.exp(1.mm) {qty}
+    
+    assert_in_delta(450.0, base.value, 0.0001)
+    assert_equal([:mm], base[:dividends]) 
+    
+    base = @calc.exp(:mm) {qty}
+    
+    assert_in_delta(450.0, base.value, 0.0001)
+    assert_equal([:mm], base[:dividends]) 
+    
+    base = @calc.exp("mm") {qty}
+    
+    assert_in_delta(450.0, base.value, 0.0001)
+    assert_equal([:mm], base[:dividends]) 
+  end
+  
+  def test_complex_conver_to
+    @calc.add_unit :unit => :km, :based_on => :m, :coefficient => 1000
+    @calc.add_unit :unit => :in, :based_on => :cm, :coefficient => 2.54
+    @calc.add_unit :unit => :ft, :based_on => :in, :coefficient => 12
+    @calc.add_unit :unit => :yd, :based_on => :ft, :coefficient => 3
+    @calc.add_unit :unit => :mi, :based_on => :yd, :coefficient => 1760
+    @calc.add_unit :unit => :min, :based_on => :sec, :coefficient => 60
+    @calc.add_unit :unit => :hour, :based_on => :min, :coefficient => 60
+
+    qty = @calc.exp(1.km/1.hour) {70.mi / 1.hour}
+    assert_in_delta(112.654, qty.value, 0.0001)
+  end
+  
+  def test_reverse_unit_conversion
+    @calc.add_unit :unit => :km, :based_on => :m, :coefficient => 1000
+    @calc.add_unit :unit => :L
+    @calc.add_unit :unit => :gal, :based_on => :L, :coefficient => 3.785332
+    @calc.add_unit :unit => :in, :based_on => :cm, :coefficient => 2.54
+    @calc.add_unit :unit => :ft, :based_on => :in, :coefficient => 12
+    @calc.add_unit :unit => :yd, :based_on => :ft, :coefficient => 3
+    @calc.add_unit :unit => :mi, :based_on => :yd, :coefficient => 1760
+
+    qty = @calc.exp(1.mi/1.gal) {5.5.L/100.km}      
+    assert_in_delta(42.765, qty.value, 0.001)
+
+  end
+  
+  def test_simple_same_base_add
+    
+    qty = @calc.exp(:cm){2.m + 17.8.cm}
+
+    assert_in_delta(217.8, qty.value, 0.0001)
+    assert_equal([:cm], qty[:dividends]) 
+
+    assert_raise(RuntimeError) {
+      @calc.exp(:cm){2.m + 17.8}
+    }
+  end
+
+  def test_simple_same_base_subtract
+    qty = @calc.exp(:cm){2.m - 20.cm}
+
+    assert_in_delta(180, qty.value, 0.0001)
+    assert_equal([:cm], qty[:dividends]) 
+
+    assert_raise(RuntimeError) {
+      @calc.exp(:cm){2.m - 5.7}
+    }
+  end
+
+  def test_simple_multiply
+    qty = @calc.exp(1.cm * 1.oz) {10.m * 5.lb}
+    
+    assert_in_delta(80000, qty.value, 0.0001)
+    assert_equal([:cm, :oz], qty[:dividends]) 
+
+    qty = @calc.exp(:m) {10.m * 5}
+    
+    assert_in_delta(50, qty.value, 0.0001)
+    assert_equal([:m], qty[:dividends]) 
+  end
+
+  def test_simple_divide
+    qty = @calc.exp(1.cm / 1.oz) {10.m / 5.lb}
+    
+    assert_in_delta(12.5, qty.value, 0.0001)
+    assert_equal([:cm], qty[:dividends]) 
+    assert_equal([:oz], qty[:divisors]) 
+
+    qty = @calc.exp(:m) {10.m / 5}
+    
+    assert_in_delta(2, qty.value, 0.0001)
+    assert_equal([:m], qty[:dividends]) 
+    
+    qty = @calc.exp {25.6.lb / 0}
+    assert_in_delta(0, qty.value, 0.0001)
+    assert_equal([:g], qty[:dividends]) 
+  end
+  
+  def test_string_unit_spec
+    qty = @calc.exp("cm/oz") {10.m / 5.lb}
+    
+    assert_in_delta(12.5, qty.value, 0.0001)
+    assert_equal([:cm], qty[:dividends]) 
+    assert_equal([:oz], qty[:divisors]) 
+  
+  end
+  
+  def test_different_calculation_approaches
+    qty = @calc.exp(:m) {25.cm + 15.8.mm + 10.m}
+    
+    result = @calc.exp(:m){ 35.cm + qty }
+    assert_in_delta(10.6158, result.value, 0.001)
+    
+    assert_in_delta(1076.58, (15.cm + result)[:value], 0.001)
+  end
+  
+  def test_add_unit
+    assert_nothing_raised(RuntimeError) {
+      @calc.add_unit({:unit=> :V})
+      qty = @calc.quantity(15, :V)
+      assert_equal("V", qty[:string])
+      @calc.add_unit({:unit => :mV, :based_on => :V, :coefficient => 0.001})
+
+      qty = @calc.quantity(15, :mV)
+      assert_equal("mV", qty[:string])
+      assert_equal([:V], qty.unit.h_base[:dividends])
+    }
+    
+    assert_raise(RuntimeError) {
+      @calc.add_unit :unit => :mW, :based_on => :W, :coefficient => 0.001
+    }
+      
+  end
+
+  def test_add_existing_unit
+    assert_raise(RuntimeError) {
+      @calc.add_unit :unit => :cm, :based_on => :mm, :coefficient => 10
+    }  
+  end
+  
+end