dimensional 0.0.6 → 0.1.1

data/test/metric_test.rb

@@ -1,6 +1,5 @@
 require 'test/unit'
 require 'dimensional/metric'
-require 'dimensional/unit'
 require 'rational'
 
 class MetricTest < Test::Unit::TestCase
@@ -12,88 +11,261 @@ class MetricTest < Test::Unit::TestCase
     Dimension.register('Force')
     System.register('British Admiralty', 'BA')
     System.register('United States Customary', 'US')
-    cable = Unit.register('cable', System::BA, Dimension::L, {})
-    fathom = Unit.register('fathom', System::BA, Dimension::L, {:reference_unit => cable, :reference_factor => Rational(1,10)})
-    yard = Unit.register('yard', System::BA, Dimension::L, {:reference_unit => fathom, :reference_factor => Rational(1,6)})
-    Unit.register('foot', System::BA, Dimension::L, {:reference_unit => yard, :reference_factor => Rational(1,3)})
-    Unit.register('foot', System::US, Dimension::L, {:reference_unit => yard, :reference_factor => Rational(1,3)})
-    Unit.register('pound', System::US, Dimension::M)
-    Unit.register('pound', System::US, Dimension::F)
+    System.register('International System of Units', 'SI')
+    # Length Units - SI
+    @meter = Unit.register('meter', System::SI, Dimension::L, {:abbreviation => 'm'})
+    @kilometer = Unit.register('kilometer', System::SI, Dimension::L, {:reference_units => {@meter => 1}, :reference_factor => 1000, :abbreviation => 'km'})
+    @centimeter = Unit.register('centimeter', System::SI, Dimension::L, {:reference_units => {@meter => 1}, :reference_factor => Rational(1,100), :abbreviation => 'cm'})
+    # Length Units - US
+    @yard_us = Unit.register('yard', System::US, Dimension::L, {:reference_units => {@meter => 1}, :reference_factor => 0.9144, :abbreviation => 'yd'})
+    @foot_us = Unit.register('foot', System::US, Dimension::L, {:reference_units => {@yard_us => 1}, :reference_factor => Rational(1,3), :abbreviation => 'ft'})
+    @mile_us = Unit.register('mile', System::US, Dimension::L, {:reference_units => {@foot_us => 1}, :reference_factor => 5280, :abbreviation => 'mi'})
+    @inch_us = Unit.register('inch', System::US, Dimension::L, {:reference_units => {@foot_us => 1}, :reference_factor => Rational(1,12), :abbreviation => 'in'})
+    # Length Units - BA
+    @nautical_mile = Unit.register('mile', System::BA, Dimension::L, {:abbreviation => 'nm'})
+    @cable = Unit.register('cable', System::BA, Dimension::L, {:reference_units => {@nautical_mile => 1}, :reference_factor => Rational(1,10)})
+    @fathom = Unit.register('fathom', System::BA, Dimension::L, {:reference_units => {@cable => 1}, :reference_factor => Rational(1,10), :abbreviation => 'fm'})
+    @yard_ba = Unit.register('yard', System::BA, Dimension::L, {:reference_units => {@fathom => 1}, :reference_factor => Rational(1,6), :abbreviation => 'yd'})
+    @foot_ba = Unit.register('foot', System::BA, Dimension::L, {:reference_units => {@yard_ba => 1}, :reference_factor => Rational(1,3), :abbreviation => 'ft'})
+    @inch_ba = Unit.register('inch', System::BA, Dimension::L, {:reference_units => {@foot_ba => 1}, :reference_factor => Rational(1,12), :abbreviation => 'in'})
+    # Mass Units
+    @pound_mass = Unit.register('pound', System::US, Dimension::M, {:abbreviation => 'lb'})
+    # Force Units
+    @pound_force = Unit.register('pound', System::US, Dimension::F, {:abbreviation => 'ft'})
+    # Dimensionless Units
+    @each = Unit.register('each', System::US, nil, {:abbreviation => 'ea'})
+    @dozen = Unit.register('dozen', System::US, nil, {:reference_units => {@each => 0}, :reference_factor => 12, :abbreviation => 'dz'})
   end
 
   def teardown
     Dimension.reset!
     System.reset!
     Unit.reset!
