eymiha_units 0.1.0

data/test/tc_formatting_derived.rb

@@ -0,0 +1,73 @@
+require 'test/unit'
+require 'test/framework'
+
+require 'units'
+
+class TC_formatting_derived < Test::Unit::TestCase
+  
+  understands UnitsTest
+
+  def test_formatting_derived
+
+    Units.create :length do |m|
+      m.system :metric do |s|
+        s.unit :name => :meter, :abbrev => :m, :greek => :ten
+      end
+    end
+    Units.derive :volume, Units.length**3 do |m|
+      m.system :metric do |s|
+        s.unit :name => :milliliter, :abbrev => :ml, :equals => 1.cm**3
+      end
+    end
+    Units.create :time do |m|
+      m.system :base do |s|
+        s.unit :name => :second, :abbrev => :s
+      end
+    end
+
+    assert((225.ml/5.cm) =~ (45.0.cm^2))
+
+    a = 225.ml
+    assert(a.to_s == "225 milliliters")
+
+    b = 5.cm
+    c = 15.cm^3
+    assert((a/b).to_s == "45.0 cm^2")
+    assert((b/a).to_s == "222.222222222222 1/m^2")
+    assert((a*b).to_s == "1125.0 cm^4")
+    ba = (b*a).to_s
+    assert((ba == "1.125e-05 m^4")||(ba == "1.125e-005 m^4"))
+    assert((a+c).to_s == "240.0 cm^3")
+    assert((c+a).to_s == "0.00024 m^3")
+    assert((a-c).to_s == "210.0 cm^3")
+    assert((c-a).to_s == "-0.00021 m^3")
+
+    assert(c.in_ml.to_s == "15.0 milliliters")
+
+    c = 15.cm^7
+    assert(c.ml.to_s == "15.0 cm ml^2")
+    NumericWithUnits.derived_align_type = :fractional_powers
+    assert(c.ml.to_s == "15.0 ml^2.33333333333333")
+
+    d = 15.ml^(7.0/3)
+    assert(d =~ c)
+    assert(c =~ d)
+    assert(c.ml =~ d)
+    assert(d.cm =~ c)
+
+    assert(c.in_ml =~ 15.ml^(7.0/3))
+    d = c.to_ml
+    assert(d.to_s == "15.0 ml^2.33333333333333")
+
+    NumericWithUnits.derived_align_type = :whole_powers
+    assert((225.ml/5.cm).to_s == '45.0 cm^2')
+    assert((225.ml/5.cm).in_ml.to_s == '45.0 ml / cm')
+
+    assert((225.ml/5.cm).align([1.cm^2]).to_s == '45.0 cm^2')
+    assert((225.ml/5.cm).align([1.ml,1/cm]).to_s == '45.0 ml / cm')
+    assert((225.ml/5.cm).align([1.m^2]).to_s == '0.0045 m^2')
+    assert((225.ml/5.cm).align([1.ml,1/m]).to_s == '4500.0 ml / m')
+
+  end
+
+end

data/test/tc_measure_create.rb

