quantity 0.1.1 → 0.1.2

data/lib/quantity/version.rb

@@ -2,7 +2,7 @@ class Quantity
   module VERSION
     MAJOR = 0
     MINOR = 1
-    TINY  = 0
+    TINY  = 2
     EXTRA = nil
 
     STRING = [MAJOR, MINOR, TINY].join('.')

data/quantity.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "quantity/version"
+
+Gem::Specification.new do |s|
+  s.name        = "quantity"
+  s.version     = Quantity::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ben Lavender", "Arto Bendiken"]
+  s.email       = ["blavender@gmail.com", "arto.bendiken@gmail.com"]
+  s.homepage    = %q{http://quantity.rubyforge.org/}
+  s.summary     = %q{Units and quantities for Ruby.}
+  s.description = %q{Quantity provides first-class quantities, units, and base quantities in pure ruby.
+Things like 1.meter / 1.second == 1 meter/second.
+}
+  
+  s.rubyforge_project = %q{quantity}
+  
+  s.add_development_dependency "rspec", ["= 1.2.9"]
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+    
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rake>, ["= 0.8.7"])
+      s.add_development_dependency(%q<rspec>, ["= 1.2.9"])
+      s.add_development_dependency(%q<yard>, ["= 0.5.2"])
+    else
+      s.add_dependency(%q<rake>, ["= 0.8.7"])
+      s.add_dependency(%q<rspec>, ["= 1.2.9"])
+      s.add_dependency(%q<yard>, ["= 0.5.2"])
+    end
+  else
+    s.add_dependency(%q<rake>, ["= 0.8.7"])
+    s.add_dependency(%q<rspec>, ["= 1.2.9"])
+    s.add_dependency(%q<yard>, ["= 0.5.2"])
+  end
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/dimension.spec

