dimensional 0.0.6 → 0.1.1

data/lib/dimensional/system.rb

@@ -29,10 +29,11 @@ module Dimensional
       @abbreviation_registry.clear
     end
 
-    attr_reader :name, :abbreviation
+    attr_reader :abbreviation, :description
 
-    def initialize(name, abbreviation = nil)
+    def initialize(name, abbreviation = nil, description = nil)
       @abbreviation = abbreviation && abbreviation.to_s
+      @description = description || name
       super(name)
     end
   end

data/lib/dimensional/unit.rb

@@ -1,20 +1,26 @@
 require 'dimensional/dimension'
 require 'dimensional/system'
 require 'set'
+require 'rational'
 
 module Dimensional
   # A standard scale unit for measuring physical quantities.  In addition to the Dimension and System attribute
   # that are well-defined by classes above, the user-defined metric attribute is available to identify units as
   # belonging to an arbitrary metric like length, draft or property size.  Effective use of the metric attribute
-  # can simplify presentation of Measures and make parsing of user input more accurate. 
+  # can simplify presentation of Measures and make parsing of user input more accurate.
   # Reference: http://en.wikipedia.org/wiki/Units_of_measurement
   class Unit
+    extend Enumerable
+
     @store = Set.new
 
+    def self.each(&block)
+      @store.each(&block)
+    end
+
     def self.register(*args)
       u = new(*args)
-      raise "Namespace collision: #{u.dimension}:#{u.system}:#{u.name}" if self[u.dimension, u.system, u.name.to_sym]
-      raise "Namespace collision: #{u.dimension}:#{u.system}:#{u.abbreviation}" if self[u.dimension, u.system, u.abbreviation.to_sym] if u.abbreviation
+      raise "Namespace collision: #{u.inspect}" if @store.include?(u)
       @store << u
       u
     end
@@ -25,7 +31,8 @@ module Dimensional
       sys = System[sys] unless sys.kind_of?(System)
       sym = sym.to_sym
       us = @store.select{|u| u.dimension == dim}.select{|u| u.system == sys}
-      us.detect{|u| sym == u.name.to_sym || (u.abbreviation && sym == u.abbreviation.to_sym)}
+      u = us.detect{|u| sym == u.name.to_sym || (u.abbreviation && sym == u.abbreviation.to_sym)}
+      u || (raise ArgumentError, "Can't find unit: #{dim}, #{sys}, #{sym}")
     end
 
     def self.reset!
@@ -34,49 +41,80 @@ module Dimensional
 
     attr_reader :name, :abbreviation
     attr_reader :system, :dimension
-    attr_reader :reference_factor, :reference_unit
+    attr_reader :reference_factor, :reference_units
+    attr_reader :detector, :format, :preference
 
     def initialize(name, system, dimension, options = {})
       @name = name.to_s
       @system = system
       @dimension = dimension
-      @reference_factor = options[:reference_factor]
-      @reference_unit = options[:reference_unit]
+      @reference_factor = options[:reference_factor] || 1
+      @reference_units = options[:reference_units] || {}
       @abbreviation = options[:abbreviation]
+      @detector = options[:detector] || /\A#{[name, abbreviation].compact.join('|')}\Z/
+      @format = options[:format] || dimension.nil? ? "%s %U" : "%s%U"
+      @preference = options[:preference] || 0
+      validate
+    end
+
+    def validate
+      return "Reference factor must be numeric: #{@reference_factor}." unless factor.kind_of?(Numeric)
+      return "Reference units must all be units: #{@reference_units}." unless reference_units.all?{|u, exp| u.kind_of?(Dimensional::Unit)}
+      return "Reference exponents must all be rationals: #{@reference_units}." unless reference_units.all?{|u, exp| exp.kind_of?(Rational)}
+      return "Preference must be numeric: #{@preference}." unless preference.kind_of?(Numeric)
     end
 
     #  If no reference was provided during initialization, this unit must itself be a base unit.
     def base?
-      !reference_unit
+      reference_units.empty?
     end
 
     # Returns the unit or array of units on which this unit's scale is ultimately based.