@@ -0,0 +1,59 @@
+require 'test/unit'
+require 'test/framework'
+
+require 'units'
+
+class TC_measure_create < Test::Unit::TestCase
+  
+  understands UnitsTest
+
+  def test_measure_create
+    
+    assert(Units.units_measures == [])
+    
+    assert(Units.create(:length).kind_of?(UnitsMeasure))
+    assert(Units.length.kind_of?(UnitsMeasure))    
+    assert_raise(UnitsException) { Units.time }
+    assert(Units.units_measures.index('length') != nil)
+    assert(Units.units_measures.index('time') == nil)
+    assert(Units.units_measures.index('distance') == nil)
+    
+    assert(Units.create('time').kind_of?(UnitsMeasure))
+    assert(Units.size == 2)
+    assert(Units.time.kind_of?(UnitsMeasure))
+    assert(Units.units_measures.index('length') != nil)
+    assert(Units.units_measures.index('time') != nil)
+    assert(Units.units_measures.index('distance') == nil)
+    
+    assert(Units.derive(:distance, 'length').kind_of?(UnitsMeasure))
+    assert(Units.size == 3)
+    assert(Units.distance.kind_of?(UnitsMeasure))
+    assert(Units.length == Units.distance)
+    assert(Units.units_measures.index('length') != nil)
+    assert(Units.units_measures.index('time') != nil)
+    assert(Units.units_measures.index('distance') != nil)
+
+    assert(Units.delete(:time).kind_of?(UnitsMeasure))
+    assert(Units.delete('time') == nil)
+    assert(Units.delete('length').kind_of?(UnitsMeasure))
+    assert(Units.delete(:length) == nil)
+    assert(Units.size == 1)
+    assert_raise(UnitsException) { Units.time }
+    assert_raise(UnitsException) { Units.length }
+    assert(Units.units_measures.index('length') == nil)
+    assert(Units.units_measures.index('time') == nil)
+    assert(Units.units_measures.index('distance') != nil)
+    
+    assert(Units.clear == Units)
+    assert(Units.size == 0)
+    assert_raise(UnitsException) { Units.time }
+    assert_raise(UnitsException) { Units.length }
+    assert_raise(UnitsException) { Units.distance }
+    assert(Units.units_measures.index('length') == nil)
+    assert(Units.units_measures.index('time') == nil)
+    assert(Units.units_measures.index('distance') == nil)
+    assert(Units.units_measures == [])
+    
+  end
+
+end

data/test/tc_measure_derive.rb

@@ -0,0 +1,46 @@
+require 'test/unit'
+require 'test/framework'
+
+require 'units'
+
+class TC_measure_derive < Test::Unit::TestCase
+
+  understands UnitsTest
+  
+  def test_measure_derive
+    
+    assert((length = Units.create :length) == Units.length)
+    assert(length.derived == nil)
+    
+    assert((distance = Units.derive 'distance', length) == Units.length)
+    assert(distance.derived == nil)
+    
+    assert((area = Units.derive 'area', length**2) == Units.area)
+    assert(area.derived.size == 1)
+    assert(area.derived[Units.length] == 2)
+    
+    assert((volume = Units.derive 'volume', area*length) == Units.volume)
+    assert(volume.derived.size == 1)
+    assert(volume.derived[Units.length] == 3)
+    
+    assert((time = Units.create 'time') == Units.time)
+    assert(time.derived == nil)
+    
+    assert((velocity = Units.derive :velocity, distance/time) ==
+             Units.velocity)
+    assert(velocity.derived.size == 2)
+    assert(velocity.derived[Units.distance] == 1)
+    assert(velocity.derived[Units.time] == -1)
+    
+    assert((acceleration = Units.derive :acceleration, distance/time**2) ==
+             Units.acceleration)
+    assert(acceleration.derived.size == 2)
+    assert(acceleration.derived[Units.distance] == 1)
+    assert(acceleration.derived[Units.time] == -2)
+    
+    assert(acceleration == Units.derive(:acceleration2, distance/time**2))
+    assert(Units.acceleration2 == Units.acceleration)
+    
+  end
+
+end

data/test/tc_system_create.rb

@@ -0,0 +1,31 @@
+require 'test/unit'
+require 'test/framework'
+
+require 'units'
+
+class TC_system_create < Test::Unit::TestCase
+  
+  understands UnitsTest
+
+  def test_system_create
+    
+    Units.create :length do |m|
+      m.system 'english'
+      m.system 'metric'
+    end
+    
+    english = Units.length.english
+    metric = Units.length.metric
+    assert(english.kind_of?(UnitsSystem))
+    assert(metric.kind_of?(UnitsSystem))
+    assert(english.name == 'english')
+    assert(metric.name == 'metric')
+    assert(english.units_measure == Units.length)
+    assert(metric.units_measure == Units.length)
+    assert(Units.length.keys.index('english') != nil)
+    assert(Units.length.keys.index('metric') != nil)
+    assert(Units.length.keys.index('foo') == nil)
+    
+  end
+  
+end