@@ -0,0 +1,330 @@
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'lib')))
+
+require 'quantity/dimension'
+
+describe Quantity::Dimension do
+
+  ## we test other things, so make sure dimensions are destroyed before we start
+  before :all do
+    Quantity::Dimension.__reset!
+  end
+
+  context "definition" do
+    after :all do
+      Quantity::Dimension.__reset!
+    end
+
+    context "creation via DSL" do
+      it "creates simple dimensions" do
+        Quantity::Dimension.add_dimension :length, :width
+        length = Quantity::Dimension.for(:length)
+        length.to_s.should == "length"
+        length.name.should == :length
+      end
+
+      it "creates complex dimensions" do
+        Quantity::Dimension.add_dimension :'length^2', :area
+        area = Quantity::Dimension.for(:area)
+        area.to_s.should == "area"
+        area.name.should == :area
+        area.reduced_name.should == :'length^2'
+      end
+
+    end
+
+    it "returns nil for non-existent dimensions" do
+      Quantity::Dimension.for(:nodimension).should be nil
+    end
+
+    # this is useful for testing
+    it "should allow resetting the world" do
+      Quantity::Dimension.__reset!
+      x = Quantity::Dimension.for(:length)
+      x.should == nil
+    end
+  end
+
+  context "use case" do
+
+    before :all do
+      Quantity::Dimension.__reset!
+      length = Quantity::Dimension.add_dimension :length, :width
+      Quantity::Dimension.add_dimension :'length^2', :area
+      mass = Quantity::Dimension.add_dimension :mass
+      time = Quantity::Dimension.add_dimension :time
+      Quantity::Dimension.add_dimension :'length/time^2', :acceleration
+      Quantity::Dimension.add_dimension(((mass * length) / time**2), :force)
+    end
+
+    # We use these for testing dimension.  the systems are tested in a separate spec.
+    # we'll be using these for the rest of the specs
+    before(:each) do
+      @length = Quantity::Dimension.for(:length)
+      @mass = Quantity::Dimension.for(:mass)
+      @area = Quantity::Dimension.for(:area)
+      @accel = Quantity::Dimension.for(:acceleration)
+      @force = Quantity::Dimension.for(:force)
+      @time = Quantity::Dimension.for(:time)
+    end
+
+    after :all do
+      Quantity::Dimension.__reset!
+    end
+
+    it "has a name for simple dimensions" do
+      @mass.name.should == :mass
+    end
+
+    it "uses the primary name for dimensions with aliases" do
+      @length.name.should == :length
+    end
+
+    it "has a name for named complex dimensions" do
+      @force.name.should == :force
+    end
+
+    it "provides a reduced form for base dimensions" do
+      @length.reduced_name.should == :'length'
+    end
+
+    it "provides a reduced form for complex dimensions" do
+      @force.reduced_name.should == :'length*mass/time^2'
+    end
+
+    it "provides a hash form for simple dimensions" do
+      @length.hash.should == { :length => 1 }
+    end
+
+    it "provides a hash form for unnamed dimensions" do
+      lm = @length * @mass
+      lm.hash.should == { :length => 1, :mass => 1 }
+    end
+
+    it "provides a hash form for named dimensions" do
+      @area.to_hash.should == { :area => 1 }
+    end
+
+    it "provides a reduced hash form" do
+      @length.to_hash.should == @length.reduced_hash
+      @area.reduced.to_hash.should == { :length => 2 }
+    end
+
+    it "provides a hash form with negative components" do
+      @force.to_hash.should = { :length => 1, :mass => -1 , :time => -2 }
+    end
+
+    it "provides a reduced form" do
+      @area.name.should == :area
+      @area.reduce.name.should == :'length^2'
+    end
+
+    ## this is going to be removed for hashes, but unit still uses it, so we test it.
+    it "should track numerators and denominators" do
+      @length.numerators.first.dimension.should == :length
+      @length.numerators.first.power.should == 1
+      @force.numerators.first.dimension.should == :length
+      @force.numerators.first.power== 1
+      @force.numerators[1].dimension.should == :mass
+      @force.numerators[1].power== 1
+      @force.denominators.first.dimension.should == :time
+      @force.denominators.first.power.should == 2
+    end
+ 
+    # This is a bad interface and will be removed.
+    it "should provide a vaguely parsable string format" do
+      component = Quantity::Dimension::DimensionComponent.new(:length,3)
+      component2 = Quantity::Dimension::DimensionComponent.new(:length,2)
+      component3 = Quantity::Dimension::DimensionComponent.new(:time,2)
+      component4 = Quantity::Dimension::DimensionComponent.new(:length,5)
+      Quantity::Dimension.string_form([component],[]).should=='length^3'
+      Quantity::Dimension.string_form([component,component2],[]).should=='length^3*length^2'
+      Quantity::Dimension.string_form([component,component2],[component3]).should=='length^3*length^2/time^2'
+      Quantity::Dimension.parse_string_form('length^3*length^2/time^2').inspect.should == [[component4],[component3]].inspect
+    end
+  
+    context "multiplication" do
+      it "multiplies base dimensions" do
+        mass_squared = @mass * @mass
+        mass_squared.name.should == :'mass^2'
+      end
+     
+      it "interns base multiplcation results" do
+        mass_squared = @mass * @mass
+        mass_squared_again = @mass * @mass
+        mass_squared.should equal mass_squared_again
+      end
+
+      it "multiplies derived complex dimensions and base dimensions" do
+        mass_squared = @mass * @mass
+        mass_cubed = mass_squared * @mass
+        mass_cubed.name.should == :'mass^3'
+      end
+
+      it "multiplies base dimensions and derived complex dimensions" do
+        mass_squared = @mass * @mass
+        mass_cubed = @mass * mass_squared
+        mass_cubed.name.should == :'mass^3'
+      end
+
+      it "interns mixed multiplcation results" do
+        mass_squared = @mass * @mass
+        mass_cubed = @mass * mass_squared
+        mass_cubed_again = mass_squared * @mass
+        mass_cubed.should equal mass_cubed_again
+      end
+
+      it "multiplies derived complex dimensions with each other" do
+        mass_squared = @mass * @mass
+        time_squared = @time * @time
+        mt = mass_squared * time_squared
+        mt.name.should == :'mass^2*time^2'
+      end
+
+      it "multiplies named complex dimensions with base dimensions" do
+        ma = @area * @mass
+        ma.name.should == :'area*mass'
+      end
+
+      it "multiplies base dimensions with named complex dimensions" do
+        ma = @mass * @area
+        ma.name.should == :'area*mass'
+      end
+
+      it "multiplies named complex dimensions with each other" do
+        l4 = @area * @area
+        l4.name.should == :'area^2'
+      end
+
+      it "performs exponentiation" do
+        (@length**3).should == @length * @length * @length
+      end
+
+      it "allows naming of units first derived via multiplication" do
+        t2 = @time * @time
+        Quantity::Dimension.add_dimension @time * @time, :time_squared
+        Quantity::Dimension.for(:time_squared).should equal t2
+      end
+
+    end
+    
+    # in division, we test base / complex, but based on equality and
+    # multiplication tests, we do not specifically test division against named
+    # and derived.  either is fine unless we expect different semantics
+    context "division" do
+
+      context "with base dividends" do
+
+        it "supports base divisors" do
+          speed = @length / @time
+          speed.name.should == :'length/time'
+        end
+  
+        it "supports complex divisors" do
+          ta = @time / @area
+          ta.name.should == :'time/area'
+        end
+  
+        it "supports complex divisors with a negative exponent" do
+          mt = @mass / @time
+          lmt = @length / mt
+          lmt.name.should == :'length*time/mass'
+        end
+    
+        # This one is a tough call.  Supporting this is difficult, since
+        # acceleration as a denominator is the same as multiplying by the
+        # reciprocal.  It's confusing for the internal representation.  I'm also
+        # hard-pressed to find examples of this being useful, i.e. when's it
+        # useful to have something divided by force?  length per force?
+        it "supports reduced form with a named complex divisor " do
+          ma = @mass / @accel
+          ma.name.should == :'mass*time^2/length'
+        end
+
+        it "supports named form with a named complex divisor" do
+          ma = @mass / @accel
+          ma.name.should == :'mass/acceleration'
+        end
+
+        it "supports a nil numerator component" do
+          speed = @mass / @time
+          t_neg_1 = speed / @mass 
+          t_neg_1.name.should == :'1/time'
+          t_neg_1.reduced_hash.should == { :time => -1 }
+        end
+
+      end
+
+      context "with complex dividends" do
+        it "supports base dimension divisors" do
+          am = @area / @mass
+          am.reduced_name.should == :'length^2/mass'
+          am.name.should == :'area/mass'
+        end
+  
+        it "supports complex divisors" do
+          am = @area / (@mass * @mass)
+          am.reduced_name.should == :'length^2/mass^2'
+          am.name.should == :'area/mass^2'
+        end
+  
+        it "supports divisors with a negative exponent" do
+          result = (@mass * @mass) / (@length / @time)
+          result.name.should == :'mass^2*time/length'
+        end
+        
+        it "supports reduced form for divisors with a negative exponent" do
+          result = (@mass * @mass) / @accel
+          result.name.should == :'mass^2*time^2/length'
+        end
+      end
+
+      context "with dividends with negative exponents" do
+        it "supports reduced form for base divisor" do
+          jerk = @accel / @time
+          jerk.reduced_name.should == :'length/time^3'
+        end
+
+        it "supports named form for base divisor" do
+          jerk = @accel / @time
+          jerk.name.should == :'acceleration/time'
+        end
+
+        it "supports reduced form for complex divisors" do
+          af = @accel / (@mass * @mass)
+          af.reduced_name.should == :'length/mass^2*time^2'
+        end
+
+        it "supports named form for complex divisors" do
+          af = @accel / (@mass * @mass)
+          af.name.should == :'acceleration/mass^2'
+        end
+
+        it "only supports reduced form for a subdimension divisor" do
+          fa = @force / @accel
+          fa.reduced_name.should == :'force/acceleration'
+          fa.reduced_name.should == :'mass'
+        end
+
+        it "supports named form for complex divisors with negative exponents" do
+          tm = @time / @mass
+          fa = @force / tm
+          fa.name.should == :'force*mass/time'
+        end
+
+        it "supports reduced form for a complex divisors with negative exponents" do
+          tm = @time / @mass
+          fa = @force / tm
+          fa.reduced_name.should == :'length*mass^2/time^3'
+        end
+      end
+
+      context "as negative exponentiation" do
+        it "supports negative exponents" do
+          length_neg_2 = @length**-2
+          length_neg_2.name.should == :'1/length^2'
+        end
+      end
+
+    end
+  end
+end