+    # The technique used is to multiply the bases' exponents by our exponent and then consolidate
+    # resulting common bases by adding their exponents.
     def base
-      return self if base?
-      @base ||= reference_unit.kind_of?(Enumerable) ? reference_unit.map{|ru| ru.base} : reference_unit.base
+      return {self => 1} if base?
+      @base ||= reference_units.inject({}) do |summary0, (ru0, exp0)|
+        t = ru0.base.inject({}){|summary1, (ru1, exp1)| summary1[ru1] = exp1 * exp0;summary1}
+        summary0.merge(t) {|ru, expa, expb| expa + expb}
+      end
     end
-    
+
     # The conversion factor relative to the base unit.
     def factor
-      return 1 if base?
-      @factor ||= reference_factor * (reference_unit.kind_of?(Enumerable) ? reference_unit.inject(1){|f, ru| f * ru.factor} : reference_unit.factor)
+      @factor ||= reference_factor * reference_units.inject(1){|f, (ru, exp)| f * (ru.factor**exp)}
     end
-    
+
     # Returns the conversion factor to convert to the other unit
     def convert(other)
       raise "Units #{self} and #{other} are not commensurable" unless commensurable?(other)
       return 1 if self == other
       self.factor / other.factor
     end
-    
+
     def commensurable?(other)
       dimension == other.dimension
     end
-    
+
+    # Equality is determined by equality of value-ish attributes.  Specifically, equal factors relative to the same base.
+    def ==(other)
+      (other.base == self.base) && other.factor == self.factor
+    end
+
+    # Hashing collisions are desired when we have same identity-defining attributes.
+    def eql?(other)
+      other.kind_of?(self.class) && other.dimension.eql?(self.dimension) && other.system.eql?(self.system) && other.name.eql?(self.name)
+    end
+
+    # This is pretty lame, but the expected usage means we shouldn't get penalized
+    def hash
+      [self.class, dimension, system, name].hash
+    end
+
     def to_s
       name rescue super
     end
-    
+
     def inspect
       "#<#{self.class.inspect}: #{dimension.to_s}:#{system.to_s}:#{to_s}>"
     end

data/lib/dimensional/version.rb

@@ -1,3 +1,3 @@
 module Dimensional
-  VERSION = "0.0.6"
+  VERSION = "0.1.1"
 end

data/test/configuration_test.rb