data/test/tc_unit_ambiguity.rb

@@ -0,0 +1,46 @@
+require 'test/unit'
+require 'test/framework'
+
+require 'units'
+
+class TC_unit_ambiguity < Test::Unit::TestCase
+  
+  understands UnitsTest
+
+  def test_unit_ambiguity
+    
+    Units.create :volume do |m|
+      m.system :english do |s|
+        s.unit :name => :ounce, :abbrev => :oz
+      end
+    end
+    volume_ounce = Units.volume.english.ounce
+    Units.create :mass do |m|
+      m.system :english do |s|
+        s.unit :name => :ounce, :abbrev => :oz
+      end
+    end
+    mass_ounce = Units.mass.english.ounce
+    
+    assert(volume_ounce.equals.unit == {volume_ounce => 1})
+    assert(mass_ounce.equals.unit == {mass_ounce => 1})
+    
+    Units.create :volume do |m|
+      m.system :english do |s|
+        s.unit :name => :cup, :abbrev => :c, :equals => 16.ounces
+      end
+    end
+    cup = Units.volume.english.cup
+    assert(cup.equals.unit == {volume_ounce => 1})
+
+    Units.create :mass do |m|
+      m.system :english do |s|
+        s.unit :name => :pound, :abbrev => :lb, :equals => 16.ounces
+      end
+    end
+    pound = Units.mass.english.pound
+    assert(pound.equals.unit == {mass_ounce => 1})
+    
+  end
+
+end

data/test/tc_unit_arithmetic.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+require 'test/framework'
+require 'units'
+
+class TC_unit_arithmetic < Test::Unit::TestCase
+  
+  understands UnitsTest
+
+  def test_unit_arithmetic
+
+    Units.create :length do |m|
+      m.system :english do |s|
+        s.unit :name => :inch,
+               :plural => :inches,
+               :abbrev => :in
+      end
+    end
+    
+    inch = Units.length.english.inch.equals
+    assert(inch.to_s == "1 inch")
+    assert(inch == 1.inch)
+    
+    yard = inch*36
+    assert(yard.to_s == "36 inches")
+    assert(yard == 36.in)
+
+    foot = yard/3
+    assert(foot.to_s == "12 inches")
+    assert(foot == 12.in)
+    
+    half_foot = foot-6
+    assert(half_foot.to_s == "6 inches")
+    assert(half_foot == 6.in)
+    
+    yard_and_a_half = yard+18
+    assert(yard_and_a_half.to_s == "54 inches")
+    assert(yard_and_a_half == 54.in)
+
+  end
+    
+end

data/test/tc_unit_create.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+require 'test/framework'
+
+require 'units'
+
+class TC_unit_create < Test::Unit::TestCase
+
+  understands UnitsTest
+  
+  def test_unit_create
+    
+    Units.create :length do |m|
+      m.system 'english' do |s|
+        s.unit :name => 'inch'
+        s.unit :name => 'foot'
+      end
+    end
+    
+    inch = Units.length.english.inch
+    foot = Units.length.english.foot
+    assert(inch.kind_of?(UnitsUnit))
+    assert(foot.kind_of?(UnitsUnit))
+    assert(inch.name == 'inch')
+    assert(foot.name == 'foot')
+    assert(inch.units_system == Units.length.english)
+    assert(foot.units_system == Units.length.english)
+    assert(inch.units_system.units_measure == Units.length)
+    assert(foot.units_system.units_measure == Units.length)
+    assert(Units.length.english.keys.index('inch') != nil)
+    assert(Units.length.english.keys.index('foot') != nil)
+    assert(Units.length.english.keys.index('foo') == nil)
+    
+  end
+  
+end

data/test/tc_unit_derive.rb