-    Metric.reset!
-  end
-
-  def test_create
-    assert_instance_of Metric, m = Metric.new('draft', Dimension::L)
-    assert_same Dimension::L, m.dimension
-    assert_equal 'draft', m.name
-  end
-  
-  def test_register
-    assert_instance_of Metric, m = Metric.register('draft', Dimension::L)
-    assert_same m, Metric[:draft]
-  end
-  
-  def test_register_metric_with_parent
-    parent = Metric.register('L', Dimension::L)
-    child = Metric.register('depth', nil, parent)
-    assert_same parent, child.parent
-  end
-  
-  def test_register_dimensionless_metric
-    assert_instance_of Metric, m = Metric.register('population', nil)
-    assert_same m, Metric[:population]
-  end
-  
-  def test_register_default_dimensionless_metric
-    assert_instance_of Metric, m = Metric.register(nil, nil)
-    assert_same m, Metric[nil]
-  end
-  
-  def test_unit_preferences
-    length = Metric.register('L', Dimension::L)
-    draft = Metric.register('draft', Dimension::L, length)
-    foot = Unit[Dimension::L, System::BA, 'foot']
-    length.prefer(foot, {:detector => /(foot|ft)?s/})
-    draft.prefer(foot, {:precision => Rational(1, 12)})
-    assert_instance_of Hash, draft.preferences(foot)
-    assert_equal Rational(1,12), draft.preferences(foot)[:precision]
-    assert_equal /(foot|ft)?s/, draft.preferences(foot)[:detector]
-  end
-  
-  def test_unit_membership
-    length = Metric.register('L', Dimension::L)
-    mass = Metric.register('M', Dimension::M)
-    depth = Metric.register('depth', Dimension::L, length)
-    foot = Unit[:L, :BA, 'foot']
-    fathom = Unit[:L, :BA, 'fathom']
-    pound = Unit[:M, :US, 'pound']
-    length.prefer(foot)
-    length.prefer(fathom)
-    depth.prefer(fathom)
-    mass.prefer(pound)
-    assert_same fathom, depth.units.first # Units should be ordered with preferred units first...
-    assert_same foot, depth.units.last  # ...followed by remaining units from parent.
-    assert_equal 2, depth.units.size # Units should be de-duped with parent
-  end
-
-  def test_enumerate
-    length = Metric.register('L', Dimension::L)
-    assert length.to_enum.kind_of?(Enumerable::Enumerator)
-    assert_respond_to length, :map
-  end
-  
-  def test_preferences_query_does_not_modify_preferences
-    draft = Metric.register('draft', Dimension::L)
-    foot = Unit[:L, :BA, 'foot']
-    p0 = draft.preference(foot)
-    draft.preferences(foot)
-    p1 = draft.preference(foot)
-    assert_equal p0, p1
+  end
+
+  def test_associated_units
+    beam = Class.new(Metric)
+    beam.dimension = Dimension::L
+    assert beam.units.include?(@cable)
+    assert !beam.units.include?(@pound_force)
+  end
+
+  def test_register_conflicting_unit
+    displacement = Class.new(Metric)
+    displacement.dimension = Dimension::M
+    assert_raises RuntimeError do
+      displacement.configure(@pound_force)
+    end
+  end
+
+  def test_create_new_measure
+    depth = Class.new(Metric)
+    depth.dimension = Dimension::L
+    assert m = depth.new(20, @fathom)
+    assert_equal 20, m
+    assert_equal @fathom, m.unit
+  end
+
+  def test_create_new_metric_with_default_unit
+    frontage = Class.new(Metric)
+    frontage.dimension = Dimension::L
+    frontage.default = Unit[:L, :US, :yard]
+    assert m = frontage.new(200)
+    assert_equal 200, m
+    assert_equal @yard_us, m.unit
+  end
+
+  def test_find_unit
+    depth = Class.new(Metric)
+    depth.dimension = Dimension::L
+    assert_same @foot_ba, depth.find_unit('foot', :BA)
+    assert_same @foot_us, depth.find_unit('foot', :US)
+  end
+
+  def test_parse
+    depth = Class.new(Metric)
+    depth.dimension = Dimension::L
+    assert m = depth.parse("15ft", :BA)
+    assert_same @foot_ba, m.unit
+    assert_equal 15, m
+  end
+
+  def test_parse_with_whitespace
+    depth = Class.new(Metric)
+    depth.dimension = Dimension::L
+    m = depth.parse("15 ft", :BA)
+    assert_same @foot_ba, m.unit
+    assert_equal 15, m
+  end
+
+  def test_parse_compound
+    depth = Class.new(Metric)
+    depth.dimension = Dimension::L
+    d = depth.parse("15ft11in", :US)
+    assert_in_delta(15 + Rational(11, 12), d, 0.000001)
+    assert_same @foot_us, d.unit
+  end
+
+  def test_parse_compound_with_whitespace
+    depth = Class.new(Metric)
+    depth.dimension = Dimension::L
+    d = depth.parse("1 ft 11 in", :US)
+    assert_same d.unit, @foot_us
+    assert_in_delta(1 + Rational(11, 12).to_f, d, 0.000001)
+    assert_same @foot_us, d.unit
+  end
+
+  def test_raise_on_parse_of_mixed_compound
+    depth = Class.new(Metric)
+    depth.dimension = Dimension::L
+    assert_raises ArgumentError do
+      depth.parse("1 foot 11cm", :L)
+    end
+  end
+
+  def test_parse_with_default_unit
+    depth = Class.new(Metric)
+    depth.dimension = Dimension::L
+    depth.default = @meter
+    assert_instance_of depth, m = depth.parse("10", :US)
+    assert_equal @meter, m.unit
+  end
+
+  def test_parse_dimensionless_units
+    count = Class.new(Metric)
+    assert m = count.parse('2 dozen')
+    assert_instance_of count, m
+    assert_equal 2, m
+    assert_equal @dozen, m.unit
+    assert_equal 12, m.unit.factor
+    assert_nil m.unit.dimension
+  end
+
+  def test_to_f
+    depth = Class.new(Metric)
+    depth.dimension = Dimension::L
+    d = depth.parse("1.85m", :SI)
+    assert_instance_of Float, d.to_f
+  end
+
+  def test_to_i
+    count = Class.new(Metric)
+    d = count.parse("1 each")
+    assert_instance_of Fixnum, d.to_i
+  end
+
+  def test_convert
+    depth = Class.new(Metric)
+    depth.dimension = Dimension::L
+    new = depth.new(1, @cable).convert(@fathom)
+    assert_in_delta(10, new, 0.000001)
+    assert_same @fathom, new.unit
+  end
+
+  def test_identity_conversion
+    depth = Class.new(Metric)
+    depth.dimension = Dimension::L
+    old_value = depth.new(12, @cable)
+    new_value = old_value.convert(@cable)
+    assert_equal old_value, new_value
+  end
+
+  # These system-conversion tests rely on very specific constants in the heuristics of #change_system
+  def test_change_system_yd
+    range = Class.new(Metric)
+    range.dimension = Dimension::L
+    m0 = range.new(1, @yard_us)
+    assert m1 = m0.change_system(:SI)
+    assert_same @meter, m1.unit
+  end
+
+  def test_change_system_with_oom_dominance
+    width = Class.new(Metric)
+    width.dimension = Dimension::L
+    m0 = width.new(1, @inch_us)
+    assert m1 = m0.change_system(:SI)
+    assert_same @centimeter, m1.unit
+  end
+
+  def test_change_system_ft
+    range = Class.new(Metric)
+    range.dimension = Dimension::L
+    m0 = range.new(1, @foot_us)
+    assert m1 = m0.change_system(:SI)
+    assert_same @meter, m1.unit
+  end
+
+  def test_change_system_mile
+    range = Class.new(Metric)
+    range.dimension = Dimension::L
+    m0 = range.new(1, @mile_us)
+    assert m1 = m0.change_system(:SI)
+    assert_same @kilometer, m1.unit
+  end
+
+  # These preferred tests rely on very specific constants in the heuristics of #prefer
+  def test_preferred_unit_with_only_oom
+    range = Class.new(Metric)
+    range.instance_eval do
+      self.dimension = Dimension::L
+    end
+    m0 = range.new(100000, @meter)
+    assert m1 = m0.preferred
+    assert_same @kilometer, m1.unit
+  end
+
+  # These preferred tests rely on very specific constants in the heuristics of #prefer
+  def test_preferred_unit_with_oom_and_preference
+    range = Class.new(Metric)
+    range.instance_eval do
+      self.dimension = Dimension::L
+      configure Unit[:L, :SI, :meter], {:preference => 3.01}
+    end
+    m0 = range.new(100000, Unit[:L, :SI, :meter])
+    assert m1 = m0.preferred
+    assert_same @meter, m1.unit
+  end
+
+  def test_convert_to_base
+    range = Class.new(Metric)
+    range.dimension = Dimension::L
+    range.base = @nautical_mile
+    b = range.new(1, @fathom).base
+    assert_in_delta(1e-2, b, 0.000001)
+    assert_same @nautical_mile, b.unit
+  end
+
+  def test_stringify_with_abbreviation
+    range = Class.new(Metric)
+    range.dimension = Dimension::L
+    assert_equal "1.85nm", range.parse('1.85 miles', :BA).to_s
+  end
+
+  def test_parse_gibberish_as_nil
+    beam = Class.new(Metric)
+    beam.dimension = Dimension::L
+    assert_nil beam.parse("gibberish", :L)
+  end
+
+  def test_format_output
+    depth = Class.new(Metric)
+    depth.dimension = Dimension::L
+    m = depth.parse("15ft3in", :BA)
+    assert_equal "15.25 (ft)", m.strfmeasure("%4.2f (%U)")
+  end
+
+  def test_format_output_with_multiple_substitutions
+    depth = Class.new(Metric)
+    depth.dimension = Dimension::L
+    m = depth.parse("15ft4in", :BA)
+    assert_equal "15.33 (ft)\t%\t<15.3333333ft>", m.strfmeasure("%4.2f (%U)\t%%\t<%10.7f%U>")
+  end
+
+  def test_precision_recognition
+    distance = Class.new(Metric)
+    distance.dimension = Dimension::L
+    distance.configure(@nautical_mile, :precision => -2)
+    assert_equal "1.8600nm", distance.parse('1.8565454 nm', :BA).strfmeasure("%.4f%U")
+    assert_equal "1.86", distance.parse('1.8565454 nm', :BA).strfmeasure("%s")
   end
 end