@@ -0,0 +1,217 @@
+require 'test/unit'
+require 'dimensional/configuration'
+
+class ConfigurationTest < Test::Unit::TestCase
+  include Dimensional
+
+  def setup
+    @s0 = System.new('International System', 'SI', "International System (kg, m)")
+    @s1 = System.new('United States Customary', 'US', "US Customary (ft, lbs)")
+    @dL = Dimension.new('Length')
+    @dM = Dimension.new('Mass')
+    @um = Unit.new('meter', @s0, @dL)
+    @ug = Unit.new('gram', @s0, @dM)
+#    System.register('British Admiralty', 'BA')
+#    Dimension.register('Area', 'A', {Dimension::L => 2})
+  end
+
+  def test_create_configuration
+    assert_instance_of Configuration, c = Configuration.new
+    assert c.dimensions.empty?
+    assert c.systems.empty?
+    assert c.empty?
+  end
+  
+  def test_add_dimension
+    c = Configuration.new
+    assert c.dimensions << @dL
+    assert_same @dL, c.dimensions['Length']
+    assert_same @dL, c.dimensions['L']
+    assert_same @dL, c.dimensions[:L]
+  end
+
+  def test_add_system
+    c = Configuration.new
+    assert c.systems << @s0
+    assert_same @s0, c.systems['SI']
+    assert_same @s0, c.systems['International System']
+    assert_same @s0, c.systems[:SI]
+  end
+
+  def test_prioritize_systems
+    c = Configuration.new
+    assert c.systems << @s0
+    assert c.systems << @s1
+    c.systems.prioritize([:US, :SI])
+    assert_equal @s1, c.systems.first
+    assert_equal [@s1, @s0], c.systems.to_a
+    c.systems.prioritize([:SI, :US])
+    assert_equal [@s0, @s1], c.systems.to_a
+  end
+
+  def test_add_unit
+    c = Configuration.new
+    assert c << @um
+    assert c.include?(@um)
+    assert c.dimensions.include?(@dL)
+    assert c.systems.include?(@s0)
+    assert_same @um, c[@dL, @s0, 'meter']
+  end
+
+  def test_scope
+    c = Configuration.new
+    c << @um
+    c << @ug
+    assert c.include?(@ug)
+    c1 = c.dimension(@dL)
+    assert c1.include?(@um)
+    assert_same @um, c1[@dL, @s0, 'meter']
+    assert !c1.include?(@ug)
+    c2 = c1.dimension(@dM)
+    assert c2.empty?
+    assert !c2.any?
+    assert c.include?(@ug)
+  end
+
+#  def test_start_configurator
+#    assert Configurator.start
+#    assert Configurator.start {true}
+#    assert !Configurator.start {false}
+#  end
+#
+#  def test_start_configurator_with_context_args
+#    assert_same Dimension::L, Configurator.start(:dimension => Dimension::L){context.dimension}
+#  end
+#
+#  def test_change_dimension_context_for_duration_of_block
+#    test_context = self
+#    Configurator.start do
+#      dimension(Dimension::L) do
+#        test_context.assert_equal Dimension::L, context.dimension
+#        true
+#      end
+#      test_context.assert_nil context.dimension
+#    end
+#  end
+#  
+#  def test_change_system_context_for_duration_of_block
+#    test_context = self
+#    Configurator.start do
+#      system(System::SI) do
+#        test_context.assert_equal System::SI, context.system
+#        true
+#      end
+#      test_context.assert_nil context.system
+#    end
+#  end
+#
+#  def test_preserve_context_within_block
+#    test_context = self
+#    Dimensional::Configurator.start do
+#      dimension(:L) do
+#        system(:SI) do
+#          base('meter') do
+#            test_context.assert uc = context.unit
+#            derive('centimeter', 'cm', 1e-2)
+#            test_context.assert_same uc, context.unit
+#          end
+#        end
+#      end
+#    end
+#  end
+#
+#  def test_build_base_unit
+#    Configurator.start(:system => System::SI, :dimension => Dimension::L) do
+#      base('meter', 'm', :detector => /\A(meters?|m)\Z/)
+#    end
+#    assert_instance_of Unit, u = Unit[Dimension::L, System::SI, 'meter']
+#    assert_same System::SI, u.system
+#    assert_same Dimension::L, u.dimension
+#    assert u.base?
+#    assert_equal 'm', u.abbreviation
+#    assert_instance_of Metric, m = Metric[:L]
+#    assert m.preferences(u)[:detector]
+#  end
+#
+#  def test_build_derived_unit
+#    Configurator.start(:system => System::SI, :dimension => Dimension::L) do
+#      base('meter', 'm', :detector => /\A(meters?|m)\Z/) do
+#        derive('centimeter', 'cm', 1e-2, :detector => /\A(centimeters?|cm)\Z/)
+#      end
+#    end
+#    u0 = Unit[Dimension::L, System::SI, 'meter']
+#    assert_instance_of Unit, u = Unit[Dimension::L, System::SI, 'centimeter']
+#    assert_same System::SI, u.system
+#    assert_same Dimension::L, u.dimension
+#    assert_same u0, u.base
+#    assert_equal 1E-2, u.factor
+#    assert_equal 'cm', u.abbreviation
+#  end
+#
+#  def test_build_aliased_unit
+#    Configurator.start(:system => System::SI, :dimension => Dimension::L) do
+#      base('meter', 'm', :detector => /\A(meters?|m)\Z/) do
+#        self.alias('decadecimeter')
+#      end
+#    end
+#    u0 = Unit[Dimension::L, System::SI, 'meter']
+#    assert_instance_of Unit, u = Unit[Dimension::L, System::SI, 'decadecimeter']
+#    assert_same System::SI, u.system
+#    assert_same Dimension::L, u.dimension
+#    assert_same u0, u.base
+#    assert_equal 1, u.factor
+#  end
+#
+#  def test_build_referenced_unit
+#    Configurator.start(:system => System::SI, :dimension => Dimension::L) do
+#      base('meter', 'm', :detector => /\A(meters?|m)\Z/)
+#      system(:US) do
+#        reference('yard', 'yd', Unit[:L, :SI, 'meter'], 0.9144, :detector => /\A(yards?|yds?)\Z/)
+#      end
+#    end
+#    u0 = Unit[Dimension::L, System::SI, 'meter']
+#    assert_instance_of Unit, u = Unit[Dimension::L, System::US, 'yard']
+#    assert_equal 0.9144, u.factor
+#    assert_same u0, u.base
+#  end
+#
+#  def test_build_combined_unit
+#    Configurator.start(:system => System::SI, :dimension => Dimension::L) do
+#      base('meter', 'm', :detector => /\A(meters?|m)\Z/)
+#      system(:US) do
+#        reference('yard', 'yd', Unit[:L, :SI, 'meter'], 0.9144, :detector => /\A(yards?|yds?)\Z/)
+#        dimension(:A) do
+#          combine('square yard', 'yd2', [Unit[:L, :US, 'yard'], Unit[:L, :US, 'yard']], :detector => /\A(yd|yard)2\Z/)
+#        end
+#      end
+#    end
+#    u1 = Unit[Dimension::L, System::US, 'yard']
+#    assert_instance_of Unit, u = Unit[:A, :US, 'square yard']
+#    assert_equal Dimension::A, u.dimension
+#    assert_equal 0.83612736, u.factor
+#    assert_equal [u1.base, u1.base], u.base
+#  end
+#  
+#  def test_add_default_preferences
+#    Configurator.start(:system => System::SI, :dimension => Dimension::L) do
+#      base('meter', 'm')
+#    end
+#    u = Unit[Dimension::L, System::SI, 'meter']
+#    m = Metric[:L]
+#    assert d = m.preferences(u)[:detector]
+#    assert_match d, 'meter'
+#    assert f = m.preferences(u)[:format]
+#  end
+#
+#  def test_register_metric_options
+#    Configurator.start(:system => System::SI, :dimension => Dimension::L) do
+#      base('meter', 'm', :detector => /\A(meters?|m)\Z/) do
+#        prefer(:length_over_all, :precision => 0.01)
+#      end
+#    end
+#    u = Unit[:L, :SI, 'm']
+#    assert_instance_of Metric, m = Metric[:length_over_all]
+#    assert_same Metric[:L], m.parent
+#    assert_equal 0.01, m.preferences(u)[:precision]
+#  end
+end