data/spec/quantity.spec

@@ -0,0 +1,282 @@
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'lib')))
+
+require 'quantity'
+require 'quantity/systems/si'
+require 'quantity/systems/us'
+
+describe Quantity do
+
+  context "instantiation" do
+    it "should be instantiated from numbers" do
+      1.meter.should == 1
+      2.5.feet.should == 2.5
+    end
+  
+    it "should work with alias names" do
+      2.meters.should == 2
+    end
+  
+    it "should know what it measures" do
+      2.meters.unit.dimension.name.should == :length
+      2.meters.measures.name.should == :length
+    end
+  
+    it "should know its units" do
+      2.meters.unit.name.should == :meter
+      2.meters.units.should == :meter
+    end
+
+    it "should have a string representation" do
+      2.meters.to_s.should == "2 meter"
+      (2.meters * 2.meters).to_s.should == (defined?(Rational) ? "4 meter^2" : "4.0 meter^2")
+    end
+
+  end
+
+  context "conversions" do
+    it "converts from one type to another" do
+      1.meter.in_centimeters.should == 100
+      10.meters.convert(:feet).should be_close 32.808399.feet, 10**-6
+    end
+  
+    it "converts from one type to another when not using the reference value for that dimension" do
+      1.kilometer.in_centimeters.should == 100_000
+    end
+  
+    it "fails to convert things that do not measure the same dimension" do
+      lambda { 1.picogram.in_meters }.should raise_error ArgumentError
+    end
+
+    it "converts derived units" do
+      Quantity.new(2,'m^2').to_feet.to_f.should be_close 21.5278208, 10**-5
+      Quantity.new(2,'m^2').convert('foot^2').to_f.should be_close 21.5278208, 10**-5
+    end
+
+    it "converts derived units to named units" do
+      (1.centimeter * 1.centimeter * 1.centimeter).should == 0.1.centiliter
+      (1000.mm * 1.mm * 1.mm).should == 1.ml
+      (1.mm**3).unit.name.should == 'millimeter^3'
+      (1.mm**3).measures.name.should == :volume
+      (1.centimeter * 1.centimeter).measures.name.should == :area
+      (30.meters / 1.second).measures.name.should == :speed
+    end
+
+    it "reduces derived units" do
+      ((1.meter / 1.second) * 1.second).should == 1.meter
+    end
+    
+    it "respond_to? conversion methods" do
+      1.meter.should respond_to(:in_centimeters)
+      1.meter.should respond_to(:to_centimeters)
+    end
+    
+  end
+
+  context "math operations" do
+    
+    context "equality" do
+      it "enforces exact equality" do
+        12.meter.should == 12.meters
+      end
+
+      it "does not intern quantities" do
+        12.meter.should_not equal 12.meters
+      end
+
+      it "enforces equality across a dimension" do
+        1.meter.should == 100.centimeter
+      end
+
+      it "does not find quantities on different dimensions to be equal" do
+        1.millimeter.should_not == 1.milligram
+      end
+
+    end
+   
+    context "general" do
+      it "supports abs" do
+        ((-(5.seconds)).abs).should == 5.seconds
+        (-5).seconds.abs.should == 5.seconds
+        5.seconds.abs.should == 5.seconds
+      end
+
+      it "supports @-" do
+        (-(35.meters)).should be_close -(114.829396.feet), 10**-5
+      end
+
+      it "supports @+" do
+        +4.kilograms.should == 4.kilograms
+      end
+
+      it "supports %" do
+        (35.meters % 6).should == 5.meters
+        (35.meters % 6.feet).should be_close 0.2528.meters, 10**-5
+      end
+
+      it "supports modulo" do
+        4.kilograms.modulo(15.grams).should == 10.grams
+      end
+
+      it "supports round" do
+        15.6.meters.round.should == 16.meters
+      end
+
+      it "supports truncate" do
+        15.2.meters.truncate.should == 15.meters
+      end
+
+      it "supports ceil" do
+        15.2.meters.ceil.should == 16.meters
+      end
+
+      it "supports floor" do
+        (-5.5.meters).floor.should == -6.meters
+      end
+
+      it "supports divmod" do
+        11.meters.divmod(3).should == [3.meter,2.meter]
+        11.meters.divmod(3.meters).should == [3.meter,2.meter]
+        11.meters.divmod(-3).should == [-4.meter,-1.meter]
+        11.meters.divmod(-3.meters).should == [-4.meter,-1.meter]
+        11.meters.divmod(3.5).should == [3.meter,0.5.meter]
+        11.meters.divmod(3.5.meters).should == [3.meter,0.5.meter]
+        (-11.meters).divmod(3.5).should == [-4.meter,3.0.meter]
+        (-11.meters).divmod(3.5.meters).should == [-4.meter,3.0.meter]
+        11.5.meters.divmod(3.5).should == [3.meter,1.0.meter]
+        11.5.meters.divmod(3.5.meters).should == [3.meter,1.0.meter]
+      end
+
+      it "supports zero?" do
+        0.kilograms.zero?.should == true
+      end
+    end
+
+    context "addition and subtraction" do
+      it "adds quantities of the same thing" do
+        (12.meters + 5.meters).should == 17.meters
+      end
+
+      it "adds quantities of the same dimension" do
+        (12.meters + 15.centimeters).should == 1215.centimeters
+      end
+
+      it "adds numerics to quantities" do
+        3.meters.should == 1.meter + 2
+      end
+
+      it "adds quantities to numerics" do
+        6.4.meters.should == 4.4 + 2.meter
+      end
+    
+      it "does not add items of different types" do
+        lambda { 12.meters + 24.picograms }.should raise_error TypeError
+      end
+   
+      it "adds negative quantities" do
+        (5.meters + (-3.meters)).should == 2.meters
+      end
+
+      it "subtracts quantities of the same thing" do
+        (12.meters - 3.meters).should == 9.meters
+      end
+
+      it "subtracts quantities of the same dimension" do
+        (12.meters - 3650.centimeters).should == -2450.centimeters
+      end
+
+      it "does not add items of different types" do
+        lambda { (12.meters - 3650.picograms)}.should raise_error TypeError
+      end
+      
+      it "subtracts numerics from quantities" do
+        (12.meters - 3).should == 9.meters
+      end
+
+      it "subtracts quantities from numerics" do
+        (15 - 5.meters).should == 10.meters
+      end
+    end
+
+    context "multiplication" do
+
+      it "multiplies quantities of the same unit" do
+        (2.meters * 5.meters).should == 10
+      end
+
+      it "multiplies quantities of the same dimension" do
+        (1.meter * 1.foot).should be_close Quantity.new(3.280839,:'foot^2'), 10**-5
+      end
+      
+      it "uses the unit on the right when multiplying across the same dimension" do
+        (1.meter * 1.foot).unit.name.should == :'foot^2'
+      end
+      
+      it "multiplies complex units" do
+        (3.meter * Quantity.new(1,:'m^2')).should == Quantity.new(3,:'m^3')
+      end
+
+      it "multiplies units of different dimensions" do
+        (2.meters * 2.kilograms).should == Quantity.new(4,:'meter*kilogram')
+      end
+    end
+
+    context "division" do 
+      it "divides numerics by quantities" do
+        (6 / 2.meters).should == 3.meters
+      end
+
+      it "divides quantities by numerics" do
+        (6.meters / 2).should == 3.meters
+      end
+
+      it "divides quantities of the same unit" do
+        (6.meters / 2.meters).should == 3.meters
+      end
+
+      it "divides quantities of the same dimension" do
+        (6.meters / 2.feet).should == 3.meters
+      end
+
+      it "divides quantities of different dimensions" do
+        (1.kilogram / 1.second).unit.name.should == :'kilogram/second'
+      end
+
+      it "correctly calculates the value of a divided unit" do
+        (10.meters / 2.picograms).should be_close 5, 10**-5
+      end
+
+    end
+
+    context "exponentiation" do
+      it "raises quantities to positive powers" do
+        (2.meters**2).should be_close Quantity.new(4,:'meter^2'), 10**-5
+      end
+
+      it "raises quantities to negative powers" do
+        (2.meters**-1).unit.name.should == :'1/meter'
+        (2.meters**-1).should == 2
+      end
+
+      it "supports a cubed function" do
+        (1.centimeter * 1.centimeter * 1.centimeter).should == 1.centimeter.cubed
+      end
+
+      it "supports a squared function" do
+        (1.centimeter * 1.centimeter).should == 1.centimeter.squared
+      end
+
+      it "does not raise to fractional powers" do
+        lambda {2.meters**1.5}.should raise_error ArgumentError
+      end
+    end
+
+    context "enumerable" do
+      it "should be comparable" do
+        2.meters.should be < 3.meters
+        150.centimeters.should be > 1.meter
+        [1.meter, 1.foot, 1.inch].sort.should == [1.inch, 1.foot, 1.meter]
+      end
+    end
+  
+  end
+end