quantitymanager 0.2.0

data/test/composed_unit_test.rb

@@ -0,0 +1,169 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+
+class CompasedUnitTest < Test::Unit::TestCase
+  
+  include Unit
+
+  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)
+    @units[:A] = SimpleUnit.new(:unit => :A)
+  
+  end
+  
+  
+  def test_to_base_conversion
+
+    unit = ComposedUnit.new({
+      :dividends => [@units[:oz]]
+    })
+
+    assert_in_delta(2834.9523125, unit.to_base(100), 0.0001)
+
+    unit = ComposedUnit.new({
+      :dividends => [@units[:lb]],
+      :divisors => [@units[:m]]
+    })
+
+    assert_in_delta(45.359237, unit.to_base(100), 0.0001)
+  
+  end
+  
+  def test_from_base_conversion
+    unit = ComposedUnit.new({ :dividends => [@units[:oz]] })
+
+    assert_in_delta(100, unit.from_base(2834.9523125), 0.0001)
+  
+    unit = ComposedUnit.new({
+      :dividends => [@units[:lb]],
+      :divisors => [@units[:m]]
+    })
+
+    assert_in_delta(100, unit.from_base(45.359237), 0.0001)
+
+  end
+  
+  def test_equal_units
+    oz = ComposedUnit.new( { :dividends => [@units[:oz]] } )
+    
+    lb = ComposedUnit.new( { :dividends => [@units[:lb]] })
+  
+    assert_not_equal(oz, lb)
+    
+    ozee = ComposedUnit.new({ :dividends => [@units[:oz], @units[:mm]] })
+    
+    mmee = ComposedUnit.new({ :dividends => [@units[:mm], @units[:oz]] })
+  
+    assert_equal(ozee, mmee)
+  end
+  
+  def test_compatible_units
+    oz = ComposedUnit.new( { :dividends => [@units[:oz]] } )
+    lb = ComposedUnit.new( { :dividends => [@units[:lb]] })
+
+    assert_equal(true, oz.compatible?(lb))
+  
+    ozee = ComposedUnit.new({ :dividends => [@units[:oz], @units[:mm]] })
+    mmee = ComposedUnit.new({ :dividends => [@units[:mm], @units[:oz]] })
+
+    assert_equal(true, ozee.compatible?(mmee))
+    
+    ozee = ComposedUnit.new({ :dividends => [@units[:oz], @units[:sec]] })
+    mmee = ComposedUnit.new({ :dividends => [@units[:mm], @units[:oz]] })
+    
+    assert_equal(false, ozee.compatible?(mmee))
+  end
+  
+  def test_get_unit
+    unit = ComposedUnit.new({ 
+          :dividends => [@units[:oz], @units[:sec]],
+          :divisors => [@units[:mm]]})
+    
+    assert_equal([:oz, :sec], unit[:dividends])    
+    assert_equal([:mm], unit[:divisors])    
+  end
+  
+  def test_get_unit_string
+
+    dividend = ComposedUnit.new({ 
+          :dividends => [@units[:oz]],
+          :divisors => [@units[:mm]]})
+
+    divisor = ComposedUnit.new({ 
+          :dividends => [@units[:sec]],
+          :divisors => [@units[:A]]})
+    
+    sample = ComposedUnit.new({:dividends => [dividend], :divisors => [divisor]})
+  
+    assert_equal("oz*A/mm*sec", sample[:string])
+  
+  end
+  
+  def test_hierarchy_base
+    unit = ComposedUnit.new({ :dividends => [@units[:lb]] })
+    
+    base_unit = unit.h_base
+  
+    assert_equal([@units[:g]], base_unit.dividends)
+    assert_equal([], base_unit.divisors)
+    assert_in_delta(1.0, base_unit.coefficient, 0.0001)
+  end
+
+  def test_reverse_unit
+    unit = ComposedUnit.new({ 
+          :coefficient => 20.0,
+          :dividends => [@units[:oz], @units[:sec]],
+          :divisors => [@units[:mm]]})
+    
+    reversed_unit = unit.reverse
+
+    assert_equal(0.05, reversed_unit.coefficient)
+    assert_equal([@units[:mm]], reversed_unit.dividends)
+    assert_equal([@units[:oz], @units[:sec]], reversed_unit.divisors)  
+  end
+  
+  def test_symbol_array_operations
+    sample = [:mm, :cm, :mm] + [:cm, :lb]
+  
+    assert_equal([:mm, :cm, :mm, :cm, :lb], sample)
+  
+    sample += (nil || [])
+
+    assert_equal([:mm, :cm, :mm, :cm, :lb], sample)
+  end
+  
+  def test_array_contains
+     assert_equal(false, [:mm, :sq_cm].contains?([:mm, :mm]))
+  end
+
+  def test_contains
+    @units[:L] = SimpleUnit.new(:unit => :L)
+    @units[:cu_in] = SimpleUnit.new(:unit => :cu_in, :based_on => @units[:L], :coefficient => 0.016387064)    
+  
+    @units[:sq_mm] = SimpleUnit.new(:unit => :sq_mm)
+    @units[:sq_cm] = SimpleUnit.new(:unit => :sq_cm, :based_on => @units[:sq_mm], :coefficient => 100)
+
+    unit = ComposedUnit.new(
+      :dividends => [@units[:mm], @units[:sq_cm]],
+      :divisors => [@units[:cu_in]]
+    )
+    
+    other = ComposedUnit.new(:dividends => [@units[:mm], @units[:mm]] )
+    
+    assert_equal(false, unit.contains?(other))
+    
+  end
+
+end