@@ -0,0 +1,87 @@
+require 'test/unit'
+require 'test/framework'
+
+require 'units'
+
+class TC_unit_derive < Test::Unit::TestCase
+
+  understands UnitsTest
+
+  def test_unit_derived
+
+    length =
+      Units.create :length do |m|
+        m.system :metric do |s|
+          s.unit :name => :meter,
+                 :abbrev => :m,
+                 :greek => :ten
+        end
+        m.system :english do |s|
+          s.unit :name => :inch,
+                 :plural => :inches,
+                 :abbrev => :in
+          s.unit :name => :foot,
+                 :plural => :feet,
+                 :abbrev => :ft,
+                 :equals => 12.inches
+          s.unit :name => :yard,
+                 :abbrev => :yd,
+                 :equals => 3.feet
+        end
+      end
+    
+    centimeter = length.metric.centimeter
+    inch = length.english.inch
+    foot = length.english.foot
+    yard = length.english.yard
+
+    volume =
+      Units.derive :volume, length**3 do |m|
+        m.system :metric do |s|
+          s.unit :name => :milliliter,
+                 :abbrev => :mL,
+                 :equals => 1.cm**3
+        end
+      end
+    
+    assert(volume.derived.size == 1)
+    assert(volume.derived[length] == 3)
+    milliliter = volume.metric.milliliter
+
+    mass = 
+      Units.create :mass do |m|
+        m.system :metric do |s|
+          s.unit :name => :gram,
+                 :abbrev => :g,
+                 :greek => :ten
+        end
+      end
+
+    gram = mass.metric.gram
+
+    density =
+      Units.derive :density, mass/volume do |m|
+        m.system :base do |s|
+          s.unit :name => :foo,
+                 :equals => 1.g/1.mL
+        end
+      end
+    
+    assert(density.derived.size == 2)
+    assert(density.derived[length] == -3)
+    assert(density.derived[mass] == 1)
+    
+    area =
+      Units.derive :area, length**2 do |m|
+        m.system :english do |s|
+          s.unit :name => :acre,
+                 :equals => 220.yards * 66.feet
+        end
+      end
+    
+    assert(area.derived.size == 1)
+    assert(area.derived[length] == 2)
+    
+  end
+    
+end

data/test/tc_unit_equality.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+require 'test/framework'
+
+require 'units'
+
+class TC_unit_equality < Test::Unit::TestCase
+  
+  understands UnitsTest
+
+  def test_unit_equality
+
+    Units.create :length do |m|
+      m.system :english do |s|
+        s.unit :name => :inch,
+               :plural => :inches,
+               :abbrev => :in
+        s.unit :name => :foot,
+               :plural => :feet,
+               :abbrev => [ :ft ],
+               :equals => 12.inches
+        s.unit :name => :yard,
+               :abbrevs => :yd,
+               :equals => 3.feet
+      end
+    end
+    
+    inch = Units.length.english.inch
+    foot = Units.length.english.foot
+    yard = Units.length.english.yard
+
+    assert(inch.equals.numeric == 1)
+    assert(inch.equals.unit == {inch => 1})
+    assert(foot.equals.numeric == 12)
+    assert(foot.equals.unit == {inch => 1})
+    assert(yard.equals.numeric == 36)
+    assert(yard.equals.unit == {inch => 1})
+
+    assert(inch.equals.to_s == "1 inch")
+    assert(foot.equals.to_s == "12 inches")
+    assert(yard.equals.to_s == "36 inches")
+
+    a = 12.feet
+    assert(a.numeric == 12)
+    assert(a.unit == {foot => 1})
+    assert(a.to_s == "12 feet")
+
+    b = (2.0.ft^2)**0.5
+    c = 1.4142135623.ft
+    assert(b != c)
+    assert(b =~ c)
+
+  end
+    
+end