data/test/unit_test.rb

@@ -11,6 +11,7 @@ class UnitTest < Test::Unit::TestCase
     Dimension.register('Length')
     Dimension.register('Mass')
     Dimension.register('Force')
+    Dimension.register('Area', 'A', {Dimension::L => 4})
   end
 
   def teardown
@@ -24,72 +25,135 @@ class UnitTest < Test::Unit::TestCase
     assert_same System::BA, u.system
     assert_same Dimension::L, u.dimension
     assert u.base?
-    assert_same u, u.base
+    assert_equal({u => 1}, u.base)
     assert_same 1, u.factor
   end
-  
+
+  def test_enumerability
+    u = Unit.register('each', System::BA, nil, {})
+    assert Unit.to_a.include?(u)
+  end
+
   def test_create_new_dimensionless_unit
     assert_instance_of Unit, u = Unit.new('each', System::BA, nil, {})
     assert_nil u.dimension
   end
-  
+
   def test_create_new_derived_unit
     cable = Unit.new('cable', System::BA, Dimension::L, {})
-    assert_instance_of Unit, u = Unit.new('fathom', System['BA'], Dimension['L'], :reference_factor => 1E-1, :reference_unit => cable) 
+    assert_instance_of Unit, u = Unit.new('fathom', System['BA'], Dimension['L'], :reference_factor => 1E-1, :reference_units => {cable => 1})
     assert !u.base?