data/test/configuration_test.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+include Unit
+include Quantity
+
+class ConfigurationTest < Test::Unit::TestCase
+
+  def setup
+    #Sinse now we can add units tocalculator, lets try it here...
+    @config = Configuration.new
+    
+    @config.unit :unit => :mm 
+    @config.unit :unit => :cm, :based_on => :mm, :coefficient => 10
+    @config.unit :unit => :m, :based_on => :cm, :coefficient => 100
+
+    @config.unit :unit => :g
+    @config.unit :unit => :kg, :based_on => :g, :coefficient => 1000.0
+    @config.unit :unit => :oz, :based_on => :g, :coefficient => 28.349523125
+    @config.unit :unit => :lb, :based_on => :oz, :coefficient => 16
+    @config.unit :unit => :mg, :based_on => :g, :coefficient => 0.001
+
+    @config.unit :unit => :sec
+  end
+
+
+  def test_create_calculator
+    
+    calc = @config.calc
+    
+    assert_not_nil calc
+    assert_nothing_raised(RuntimeError){ calc.add_conversion 1.m => 10.lb }
+    assert_equal(0, @config.calc.conversions.length)    
+    assert_nothing_raised(RuntimeError){@config.conversion 1.m => 5.lb}
+    
+    qty = calc.exp(:lb){1.m}
+    assert_in_delta(10.0, qty.value, 0.0001)
+  end
+  
+  def test_block_initialization
+    
+    config = Configuration.new(){|conf|
+      conf.unit :unit => :mm 
+      conf.unit :unit => :cm, :based_on => :mm, :coefficient => 10
+      conf.unit :unit => :m, :based_on => :cm, :coefficient => 100
+  
+      conf.unit :unit => :g
+      conf.unit :unit => :oz, :based_on => :g, :coefficient => 28.349523125
+      conf.unit :unit => :lb, :based_on => :oz, :coefficient => 16
+    
+      conf.conversion 1.m => 5.lb  
+     
+    }
+  
+    calc = config.calc
+
+    qty = calc.exp(:lb){1.m}
+    assert_in_delta(5.0, qty.value, 0.0001)
+  end
+
+  def test_default_configuration
+    assert_not_nil($configuration)
+    
+    calc = $configuration.calc
+    
+    qty = calc.exp(:m){20.cm + 600.mm}
+    
+    assert_in_delta(0.8, qty.value, 0.0001)
+  end
+
+end

