vanunits 1.5.0

data/lib/van/units_currency.rb

@@ -0,0 +1,12 @@
+require 'van/units/currency'
+
+module Van
+module Units
+
+  # Load conversion units.
+  class Converter
+    require("currency-standard")
+  end
+
+end
+end

data/meta/author

@@ -0,0 +1 @@
+Peter Vanbroekhoven

data/meta/collection

@@ -0,0 +1 @@
+rubyworks

data/meta/contact

@@ -0,0 +1 @@
+Trans <transfire at gmail.com>

data/meta/created

@@ -0,0 +1 @@
+2005-11-26

data/meta/description

@@ -0,0 +1,5 @@
+VanUnits is a units system providing both SI units and web-updated
+currency units, via a very easy to use method-based interface.
+It also include a large set of real world contants, provided in
+"m kg s" and "cm kg s" measures.
+

data/meta/homepage

@@ -0,0 +1 @@
+http://rubyworks.github.com/vanunits

data/meta/name

@@ -0,0 +1 @@
+vanunits

data/meta/summary

@@ -0,0 +1 @@
+Vanbroekhoven's Units System

data/meta/title

@@ -0,0 +1 @@
+VanUnits

data/meta/version

@@ -0,0 +1 @@
+1.5.0

data/qed/conversion.rdoc

@@ -0,0 +1,14 @@
+= Unit Conversions
+
+    require 'stick/units/si'
+
+Check conversions to same type.
+
+    1.g.to(1.g).assert == 1.g
+    1.kg.to(1.kg).assert == 1.kg
+
+Check conversions of simple multiples.
+
+    1.kg.to(1.g).assert == 1000.g
+    1.km.to(1.m).assert == 1000.m
+

data/qed/equality.rdoc

@@ -0,0 +1,150 @@
+= Unit Equality
+
+Equality is a broader issue for unit systems, then it is for
+the usual type system, since two aspect of a thing are being
+compared, the measures value and it's unit.
+
+  require 'stick/units/si'
+
+== Case Equality
+
+Check case equality of prime units.
+
+    1.g.assert  === 1.g
+    1.kg.assert === 1.kg
+    1.N.assert  === 1.N
+
+    1.g.assert  === 10.g
+    1.kg.assert === 10.kg
+    1.N.assert  === 10.N
+
+
+== Value Equality
+
+Check value equality of prime units.
+
+    1.g.assert  == 1.g
+    1.kg.assert == 1.kg
+    1.km.assert == 1.km
+
+    1.g.refute  == 10.g
+    1.kg.refute == 10.kg
+    1.km.refute == 10.km
+
+Check value equality of commensurate prime units.
+
+    1.kg.assert == 1000.g
+    1.km.assert == 1000.m
+
+    1000.g.assert == 1.kg
+    1000.m.assert == 1.km
+
+Check value equality of commensurate prefixed units.
+
+    1000000.g.assert  == 1.Mg
+    0.001.g.assert == 1.mg
+
+Check value equality of compound units.
+
+    1.g.m.assert  == 1.g.m
+    1.kg.m.assert == 1.kg.m
+
+    1.m.g.assert  == 1.g.m
+    1.m.kg.assert == 1.kg.m
+
+Check value equality of commensurate compound units.
+
+    1.kg.m.assert == 1000.g.m
+    1.km.s.assert == 1000.m.s
+
+    1.m.kg.assert == 1000.g.m
+    1.s.km.assert == 1000.m.s
+
+    1.s.kg.refute == 1000.g.m
+
+
+== Unit Equality
+
+Check unit equality of like units.
+
+    1.g.assert.equals? 1.g
+    1.kg.assert.equals? 1.kg
+    1.km.assert.equals? 1.km
+
+Check unit inequality of commensutate units.
+
+    1.kg.refute.equals? 1000.g
+    1.km.refute.equals? 1000.m
+
+    1000.g.refute.equals? 1.kg
+    1000.m.refute.equals? 1.km
+
+Check unit equality of commensurate prefixed units.
+
+    1000000.g.refute.equals? 1.Mg
+    0.001.g.refute.equals? 1.mg
+
+Check unit equality of compound units.
+
+    1.g.m.assert.equals? 1.g.m
+    1.kg.m.assert.equals? 1.kg.m
+
+    1.m.g.assert.equals? 1.g.m
+    1.m.kg.assert.equals? 1.kg.m
+
+
+== Identity Equality
+
+TODO: Check identity equality of like units.
+This may need fixing.
+
+    1.g.assert.eql? 1.g
+    1.kg.assert.eql? 1.kg
+    1.km.assert.eql? 1.km
+
+
+== Commensurate Equality
+
+Two measures are commensurate when their units ar the
+same or can be converted to be the same, irregardless
+of the powers of those units.
+
+    1.kg.assert.commensurate? 1.kg
+    1.kg.assert.commensurate? 1.g
+
+    1.kg.assert.commensurate? 1.kg**2
+    1.kg.assert.commensurate? 1.g**2
+
+
+== Proportional Equality
+
+Two measures are proportional when their units are
+exactly the same or can be converted to be exactly 
+the same --including their power.
+
+    1.kg.assert.proportional? 1.kg
+    1.kg.assert.proportional? 1.g
+
+    1.kg.refute.proportional? 1.kg**2
+
+Check proportional equality of commensurate prefixed units.
+
+    1000000.g.assert.proportional? 1.Mg
+    0.001.g.assert.proportional? 1.mg
+
+== Systemtic Equality
+
+Two measures are systemic when all their units
+are from the same unit system.
+
+    1.kg.assert.systemic? 1.kg
+    1.kg.assert.systemic? 1.g
+
+Check proportional equality of commensurate prefixed units.
+
+    1000000.g.assert.systemic? 1.Mg
+    0.001.g.assert.systemic? 1.mg
+
+---
+* Helper[helper.rb]
+

