dimensional 0.0.6 → 0.1.1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dimensional
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
+  version: 0.1.1
 platform: ruby
 authors: 
 - Chris Hapgood
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-09 00:00:00 -04:00
+date: 2010-02-05 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -25,17 +25,16 @@ files:
 - lib/dimensional/configuration.rb
 - lib/dimensional/configurator.rb
 - lib/dimensional/dimension.rb
-- lib/dimensional/measure.rb
 - lib/dimensional/metric.rb
 - lib/dimensional/system.rb
 - lib/dimensional/unit.rb
 - lib/dimensional/version.rb
 - lib/dimensional.rb
+- test/configuration_test.rb
 - test/configurator_test.rb
 - test/demo.rb
 - test/dimension_test.rb
 - test/dimensional_test.rb
-- test/measure_test.rb
 - test/metric_test.rb
 - test/system_test.rb
 - test/unit_test.rb
@@ -72,11 +71,11 @@ signing_key:
 specification_version: 3
 summary: Dimensional provides handling for numbers with units.
 test_files: 
+- test/configuration_test.rb
 - test/configurator_test.rb
 - test/demo.rb
 - test/dimension_test.rb
 - test/dimensional_test.rb
-- test/measure_test.rb
 - test/metric_test.rb
 - test/system_test.rb
 - test/unit_test.rb

data/lib/dimensional/measure.rb