data/test/custom_conversion_test.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+include Unit
+include Quantity
+
+class CustomUnitConversionTest < Test::Unit::TestCase
+
+  def setup
+    #Sinse now we can add units tocalculator, lets try it here...
+    @calc = Calculator.new
+    
+    @calc.add_unit :unit => :mm 
+    @calc.add_unit :unit => :cm, :based_on => :mm, :coefficient => 10
+    @calc.add_unit :unit => :m, :based_on => :cm, :coefficient => 100
+
+    @calc.add_unit :unit => :g
+    @calc.add_unit :unit => :kg, :based_on => :g, :coefficient => 1000.0
+    @calc.add_unit :unit => :oz, :based_on => :g, :coefficient => 28.349523125
+    @calc.add_unit :unit => :lb, :based_on => :oz, :coefficient => 16
+    @calc.add_unit :unit => :mg, :based_on => :g, :coefficient => 0.001
+
+    @calc.add_unit :unit => :sec
+  end
+
+  def test_add_custom_unit_conversion
+    @calc.add_unit :unit => :PA
+    @calc.add_unit :unit => :sq_in
+  
+    @calc.add_conversion 1.PA => 6894.757.lb / 1.sq_in
+    assert_equal(2, @calc.conversions.length)
+
+    @calc.add_conversion 1.m => 10.lb
+    assert_equal(4, @calc.conversions.length)
+  end
+  
+  def test_add_unknown_unit_conversion
+
+    assert_raise(RuntimeError) { @calc.add_conversion 1.PA => 6894.757.lb / 1.sq_in }
+  
+  end
+  
+  def test_conversion_usage
+    @calc.add_conversion 1.m => 10.lb
+
+    qty = @calc.exp(:m) {50.cm + 1.lb}
+    assert_in_delta(0.6, qty.value, 0.0001)
+    assert_equal([:m], qty.unit[:dividends])  
+    
+    qty = @calc.exp(:m){10.lb}
+    assert_in_delta(1, qty.value, 0.0001)
+    assert_equal([:m], qty.unit[:dividends])  
+  end
+  
+  def test_composed_conversion_usage
+  
+    @calc.add_unit :unit =>:t
+    @calc.add_conversion 1.m => 10.lb
+    @calc.add_conversion 1.lb => 10.t
+  
+    qty = @calc.exp(:m) {200.cm + 300.t}
+  
+    assert_in_delta(5, qty.value, 0.0001)
+    assert_equal([:m], qty.unit[:dividends])  
+  end
+  
+  
+  def test_numeric_coerce
+    @calc.add_unit :unit => :Hz
+    @calc.add_conversion 1.Hz => 1.0 / 1.sec
+    
+    qty = @calc.exp(:sec) {60.Hz}
+    
+    assert_in_delta(0.016666667, qty.value, 0.0001)
+    assert_equal([:sec], qty[:dividends])
+  end
+  
+  
+  def test_default_configuration_conversions
+    calc = $configuration.calc
+    
+    assert_nothing_raised(RuntimeError) {
+      qty = calc.exp(:mm) {1.cu_in / 1.sq_cm}
+      
+      assert_in_delta(163.8706, qty.value, 0.0001)
+      assert_equal("mm", qty[:string])
+    }
+  
+    
+  end
+end  

data/test/quantifiable_test.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class QuantifiableTest < Test::Unit::TestCase
+  
+  include Quantity
+
+  def test_quantifiable_validation
+  
+    info = QuantityInfo.new(14, :mm)
+  
+    assert_raise(RuntimeError){ info + "Alex" }
+    
+    assert_nothing_raised(RuntimeError) {info + QuantityInfo.new(10, :mm)}
+  
+  end
+  
+  def test_numeric_mixin
+    info = 12.mm
+    assert(info.kind_of?(QuantityInfo))
+    assert_equal(12, info.value)
+    assert_equal(:mm, info.unit_sym)
+
+    info = 12.566.mm
+    assert(info.kind_of?(QuantityInfo))
+    assert_in_delta(12.566, info.value, 0.0001)
+    assert_equal(:mm, info.unit_sym)
+  end
+
+  def test_operation_mixin
+    
+    operation = 10.mm + 23.cm
+  
+    assert(operation.kind_of?(OperationInfo))
+    assert(operation.first_operand.kind_of?(QuantityInfo))
+    assert(operation.second_operand.kind_of?(QuantityInfo))
+    assert_equal(:+, operation.operation)
+    
+    assert_raise(RuntimeError){ 17.lb + "Alex" }
+    
+    operation = (24.lb + 15.8.kg) / (3.cm - 6.mm)
+
+    assert(operation.kind_of?(OperationInfo))
+    assert(operation.first_operand.kind_of?(OperationInfo))
+    assert(operation.second_operand.kind_of?(OperationInfo))
+    assert_equal(:/, operation.operation)
+    
+    assert(operation.first_operand.first_operand.kind_of?(QuantityInfo))
+    assert(operation.first_operand.second_operand.kind_of?(QuantityInfo))
+    assert_equal(:+, operation.first_operand.operation)
+    
+    assert(operation.second_operand.first_operand.kind_of?(QuantityInfo))
+    assert(operation.second_operand.second_operand.kind_of?(QuantityInfo))
+    assert_equal(:-, operation.second_operand.operation)
+  end
+  
+  def test_mixed_operation
+    
+    assert_nothing_raised(RuntimeError) {
+      
+      info = 10.mm * 10
+      assert(info.kind_of?(OperationInfo))
+      
+      info = 10.mm + 10
+      assert(info.kind_of?(OperationInfo))
+
+      info = 10 + 34.mm
+      assert(info.kind_of?(OperationInfo))
+    
+    }
+
+  end
+
+end