-    assert_same cable, u.base
+    t = u.base
+    assert_equal({cable => 1}, t)
     assert_equal 1E-1, u.factor
   end
 
   def test_create_new_combined_unit
     meter = Unit.new('meter', System::SI, Dimension::L, {})
-    assert_instance_of Unit, u = Unit.new('square meter', System::SI, Dimension::L, :reference_factor => 1, :reference_unit => [meter, meter]) 
+    assert_instance_of Unit, u = Unit.new('square meter', System::SI, Dimension::L, :reference_factor => 1, :reference_units => {meter => 2})
     assert !u.base?
-    assert_equal [meter, meter], u.base
+    assert_equal({meter => 2}, u.base)
     assert_equal 1, u.factor
   end
 
+  def test_create_new_combined_with_derived_unit_and_big_exponents
+    meter = Unit.new('meter', System::SI, Dimension::L, {})
+    assert_instance_of Unit, yard = Unit.new('yard', System::US, Dimension::L, :reference_factor => 0.9144, :reference_units => {meter => 1})
+    assert_instance_of Unit, yard2 = Unit.new('square yard', System::SI, Dimension::A, :reference_factor => 1, :reference_units => {yard => 2})
+    assert !yard2.base?
+    assert_equal({meter => 2}, yard2.base)
+    assert_equal 0.83612736, yard2.factor
+  end
+
   def test_regsiter_new_unit
     assert_instance_of Unit, u = Unit.register('fathom', System::BA, Dimension::L, {:abbreviation => 'fm'})
     assert_same u, Unit[Dimension::L, System::BA, 'fathom']
     assert_same u, Unit[Dimension::L, System::BA, 'fm']
   end
-  
+
   def test_regsiter_new_dimensionless_unit
     assert_instance_of Unit, u = Unit.register('each', System::BA, nil, {:abbreviation => 'ea'})
     assert_same u, Unit[nil, System::BA, 'each']
     assert_same u, Unit[nil, System::BA, 'ea']
   end
