ruby-units-brewpoo 1.3.0

data/lib/ruby_units/string.rb

@@ -0,0 +1,118 @@
+require 'time'
+# make a string into a unit
+class String
+  def to_unit(other = nil)
+    other ? Unit.new(self).to(other) : Unit.new(self)
+  end
+  alias :unit :to_unit
+  alias :u :to_unit
+  alias :unit_format :%
+  
+  # format unit output using formating codes '%0.2f' % '1 mm'.unit => '1.00 mm'
+  def %(*args)
+		return if self.empty?
+    case 
+    when Unit === args[0]
+      args[0].to_s(self)
+    when (!defined?(Uncertain).nil? && (Uncertain === args[0]))
+      args[0].to_s(self)
+    when Complex === args[0]
+      args[0].to_s
+    else
+      unit_format(*args)
+    end
+  end
+  
+  #needed for compatibility with Rails, which defines a String.from method  
+  if self.public_instance_methods.include? 'from'
+    alias :old_from :from
+  end 
+  
+  def from(time_point = ::Time.now)
+    return old_from(time_point) if Integer === time_point
+    self.unit.from(time_point)
+  end
+  
+  alias :after :from
+  alias :from_now :from
+  
+  def ago
+    self.unit.ago
+  end
+  
+  def before(time_point = ::Time.now)
+    self.unit.before(time_point)
+  end
+  alias :before_now :before
+  
+  def since(time_point = ::Time.now)
+    self.unit.since(time_point)
+  end
+  
+  def until(time_point = ::Time.now)
+    self.unit.until(time_point)
+  end
+  
+  def to(other)
+    self.unit.to(other)
+  end
+  
+  def time(options = {})
+    self.to_time(options) rescue self.to_datetime(options)
+  end
+  
+  def to_time(options = {})
+    begin
+      #raises exception when Chronic not defined or when it returns a nil (i.e., can't parse the input)
+      r = Chronic.parse(self,options)
+      raise(ArgumentError, 'Invalid Time String') unless r
+      return r
+    rescue
+      case
+      when self == "now"
+        Time.now
+      when Time.respond_to?(:parse)
+        Time.parse(self)
+      else
+        Time.local(*ParseDate.parsedate(self))
+      end
+    end
+  end
+  
+  def to_datetime(options = {})
+    begin
+      # raises an exception if Chronic.parse = nil or if Chronic not defined
+      r = Chronic.parse(self,options).send(:to_datetime)
+    rescue Exception  => e
+      r = case
+      when self.to_s == "now"
+        DateTime.now
+      else
+        DateTime.parse(self)
+      end
+    end
+    raise RuntimeError, "Invalid Time String (#{self.to_s})" if r == DateTime.new      
+    return r
+  end
+  
+  def to_date(options={})
+    begin
+      r = Chronic.parse(self,options).to_date
+    rescue
+      r = case
+      when self == "today" 
+        Date.today
+      when RUBY_VERSION < "1.9"
+        Date.civil(*ParseDate.parsedate(self)[0..5].compact)
+      else
+        Date.parse(self)
+      end
+    end
+    raise RuntimeError, 'Invalid Date String' if r == Date.new
+    return r
+  end
+
+  def datetime(options = {})
+    self.to_datetime(options) rescue self.to_time(options)
+  end
+end

data/lib/ruby_units/time.rb

@@ -0,0 +1,73 @@
+#
+# Time math is handled slightly differently.  The difference is considered to be an exact duration if
+# the subtracted value is in hours, minutes, or seconds.  It is rounded to the nearest day if the offset
+# is in years, decades, or centuries.  This leads to less precise values, but ones that match the 
+# calendar better.
+class Time
+  
+  class << self
+    alias unit_time_at at
+  end
+  
+  def self.at(*args)
+    if Unit === args[0]
+      unit_time_at(args[0].to("s").scalar)
+    else
+      unit_time_at(*args)
+    end
+  end
+  
+  def to_unit(other = nil)
+    other ? Unit.new(self).to(other) : Unit.new(self)
+  end
+  alias :unit :to_unit
+  alias :u :to_unit
+  alias :unit_add :+
+  
+  unless Time.instance_methods.include?(:to_date)
+    def to_date
+      x=(Date.civil(1970,1,1)+((self.to_f+self.gmt_offset)/86400.0)-0.5)
+      Date.civil(x.year, x.month, x.day)
+    end
+  end
+  
+  def +(other)
+    case other
+    when Unit
+      other = other.to('d').round.to('s') if ['y', 'decade', 'century'].include? other.units  
+      begin
+        unit_add(other.to('s').scalar)
+      rescue RangeError
+        self.to_datetime + other
+      end
+    when DateTime
+      unit_add(other.to_time)
+    else
+      unit_add(other)
+    end
+  end
+  
+  # usage: Time.in '5 min'
+  def self.in(duration)
+    Time.now + duration.to_unit
+  end
+  
+  alias :unit_sub :-
+  
+  def -(other)
+    case other
+    when Unit
+      other = other.to('d').round.to('s') if ['y', 'decade', 'century'].include? other.units  
+      begin
+        unit_sub(other.to('s').scalar)
+      rescue RangeError
+        self.send(:to_datetime) - other
+      end
+      
+    when DateTime
+      unit_sub(other.to_time)
+    else
+      unit_sub(other)
+    end
+  end
+end

data/lib/ruby_units/units.rb