data/test/quantity_test.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class QuantityTest < Test::Unit::TestCase
+
+  include Unit
+  include Quantity
+
+  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_simple_operation
+    q = @calc.quantity(10, :mm)
+
+    assert_nothing_raised(RuntimeError){ q + 10.cm}
+    
+    assert_raise(RuntimeError){ 15.lb - q}
+    
+    assert_raise(RuntimeError) { (14.mm + 34.7.ft) - q}
+
+    qty = (14.mm + 4.9.cm) * q
+    
+    assert_not_nil(qty)
+    assert_in_delta(630, qty.value, 0.001)
+    assert_equal([:mm,:mm], qty[:dividends])
+    
+    qty = 14.m * q
+    assert_not_nil(qty)
+  end
+
+  def test_quantity_info_conversion
+    
+    qty = 14.m.to_quantity(@calc)
+    assert_not_nil(qty)
+    assert_equal(14, qty.value)
+    assert_equal([:m], qty[:dividends])
+    
+    qty = qty * @calc.quantity(5, :lb)
+    assert(qty)
+    assert_equal(14 * 5, qty.value)
+    assert_equal([:m, :lb], qty[:dividends])
+  end
+
+  def test_quantity_value
+    q = @calc.quantity(10, :mm)
+
+    assert_equal(10.0, q.value)    
+  end
+  
+  def test_quantity_unit
+
+    q = @calc.quantity(10, :mm)
+    
+    assert_equal([:mm], q[:dividends])
+    assert_equal([], q[:divisors])  
+  end
+
+  def test_string_unit
+    q = @calc.quantity(10, :mm) * @calc.quantity(5, :lb)
+    
+    assert_equal("mm*lb", q[:string])
+  end
+
+end

data/test/simple_unit_test.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SimpleUnitTest < Test::Unit::TestCase
+
+    include Unit
+
+	def setup
+      @millimeter = SimpleUnit.new(:unit => :mm)
+  	  @centimeter = SimpleUnit.new(:unit => :cm, :based_on => @millimeter, :coefficient => 10)
+  	  @meter = SimpleUnit.new(:unit => :m, :based_on => @centimeter, :coefficient => 100)
+
+      @g = SimpleUnit.new(:unit => :g)
+      @oz = SimpleUnit.new(:unit => :oz, :based_on => @g, :coefficient => 28.349523125)
+      @lb = SimpleUnit.new(:unit => :lb, :based_on => @oz, :coefficient => 16)
+    end
+	
+	def test_to_base_conversion
+
+      assert_equal(@centimeter, @meter.based_on)
+      assert_equal( 10000.0, @meter.to_base(10))
+      assert_equal( 100.0, @centimeter.to_base(10))
+      assert_equal( @meter.to_base(1), @centimeter.to_base(100))
+
+      assert_in_delta(28.349523125 * 16, @lb.to_base(1), 0.0001)
+
+	end
+
+    def test_from_base_conversion
+      
+      assert_equal(10.0, @meter.from_base(10000))
+      assert_equal(10.0, @centimeter.from_base(100))
+        
+    end
+    
+    def test_hierarchy_base
+      
+      assert_equal(@g, @lb.h_base)
+      
+    end
+    
+    def test_compatible_units
+      
+      assert_equal(true, @millimeter.compatible?(@meter))
+      assert_equal(true, @millimeter.compatible?(@centimeter))
+
+      assert_equal(false, @millimeter.compatible?(@g))
+      assert_equal(false, @millimeter.compatible?(@lb))
+
+      assert_equal(true, @lb.compatible?(@oz))
+      assert_equal(true, @oz.compatible?(@g))
+    end
+    
+    def test_string_unit
+      
+      assert_equal("mm", @millimeter[:string])
+      assert_equal("cm", @centimeter[:string])
+      
+    end
+end