data/test/tc_unit_forward_reference.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+require 'test/framework'
+
+require 'units'
+
+class TC_unit_forward_reference < Test::Unit::TestCase
+
+  understands UnitsTest
+  
+  def test_unit_forward_reference
+
+    Units.create :length do |m|
+      m.system :english do |s|
+        s.unit :name => :yard,
+               :abbrevs => :yd,
+               :equals => 3.feet
+        s.unit :name => :foot,
+               :plural => :feet,
+               :abbrev => [ :ft ],
+               :equals => 12.inches
+        s.unit :name => :inch,
+               :plural => :inches,
+               :abbrev => :in
+      end
+    end
+    
+    inch = Units.length.english.inch
+    foot = Units.length.english.foot
+    yard = Units.length.english.yard
+
+    assert(inch.equals.numeric == 1)
+    assert(inch.equals.unit == {inch => 1})
+    assert(foot.equals.numeric == 12)
+    assert(foot.equals.unit == {inch => 1})
+    assert(yard.equals.numeric == 36)
+    assert(yard.equals.unit == {inch => 1})
+
+    assert(inch.equals.to_s == "1 inch")
+    assert(foot.equals.to_s == "12 inches")
+    assert(yard.equals.to_s == "36 inches")
+
+  end
+    
+end

data/test/tc_unit_greek.rb