data/test/configurator_test.rb

@@ -10,6 +10,8 @@ class ConfiguratorTest < Test::Unit::TestCase
     System.register('British Admiralty', 'BA')
     Dimension.register('Length')
     Dimension.register('Area', 'A', {Dimension::L => 2})
+    Dimension.register('Time', 'T')
+    Dimension.register('Acceleration', 'Accel', {Dimension::L => 1, Dimension::T => -2})
     Dimension.register('Mass')
   end
 
@@ -17,7 +19,6 @@ class ConfiguratorTest < Test::Unit::TestCase
     Dimension.reset!
     System.reset!
     Unit.reset!
-    Metric.reset!
   end
 
   def test_create_configurator
@@ -47,7 +48,7 @@ class ConfiguratorTest < Test::Unit::TestCase
       test_context.assert_nil context.dimension
     end
   end
-  
+
   def test_change_system_context_for_duration_of_block
     test_context = self
     Configurator.start do
@@ -76,15 +77,14 @@ class ConfiguratorTest < Test::Unit::TestCase
 
   def test_build_base_unit
     Configurator.start(:system => System::SI, :dimension => Dimension::L) do
-      base('meter', 'm', :detector => /\A(meters?|m)\Z/)
+      base('meter', 'm', :detector => /\A(met(er|re)s?|m)\Z/)
     end
     assert_instance_of Unit, u = Unit[Dimension::L, System::SI, 'meter']
     assert_same System::SI, u.system
     assert_same Dimension::L, u.dimension
     assert u.base?
     assert_equal 'm', u.abbreviation