data/test/test_helper.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+require 'logger'
+
+require File.dirname(__FILE__) + '/../lib/quantity'
+
+class Test::Unit::TestCase
+  # Add more helper methods to be used by all tests here...
+  
+  def logger
+    unless @log
+      @log = Logger.new(STDOUT)
+      @log.level = Logger::DEBUG
+      @log.datetime_format = '%a %b %d %H:%M:%S %Z %Y'
+    end
+    
+    @log
+  end
+end

data/test/unit_optimizer_test.rb

@@ -0,0 +1,104 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class UnitOptemizerTest < Test::Unit::TestCase
+
+  include Unit
+
+  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)
+ 
+  end
+
+  def test_no_units
+      results = Optimizer.process({
+        :dividends => [], :divisors => []
+      })
+  
+      assert_equal(true, results.kind_of?(Hash))
+      assert_equal(1.0, results[:coefficient])
+      assert_equal([], results[:dividends])
+      assert_equal([], results[:divisors])
+  end
+
+  def test_no_optimization_needed
+
+      results = Optimizer.process({
+        :dividends => [@units[:mm], @units[:sec]], :divisors => [@units[:g]]
+      })
+  
+      assert_equal(true, results.kind_of?(Hash))
+      assert_equal(1.0, results[:coefficient])
+      assert_equal([@units[:mm], @units[:sec]], results[:dividends])
+      assert_equal([@units[:g]], results[:divisors])
+  
+  end
+
+  def test_simple_optimization
+
+      results = Optimizer.process({
+        :dividends => [@units[:mm], @units[:kg]], :divisors => [@units[:g]]
+      })
+  
+      assert_equal(true, results.kind_of?(Hash))
+      assert_equal(1000.0, results[:coefficient])
+      assert_equal([@units[:mm]], results[:dividends])
+      assert_equal([], results[:divisors])
+
+  end
+  
+  def test_existing_coefficient_optimization
+      results = Optimizer.process({
+        :coefficient => 7,
+        :dividends => [@units[:mm], @units[:kg]], 
+        :divisors => [@units[:g]]
+      })
+  
+      assert_equal(true, results.kind_of?(Hash))
+      assert_in_delta(7000.0, results[:coefficient], 0.001)
+      assert_equal([@units[:mm]], results[:dividends])
+      assert_equal([], results[:divisors])
+  end
+  
+  def test_multiple_step_optimization
+
+      results = Optimizer.process({
+        :dividends => [@units[:mm], @units[:kg]], :divisors => [@units[:lb]]
+      })
+  
+      assert_equal(true, results.kind_of?(Hash))
+      assert_in_delta(2.204622622, results[:coefficient], 0.00001)
+      assert_equal([@units[:mm]], results[:dividends])
+      assert_equal([], results[:divisors])
+  end
+  
+  def test_full_unit_optimization
+      results = Optimizer.process({
+        :dividends => [@units[:mm], @units[:kg]], :divisors => [@units[:lb], @units[:cm] ]
+      })
+  
+      assert_equal([], results[:dividends])
+      assert_equal([], results[:divisors])
+  end
+
+  # Just to make sure it is Ok to use.
+  def test_array_intersection
+    intersection = [@units[:g], @units[:mm]] & [@units[:g]]
+    assert_equal([@units[:g]], intersection)
+    
+    intersection = [@units[:g], @units[:g], @units[:mm]] & [@units[:g], @units[:g],]
+    assert_equal([@units[:g]], intersection)
+  end
+  
+end