data/qed/operations.rdoc

@@ -0,0 +1,74 @@
+= Unit Operations
+
+Unit operations include all the typical numerical operations.
+
+  require 'stick/units/si'
+
+== Unit Power
+
+Unit power is used to create a measure of a squared, cubic
+or higher diemension units. It works just like the normal
+power method (#**) except that it leaves the measure numerical
+value unchanged.
+
+  (1.m^2).assert == 1.m * 1.m
+  (2.m^2).assert == 2.m * 1.m
+
+
+== Power
+
+  (1.m ** 2).assert == 1.m * 1.m
+  (2.m ** 2).assert == 2.m * 2.m
+
+
+== Multiplication
+
+Multiplication with scalars.
+
+  (1.m * 1).assert == 1.m
+  (1.m * 2).assert == 2.m
+  (3.m * 2).assert == 6.m
+
+Multiplication of like units.
+
+  (1.m * 1.m).assert == 1.m^2
+  (2.m * 3.m).assert == 6.m^2
+
+  (2.m * 3.m * 4.m).assert == 24.m^3
+
+  (1.N * 1.kN).assert == 1001.N
+
+Multiplication of unlike units.
+
+  (1.m * 2.g).assert == 1.m * 1.g * 2
+
+
+== Division
+
+Division with like units.
+
+  ((2.m^2) / 2.m).assert == 1.m
+
+Division with scalars.
+
+  (1.m / 1.m).assert == 1
+  (2.m / 1.m).assert == 2
+
+
+== Addition
+
+  (1.m + 1.m).assert == 2.m
+
+
+== Subtraction
+
+  (2.m - 1.m).assert == 1.m
+
+
+== Inversion
+
+  2.m.invert.assert == 0.5 * (1.m^-1)
+
+---
+
+

data/test/test_constants.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+
+class TestConstants < Test::Unit::TestCase
+
+  def test_require_constants
+    assert_nothing_raised do
+      require 'van/units/constants'
+    end
+  end
+
+end
+

data/test/test_currency.rb

@@ -0,0 +1,26 @@
+$:.unshift(File.dirname(__FILE__) + '../lib')
+
+require 'test/unit'
+require 'van/units_currency'
+
+class TestUnitsCurrency < Test::Unit::TestCase
+
+  include Van::Units
+
+  def test_typerror
+    assert_raises(TypeError) do
+      assert_equal(1.usd,  1.try.to(:usd))
+    end
+  end
+
+  def test_cex
+    e = 1.twd().unit
+    r = 1.usd(:cex).to(twd(:cex))
+    assert_equal( e, r.unit )
+  end
+
+  def test_usd_to_tws
+    assert_equal( 1.tws, 1.usd.to(tws) )
+  end
+
+end

data/test/test_units.rb

@@ -0,0 +1,205 @@
+$:.unshift(File.dirname(__FILE__) + '../lib')
+
+require 'test/unit'
+require 'van/units'
+
+class TestUnits < Test::Unit::TestCase
+
+  include Van::Units
+
+  def assert_in_unit_delta(v1, v2, d)
+    assert( v2 * (1 - d) <= v1 && v1 <= v2 * (1 + d), "<#{v1}> expected but was\n<#{v2}>" )
+  end
+
+  def test_bit_and_bytes
+    assert_equal( 65.bit/s,  1.bit/s + 8.bytes/s )
+    assert_equal( 0.125.byte/s, ((1.bit/s).to(byte/s)) )
+    # PETER : Why 0?
+    # assert_equal( 0, ((1.bit/s).to(byte/s)) )
+  end
+
+  def miles_to_feet
+    assert_equal( 5000.feet,  1.mile.to(feet) )
+  end
+
+  def test_acre_to_yards_squared
+    assert_equal( 4840.sq_yd,  1.acre.to(yd**2) )
+    # PETER : This obviously fails because yards and square yards are not the same.
+    # assert_equal( 4840.yd,  1.acre.to(yd**2) )
+  end
+
+  def test_acre_to_sq_yd
+    assert_equal( 4840.sq_yd,  1.acre.to(sq_yd) )
+  end
+
+  def test_gallon_to_liter
+    assert_in_unit_delta( 3.785411784.L, 1.gallon.to(L), 1e-15 )
+    # PETER : A gallon expressed in liters is not a liter.
+    # assert_equal( 1.L, 1.gallon.to(L) )
+  end
+
+  def test_lb_to_kg
+    assert_equal( 0.45359237.kg, 1.lb.to(kg) )
+  end
+
+  def test_m_s_to_m_s
+    assert_equal( 1.m.s, 1.m.s.to(m.s) )
+  end
+
+  def test_sq_mi_to_km_squared
+    assert_in_unit_delta( 2.589988110336.to_value(km**2), 1.sq_mi.to(km**2), 1e-15 )
+    # PETER : See comment in #test_bandwidth.
+    # assert_equal( 1.to(km**2), 1.sq_mi.to(km**2) )
+  end
+
+  def test_mile_to_km
+    assert_in_unit_delta( 1.609344.km, 1.mile.to(km), 1e-15 )
+    # PETER : These are floats, they don't compare.
+    # assert_equal( 1.609344.km, 1.mile.to(km) )
+  end
+
+  def test_with_unit_convertor_uk
+    with_unit_converter(:uk) {
+      assert_equal( 112.lb,  1.cwt.to(lb) )
+    }
+    assert_equal( 112.lb(:uk), 1.cwt(:uk).to(lb(:uk)) )
+    # PETER : That would be a very small hundredweight
+    # assert_equal( 1.lb(:uk), 1.cwt(:uk).to(lb(:uk)) )
+  end
+
+  def test_with_unit_convertor_us
+    with_unit_converter(:us) {
+      assert_equal( 100.lb,  1.cwt.to(lb) )
+    }
+    assert_equal( 100.lb(:us), 1.cwt(:us).to(lb(:us)) )
+    # PETER : That would be a very small hundredweight
+    # assert_equal( 1.lb(:us), 1.cwt(:us).to(lb(:us)) )
+  end
+
+  def test_current_lb
+    assert_equal( lb, Converter.current.lb )
+    # PETER : compares values and units again.
+    # assert_equal( 1.lb, Converter.current.lb )
+  end
+
+  def test_cwt
+    assert_equal( 1.12.cwt(:us), 1.cwt(:uk).to(cwt(:us)) )
+    assert_equal( 1.cwt(:uk), 1.12.cwt(:us).to(cwt(:uk)) )
+  end
+
+  def test_unit_convertor_cwt
+    with_unit_converter(:uk) {
+      assert_equal( 1.cwt, 1.cwt.to(cwt(:us)) )
+      assert_equal( 1.cwt(:us), 1.cwt(:us).to(cwt) )
+      # PETER : This is not correct. The conversion does
+      #   not change the magnitude of the thing, i.e.,
+      #   something that weighs a hundredweight UK style does
+      #   not weigh a hundredweight US style even when its
+      #   weight us expressed in US style hundredweights
+      #   (if that makes sense.)
+      #   Also, this converter has no effect because the
+      #   converter is specified everywhere. So it is really
+      #   the same as the above.
+      # assert_equal( 1.cwt(:us), 1.cwt(:uk).to(cwt(:us)) )
+      # assert_equal( 1.cwt(:uk), 1.cwt(:us).to(cwt(:uk)) )
+    }
+  end
+
+  #def test_registered_convertors
+  #  assert_equal( [:cex, :default, :uk, :us], Converter.registered_converters.sort )
+  #end
+
+  def test_spaceship
+    assert_nil( 1.m <=> 1.L )
+    # PETER : meter and liter are like apples and oranges.
+    #   returns nil instead.
+    # assert_equal( 0, (1.m <=> 1.L) )
+    assert_equal( 1, (1.m <=> 1.cm) )
+  end
+
+  def test_bandwidth
+    assert_equal( 1024.to_value(kB / s), ((1.MB / s).to(kB / s)) )
+    with_unit_converter(:binary_iec_base) {
+      assert_equal( 1000.to_value(kB / s), ((1.MB / s).to(kB / s)) )
+    }
+    # PETER : The #to method does conversion from one unit
+    #   to another compatible unit. Although it could make
+    #   sense to convert a unitless number to a unit
+    #   that is essentially unitless too (like kB/MB), there
+    #   are better ways to do the same, and the below still
+    #   wouldn't work because 1 is unitless and 1.kB/s is not.
+    #   I've added a to_value method for this.
+    # assert_equal( 1.to(kB / s), ((1.MB / s).to(kB / s)) )
+    # with_unit_converter(:binary_iec_base) {
+    #   assert_equal( 1.to(kB / s), ((1.MB / s).to(kB / s)) )
+    # }
+  end
+
+  def test_to_unit
+    assert_equal( m/s, "m / s".to_unit )
+    # PETER : m/s and 1 m/s are not the same thing.
+    # assert_equal( 1.to(m / s), "m / s".to_unit )
+  end
+
+  def test_to_value
+    assert_equal( 1.m/s, "1 m / s".to_value )
+    # PETER : See remark in #test_bandwidth.
+    # assert_equal( 1.to(m / s), "1 m / s".to_value )
+  end
+
+  def test_simplify
+    # PETER : Don't see how this could be zero. Don't know
+    #   exactly what you want to test though...
+    # assert_equal( 0, "1 m / cm L".to_value.simplify )
+  end
+
+  def test_float
+    assert_equal( 100.0, "1 m / cm".to_value.to_f )
+  end
+
+  def test_m_to_str_cm
+    assert_equal( 100.cm, 1.m.to("cm") )
+  end
+
+  def test_m_plus_str_cm
+    assert_equal( 105.cm, 1.m + "5cm" )
+  end
+
+  def test_plus
+    assert_equal( 1.05.m, 1.m + 5.cm )
+  end
+
+  def test
+    assert_equal( 105.m, 5.cm + 1.m )
+  end
+
+  # PETER : This compares a value (quantity + unit) to a unit. This could
+  #   be allowed by saying that the unit of meter and 1 meter is the
+  #   same, but personally I'd like to keep the distinction.
+  # def test_
+  #   assert_equal( 101.cm, cm * m )
+  # end
+
+  # def test_
+  #   assert_equal( 101.cm, cm * "m" )
+  # end
+
+  def test_value
+    assert_equal(-5.mm, "-5mm".to_value )
+    # PETER : -5mm is not the same as -5
+    # assert_equal(-5, "-5mm".to_value )
+  end
+
+  def test_value_abs
+    assert_equal(5.mm, "-5mm".to_value.abs )
+    # PETER : 5mm is not the same as 5
+    # assert_equal(5, "-5mm".to_value.abs )
+  end
+
+  def test_infinite?
+    # PETER : I'm not sure what the point of this is, but in
+    #   any case, a Value does not have an infinite? method
+    # assert_equal( false, ("5.0mm".to_value / 1).infinite? )
+  end
+
+end