@@ -0,0 +1,252 @@
+
+
+class Unit < Numeric
+UNIT_DEFINITIONS = { 
+  # prefixes
+  '<googol>' => [%w{googol}, 1e100, :prefix],
+  '<kibi>'  =>  [%w{Ki Kibi kibi}, 2**10, :prefix],
+  '<mebi>'  =>  [%w{Mi Mebi mebi}, 2**20, :prefix],
+  '<gibi>'  =>  [%w{Gi Gibi gibi}, 2**30, :prefix],
+  '<tebi>'  =>  [%w{Ti Tebi tebi}, 2**40, :prefix],
+  '<pebi>'  =>  [%w{Pi Pebi pebi}, 2**50, :prefix],
+  '<exi>'   =>  [%w{Ei Exi exi}, 2**60, :prefix],
+  '<zebi>'  =>  [%w{Zi Zebi zebi}, 2**70, :prefix],
+  '<yebi>'  =>  [%w{Yi Yebi yebi}, 2**80, :prefix],
+  '<yotta>' =>  [%w{Y Yotta yotta}, 1e24, :prefix],
+  '<zetta>' =>  [%w{Z Zetta zetta}, 1e21, :prefix],
+  '<exa>'   =>  [%w{E Exa exa}, 1e18, :prefix],
+  '<peta>'  =>  [%w{P Peta peta}, 1e15, :prefix],
+  '<tera>'  =>  [%w{T Tera tera}, 1e12, :prefix],
+  '<giga>'  =>  [%w{G Giga giga}, 1e9, :prefix],
+  '<mega>'  =>  [%w{M Mega mega}, 1e6, :prefix],
+  '<kilo>'  =>  [%w{k kilo}, 1e3, :prefix],
+  '<hecto>' =>  [%w{h Hecto hecto}, 1e2, :prefix],
+  '<deca>'  =>  [%w{da Deca deca deka}, 1e1, :prefix],
+  '<deci>'  =>  [%w{d Deci deci}, 1e-1, :prefix],
+  '<centi>'  => [%w{c Centi centi}, 1e-2, :prefix],
+  '<milli>' =>  [%w{m Milli milli}, 1e-3, :prefix],
+  '<micro>'  => [%w{u Micro micro}, 1e-6, :prefix],
+  '<nano>'  =>  [%w{n Nano nano}, 1e-9, :prefix],
+  '<pico>'  =>  [%w{p Pico pico}, 1e-12, :prefix],
+  '<femto>' =>  [%w{f Femto femto}, 1e-15, :prefix],
+  '<atto>'  =>  [%w{a Atto atto}, 1e-18, :prefix],
+  '<zepto>' =>  [%w{z Zepto zepto}, 1e-21, :prefix],
+  '<yocto>' =>  [%w{y Yocto yocto}, 1e-24, :prefix],
+  '<1>'     =>  [%w{1},1,:prefix],
+
+  # length units
+  '<meter>' =>  [%w{m meter meters metre metres}, 1.0, :length, %w{<meter>} ],
+  '<inch>'  =>  [%w{in inch inches "}, 0.0254, :length, %w{<meter>}],
+  '<foot>'  =>  [%w{ft foot feet '}, 0.3048, :length, %w{<meter>}],
+  '<yard>'  =>  [%w{yd yard yards}, 0.9144, :length, %w{<meter>}],
+  '<mile>'  =>  [%w{mi mile miles}, 1609.344, :length, %w{<meter>}],
+  '<naut-mile>' => [%w{nmi}, 1852, :length, %w{<meter>}],
+  '<league>'=>  [%w{league leagues}, 4828, :length, %w{<meter>}],
+  '<furlong>'=> [%w{furlong furlongs}, 201.2, :length, %w{<meter>}],
+  '<rod>'   =>  [%w{rd rod rods}, 5.029, :length, %w{<meter>}],
+  '<mil>'   =>  [%w{mil mils}, 0.0000254, :length, %w{<meter>}],
+  '<angstrom>'  =>[%w{ang angstrom angstroms}, 1e-10, :length, %w{<meter>}],
+  '<fathom>' => [%w{fathom fathoms}, 1.829, :length, %w{<meter>}],  
+  '<pica>'  => [%w{pica picas}, 0.004217, :length, %w{<meter>}],
+  '<point>' => [%w{pt point points}, 0.0003514, :length, %w{<meter>}],
+  '<redshift>' => [%w{z red-shift}, 1.302773e26, :length, %w{<meter>}],
+  '<AU>'    => [%w{AU astronomical-unit}, 149597900000, :length, %w{<meter>}],
+  '<light-second>'=>[%w{ls light-second}, 299792500, :length, %w{<meter>}],
+  '<light-minute>'=>[%w{lmin light-minute}, 17987550000, :length, %w{<meter>}],
+  '<light-year>' => [%w{ly light-year}, 9460528000000000, :length, %w{<meter>}],
+  '<parsec>'  => [%w{pc parsec parsecs}, 30856780000000000, :length, %w{<meter>}],
+
+  #mass
+  '<kilogram>' => [%w{kg kilogram kilograms}, 1.0, :mass, %w{<kilogram>}],
+  '<AMU>' => [%w{u AMU amu}, 6.0221415e26, :mass, %w{<kilogram>}],
+  '<dalton>' => [%w{Da Dalton Daltons dalton daltons}, 6.0221415e26, :mass, %w{<kilogram>}],
+  '<slug>' => [%w{slug slugs}, 14.5939029, :mass, %w{<kilogram>}],
+  '<short-ton>' => [%w{tn ton}, 907.18474, :mass, %w{<kilogram>}],
+  '<metric-ton>'=>[%w{tonne}, 1000, :mass, %w{<kilogram>}],
+  '<carat>' => [%w{ct carat carats}, 0.0002, :mass, %w{<kilogram>}],
+  '<pound>' => [%w{lbs lb pound pounds #}, 0.45359237, :mass, %w{<kilogram>}],
+  '<ounce>' => [%w{oz ounce ounces}, 0.0283495231, :mass, %w{<kilogram>}],
+  '<gram>'    =>  [%w{g gram grams gramme grammes},1e-3,:mass, %w{<kilogram>}],
+
+  #area
+  '<hectare>'=>[%w{hectare}, 10000, :area, %w{<meter> <meter>}],
+  '<acre>'=>[%w(acre acres), 4046.85642, :area, %w{<meter> <meter>}],
+  '<sqft>'=>[%w(sqft), 1, :area, %w{<feet> <feet>}],
+
+  #volume
+  '<liter>' => [%w{l L liter liters litre litres}, 0.001, :volume, %w{<meter> <meter> <meter>}],
+  '<barrel>' => [%w{bbl bbls barrel barrels}, 0.00852167911, :volume, %w{<meter> <meter> <meter>}],
+  '<keg>' => [%w{keg kegs}, 0.0170433582, :volume, %w{<meter> <meter> <meter>}],
+  '<gallon>'=>  [%w{gal gallon gallons}, 0.0037854118, :volume, %w{<meter> <meter> <meter>}],
+  '<quart>'=>  [%w{qt quart quarts}, 0.00094635295, :volume, %w{<meter> <meter> <meter>}],
+  '<pint>'=>  [%w{pt pint pints}, 0.000473176475, :volume, %w{<meter> <meter> <meter>}],
+  '<cup>'=>  [%w{cu cup cups}, 0.000236588238, :volume, %w{<meter> <meter> <meter>}],
+  '<fluid-ounce>'=>  [%w{floz fluid-ounce}, 2.95735297e-5, :volume, %w{<meter> <meter> <meter>}],
+  '<tablespoon>'=>  [%w{tbs tablespoon tablespoons}, 1.47867648e-5, :volume, %w{<meter> <meter> <meter>}],
+  '<teaspoon>'=>  [%w{tsp teaspoon teaspoons}, 4.92892161e-6, :volume, %w{<meter> <meter> <meter>}],
+
+  #speed
+  '<kph>' => [%w{kph}, 0.277777778, :speed, %w{<meter>}, %w{<second>}],
+  '<mph>' => [%w{mph}, 0.44704, :speed, %w{<meter>}, %w{<second>}],
+  '<knot>' => [%w{kt kn kts knot knots}, 0.514444444, :speed, %w{<meter>}, %w{<second>}],
+  '<fps>'  => [%w{fps}, 0.3048, :speed, %w{<meter>}, %w{<second>}],
+  
+  #acceleration
+  '<gee>' => [%w{gee}, 9.80655, :acceleration, %w{<meter>}, %w{<second> <second>}],
+
+  #temperature_difference
+  '<kelvin>' => [%w{degK kelvin}, 1.0, :temperature, %w{<kelvin>}],
+  '<celsius>' => [%w{degC celsius celsius centigrade}, 1.0, :temperature, %w{<kelvin>}],
+  '<fahrenheit>' => [%w{degF fahrenheit}, 1/1.8, :temperature, %w{<kelvin>}],
+  '<rankine>' => [%w{degR rankine}, 1/1.8, :temperature, %w{<kelvin>}],
+  '<temp-K>'  => [%w{tempK}, 1.0, :temperature, %w{<temp-K>}],
+  '<temp-C>'  => [%w{tempC}, 1.0, :temperature, %w{<temp-K>}],
+  '<temp-F>'  => [%w{tempF}, 1/1.8, :temperature, %w{<temp-K>}],
+  '<temp-R>'  => [%w{tempR}, 1/1.8, :temperature, %w{<temp-K>}],
+  
+  #time
+  '<second>'=>  [%w{s sec second seconds}, 1.0, :time, %w{<second>}],
+  '<minute>'=>  [%w{min minute minutes}, 60.0, :time, %w{<second>}],  
+  '<hour>'=>  [%w{h hr hrs hour hours}, 3600.0, :time, %w{<second>}],  
+  '<day>'=>  [%w{d day days}, 3600*24, :time, %w{<second>}],
+  '<week>'=>  [%w{wk week weeks}, 7*3600*24, :time, %w{<second>}],
+  '<fortnight>'=> [%w{fortnight fortnights}, 1209600, :time, %W{<second>}],
+  '<year>'=>  [%w{y yr year years annum}, 31556926, :time, %w{<second>}],
+  '<decade>'=>[%w{decade decades}, 315569260, :time, %w{<second>}],
+  '<century>'=>[%w{century centuries}, 3155692600, :time, %w{<second>}],
+
+  #pressure
+  '<pascal>' => [%w{Pa pascal Pascal}, 1.0, :pressure, %w{<kilogram>},%w{<meter> <second> <second>}],
+  '<bar>' => [%w{bar bars}, 100000, :pressure, %w{<kilogram>},%w{<meter> <second> <second>}],
+  '<mmHg>' => [%w{mmHg}, 133.322368,:pressure, %w{<kilogram>},%w{<meter> <second> <second>}],
+  '<inHg>' => [%w{inHg}, 3386.3881472,:pressure, %w{<kilogram>},%w{<meter> <second> <second>}],
+  '<torr>' => [%w{torr}, 133.322368,:pressure, %w{<kilogram>},%w{<meter> <second> <second>}],
+  '<bar>' => [%w{bar}, 100000,:pressure, %w{<kilogram>},%w{<meter> <second> <second>}],
+  '<atm>' => [%w{atm ATM atmosphere atmospheres}, 101325,:pressure, %w{<kilogram>},%w{<meter> <second> <second>}],
+  '<psi>' => [%w{psi}, 6894.76,:pressure, %w{<kilogram>},%w{<meter> <second> <second>}],
+  '<cmh2o>' => [%w{cmH2O}, 98.0638,:pressure, %w{<kilogram>},%w{<meter> <second> <second>}],
+  '<inh2o>' => [%w{inH2O}, 249.082052,:pressure, %w{<kilogram>},%w{<meter> <second> <second>}],
+  
+  #viscosity
+  '<poise>'  => [%w{P poise}, 0.1, :viscosity, %w{<kilogram>},%w{<meter> <second>} ],
+  '<stokes>' => [%w{St stokes}, 1e-4, :viscosity, %w{<meter> <meter>}, %w{<second>}],
+
+  #substance
+  '<mole>'  =>  [%w{mol mole}, 1.0, :substance, %w{<mole>}],
+
+  #concentration
+  '<molar>' => [%w{M molar}, 1000, :concentration, %w{<mole>}, %w{<meter> <meter> <meter>}],
+  '<wtpercent>'  => [%w{wt% wtpercent}, 10, :concentration, %w{<kilogram>}, %w{<meter> <meter> <meter>}],
+
+  #activity
+  '<katal>' =>  [%w{kat katal Katal}, 1.0, :activity, %w{<mole>}, %w{<second>}],
+  '<unit>'  =>  [%w{U enzUnit}, 16.667e-16, :activity, %w{<mole>}, %w{<second>}],
+
+  #capacitance
+  '<farad>' =>  [%w{F farad Farad}, 1.0, :capacitance, %w{<farad>}],
+
+  #charge
+  '<coulomb>' =>  [%w{C coulomb Coulomb}, 1.0, :charge, %w{<ampere> <second>}],
+
+  #current
+  '<ampere>'  =>  [%w{A Ampere ampere amp amps}, 1.0, :current, %w{<ampere>}],
+
+  #conductance
+  '<siemens>' => [%w{S Siemens siemens}, 1.0, :resistance, %w{<second> <second> <second> <ampere> <ampere>}, %w{<kilogram> <meter> <meter>}],
+
+  #inductance
+  '<henry>' =>  [%w{H Henry henry}, 1.0, :inductance, %w{<meter> <meter> <kilogram>}, %w{<second> <second> <ampere> <ampere>}],
+
+  #potential
+  '<volt>'  =>  [%w{V Volt volt volts}, 1.0, :potential, %w{<meter> <meter> <kilogram>}, %w{<second> <second> <second> <ampere>}],
+
+  #resistance
+  '<ohm>' =>  [%w{Ohm ohm}, 1.0, :resistance, %w{<meter> <meter> <kilogram>},%w{<second> <second> <second> <ampere> <ampere>}],
+
+  #magnetism
+  '<weber>' => [%w{Wb weber webers}, 1.0, :magnetism, %w{<meter> <meter> <kilogram>}, %w{<second> <second> <ampere>}],
+  '<tesla>'  => [%w{T tesla teslas}, 1.0, :magnetism, %w{<kilogram>}, %w{<second> <second> <ampere>}],
+  '<gauss>' => [%w{G gauss}, 1e-4, :magnetism,  %w{<kilogram>}, %w{<second> <second> <ampere>}],
+  '<maxwell>' => [%w{Mx maxwell maxwells}, 1e-8, :magnetism, %w{<meter> <meter> <kilogram>}, %w{<second> <second> <ampere>}],
+  '<oersted>'  => [%w{Oe oersted oersteds}, 250.0/Math::PI, :magnetism, %w{<ampere>}, %w{<meter>}],
+
+  #energy
+  '<joule>' =>  [%w{J joule Joule joules}, 1.0, :energy, %w{<meter> <meter> <kilogram>}, %w{<second> <second>}],
+  '<erg>'   =>  [%w{erg ergs}, 1e-7, :energy, %w{<meter> <meter> <kilogram>}, %w{<second> <second>}],
+  '<btu>'   =>  [%w{BTU btu BTUs}, 1055.056, :energy, %w{<meter> <meter> <kilogram>}, %w{<second> <second>}],
+  '<calorie>' =>  [%w{cal calorie calories}, 4.18400, :energy,%w{<meter> <meter> <kilogram>}, %w{<second> <second>}],
+  '<Calorie>' =>  [%w{Cal Calorie Calories}, 4184.00, :energy,%w{<meter> <meter> <kilogram>}, %w{<second> <second>}],
+  '<therm-US>' => [%w{th therm therms Therm}, 105480400, :energy,%w{<meter> <meter> <kilogram>}, %w{<second> <second>}],
+
+  #force
+  '<newton>'  => [%w{N Newton newton}, 1.0, :force, %w{<kilogram> <meter>}, %w{<second> <second>}],
+  '<dyne>'  => [%w{dyn dyne}, 1e-5, :force, %w{<kilogram> <meter>}, %w{<second> <second>}],
+  '<pound-force>'  => [%w{lbf pound-force}, 4.448222, :force, %w{<kilogram> <meter>}, %w{<second> <second>}],
+
+  #frequency
+  '<hertz>' => [%w{Hz hertz Hertz}, 1.0, :frequency, %w{<1>}, %{<second>}],
+
+  #angle
+  '<radian>' =>[%w{rad radian radian}, 1.0, :angle, %w{<radian>}],
+  '<degree>' =>[%w{deg degree degrees}, Math::PI / 180.0, :angle, %w{<radian>}],
+  '<grad>'   =>[%w{grad gradian grads}, Math::PI / 200.0, :angle, %w{<radian>}],
+  '<steradian>'  => [%w{sr steradian steradians}, 1.0, :solid_angle, %w{<steradian>}],
+
+  #rotation
+  '<rotation>' => [%w{rotation}, 2.0*Math::PI, :angle, %w{<radian>}],
+  '<rpm>'   =>[%w{rpm}, 2.0*Math::PI / 60.0, :angular_velocity, %w{<radian>}, %w{<second>}],
+
+  #memory
+  '<byte>'  =>[%w{B byte}, 1.0, :memory, %w{<byte>}],
+  '<bit>'  =>[%w{b bit}, 0.125, :memory, %w{<byte>}],
+
+  #currency
+  '<dollar>'=>[%w{USD dollar}, 1.0, :currency, %w{<dollar>}],
+  '<cents>' =>[%w{cents}, 0.01, :currency, %w{<dollar>}],
+
+  #luminosity
+  '<candela>' => [%w{cd candela}, 1.0, :luminosity, %w{<candela>}],
+  '<lumen>' => [%w{lm lumen}, 1.0, :luminous_power, %w{<candela> <steradian>}],
+  '<lux>' =>[%w{lux}, 1.0, :illuminance, %w{<candela> <steradian>}, %w{<meter> <meter>}],
+
+  #power
+  '<watt>'  => [%w{W watt watts}, 1.0, :power, %w{<kilogram> <meter> <meter>}, %w{<second> <second> <second>}],
+  '<horsepower>'  =>  [%w{hp horsepower}, 745.699872, :power, %w{<kilogram> <meter> <meter>}, %w{<second> <second> <second>}],
+
+  #radiation
+  '<gray>' => [%w{Gy gray grays}, 1.0, :radiation, %w{<meter> <meter>}, %w{<second> <second>}],
+  '<roentgen>' => [%w{R roentgen}, 0.009330, :radiation, %w{<meter> <meter>}, %w{<second> <second>}],
+  '<sievert>' => [%w{Sv sievert sieverts}, 1.0, :radiation, %w{<meter> <meter>}, %w{<second> <second>}],
+  '<becquerel>' => [%w{Bq bequerel bequerels}, 1.0, :radiation, %w{<1>},%w{<second>}],
+  '<curie>' => [%w{Ci curie curies}, 3.7e10, :radiation, %w{<1>},%w{<second>}],
+  
+  # rate
+  '<cpm>' => [%w{cpm}, 1.0/60.0, :rate, %w{<count>},%w{<second>}],
+  '<dpm>' => [%w{dpm}, 1.0/60.0, :rate, %w{<count>},%w{<second>}],
+  '<bpm>' => [%w{bpm}, 1.0/60.0, :rate, %w{<count>},%w{<second>}],
+
+  #resolution / typography
+  '<dot>' => [%w{dot dots}, 1, :resolution, %w{<each>}],
+  '<pixel>' => [%w{pixel px}, 1, :resolution, %w{<each>}],
+  '<ppi>' => [%w{ppi}, 1, :resolution, %w{<pixel>}, %w{<inch>}],
+  '<dpi>' => [%w{dpi}, 1, :typography, %w{<dot>}, %w{<inch>}],
+  '<pica>' => [%w{pica}, 0.00423333333 , :typography, %w{<meter>}],
+  '<point>' => [%w{point pt}, 0.000352777778, :typography, %w{<meter>}],
+
+  #other
+  '<cell>' => [%w{cells cell}, 1, :counting, %w{<each>}],
+  '<each>' => [%w{each}, 1.0, :counting, %w{<each>}],
+  '<count>' => [%w{count}, 1.0, :counting, %w{<each>}],  
+  '<base-pair>'  => [%w{bp}, 1.0, :counting, %w{<each>}],
+  '<nucleotide>' => [%w{nt}, 1.0, :counting, %w{<each>}],
+  '<molecule>' => [%w{molecule molecules}, 1.0, :counting, %w{<1>}],
+  '<dozen>' =>  [%w{doz dz dozen},12.0,:prefix_only, %w{<each>}],
+  '<percent>'=> [%w{% percent}, 0.01, :prefix_only, %w{<1>}],
+  '<ppm>' =>  [%w{ppm},1e-6,:prefix_only, %w{<1>}],
+  '<ppt>' =>  [%w{ppt},1e-9,:prefix_only, %w{<1>}],
+  '<gross>' =>  [%w{gr gross},144.0, :prefix_only, %w{<dozen> <dozen>}],
+  '<decibel>'  => [%w{dB decibel decibels}, 1.0, :logarithmic, %w{<decibel>}]
+
+
+} # doc
+end

data/test/test_ruby-units.rb

@@ -0,0 +1,982 @@
+require 'rubygems'
+require 'test/unit'
+require 'ruby-units'
+require 'yaml'
+begin
+	require 'chronic'
+rescue LoadError
+	warn "Can't test Chronic integration unless gem 'chronic' is installed"
+end
+begin 
+	require 'uncertain'
+rescue LoadError
+	warn "Can't test Uncertain Units unless 'Uncertain' gem is installed"
+end
+
+
+class Unit < Numeric
+  @@USER_DEFINITIONS = {'<inchworm>' =>  [%w{inworm inchworm}, 0.0254, :length, %w{<meter>} ],
+                        '<habenero>'   => [%w{degH}, 100, :temperature, %w{<celsius>}]}
+  Unit.setup
+end
+
+class Time
+  @@forced_now = nil
+  @@forced_gmt = nil
+  class << self
+    alias :unforced_now :now
+    def forced_now
+      @@forced_now.nil? ? unforced_now : @@forced_now
+    end
+    alias :now :forced_now
+    
+    def forced_now=(now)
+      @@forced_now = now
+    end
+  end
+    
+  alias :unforced_gmt :gmt_offset
+  def forced_gmt
+    @@forced_gmt.nil? ? unforced_gmt : @@forced_gmt
+  end
+  alias :gmt_offset :forced_gmt
+
+  def forced_gmt=(gmt)
+    @@forced_gmt = now
+  end
+    
+end
+
+class DateTime
+  @@forced_now = nil
+  class << self
+    alias :unforced_now :now
+    def forced_now
+      return @@forced_now ? @@forced_now : unforced_now
+    end
+    alias :now :forced_now
+    
+    def forced_now=(now)
+      @@forced_now = now
+    end
+    
+  end
+end
+
+class Dummy
+  def to_unit
+    '1 mm'.unit
+  end
+end
+
+class TestRubyUnits < Test::Unit::TestCase
+ 
+  def setup
+    @april_fools = Time.at 1143910800
+    @april_fools_datetime = DateTime.parse('2006-04-01T12:00:00-05:00')
+    Time.forced_now = @april_fools
+    DateTime.forced_now = @april_fools_datetime 
+    #Unit.clear_cache
+  end
+  
+  def teardown
+    Time.forced_now = nil
+    DateTime.forced_now = nil
+  end
+  
+  def test_to_yaml
+    unit = "1 mm".u
+    assert_equal "--- !ruby/object:Unit \nscalar: 1.0\nnumerator: \n- <milli>\n- <meter>\ndenominator: \n- <1>\nsignature: 1\nbase_scalar: 0.001\n", unit.to_yaml    
+  end
+
+  def test_time
+    a = Time.now
+    assert_equal "s", a.to_unit.units
+    assert_equal a + 3600, a + "1 h".unit
+    assert_equal a - 3600, a - "1 h".unit
+    assert_in_delta Time.now - "1 h".unit, "1 h".ago, 1
+    assert_in_delta Time.now + 3600, "1 h".from_now, 1
+    assert_in_delta "1 h".unit + Time.now, "1 h".from_now, 1
+    assert_in_delta Time.now - 3600, "1 h".before_now, 1
+    assert_in_delta((Time.now.unit - Time.now).unit.scalar, 0, 1)
+    assert_equal "60 min", "min".until(Time.now + 3600).to_s
+    assert_equal "01:00", "min".since(Time.now - 3600).to_s("%H:%M")
+    assert_in_delta Time.now, "now".time, 1
+  end
+  
+	def test_from_now
+		assert_equal "1 day".from_now, @april_fools + 86400
+	end
+	
+	def test_from
+		assert_equal "1 day".from("now"), @april_fools + 86400
+	end
+
+	def test_ago
+		assert_equal "1 day".ago, @april_fools - 86400
+	end
+	
+	def test_before_now
+		assert_equal "1 day".before_now, @april_fools - 86400
+	end
+	
+	def test_before
+		assert_equal '1 days'.before('now'), @april_fools - 86400
+	end
+
+	def test_since
+    assert_equal 'days'.since(@april_fools - 86400), "1 day".unit
+    assert_equal 'days'.since('2006-3-31 12:00:00 -5:00'), "1 day".unit
+    assert_equal 'days'.since(DateTime.parse('2006-3-31 12:00 -5:00')), "1 day".unit		
+    assert_raises(ArgumentError) { 'days'.since(1) }
+	end
+
+	def test_until
+    assert_equal 'days'.until('2006-04-2 12:00:00 -5:00'), '1 day'.unit		
+    assert_raises(ArgumentError) { 'days'.until(1) }
+	end
+
+  def test_time_helpers
+    assert_equal @april_fools, Time.now
+    assert_equal @april_fools_datetime, DateTime.now
+    assert_equal Time.now, 'now'.time
+    assert_equal DateTime.now, 'now'.datetime
+    assert_equal 1143910800, Unit.new(Time.now).scalar
+    assert_equal @april_fools.unit.to_time, @april_fools
+    assert_equal Time.in('1 day'), @april_fools + 86400
+    assert_equal "2006-04-01T12:00:00-05:00", @april_fools_datetime.inspect
+    assert_equal "2006-04-01T00:00:00+00:00", '2453826.5 days'.unit.to_datetime.to_s 
+  end
+  
+  def test_string_helpers
+    assert_equal '1 mm'.to('in'), Unit('1 mm').to('in')
+  end
+
+  [:sin, :cos, :tan, :sinh, :cosh, :tanh].each do |trig|
+		define_method("test_#{trig}") do
+			assert_equal Math.send(trig, Math::PI), Math.send(trig, "180 deg".unit)
+		end
+	end
+	
+  def test_clone
+    unit1= "1 mm".unit
+    unit2 = unit1.clone
+    assert_not_equal unit1.numerator.object_id, unit2.numerator.object_id
+    assert_not_equal unit1.denominator.object_id, unit2.denominator.object_id
+    assert unit1 === unit2
+  end 
+  
+  def test_unary_minus
+    unit1 = Unit.new("1 mm^2")
+    unit2 = Unit.new("-1 mm^2")
+    assert_equal unit1, -unit2
+  end
+  
+  def test_unary_plus
+    unit1 = Unit.new("1 mm")
+    assert_equal unit1, +unit1
+  end
+
+  def test_create_unit_only
+    unit1 = Unit.new("m")
+    assert_equal ['<meter>'], unit1.numerator
+    assert_equal 1.0, unit1.scalar
+  end
+  
+  def test_to_base
+    unit1 = Unit.new("100 cm")
+    assert_in_delta 1, unit1.to_base.scalar, 0.001
+    unit2 = Unit("1 mm^2 ms^-2")
+    assert_in_delta 1,  unit2.to_base.scalar, 0.001 
+  end
+  
+  def test_to_unit
+    unit1 = "1 mm".to_unit
+    assert_equal unit1, unit1.to_unit
+    assert Unit === unit1
+    unit2 = Unit("1 mm")
+    assert Unit === unit1
+    assert unit1 == unit2
+    unit1 = "2.54 cm".to_unit("in")
+    assert_in_delta 1, unit1.scalar, 0.001 
+    assert_equal ['<inch>'], unit1.numerator
+    unit1 = "2.54 cm".unit("in")
+    assert_in_delta 1, unit1.scalar, 0.001
+    assert_equal ['<inch>'], unit1.numerator
+    unit1 = 1.unit
+    assert_in_delta 1, unit1.scalar, 0.001
+    assert_equal ['<1>'], unit1.numerator
+    unit1 = [1,'mm'].unit
+    assert_in_delta 1, unit1.scalar, 0.001
+    assert_equal ['<milli>','<meter>'], unit1.numerator
+  end
+  
+  def test_create_unitless
+    unit1 = Unit("1")
+    assert_equal 1, unit1.to_f
+    assert_equal ['<1>'],unit1.numerator
+    assert_equal ['<1>'],unit1.denominator
+    unit1 = Unit.new("1.5")
+    assert_equal 1.5,unit1.to_f
+    assert_equal ['<1>'],unit1.numerator
+    assert_equal ['<1>'],unit1.denominator
+  end
+  
+  def test_create_simple
+    unit1 = Unit.new("1 m")
+    assert_equal 1,unit1.scalar
+    assert_equal ['<meter>'], unit1.numerator
+    assert_equal ['<1>'],unit1.denominator
+  end
+  
+  def test_create_compound
+    unit1 = Unit.new("1 N*m")
+    assert_equal 1,unit1.scalar 
+    assert_equal ['<newton>','<meter>'],unit1.numerator
+    assert_equal ['<1>'],unit1.denominator
+  end
+  
+  def test_create_with_denominator
+    unit1 = Unit.new("1 m/s")
+    assert_equal 1, unit1.scalar
+    assert_equal ['<meter>'],unit1.numerator
+    assert_equal ['<second>'],unit1.denominator
+  end
+  
+  def test_create_with_powers
+    unit1 = Unit.new("1 m^2/s^2")
+    assert_equal 1, unit1.scalar
+    assert_equal ['<meter>','<meter>'],unit1.numerator
+    assert_equal ['<second>','<second>'],unit1.denominator
+    unit1 = Unit.new("1 m^2 kg^2 J^2/s^2")
+    assert_equal 1, unit1.scalar
+    assert_equal ['<meter>','<meter>','<kilogram>','<kilogram>','<joule>','<joule>'],unit1.numerator
+    assert_equal ['<second>','<second>'],unit1.denominator
+    
+  end
+
+  def test_create_with_zero_power
+    unit1 = Unit.new("1 m^0")
+    assert_equal 1,unit1.scalar
+    assert_equal ['<1>'],unit1.numerator
+    assert_equal ['<1>'],unit1.denominator
+  end
+
+  def test_create_with_negative_powers
+    unit1 = Unit.new("1 m^2 s^-2")
+    assert_equal 1, unit1.scalar
+    assert_equal ['<meter>','<meter>'],unit1.numerator
+    assert_equal ['<second>','<second>'],unit1.denominator
+  end
+  
+  def test_create_from_array
+    unit1 = Unit.new(1, "mm^2", "ul^2")
+    assert_equal 1, unit1.scalar
+    assert_equal ['<milli>','<meter>','<milli>','<meter>'], unit1.numerator
+    assert_equal ['<micro>','<liter>','<micro>','<liter>'], unit1.denominator
+  end
+  
+  def test_bad_create
+    assert_raises(ArgumentError) { Unit.new(nil)}
+    assert_raises(ArgumentError) { Unit.new(true)}
+    assert_raises(ArgumentError) { Unit.new(false)}
+    assert_raises(ArgumentError) { Unit.new(/(.+)/)}
+  end
+  
+  def test_convert
+    unit1 = Unit.new("1 attoparsec/microfortnight")
+    assert_nothing_raised {
+      unit2 = unit1 >> "in/s"
+      assert_equal ['<inch>'],unit2.numerator
+      assert_equal ['<second>'],unit2.denominator
+      assert_in_delta 1.0043269330917,unit2.scalar,0.00001 
+    }
+  end
+  
+  def test_add_operator
+    a = '0 mm'.unit
+    b = '10 cm'.unit
+    c = '1 in'.unit
+    d = '1 ml'.unit
+    
+    assert_equal((a+b), b)
+    assert_equal((a+b).units, b.units)
+    assert_equal((b+a), b)
+    assert_equal((b+a).units, b.units)
+    assert_in_delta((b+c).scalar, 12.54, 0.01)
+    assert_equal((b+c).units, 'cm')
+    assert_raises(ArgumentError) {
+      b + d
+    }
+  end
+  
+  def test_subtract_operator
+    a = '0 mm'.unit
+    b = '10 cm'.unit
+    c = '1 in'.unit
+    d = '1 ml'.unit
+    
+    assert_equal((a-b), -b)
+    assert_equal((a-b).units, b.units)
+    assert_equal((b-a), b)
+    assert_equal((b-a).units, b.units)
+    assert_in_delta((b-c).scalar, 7.46, 0.01)
+    assert_equal((b-c).units, 'cm')
+    assert_raises(ArgumentError) {
+      b - d
+    }
+  end
+  
+  def test_convert_to
+    unit1 = Unit.new("1 mm")
+    unit2 = Unit.new("1 ft")
+    assert_nothing_raised {
+      unit3 = unit1 >> unit2
+      assert_equal ['<foot>'], unit3.numerator
+      assert_equal ['<1>'],unit3.denominator
+      unit3 = unit1 >> "ft"
+      assert_equal ['<foot>'], unit3.numerator
+      assert_equal ['<1>'],unit3.denominator
+    }
+    assert_raises(ArgumentError) { unit1 >> 5.0}
+    assert_equal unit1, unit1.to(true)
+    assert_equal unit1, unit1.to(false)
+    assert_equal unit1, unit1.to(nil)
+  end
+  
+  def test_compare 
+    unit1 = "1 mm".unit
+    unit2 = "1 mm".unit
+    unit3 = unit2 >> "in"
+    assert unit1 === unit2
+    assert !(unit1 === unit3)
+    assert unit1 === "1 mm"
+  end
+  
+  def test_matched_units
+    unit1 = Unit.new("1 m*kg/s")
+    unit2 = Unit.new("1 in*pound/min")
+    assert unit1 =~ unit2
+  end
+  
+  def test_matched_units_using_string
+    unit1 = Unit.new("1 m*kg/s")
+    assert unit1 =~ "in*pound/min"
+  end
+  
+  def test_unmatched_units
+    unit1 = Unit.new("1 m*kg/s")
+    unit2 = Unit.new("1 mm")
+    assert unit1 !~ unit2
+  end
+  
+  def test_comparison_like_units
+    unit1 = Unit.new("1 in")
+    unit2 = Unit.new("1 mm")
+    assert_nothing_raised {
+      assert unit1 > unit2
+    }
+  end
+  
+  def test_comparison_unlike_units
+    unit1 = Unit.new("1 kg")
+    unit2 = Unit.new("1 mm")
+    assert_raise(ArgumentError) { unit1 > unit2 }
+  end
+  
+  def test_add_like_units
+    unit1 = Unit.new("1 mm")
+    unit2 = Unit.new("2 mm")
+    assert_nothing_raised {  
+      assert_equal 3.0, (unit1+unit2).scalar
+      }
+  end
+  
+  def test_add_similar_units
+    unit1 = Unit.new("1 cm")
+    unit2 = Unit.new("1 in")
+    assert_nothing_raised {
+      unit3 = unit1 + unit2
+      assert_in_delta 3.54, unit3.scalar, 0.01
+      }
+  end
+
+  def test_subtract_similar_units
+    unit1 = Unit.new("1 cm")
+    unit2 = Unit.new("1 in")
+    assert_nothing_raised {
+      unit3 = unit1 - unit2
+      assert_in_delta(-1.54, unit3.scalar, 0.01)
+      }
+  end
+  
+  def test_add_unlike_units
+    unit1 = Unit.new("1 mm")
+    unit2 = Unit.new("2 ml")
+    assert_raise(ArgumentError) {(unit1+unit2).scalar}
+  end
+  
+  def test_add_coerce
+    unit1 = "1 mm".unit
+    assert_nothing_raised {
+      unit2 = unit1 + "1 mm"
+      assert_equal "2 mm".unit, unit2
+    }
+    assert_nothing_raised {
+      unit2 = unit1 + [1,"mm"]
+      assert_equal "2 mm".unit, unit2
+    }
+    assert_nothing_raised {
+      unit2 = "1".unit + 1
+      assert_equal "2".unit, unit2
+    }
+    assert_raises(ArgumentError) {
+      "1".unit + nil
+    }
+  end
+
+  def test_subtract_coerce
+    unit1 = "1 mm".unit
+    assert_nothing_raised {
+      unit2 = unit1 - "1 mm"
+      assert_equal "0 mm".unit, unit2
+    }
+  end
+  def test_multiply_coerce
+    unit1 = "1 mm".unit
+    assert_nothing_raised {
+      unit2 = unit1 * "1 mm"
+      assert_equal "1 mm^2".unit, unit2
+    }
+  end
+  def test_divide_coerce
+    unit1 = "1 mm".unit
+    assert_nothing_raised {
+      unit2 = unit1 / "1 mm"
+      assert_equal "1".unit, unit2
+    }
+  end
+  
+  def test_signature #"1 m s deg K kg A mol cd byte rad
+    unit1 = Unit.new("1 m*s*degK*kg*A*mol*cd*byte*rad*dollar")
+    assert_equal unit1.signature, (0..9).inject(0) {|product, n| product + 20**n}
+  end
+  
+  def test_subtract_like_units
+    unit1 = Unit.new("1 mm")
+    unit2 = Unit.new("2 mm")
+    assert_nothing_raised {
+      assert_equal(-1, (unit1-unit2).scalar)
+      }
+  end
+  
+  def test_subtract_unlike_units
+    unit1 = Unit.new("1 mm")
+    unit2 = Unit.new("2 ml")
+    assert_raise(ArgumentError) {(unit1-unit2).scalar}
+  end
+  
+  def test_multiply
+    unit1 = Unit.new("1 m/ms")
+    unit2 = Unit.new("1 m/ms")
+    assert_nothing_raised {
+      unit3 = unit1 * unit2
+      assert_equal Unit.new("1 m^2/ms^2"), unit3    
+    }
+    assert_equal unit1 * 0, '0 m/ms'.unit
+  end
+  
+  def test_divide
+    unit1 = Unit.new("200 M*g/mol")
+    unit2 = Unit.new("200 g/mole")
+    assert_nothing_raised {
+      unit3 = unit1 / unit2
+      assert_equal Unit.new("1 M"), unit3
+      }
+    assert_equal unit2 / 1, unit2
+    unit3 = '0 s'.unit
+    assert_raises(ZeroDivisionError) {
+      unit1 / unit3
+    }
+    
+    assert_raises(ZeroDivisionError) {
+      unit1 / 0
+    }
+  end
+  
+  def test_inverse
+    unit1 = Unit.new("1 m")
+    unit2 = Unit.new("1 1/m")
+    assert_equal unit2, unit1.inverse
+    assert_raises((ZeroDivisionError)) { 0.unit.inverse }
+  end
+  
+  def test_exponentiate_positive
+    unit1 = Unit.new("1 mm")
+    unit2 = Unit.new("1 mm^2")
+    assert_nothing_raised {
+      assert_equal unit2, unit1**2
+      }
+  end
+  
+  def test_exponentiate_float
+    unit1 = Unit.new("1 mm")
+    assert_raise(ArgumentError) {unit1**2.5}
+  end
+   
+  def test_exponentiate_negative
+    unit1 = Unit.new("1 m")
+    unit2 = Unit.new("1 m^-2")
+    assert_nothing_raised {
+      assert_equal unit2, unit1**-2
+      }
+    assert_raises(ZeroDivisionError) {
+      "0 mm".unit**-1
+    }
+  end
+
+  def test_exponentiate_zero
+    unit1 = Unit.new("10 mm")
+    unit2 = Unit.new("1")
+    assert_nothing_raised {
+      assert_equal unit2, unit1**0
+    }
+    assert_equal 1, "0 mm".unit**0
+  end
+  
+  def test_abs
+    unit1 = Unit.new("-1 mm")
+    assert_equal 1, unit1.abs
+  end
+  
+  def test_ceil
+    unit1 = Unit.new("1.1 mm")
+    unit2 = Unit.new("2 mm")
+    assert_equal unit2, unit1.ceil
+    assert_equal(('1 mm'.unit / '1 mm'.unit).ceil, 1)  
+    assert_equal("11 kg*m".unit, ("1003 kg*m".unit / 100).ceil)
+  end
+  
+  def test_floor
+    unit1 = Unit.new("1.1 mm")
+    unit2 = Unit.new("1 mm")
+    assert_equal unit2, unit1.floor
+    assert_equal(('1 mm'.unit / '1 mm'.unit).floor, 1)
+  end
+  
+  def test_to_int
+    assert_raises(RuntimeError)  {Unit.new("1.1 mm").to_i}
+    assert_nothing_raised {Unit.new(10.5).to_i}
+  end
+  
+  def test_truncate
+    unit1 = Unit.new("1.1 mm")
+    unit2 = Unit.new("1 mm")
+    assert_equal unit2, unit1.truncate
+    assert_equal((unit1/unit2).truncate, 1)
+  end
+  
+  def test_round
+    unit1 = Unit.new("1.1 mm")
+    unit2 = Unit.new("1 mm")
+    assert_equal unit2, unit1.round
+    assert_equal((unit1/unit2).round, 1)
+  end
+  
+  def test_zero?
+    unit1 = Unit.new("0")
+    assert unit1.zero?
+  end
+  
+  def test_nonzero?
+    unit1 = Unit.new("0")
+    unit2 = Unit.new("1 mm")
+    assert_nil unit1.nonzero?
+    assert_equal unit2, unit2.nonzero?
+  end
+  
+  def test_equality
+    unit1 = Unit.new("1 cm")
+    unit2 = Unit.new("10 mm")
+    assert unit1 == unit2
+  end
+  
+  def test_temperature_conversions
+    assert_raises(ArgumentError) { '-1 tempK'.unit}
+    assert_raises(ArgumentError) { '-1 tempR'.unit}
+    assert_raises(ArgumentError) { '-1000 tempC'.unit}
+    assert_raises(ArgumentError) { '-1000 tempF'.unit}
+    
+    assert_in_delta '32 tempF'.unit.base_scalar, '0 tempC'.unit.base_scalar, 0.01
+    assert_in_delta '0 tempC'.unit.base_scalar, '32 tempF'.unit.base_scalar, 0.01
+    assert_in_delta '0 tempC'.unit.base_scalar, '273.15 tempK'.unit.base_scalar, 0.01
+    assert_in_delta '0 tempC'.unit.base_scalar, '491.67 tempR'.unit.base_scalar, 0.01
+    
+    a = '10 degC'.unit
+    assert_equal a >> 'tempC', '-263.15 tempC'.unit
+    assert_equal a >> 'tempK', '10 tempK'.unit
+    assert_equal a >> 'tempR', '18 tempR'.unit
+    assert_equal a >> 'tempF', '-441.67 tempF'.unit
+    
+    unit1 = '37 tempC'.unit
+    assert_equal unit1 >> 'tempF' >> 'tempK' >> 'tempR' >> 'tempC', unit1
+    
+    a = '100 tempF'.unit
+    b = '10 degC'.unit
+    c = '50 tempF'.unit
+    d = '18 degF'.unit
+    assert_equal('118 tempF'.unit,a+b)
+    assert_equal b+a, '118 tempF'.unit
+    assert_equal a-b, '82 tempF'.unit
+    assert_in_delta((a-c).scalar, '50 degF'.unit.scalar, 0.01)
+    assert_equal b+d, '20 degC'.unit
+    
+    assert_raises(ArgumentError) { a * b }
+    assert_raises(ArgumentError) { a / b }
+    assert_raises(ArgumentError) { a ** 2 }
+    assert_raises(ArgumentError) { c - '400 degK'.unit}
+    assert_equal a, a.to('tempF')
+  end
+  
+  def test_feet
+    unit1 = Unit.new("6'6\"")
+    assert_in_delta 6.5, unit1.scalar, 0.01
+    unit2 = "6'".unit
+    assert_equal unit2, '6 feet'.unit
+    unit3 = '6"'.unit
+    assert_equal unit3, '6 inch'.unit
+
+  end
+  
+  def test_pounds
+    unit1 = Unit.new("8 pounds, 8 ounces")
+    assert_in_delta 8.5, unit1.scalar, 0.01
+    assert_equal '150#'.unit, '150 lbs'.unit
+  end
+  
+  # these units are 'ambiguous' and could be mis-parsed
+  def test_parse_tricky_units
+    unit1 = Unit.new('1 mm')      #sometimes parsed as 'm*m'
+    assert_equal ['<milli>','<meter>'], unit1.numerator
+    unit2 = Unit.new('1 cd')      # could be a 'centi-day' instead of a candela
+    assert_equal ['<candela>'], unit2.numerator
+    unit3 = Unit.new('1 min')      # could be a 'milli-inch' instead of a minute
+    assert_equal ['<minute>'], unit3.numerator
+    unit4 = Unit.new('1 ft')      # could be a 'femto-ton' instead of a foot
+    assert_equal ['<foot>'], unit4.numerator  
+    unit5 = "1 atm".unit
+    assert_equal ['<atm>'], unit5.numerator
+    unit6 = "1 doz".unit
+    assert_equal ['<dozen>'], unit6.numerator
+  end
+   
+  def test_to_s
+    unit1 = Unit.new("1")
+    assert_equal "1", unit1.to_s
+    unit2 = Unit.new("mm")
+    assert_equal "1 mm", unit2.to_s
+    assert_equal "0.04 in", unit2.to_s("%0.2f in")
+    assert_equal "0.1 cm", unit2.to_s("cm")
+    unit3 = Unit.new("1 mm")
+    assert_equal "1 mm", unit3.to_s
+    assert_equal "0.04 in", unit3.to_s("%0.2f in")
+    unit4 = Unit.new("1 mm^2")
+    assert_equal "1 mm^2", unit4.to_s
+    unit5 = Unit.new("1 mm^2 s^-2")
+    assert_equal "1 mm^2/s^2", unit5.to_s
+    unit6= Unit.new("1 kg*m/s")
+    assert_equal "1 kg*m/s", unit6.to_s
+    unit7= Unit.new("1 1/m")
+    assert_equal "1 1/m", unit7.to_s
+    assert_equal("1.5 mm", Unit.new("1.5 mm").to_s)
+    assert_equal("1.5 mm", "#{Unit.new('1.5 mm')}")
+  end
+  
+  def test_to_feet_inches
+    unit1 = Unit.new("6'5\"")
+    assert_equal "6'5\"", unit1.to_s(:ft)
+    assert_raises(ArgumentError) {
+      unit1 = Unit.new("1 kg")
+      unit1.to_s(:ft)
+    }
+  end
+  
+  def test_to_lbs_oz
+    unit1 = Unit.new("8 lbs 8 oz")
+    assert_equal "8 lbs, 8 oz", unit1.to_s(:lbs)
+    assert_raises(ArgumentError) {
+      unit1 = Unit.new("1 m")
+      unit1.to_s(:lbs)
+    }
+  end
+  
+  def test_add_units
+    a = Unit.new("1 inchworm")
+    assert_equal "1 inworm", a.to_s
+  end
+  
+  def test_ideal_gas_law
+    p = Unit "100 kPa"
+    v = Unit "1 m^3"
+    n = Unit "1 mole"
+    r = Unit "8.31451 J/mol*degK"
+    t = ((p*v)/(n*r)).to('tempK')
+    assert_in_delta 12027.16,t.base_scalar, 0.1
+  end
+  
+  
+  def test_eliminate_terms
+    a = ['<meter>','<meter>','<kelvin>','<second>']
+    b = ['<meter>','<meter>','<second>']
+    h = Unit.eliminate_terms(1,a,b)
+    assert_equal ['<kelvin>'], h[:numerator]
+  end
+  
+  def test_to_base_consistency
+    a = "1 W*m/J*s".unit
+    assert_equal a.signature, a.to_base.signature
+  end
+  
+  def test_unit_roots
+    unit1 = Unit "2 m*J*kg"
+    unit2 = Unit "4 m^2*J^2*kg^2"
+    unit3 = Unit "8 m^3*J^3*kg^3"
+    assert_equal unit2**(1/2), unit1
+    assert_equal unit3**(1/3), unit1
+  end
+  
+  def test_inspect
+    unit1 = Unit "1 mm"
+    assert_equal "1 mm", unit1.inspect
+    assert_not_equal "1.0 mm", unit1.inspect(:dump)
+  end
+  
+  def test_to_f
+    assert_equal 1, 1.unit.to_f
+    assert_raises(RuntimeError) {
+      assert_equal 1, "1 mm".unit.to_f
+    }
+  end
+  
+  def test_exponentiate_float2
+    assert_equal "2 m".unit, "4 m^2".unit**(0.5) 
+    assert_raises(ArgumentError) { "1 mm".unit**(2/3)}
+    assert_raises(ArgumentError) { "1 mm".unit**("A")}
+    
+  end
+  
+  def test_range
+    a = Unit "1 mm"
+    b = Unit "3 mm"
+    c = (a..b).to_a
+    assert_equal ["1 mm".unit, "2 mm".unit, "3 mm".unit], c
+  end
+  
+  def test_scientific
+    a = Unit "1e6 cells"
+    assert_equal 1e6, a.scalar
+    assert_equal "cells", a.units
+  end
+  
+	if defined?(Uncertain)
+		def test_uncertain
+			a = '1 +/- 1 mm'.unit
+			assert_equal a.to_s, '1 +/- 1 mm' 
+		end  
+	end
+  
+  def test_format
+    assert_equal "%0.2f" % "1 mm".unit, "1.00 mm" 
+  end
+  
+  def test_bad_units
+    assert_raises(ArgumentError) { '1 doohickey / thingamabob'.unit}
+    assert_raises(ArgumentError) { '1 minimeter'.unit}
+  end
+  
+  def test_currency
+    assert_nothing_raised {"$1".unit}
+  end
+  
+  def test_kind
+    a = "1 mm".unit
+    assert_equal a.kind, :length
+  end
+  
+  def test_percent
+      assert_nothing_raised {
+      	"1 percent".unit
+        "1%".unit
+        "0.01%".unit
+      }
+      a = '100 ml'.unit
+      b = '50%'.unit
+      c = a*b >> 'ml'
+      assert c =~ a
+      assert_in_delta '50 ml'.unit.scalar, c.scalar, 0.0001
+  end
+  
+  def test_parse
+    assert_nothing_raised { "1 1/m".unit }
+    assert_raises(ArgumentError) { "3 s/s/ft".unit }
+    assert_raises(ArgumentError) { "3 s**2|,s**2".unit }
+    assert_raises(ArgumentError) { "3 s**2 4s s**2".unit }
+    assert_raises(ArgumentError) { "3 s 5^6".unit }
+    assert_raises(ArgumentError) { "".unit }
+  end
+  
+  def test_time_conversions
+    today = 'now'.to_time
+    assert_equal today,@april_fools
+    last_century = today - '150 years'.unit
+    assert_equal last_century.to_date, '1856-04-01'.to_date
+  end
+  
+  def test_coercion
+    assert_nothing_raised { 1.0 * '1 mm'.unit}
+    assert_nothing_raised { '1 mm'.unit * 1.0}
+  end
+  
+  def test_zero
+    assert_nothing_raised { Unit.new(0) }
+  end
+  
+  def test_divide_results_in_unitless
+    a = '10 mg/ml'.unit
+    b = '10 mg/ml'.unit
+    assert_equal a/b, 1
+  end
+
+  def test_wt_percent
+    a = '1 wt%'.unit
+    b = '1 g/dl'.unit
+    assert_equal a,b
+  end
+  
+  def test_parse_durations
+    assert_equal "1:00".unit, '1 hour'.unit
+    assert_equal "1:30".unit, "1.5 hour".unit
+    assert_equal "1:30:30".unit, "1.5 hour".unit + '30 sec'.unit
+    assert_equal "1:30:30,200".unit, "1.5 hour".unit + '30 sec'.unit + '200 usec'.unit
+  end
+  
+  def test_coercion_2
+    a = Dummy.new
+    b = '1 mm'.unit
+    assert_equal '2 mm'.unit, b + a
+  end
+  
+  def test_create_with_other_unit
+    a = '1 g'.unit
+    b = 0.unit(a)
+    assert_equal b, '0 g'.unit
+  end
+  
+  def test_sqrt
+    a = '-9 mm^2'.unit
+    b = a**(0.5)
+    assert_in_delta Math.sqrt(a).to_unit.scalar.real, b.scalar.real, 0.00001
+		# ruby 1.8.x uses .image while 1.9.x uses .imaginary
+		if Complex.instance_methods.include?(:imaginary)
+    	assert_in_delta Math.sqrt(a).to_unit.scalar.imaginary, b.scalar.imaginary, 0.00001
+		else
+			assert_in_delta Math.sqrt(a).to_unit.scalar.image, b.scalar.image, 0.00001
+		end
+  end
+
+	def test_div
+		assert_equal 11,"23 m".unit.div('2 m'.unit)
+	end
+	
+	def test_divmod
+		assert_equal [277,1], 555.unit('mm').divmod(2.unit('mm'))
+		assert_equal [277, 0.0010000000000000373], '0.555 m'.unit.divmod('2 mm'.unit)
+		assert_raises(ArgumentError) { '1 m'.unit.divmod('1 kg'.unit) }
+	end
+
+	if Math.respond_to?(:cbrt)
+		def test_cbrt
+			assert_in_delta '2 mm'.to_unit, Math.cbrt('8 mm^3'.to_unit), 0.0001
+		end
+	end
+  
+  def test_hypot
+    assert_equal Math.hypot('3 mm'.unit,'4 mm'.unit), '5 mm'.unit
+    assert_raises(ArgumentError) { Math.hypot('3 mm'.unit, '4 kg'.unit)}
+  end
+  
+  def test_complex
+    assert_equal '1+1i mm'.unit.scalar, Complex(1,1)
+    assert_equal '1+1i'.unit.scalar, Complex(1,1)
+    assert_raises(RuntimeError) { '1+1i mm'.unit.to_c}
+  end
+
+  def test_atan2
+    assert_equal Math.atan2('1 mm'.unit,'1 mm'.unit), Math.atan2(1,1)
+    assert_raises(ArgumentError) {Math.atan2('1 mm'.unit, '1 lb'.unit)}
+    assert_raises(ArgumentError) {Math.atan2('1 mm'.unit, 1)}
+  end
+
+  def test_rational_units
+    assert_equal '1/4 cup'.unit, '0.25 cup'.unit
+    assert_equal '1/4 in/s'.unit, '0.25 in/s'.unit
+    assert_equal '1/4'.unit, 0.25
+  end
+  
+  def test_to_date
+    a = Time.now
+    assert_equal a.send(:to_date), Date.today
+  end
+  
+  def test_natural_language
+    assert_equal Unit.parse("10 mm in cm"), '10 mm'.unit.to('cm')
+  end
+  
+  def test_round_pounds
+    assert_equal '1 lbs'.unit, '1.1 lbs'.unit.round
+  end
+
+  def test_explicit_init
+    assert_equal '1 lbf'.unit, '1 <pound-force>'.unit
+    assert_equal '1 lbs'.unit, '1 <pound>'.unit
+    assert_equal('1 kg*m'.unit, '1 <kilogram>*<meter>'.unit)
+  end
+  
+  def test_format_nil_string
+    assert_nothing_raised {"" % nil}
+    assert_nothing_raised {"" % false}
+  end
+  
+  def test_to_s_cache
+    Unit.clear_cache
+    a = Unit.new('1 mm')
+    a.to_s                # cache the conversion to itself
+    b = Unit.new('2 mm')
+    assert_equal('2 mm', b.to_s)
+    assert_equal('0.001 m', a.to_s('m'))
+    assert_equal('0.001 m', a.output['m'])
+  end
+    
+  def test_version
+    assert_equal('1.2.0.a', Unit::VERSION)
+  end
+  
+  def test_negation
+    a = 1.to_unit
+    assert_equal(a.class, (1-a).class)
+  end
+  
+  def test_degree
+    assert "100 tempF".unit.degree?
+    assert "100 degC".unit.degree?
+    assert !"1 mm".unit.degree?
+  end
+
+  def test_temperature
+    assert "100 tempF".unit.temperature?
+    assert !"100 degC".unit.temperature?
+    assert !"1 mm".unit.temperature?    
+  end
+  
+end
+