@@ -0,0 +1,163 @@
+require 'test/unit'
+require 'test/framework'
+
+require 'units'
+
+# note that different rubys apparently have different minimum exponent digits
+
+class TC_unit_greek < Test::Unit::TestCase
+  
+  understands UnitsTest
+
+  def test_unit_greek
+
+    Units.create :length do |m|
+      m.system :metric do |s|
+        s.unit :name => :meter,
+               :abbrev => :m,
+               :greek => :ten
+      end
+    end
+    
+    yoctometer = Units.length.metric.yoctometer.equals
+    assert((yoctometer.to_s == "1.0e-24 meters")||
+           (yoctometer.to_s == "1.0e-024 meters"))
+    assert(yoctometer == 0.000000000000000000000001.meters)
+
+    zeptometer = Units.length.metric.zeptometer.equals
+    assert((zeptometer.to_s == "1.0e-21 meters")||
+           (zeptometer.to_s == "1.0e-021 meters"))
+    assert(zeptometer == 0.000000000000000000001.meters)
+    
+    attometer = Units.length.metric.attometer.equals
+    assert((attometer.to_s == "1.0e-18 meters")||
+           (attometer.to_s == "1.0e-018 meters"))
+    assert(attometer == 0.000000000000000001.meters)
+    
+    femtometer = Units.length.metric.femtometer.equals
+    assert((femtometer.to_s == "1.0e-15 meters")||
+           (femtometer.to_s == "1.0e-015 meters"))
+    assert(femtometer == 0.000000000000001.meters)
+    
+    picometer = Units.length.metric.picometer.equals
+    assert((picometer.to_s == "1.0e-12 meters")||
+           (picometer.to_s == "1.0e-012 meters"))
+    assert(picometer == 0.000000000001.meters)
+    
+    nanometer = Units.length.metric.nanometer.equals
+    assert((nanometer.to_s == "1.0e-09 meters")||
+           (nanometer.to_s == "1.0e-009 meters"))
+    assert(nanometer == 0.000000001.meters)
+    
+    micrometer = Units.length.metric.micrometer.equals
+    assert((micrometer.to_s == "1.0e-06 meters")||
+           (micrometer.to_s == "1.0e-006 meters"))
+    assert(micrometer == 0.000001.meters)
+    
+    millimeter = Units.length.metric.millimeter.equals
+    assert(millimeter.to_s == "0.001 meters")
+    assert(millimeter == 0.001.meters)
+    
+    centimeter = Units.length.metric.centimeter.equals
+    assert(centimeter.to_s == "0.01 meters")
+    assert(centimeter == 0.01.meters)
+    
+    decimeter = Units.length.metric.decimeter.equals
+    assert(decimeter.to_s == "0.1 meters")
+    assert(decimeter == 0.1.meters)
+    
+    meter = Units.length.metric.meter.equals
+    assert(meter.to_s == "1 meter")
+    assert(meter == 1.meter)
+    
+    decameter = Units.length.metric.decameter.equals
+    assert(decameter.to_s == "10.0 meters")
+    assert(decameter == 10.meters)
+    
+    hectometer = Units.length.metric.hectometer.equals
+    assert(hectometer.to_s == "100.0 meters")
+    assert(hectometer == 100.meters)
+    
+    kilometer = Units.length.metric.kilometer.equals
+    assert(kilometer.to_s == "1000.0 meters")
+    assert(kilometer == 1000.meters)
+    
+    megameter = Units.length.metric.megameter.equals
+    assert(megameter.to_s == "1000000.0 meters")
+    assert(megameter == 1000000.meters)
+    
+    gigameter = Units.length.metric.gigameter.equals
+    assert(gigameter.to_s == "1000000000.0 meters")
+    assert(gigameter == 1000000000.meters)
+    
+    terameter = Units.length.metric.terameter.equals
+    assert(terameter.to_s == "1000000000000.0 meters")
+    assert(terameter == 1000000000000.meters)
+    
+    petameter = Units.length.metric.petameter.equals
+    assert((petameter.to_s == "1.0e+15 meters")||
+           (petameter.to_s == "1.0e+015 meters"))
+    assert(petameter == 1000000000000000.meters)
+    
+    exameter = Units.length.metric.exameter.equals
+    assert((exameter.to_s == "1.0e+18 meters")||
+           (exameter.to_s == "1.0e+018 meters"))
+    assert(exameter == 1000000000000000000.meters)
+    
+    zettameter = Units.length.metric.zettameter.equals
+    assert((zettameter.to_s == "1.0e+21 meters")||
+           (zettameter.to_s == "1.0e+021 meters"))
+    assert(zettameter == 1000000000000000000000.meters)
+    
+    yottameter = Units.length.metric.yottameter.equals
+    assert((yottameter.to_s == "1.0e+24 meters")||
+           (yottameter.to_s == "1.0e+024 meters"))
+    assert(yottameter == 1000000000000000000000000.meters)
+    
+    Units.create :storage do |m|
+      m.system :base do |s|
+        s.unit :name => :byte,
+               :abbrev => :b,
+               :greek => :two
+      end
+    end
+    
+    byte = Units.storage.base.byte.equals
+    assert(byte.to_s == "1 byte")
+    assert(byte == 1.byte)
+
+    kilobyte = Units.storage.base.kilobyte.equals
+    assert(kilobyte.to_s == "1024 bytes")
+    assert(kilobyte == 1024.bytes)
+
+    megabyte = Units.storage.base.megabyte.equals
+    assert(megabyte.to_s == "1048576 bytes")
+    assert(megabyte == 1048576.bytes)
+
+    gigabyte = Units.storage.base.gigabyte.equals
+    assert(gigabyte.to_s == "1073741824 bytes")
+    assert(gigabyte == 1073741824.bytes)
+
+    terabyte = Units.storage.base.terabyte.equals
+    assert(terabyte.to_s == "1099511627776 bytes")
+    assert(terabyte == 1099511627776.bytes)
+
+    petabyte = Units.storage.base.petabyte.equals
+    assert(petabyte.to_s == "1125899906842624 bytes")
+    assert(petabyte == 1125899906842624.bytes)
+
+    exabyte = Units.storage.base.exabyte.equals
+    assert(exabyte.to_s == "1152921504606846976 bytes")
+    assert(exabyte == 1152921504606846976.byte)
+
+    zettabyte = Units.storage.base.zettabyte.equals
+    assert(zettabyte.to_s == "1180591620717411303424 bytes")
+    assert(zettabyte == 1180591620717411303424.bytes)
+
+    yottabyte = Units.storage.base.yottabyte.equals
+    assert(yottabyte.to_s == "1208925819614629174706176 bytes")
+    assert(yottabyte == 1208925819614629174706176.bytes)
+
+  end
+    
+end