-  
+
   def test_lookup_unit_with_symbols
     u = Unit.register('fathom', System::BA, Dimension::L, {:abbreviation => 'fm'})
-    assert_nil Unit[:L, :SI, 'fathom']
-    assert_nil Unit[:M, :BA, 'fathom']
-    assert_nil Unit[:L, :BA, 'somethingelse']
     assert_same u, Unit[:L, :BA, 'fathom']
   end
-  
+
+  def test_lookup_failure
+    assert_raises ArgumentError do
+      Unit[:L, :SI, 'fathom']
+    end
+    assert_raises ArgumentError do
+      Unit[:M, :BA, 'fathom']
+    end
+    assert_raises ArgumentError do
+      Unit[:L, :BA, 'somethingelse']
+    end
+  end
+
   def test_convert
     cable = Unit.new('cable', System::BA, Dimension::L, {})
-    fathom = Unit.new('fathom', System::BA, Dimension::L, :reference_factor => 1E-1, :reference_unit => cable) 
+    fathom = Unit.new('fathom', System::BA, Dimension::L, :reference_factor => 1E-1, :reference_unit => cable)
     assert_equal 10, cable.convert(fathom)
     assert_equal 1E-1, fathom.convert(cable)
     assert_equal 1, fathom.convert(fathom)
   end
-  
+
   def test_identify_commensurable_units
-    u0 = Unit.new('mile', System::BA, Dimension::L, :detector => /\A(nm|nmi)\Z/, :abbreviation => 'nm') 
-    u1 = Unit.new('cable', System::BA, Dimension::L, :detector => /\A(cables?|cbls?)\Z/, :reference_factor => 1E-1, :reference_unit => u0) 
+    u0 = Unit.new('mile', System::BA, Dimension::L, :abbreviation => 'nm')
+    u1 = Unit.new('cable', System::BA, Dimension::L, :reference_factor => 1E-1, :reference_unit => u0)
     u2 = Unit.new('ton', System::BA, Dimension::M, :abbreviation => 't')
     assert u0.commensurable?(u1)
     assert !u0.commensurable?(u2)
   end
 
   def test_identify_commensurable_composed_units
-    u0 = Unit.new('mile', System::BA, Dimension::L, :detector => /\A(nm|nmi)\Z/, :abbreviation => 'nm') 
-    u1 = Unit.new('cable', System::BA, Dimension::L, :detector => /\A(cables?|cbls?)\Z/, :reference_factor => 1E-1, :reference_unit => u0) 
+    u0 = Unit.new('mile', System::BA, Dimension::L, :abbreviation => 'nm')
+    u1 = Unit.new('cable', System::BA, Dimension::L, :reference_factor => 1E-1, :reference_unit => u0)
     u2 = Unit.new('ton', System::BA, Dimension::M, :abbreviation => 't')
     assert u0.commensurable?(u1)
     assert !u0.commensurable?(u2)
   end
+
+  def test_identity
+    u0 = Unit.new('mile', System::BA, Dimension::L)
+    u1 = Unit.new('mile', System::BA, Dimension::L)
+    u2 = Unit.new('statute mile', System::BA, Dimension::L)
+    # u0 and u1 are effectively identical and should collide in hashes
+    assert_same u0.hash, u1.hash
+    assert u0.eql?(u1)
+    # u0 and u2 are distinct and should not collide in hashes
+    assert_not_same u0.hash, u2.hash
+    assert !u0.eql?(u2)
+  end
+
+  def test_equality
+    u0 = Unit.new('mile', System::BA, Dimension::L)
+    u1 = Unit.new('sea mile', System::BA, Dimension::L, :reference_factor => 1, :reference_units => {u0 => 1})
+    u2 = Unit.new('mile', System::BA, Dimension::L, :reference_factor => 0.93, :reference_units => {u0 => 1}) # modern approximation
+    # u0 and u1 have the same value but different identities
+    assert_equal u0, u1
+    # u0 and u2 have the same identity but different values
+    assert_not_equal u0, u2
+  end
+
+  def test_default_detector
+    u0 = Unit.new('mile', System::BA, Dimension::L, :abbreviation => 'nm')
+    assert_match u0.detector, 'mile'
+    assert_match u0.detector, 'nm'
+  end
+
+  def test_default_format
+    u0 = Unit.new('mile', System::BA, Dimension::L, :abbreviation => 'nm')
+    assert_match /%.*s/, u0.format
+    assert_match /%.*U/i, u0.format
+  end
+
+  def test_default_preference
+    u0 = Unit.new('mile', System::BA, Dimension::L, :abbreviation => 'nm')
+    assert_equal 0, u0.preference
+  end
 end