@@ -1,122 +0,0 @@
-require 'dimensional/unit'
-require 'dimensional/metric'
-require 'delegate'
-
-module Dimensional
-  # A numeric-like class used to represent the measure of a physical quantity.  An instance of this
-  # class represents both the unit and the numerical value of a measure.  In turn, the (scale)
-  # unit implies a dimension of the measure.  Instances of this class are immutable (value objects)
-  # Reference: http://en.wikipedia.org/wiki/Physical_quantity
-  class Measure < DelegateClass(Numeric)
-    # A Measure string is composed of a number followed by a unit separated by optional whitespace.
-    # A unit (optional) is composed of a non-digit character followed by zero or more word characters and terminated by some stuff.
-    # Scientific notation is not currently supported.
-    NUMERIC_REGEXP = /((?=\d|\.\d)\d*(?:\.\d*)?)\s*(\D\w*?)?(?=\b|\d|\W|$)/
-  
-    # Parse a string into a Measure instance.  The metric and system parameters may be keys for looking up the associated values. 
-    # Unrecognized strings return nil.
-    def self.parse(str, metric, system = nil)
-      metric = Metric[metric] unless metric.kind_of?(Metric)
-      system = System[system] unless system.kind_of?(System)
-      raise "Metric not specified" unless metric
-      units = metric.units
-      elements = str.to_s.scan(NUMERIC_REGEXP).map do |(v, us)|
-        units = units.select{|u| system == u.system} if system
-        unit = us.nil? ? units.first : units.detect{|u| metric.preferences(u)[:detector].match(us)}
-        raise ArgumentError, "Unit cannot be determined (#{us})" unless unit
-        system = unit.system
-        value = unit.dimension.nil? ? v.to_i : v.to_f
-        new(value, unit, metric)
-      end
-      # Coalesce the elements into a single Measure instance in "expression base" units.
-      # The expression base is the first provided unit in an expression like "1 mile 200 feet"
-      elements.inject do |t, e|
-        converted_value = e.convert(t.unit)
-        new(t + converted_value, t.unit, metric)
-      end
-    end
-
-    attr_reader :unit, :metric
-
-    def initialize(value, unit, metric = nil)
-      @unit = unit
-      metric = Metric[metric] if metric.kind_of?(Symbol)
-      @metric = metric || Metric[unit.dimension]
-      super(value)
-    end
-
-    # Convert this dimensional value to a different unit
-    def convert(new_unit)
-      new_value = self * unit.convert(new_unit)
-      self.class.new(new_value, new_unit, metric)
-    end
-    
-    # Convert this measure to the most appropriate unit in the given system
-    # A heuristic approach is used that considers the resulting measure's order-of-magnitude (similar
-    # is good) and membership in the preferred units of the measure's metric (membership is good).
-    def change_system(system, fallback = false)
-      system = System[system] unless system.kind_of?(System)
-      units = metric.units.select{|u| system == u.system}
-      if units.empty?
-        if fallback
-          units = metric.units
-        else
-          raise "No suitable units available in #{system}"
-        end
-      end
-      target_oom = Math.log10(self.unit.factor)
-      units = units.sort_by do |u|
-        oom_delta = (Math.log10(u.factor) - target_oom).abs #  == Math.log10(self.unit.factor / u.factor)
-        magnitude_fit = Math.exp(-0.20 * oom_delta) # decay function
-        0.75 * magnitude_fit + 0.25 * metric.preference(u)
-      end
-      u = units.last
-      convert(u)
-    end
-
-    # Return a new dimensional value expressed in the base unit
-    # DEPRECATE: this method has dubious semantics for composed units as there may be no defined unit with
-    # a matching dimension vector.
-    def base
-      raise "Composed units cannot be converted to a base unit" if unit.reference_unit.kind_of?(Enumerable)
-      convert(unit.base)
-    end
-
-    def to_s
-      strfmeasure(metric.preferences(unit)[:format] || "%s%U")
-    end
-
-    # Like Date, Time and DateTime, Measure represents both a value and a context.  Like those built-in classes,
-    # Measure needs this output method to control the context.  The format string is identical to that used by
-    # Kernel.sprintf with the addition of support for the U specifier:
-    #   %U  replace with unit.  This specifier supports the '#' flag to use the unit's name instead of abbreviation
-    #       In addition, this specifier supports the same width and precision modfiers as the '%s' specifier.  
-    #       For example: %#10.10U
-    # All other specifiers are applied to the numeric value of the measure.
-    # TODO: Support modulo subordinate units with format hash -> {1 => "'", 12 => :inch} or {1 => "%d#", 16 => "%doz."}
-    def strfmeasure(format)
-      # We need the native value to prevent infinite recursion if the user specifies the %s specifier.
-      v = if precision = metric.preferences(unit)[:precision]
-        pfactor = 10**(-precision)
-        ((self * pfactor).round / pfactor.to_f).to_s
-      else
-        native
-      end
-      format = format.gsub(/%(#)?([\d.\-\*]*)U/) do |s|
-        us = ($1) ? unit.name : (unit.abbreviation || unit.name)
-        Kernel.sprintf("%#{$2}s", us)
-      end
-      count = format.scan(/(?:\A|[^%])(%[^% ]*[A-Za-z])/).size
-      Kernel.sprintf(format, *Array.new(count, v)) 
-    end
-
-    def inspect
-      strfmeasure("<%p <%#U>>")
-    end
-
-    private
-    def native
-      metric.dimension ? to_f : to_i
-    end
-  end
-end

data/test/measure_test.rb

@@ -1,226 +0,0 @@
-require 'test/unit'
-require 'dimensional/measure'
-require 'dimensional/configurator'
-require 'rational'
-
-class MeasureTest < Test::Unit::TestCase
-  include Dimensional
-
-  def setup
-    System.register('International System of Units', 'SI')
-    System.register('United States Customary Units', 'US')
-    System.register('British Admiralty', 'BA')
-    
-    Dimension.register('Length')
-    Dimension.register('Mass')
-    
-    Metric.register('length', :L)
-
-    Configurator.start do
-      dimension(:L) do
-        system(:SI) do
-          base('meter', 'm', :detector => /\A(meters?|m)\Z/) do
-            prefer(:length_over_all, :precision => 0.01)
-            derive('centimeter', 'cm', 1e-2, :detector => /\A(centimeters?|cm)\Z/)
-            derive('kilometer', 'km', 1e3, :detector => /\A(kilometers?|km)\Z/)
-          end
-        end
-        system(:US) do # As of 1 July 1959 (http://en.wikipedia.org/wiki/United_States_customary_units#Units_of_length)
-          reference('yard', 'yd', Unit[:L, :SI, 'meter'], 0.9144, :detector => /\A(yards?|yds?)\Z/) do
-            derive('foot', 'ft', Rational(1,3), :detector => /\A(foot|feet|ft|')\Z/, :format => "%p'") do
-              prefer(:length_over_all, :precision => Rational(1, 12))
-              derive('inch', 'in', Rational(1,12), :detector => /\A(inch|inches|in|")\Z/, :format => "%p\"")          
-            end
-            derive('furlong', nil, 220, :detector => /\A(furlongs?)\Z/) do
-              derive('mile', 'mi', 8, :detector => /\Amiles?\Z/)
-            end
-          end
-        end
-        system(:BA) do
-          base('mile', 'nm', :detector => /\A(miles?|nm|nmi)\Z/) do
-            prefer(:distance, :precision => -2)
-            derive('cable', nil, Rational(1,10), :detector => /\A(cables?|cbls?)\Z/) do
-              derive('fathom', 'fm', Rational(1,10), :detector => /\A(fathoms?|fms?)\Z/) do
-                derive('yard', 'yd', Rational(1,6), :detector => /\A(yards?|yds?)\Z/) do
-                  derive('foot', 'ft', Rational(1,3), :detector => /\A(foot|feet|ft|')\Z/) do
-                    prefer(:length_over_all, :precision => Rational(1, 12))
-                    derive('inch', 'in', Rational(1,12), :detector => /\A(inch|inches|in|")\Z/)
-                  end
-                end
-              end
-            end
-          end           
-        end
-      end
-      dimension(:M) do
-        system(:SI) do
-          base('kilogram', 'kg', :detector => /\A(kilograms?|kg)\Z/) do
-            derive('tonne', 't', 1000, :detector => /\A(tonnes?)\Z/) # metric ton
-            derive('gram', 'g', Rational(1, 1000), :detector => /\A(grams?|g)\Z/)
-          end
-        end
-      end
-      # Dimensionless Units
-      base('each', 'ea') do
-        derive('dozen', 'dz', 12)
-      end
-    end
-  end
-
-  def teardown
-    Dimension.reset!
-    System.reset!
-    Unit.reset!
-    Metric.reset!
-  end
-
-  def test_create_new_measure
-    u = Unit[:L, :BA, 'mile']
-    assert m = Measure.new(3000, u, :length)
-    assert_equal 3000, m
-    assert_equal u, m.unit
-    assert_same Metric[:length], m.metric
-  end
-
-  def test_to_f
-    d = Measure.parse("1.85m", :L, :SI)
-    assert_instance_of Float, d.to_f
-  end
-
-  def test_to_i
-    d = Measure.parse("1 each", Metric[nil])
-    assert_instance_of Fixnum, d.to_i
-  end
-
-  def test_convert
-    old_unit = Unit[:L, :BA, 'cable']
-    new_unit = Unit[:L, :BA, 'fathom']
-    new = Measure.new(1, old_unit).convert(new_unit)
-    assert_in_delta(10, new, 0.000001)
-    assert_same new_unit, new.unit
-  end
-
-  def test_do_identity_conversion
-    old_unit = Unit[:L, :BA, 'cable']
-    new_unit = old_unit
-    old_value = Measure.new(12, old_unit)
-    new_value = old_value.convert(new_unit)
-    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
-    u0 = Unit[:L, :US, 'yd']
-    m0 = Measure.new(1, u0, :length_over_all)
-    u1 = Unit[:L, :SI, 'm']
-    assert m1 = m0.change_system(:SI)
-    assert_same u1, m1.unit
-  end
-
-  def test_change_system_with_metric_override
-    u0 = Unit[:L, :US, 'in']
-    m0 = Measure.new(1, u0, :length_over_all)
-    u1 = Unit[:L, :SI, 'm']
-    assert m1 = m0.change_system(:SI)
-    assert_same u1, m1.unit
-  end
-
-  def test_change_system_with_oom_dominance
-    u0 = Unit[:L, :US, 'in']
-    m0 = Measure.new(1, u0, :L)
-    u1 = Unit[:L, :SI, 'cm']
-    assert m1 = m0.change_system(:SI)
-    assert_same u1, m1.unit
-  end
-
-  def test_change_system_ft
-    u0 = Unit[:L, :US, 'ft']
-    m0 = Measure.new(1, u0, :length_over_all)
-    u1 = Unit[:L, :SI, 'm']
-    assert m1 = m0.change_system(:SI)
-    assert_same u1, m1.unit
-  end
-
-  def test_change_system_mile
-    u0 = Unit[:L, :US, 'mile']
-    m0 = Measure.new(1, u0, :length_over_all)
-    u1 = Unit[:L, :SI, 'km']
-    assert m1 = m0.change_system(:SI)
-    assert_same u1, m1.unit
-  end
-
-  def test_return_base
-    u = Unit[:L, :BA, 'fathom']
-    b = Measure.new(1, u).base
-    assert_in_delta(1e-2, b, 0.000001)
-    assert_same u.base, b.unit
-  end
-
-  def test_parse
-    assert m = Measure.parse("15'", :L, :BA)
-    assert_same Unit[:L, :BA, 'foot'], m.unit
-    assert_equal 15, m
-  end
-  
-  def test_parse_with_whitespace
-    m = Measure.parse("15 feet", :L, :BA)
-    assert_same Unit[:L, :BA, 'foot'], m.unit
-    assert_equal 15, m
-  end
-
-  def test_parse_compound
-    d = Measure.parse("15'11\"", :L, :US)
-    assert_in_delta(15 + Rational(11, 12), d, 0.000001)
-  end
-
-  def test_parse_compound_with_whitespace
-    d = Measure.parse("1 foot 11 inches", :L, :US)
-    assert_same d.unit, Unit[:L, :US, 'foot']
-    assert_in_delta(1 + Rational(11, 12).to_f, d, 0.000001)
-  end
-
-  def test_raise_on_parse_of_mixed_compound
-    assert_raises ArgumentError do
-      Measure.parse("1 foot 11cm", :L)
-    end
-  end
-
-  def test_parse_with_default_unit
-    metric = Metric[:L]
-    du = metric.units.first
-    assert_instance_of Measure, m = Measure.parse("10", :L) 
-    assert_equal du, m.unit
-  end
-
-  def test_parse_dimensionless_units
-    assert m = Measure.parse('2 dozen', nil)
-    assert_instance_of Measure, m
-    assert_equal 2, m
-    assert_equal Unit[nil, nil, 'dozen'], m.unit
-    assert_equal 12, m.unit.factor
-    assert_nil m.unit.dimension
-  end
-  
-  def test_stringify_with_abbreviation
-    assert_equal "1.85nm", Measure.parse('1.85 miles', :L, :BA).to_s
-  end
-
-  def test_parse_gibberish_as_nil
-    assert_nil Measure.parse("gibberish", :L)
-  end
-  
-  def test_format_output
-    m = Measure.parse("15'3\"", :L, :BA)
-    assert_equal "15.25 (ft)", m.strfmeasure("%4.2f (%U)")
-  end
-
-  def test_format_output_with_multiple_substitutions
-    m = Measure.parse("15'4\"", :L, :BA)
-    assert_equal "15.33 (ft)\t%\t<15.3333333ft>", m.strfmeasure("%4.2f (%U)\t%%\t<%.10s%U>")
-  end
-
-  def test_precision_recognition
-    assert_equal "1.8600nm", Measure.parse('1.8565454 miles', :distance, :BA).strfmeasure("%.4f%U")
-    assert_equal "1.86", Measure.parse('1.8565454 miles', :distance, :BA).strfmeasure("%s")
-  end
-end