-    assert_instance_of Metric, m = Metric[:L]
-    assert m.preferences(u)[:detector]
+    assert_equal /\A(met(er|re)s?|m)\Z/, u.detector
   end
 
   def test_build_derived_unit
@@ -97,7 +97,7 @@ class ConfiguratorTest < Test::Unit::TestCase
     assert_instance_of Unit, u = Unit[Dimension::L, System::SI, 'centimeter']
     assert_same System::SI, u.system
     assert_same Dimension::L, u.dimension
-    assert_same u0, u.base
+    assert_equal({u0 => 1}, u.base)
     assert_equal 1E-2, u.factor
     assert_equal 'cm', u.abbreviation
   end
@@ -112,7 +112,7 @@ class ConfiguratorTest < Test::Unit::TestCase
     assert_instance_of Unit, u = Unit[Dimension::L, System::SI, 'decadecimeter']
     assert_same System::SI, u.system
     assert_same Dimension::L, u.dimension
-    assert_same u0, u.base
+    assert_equal({u0 => 1}, u.base)
     assert_equal 1, u.factor
   end
 
@@ -126,7 +126,7 @@ class ConfiguratorTest < Test::Unit::TestCase
     u0 = Unit[Dimension::L, System::SI, 'meter']
     assert_instance_of Unit, u = Unit[Dimension::L, System::US, 'yard']
     assert_equal 0.9144, u.factor
-    assert_same u0, u.base
+    assert_equal({u0 => 1}, u.base)
   end
 
   def test_build_combined_unit
@@ -135,37 +135,32 @@ class ConfiguratorTest < Test::Unit::TestCase
       system(:US) do
         reference('yard', 'yd', Unit[:L, :SI, 'meter'], 0.9144, :detector => /\A(yards?|yds?)\Z/)
         dimension(:A) do
-          combine('square yard', 'yd2', [Unit[:L, :US, 'yard'], Unit[:L, :US, 'yard']], :detector => /\A(yd|yard)2\Z/)
+          combine('square yard', 'yd2', {Unit[:L, :US, 'yard'] => 2}, :detector => /\A(yd|yard)2\Z/)
         end
       end
     end
-    u1 = Unit[Dimension::L, System::US, 'yard']
+    u0 = Unit[Dimension::L, System::SI, 'meter']
     assert_instance_of Unit, u = Unit[:A, :US, 'square yard']
     assert_equal Dimension::A, u.dimension
     assert_equal 0.83612736, u.factor
-    assert_equal [u1.base, u1.base], u.base
-  end
-  
-  def test_add_default_preferences
-    Configurator.start(:system => System::SI, :dimension => Dimension::L) do
-      base('meter', 'm')
-    end
-    u = Unit[Dimension::L, System::SI, 'meter']
-    m = Metric[:L]
-    assert d = m.preferences(u)[:detector]
-    assert_match d, 'meter'
-    assert f = m.preferences(u)[:format]
+    assert_equal({u0 => 2}, u.base)
   end
 
-  def test_register_metric_options
-    Configurator.start(:system => System::SI, :dimension => Dimension::L) do
-      base('meter', 'm', :detector => /\A(meters?|m)\Z/) do
-        prefer(:length_over_all, :precision => 0.01)
+  def test_build_combined_unit_with_reference_factor
+    Configurator.start(:system => System::SI) do
+      dimension(:L) do
+        base('meter', 'm')
+      end
+      dimension(:T) do
+        base('second', 's')
+      end
+      dimension(:Accel) do
+        combine('gravity', 'g', {Unit[:L, :SI, :m] => 1, Unit[:T, :SI, :s] => -2}, :reference_factor => 9.8)
       end
     end
-    u = Unit[:L, :SI, 'm']
-    assert_instance_of Metric, m = Metric[:length_over_all]
-    assert_same Metric[:L], m.parent
-    assert_equal 0.01, m.preferences(u)[:precision]
+    u = Unit[Dimension::Accel, System::SI, :g]
+    assert_equal Dimension::Accel, u.dimension
+    assert_equal 9.8, u.factor
+    assert_equal({Unit[:L, :SI, :m] => 1, Unit[:T, :SI, :s] => -2}, u.base)
   end
 end