ruby-units 0.2.3 → 0.3.1

data/CHANGELOG

@@ -108,5 +108,13 @@ Change Log for Ruby-units
                     * 'string'.to_datetime returns a DateTime object
                     * 'string'.time returns a Time object or a DateTime if the Time object fails
                     * 'string'.datetime returns a DateTime or a Time if the DateTime fails
-                    
-                       
+
+2006-10-02  0.3.0   * Performance enhanced by caching results of many functions
+                      (Thanks to Kurt Stephens for pushing this.)
+                    * Throws an exception if the unit is not recognized
+                    * units can now identify what 'kind' they are (:length, :mass, etc..)
+                    * New constructors:  
+                      Unit(1,"mm") 
+                      Unit(1,"mm/s")
+                      Unit(1,"mm","s")
+2006-10-02  0.3.1   * minor bug fixes                       

data/lib/ruby-units.rb

@@ -2,7 +2,7 @@ require 'mathn'
 require 'rational'
 require 'date'
 require 'parsedate'
-# = Ruby Units 0.2.3
+# = Ruby Units 0.3.1
 #
 # Copyright 2006 by Kevin C. Olbrich, Ph.D.
 # 
@@ -40,49 +40,124 @@ require 'parsedate'
 class Unit < Numeric
   require 'units'
   # pre-generate hashes from unit definitions for performance.  
+  VERSION = '0.3.0'
   @@USER_DEFINITIONS = {}
   @@PREFIX_VALUES = {}
   @@PREFIX_MAP = {}
   @@UNIT_MAP = {}
   @@UNIT_VALUES = {}
   @@OUTPUT_MAP = {}
-  @@UNIT_VECTORS = {}
+  @@BASE_UNITS = ['<meter>','<kilogram>','<second>','<mole>', '<farad>', '<ampere>','<radian>','<kelvin>','<byte>','<dollar>','<candela>','<each>','<steradian>','<decibel>']
+  UNITY = '<1>'
+  UNITY_ARRAY= [UNITY]
+  FEET_INCH_REGEX = /(\d+)\s*(?:'|ft|feet)\s*(\d+)\s*(?:"|in|inches)/
+  LBS_OZ_REGEX = /(\d+)\s*(?:#|lbs|pounds)+[\s,]*(\d+)\s*(?:oz|ounces)/
+  SCI_NUMBER = %r{([+-]?\d*[.]?\d+(?:[Ee][+-]?)?\d*)}
+  NUMBER_REGEX = /#{SCI_NUMBER}*\s*(.+)?/
+  UNIT_STRING_REGEX = /#{SCI_NUMBER}*\s*([^\/]*)\/*(.+)*/
+  TOP_REGEX = /([^ \*]+)(?:\^|\*\*)([\d-]+)/
+  BOTTOM_REGEX = /([^* ]+)(?:\^|\*\*)(\d+)/
+  
+  KELVIN = ['<kelvin>']
+  FARENHEIT = ['<farenheit>']
+  RANKINE = ['<rankine>']
+  CELCIUS = ['<celcius>']
 
+  SIGNATURE_VECTOR = [:length, :time, :temperature, :mass, :current, :substance, :luminosity, :currency, :memory, :angle, :capacitance]
+  @@KINDS = {
+    -312058=>:resistance, 
+    -312038=>:inductance, 
+    -152040=>:magnetism, 
+    -152038=>:magnetism, 
+    -152058=>:potential, 
+    -39=>:acceleration,
+    -38=>:radiation, 
+    -20=>:frequency, 
+    -19=>:speed, 
+    -18=>:viscosity, 
+    0=>:unitless, 
+    1=>:length, 
+    2=>:area, 
+    3=>:volume, 
+    20=>:time, 
+    400=>:temperature, 
+    7942=>:power, 
+    7959=>:pressure, 
+    7962=>:energy, 
+    7979=>:viscosity, 
+    7981=>:force, 
+    7997=>:mass_concentration,
+    8000=>:mass, 
+    159999=>:magnetism, 
+    160000=>:current, 
+    160020=>:charge, 
+    312058=>:resistance, 
+    3199980=>:activity, 
+    3199997=>:molar_concentration, 
+    3200000=>:substance, 
+    63999998=>:illuminance, 
+    64000000=>:luminous_power, 
+    1280000000=>:currency, 
+    25600000000=>:memory,
+    511999999980=>:angular_velocity, 
+    512000000000=>:angle, 
+    10240000000000=>:capacitance, 
+    }
+  
+  @@cached_units = {}
+  @@base_unit_cache = {}
+  
   def self.setup
-    (UNIT_DEFINITIONS.merge!(@@USER_DEFINITIONS)).each do |key, value|
+    @@ALL_UNIT_DEFINITIONS = UNIT_DEFINITIONS.merge!(@@USER_DEFINITIONS)
+    for unit in (@@ALL_UNIT_DEFINITIONS) do
+      key, value = unit
       if value[2] == :prefix then
-        @@PREFIX_VALUES[Regexp.escape(key)]=value[1]
-        value[0].each {|x| @@PREFIX_MAP[Regexp.escape(x)]=key}    
+        @@PREFIX_VALUES[key]=value[1]
+        for name in value[0] do
+          @@PREFIX_MAP[name]=key
+        end    
       else
-        @@UNIT_VALUES[Regexp.escape(key)]={}
-        @@UNIT_VALUES[Regexp.escape(key)][:scalar]=value[1]
-        @@UNIT_VALUES[Regexp.escape(key)][:numerator]=value[3] if value[3]
-        @@UNIT_VALUES[Regexp.escape(key)][:denominator]=value[4] if value[4]
-        value[0].each {|x| @@UNIT_MAP[Regexp.escape(x)]=key}
-        @@UNIT_VECTORS[value[2]] = [] unless @@UNIT_VECTORS[value[2]]
-        @@UNIT_VECTORS[value[2]] = @@UNIT_VECTORS[value[2]]+[Regexp.escape(key)]
+        @@UNIT_VALUES[key]={}
+        @@UNIT_VALUES[key][:scalar]=value[1]
+        @@UNIT_VALUES[key][:numerator]=value[3] if value[3]
+        @@UNIT_VALUES[key][:denominator]=value[4] if value[4]
+        for name in value[0] do
+          @@UNIT_MAP[name]=key
+        end
       end
-      @@OUTPUT_MAP[Regexp.escape(key)]=value[0][0]
+      @@OUTPUT_MAP[key]=value[0][0]        
     end
     @@PREFIX_REGEX = @@PREFIX_MAP.keys.sort_by {|prefix| prefix.length}.reverse.join('|')
     @@UNIT_REGEX = @@UNIT_MAP.keys.sort_by {|unit| unit.length}.reverse.join('|')
+    @@UNIT_MATCH_REGEX = /(#{@@PREFIX_REGEX})*?(#{@@UNIT_REGEX})\b/  
+    
   end
   
-  self.setup
   
   include Comparable
-  attr_accessor :scalar, :numerator, :denominator, :signature, :base_scalar
+  attr_accessor :scalar, :numerator, :denominator, :signature, :base_scalar, :base_numerator, :base_denominator, :output, :unit_name
 
   def to_yaml_properties
     %w{@scalar @numerator @denominator @signature @base_scalar}
   end
+
+  def copy(from)
+    @scalar = from.scalar
+    @numerator = from.numerator
+    @denominator = from.denominator
+    @is_base = from.is_base?
+    @signature = from.signature
+    @base_scalar = from.base_scalar
+    @output = from.output rescue nil
+    @unit_name = from.unit_name rescue nil
+  end
   
   # basically a copy of the basic to_yaml.  Needed because otherwise it ends up coercing the object to a string
   # before YAML'izing it.
   def to_yaml( opts = {} )
     YAML::quick_emit( object_id, opts ) do |out|
       out.map( taguri, to_yaml_style ) do |map|
-        to_yaml_properties.each do |m|
+        for m in to_yaml_properties do 
           map.add( m[1..-1], instance_variable_get( m ) )
         end
       end
@@ -101,28 +176,77 @@ class Unit < Numeric
   #  6'4"  -- recognized as 6 feet + 4 inches 
   #  8 lbs 8 oz -- recognized as 8 lbs + 8 ounces
   #
-  def initialize(options)    
-    case options
-    when String: parse(options)
+  def initialize(*options)
+    if options.size == 2
+      begin
+        cached = @@cached_units[options[1]] * options[0] 
+        copy(cached)
+      rescue 
+        initialize("#{options[0]} #{options[1]}")
+      end
+      return
+    end
+    if options.size == 3
+      begin
+        cached = @@cached_units["#{options[1]}/#{options[2]}"] * options[0] 
+        copy(cached)
+      rescue 
+        initialize("#{options[0]} #{options[1]}/#{options[2]}")
+      end
+      return
+    end
+    
+    
+    case options[0]
+    when String: parse(options[0])
     when Hash:
-      @scalar = options[:scalar] || 1
-      @numerator = options[:numerator] || ["<1>"]
-      @denominator = options[:denominator] || []
-    when Array: 
-      parse("#{options[0]} #{options[1]}/#{options[2]}")
+      @scalar = options[0][:scalar] || 1
+      @numerator = options[0][:numerator] || UNITY_ARRAY
+      @denominator = options[0][:denominator] || UNITY_ARRAY
+      @signature = options[0][:signature]
+    when Array:
+      initialize(*options[0])
+      return
     when Numeric:
-      @scalar = options
-      @numerator = @denominator = ['<1>']
+      @scalar = options[0]
+      @numerator = @denominator = UNITY_ARRAY
     when Time:
-      @scalar = options.to_f
+      @scalar = options[0].to_f
       @numerator = ['<second>']
-      @denominator = ['<1>']
+      @denominator = UNITY_ARRAY
     else
       raise ArgumentError, "Invalid Unit Format"
     end
     self.update_base_scalar
     self.replace_temperature
-    self.freeze
+
+    unary_unit = self.units
+    opt_units = options[0].scan(NUMBER_REGEX)[0][1] if String === options[0]
+    unless @@cached_units.keys.include?(opt_units) || (opt_units =~ /(temp|deg)(C|K|R|F)/)
+      @@cached_units[opt_units] = (self.scalar == 1 ? self : opt_units.unit) if opt_units && !opt_units.empty?
+    end
+    unless @@cached_units.keys.include?(unary_unit) || (unary_unit =~ /(temp|deg)(C|K|R|F)/) then
+      @@cached_units[unary_unit] = (self.scalar == 1 ? self : unary_unit.unit)
+    end
+    @scalar.freeze
+    @numerator.freeze
+    @denominator.freeze
+    @base_scalar.freeze
+    @signature.freeze
+    @is_base.freeze
+    self
+  end
+
+  def kind
+    return @@KINDS[self.signature]
+  end
+  
+  def self.cached
+    return @@cached_units
+  end
+
+  def self.base_unit_cache
+    return @@base_unit_cache
   end
   
   def to_unit
@@ -132,48 +256,49 @@ class Unit < Numeric
   
   # Returns 'true' if the Unit is represented in base units
   def is_base?
-    return true if @signature == 400 && @numerator.size == 1 && @numerator[0] =~ /(celcius|kelvin|farenheit|rankine)/
+    return @is_base if defined? @is_base
+    return @is_base=true if @signature == 400 && @numerator.size == 1 && @numerator[0] =~ /(celcius|kelvin|farenheit|rankine)/
     n = @numerator + @denominator
-    n.compact.each do |x|
-      return false unless x == '<1>' || 
-        (@@UNIT_VALUES[Regexp.escape(x)] &&  
-          @@UNIT_VALUES[Regexp.escape(x)][:denominator].nil? && 
-            @@UNIT_VALUES[Regexp.escape(x)][:numerator].include?(Regexp.escape(x)))
+    for x in n.compact do 
+      return @is_base=false unless x == UNITY || (@@BASE_UNITS.include?((x)))
     end
-    return true
+    return @is_base = true
   end  
   
   #convert to base SI units
   def to_base
     return self if self.is_base?
-#    return self.to('degK') if self.units =~ /temp(C|K|F|R)/ 
+    cached = @@base_unit_cache[self.units] * self.scalar rescue nil
+    return cached if cached
+    
     num = []
     den = []
-    q = @scalar
-    @numerator.compact.each do |unit|
-        if @@PREFIX_VALUES[Regexp.escape(unit)]
-          q *= @@PREFIX_VALUES[Regexp.escape(unit)]
+    q = 1
+    for unit in @numerator.compact do
+        if @@PREFIX_VALUES[unit]
+          q *= @@PREFIX_VALUES[unit]
         else
-          q *= @@UNIT_VALUES[Regexp.escape(unit)][:scalar] if @@UNIT_VALUES[Regexp.escape(unit)]
-          num << @@UNIT_VALUES[Regexp.escape(unit)][:numerator] if @@UNIT_VALUES[Regexp.escape(unit)] && @@UNIT_VALUES[Regexp.escape(unit)][:numerator]
-          den << @@UNIT_VALUES[Regexp.escape(unit)][:denominator] if @@UNIT_VALUES[Regexp.escape(unit)] && @@UNIT_VALUES[Regexp.escape(unit)][:denominator]
+          q *= @@UNIT_VALUES[unit][:scalar] if @@UNIT_VALUES[unit]
+          num << @@UNIT_VALUES[unit][:numerator] if @@UNIT_VALUES[unit] && @@UNIT_VALUES[unit][:numerator]
+          den << @@UNIT_VALUES[unit][:denominator] if @@UNIT_VALUES[unit] && @@UNIT_VALUES[unit][:denominator]
         end
     end
-    @denominator.compact.each do |unit|
-        if @@PREFIX_VALUES[Regexp.escape(unit)]
-          q /= @@PREFIX_VALUES[Regexp.escape(unit)]
+    for unit in @denominator.compact do
+        if @@PREFIX_VALUES[unit]
+          q /= @@PREFIX_VALUES[unit]
         else
-          q /= @@UNIT_VALUES[Regexp.escape(unit)][:scalar] if @@UNIT_VALUES[Regexp.escape(unit)]
-          den << @@UNIT_VALUES[Regexp.escape(unit)][:numerator] if @@UNIT_VALUES[Regexp.escape(unit)] && @@UNIT_VALUES[Regexp.escape(unit)][:numerator]
-          num << @@UNIT_VALUES[Regexp.escape(unit)][:denominator] if @@UNIT_VALUES[Regexp.escape(unit)] && @@UNIT_VALUES[Regexp.escape(unit)][:denominator]
+          q /= @@UNIT_VALUES[unit][:scalar] if @@UNIT_VALUES[unit]
+          den << @@UNIT_VALUES[unit][:numerator] if @@UNIT_VALUES[unit] && @@UNIT_VALUES[unit][:numerator]
+          num << @@UNIT_VALUES[unit][:denominator] if @@UNIT_VALUES[unit] && @@UNIT_VALUES[unit][:denominator]
         end
     end
     
     num = num.flatten.compact
     den = den.flatten.compact
-    num = ['<1>'] if num.empty?
-   
-    Unit.new(Unit.eliminate_terms(q,num,den))
+    num = UNITY_ARRAY if num.empty?
+    base= Unit.new(Unit.eliminate_terms(q,num,den))
+    @@base_unit_cache[self.units]=base
+    return base * @scalar
   end
   
   # Generate human readable output.
@@ -183,23 +308,29 @@ class Unit < Numeric
   #  :ft - outputs in feet and inches (e.g., 6'4")
   #  :lbs - outputs in pounds and ounces (e.g, 8 lbs, 8 oz)
   def to_s(target_units=nil)
-    case target_units
-    when :ft:
-      inches = self.to("in").scalar
-      "#{(inches / 12).truncate}\'#{(inches % 12).round}\""
-    when :lbs:
-      ounces = self.to("oz").scalar
-      "#{(ounces / 16).truncate} lbs, #{(ounces % 16).round} oz"
-    when String
-      begin #first try a standard format string
-        target_units =~ /(%[\w\d#+-.]*)*\s*(.+)*/
-        return self.to($2).to_s($1) if $2
-        "#{($1 || '%g') % @scalar || 0} #{self.units}".strip
-      rescue #if that is malformed, try a time string
-        return (Time.gm(0) + self).strftime(target_units)
-      end
+    out = @output[target_units] rescue nil
+    if out
+      return out
     else
-      "#{'%g' % @scalar} #{self.units}".strip
+      case target_units
+      when :ft:
+        inches = self.to("in").scalar
+        out = "#{(inches / 12).truncate}\'#{(inches % 12).round}\""
+      when :lbs:
+        ounces = self.to("oz").scalar
+        out = "#{(ounces / 16).truncate} lbs, #{(ounces % 16).round} oz"
+      when String
+        begin #first try a standard format string
+          target_units =~ /(%[\w\d#+-.]*)*\s*(.+)*/
+          out = $2 ? self.to($2).to_s($1) : "#{($1 || '%g') % @scalar || 0} #{self.units}".strip
+        rescue #if that is malformed, try a time string
+          out = (Time.gm(0) + self).strftime(target_units)
+        end
+      else
+        out = "#{'%g' % @scalar} #{self.units}".strip
+      end
+      @output = {target_units => out}
+      return out
     end    
   end
   
@@ -209,8 +340,9 @@ class Unit < Numeric
   end
   
   # returns true if no associated units
+  # false, even if the units are "unitless" like 'radians, each, etc'
   def unitless?
-    (@numerator == ['<1>'] && @denominator == ['<1>'])
+    (@numerator == UNITY_ARRAY && @denominator == UNITY_ARRAY)
   end
   
   # Compare two Unit objects. Throws an exception if they are not of compatible types.
@@ -266,9 +398,8 @@ class Unit < Numeric
   def +(other)   
     if Unit === other 
       if self =~ other then
-        a = self.to_base
-        b = other.to_base
-        Unit.new(:scalar=>(a.scalar + b.scalar), :numerator=>a.numerator, :denominator=>b.denominator).to(self)
+        q = self.zero? ? 1 : (self.scalar / self.base_scalar)
+        Unit.new(:scalar=>(self.base_scalar + other.base_scalar)*q, :numerator=>@numerator, :denominator=>@denominator, :signature => @signature)
       else
          raise ArgumentError,  "Incompatible Units"
       end
@@ -285,9 +416,8 @@ class Unit < Numeric
   def -(other)
     if Unit === other 
       if self =~ other then
-        a = self.to_base
-        b = other.to_base
-        Unit.new(:scalar=>(a.scalar - b.scalar), :numerator=>a.numerator, :denominator=>b.denominator).to(self)
+        q = self.zero? ? 1 : (self.scalar / self.base_scalar)
+        Unit.new(:scalar=>(self.base_scalar - other.base_scalar)*q, :numerator=>@numerator, :denominator=>@denominator, :signature=>@signature)
       else
          raise ArgumentError,  "Incompatible Units"
       end
@@ -295,14 +425,19 @@ class Unit < Numeric
       other - self
     else
         x,y = coerce(other)
-        x - y
+        y-x
     end
   end
   
   # Multiply two units.
   def *(other)
-    if Unit === other
-      Unit.new(Unit.eliminate_terms(@scalar*other.scalar, @numerator + other.numerator ,@denominator + other.denominator))      
+    case other
+    when Unit
+      opts = Unit.eliminate_terms(@scalar*other.scalar, @numerator + other.numerator ,@denominator + other.denominator)
+      opts.merge!(:signature => @signature + other.signature)
+      Unit.new(opts)      
+    when Numeric
+      Unit.new(:scalar=>@scalar*other, :numerator=>@numerator, :denominator=>@denominator, :signature => @signature)
     else
       x,y = coerce(other)
       x * y
@@ -312,9 +447,15 @@ class Unit < Numeric
   # Divide two units.
   # Throws an exception if divisor is 0
   def /(other)
-    if Unit === other
+    case other
+    when Unit 
+      raise ZeroDivisionError if other.zero?
+      opts = Unit.eliminate_terms(@scalar/other.scalar, @numerator + other.denominator ,@denominator + other.numerator)
+      opts.merge!(:signature=> @signature - other.signature)
+      Unit.new(opts)      
+    when Numeric
       raise ZeroDivisionError if other.zero?
-      Unit.new(Unit.eliminate_terms(@scalar/other.scalar, @numerator + other.denominator ,@denominator + other.numerator))      
+      Unit.new(:scalar=>@scalar/other, :numerator=>@numerator, :denominator=>@denominator, :signature => @signature)      
     else
       x,y = coerce(other)
       y / x
@@ -375,16 +516,16 @@ class Unit < Numeric
     vec = self.unit_signature_vector
     vec=vec.map {|x| x % n}      
     raise ArgumentError, "Illegal root" unless vec.max == 0
-    num = @numerator.clone
-    den = @denominator.clone
+    num = @numerator.dup
+    den = @denominator.dup
       
-    @numerator.uniq.each do |item|
+    for item in @numerator.uniq do
       x = num.find_all {|i| i==item}.size
       r = ((x/n)*(n-1)).to_int
       r.times {|x| num.delete_at(num.index(item))}
     end
     
-    @denominator.uniq.each do |item|
+    for item in @denominator.uniq do 
       x = den.find_all {|i| i==item}.size
       r = ((x/n)*(n-1)).to_int
       r.times {|x| den.delete_at(den.index(item))}
@@ -419,7 +560,6 @@ class Unit < Numeric
     return self if FalseClass === other
     if (Unit === other && other.units =~ /temp(K|C|R|F)/) || (String === other && other =~ /temp(K|C|R|F)/) 
       raise ArgumentError, "Receiver is not a temperature unit" unless self.signature==400 
-      return self.to_base.to(other) unless self.is_base?
       start_unit = self.units
       target_unit = other.units rescue other
       q=case start_unit
@@ -452,7 +592,8 @@ class Unit < Numeric
             when 'tempR'  : @scalar
           end
         else
-          raise ArgumentError, "Unknown temperature conversion requested #{self.numerator}"
+          return self.to_base.to(other) unless self.is_base?
+          #raise ArgumentError, "Unknown temperature conversion requested #{self.numerator}"
       end
       target_unit =~ /temp(C|K|F|R)/
       Unit.new("#{q} deg#{$1}")
@@ -466,14 +607,14 @@ class Unit < Numeric
             raise ArgumentError, "Unknown target units"
         end
       raise ArgumentError,  "Incompatible Units" unless self =~ target
-      one = @numerator.map {|x| @@PREFIX_VALUES[Regexp.escape(x)] ? @@PREFIX_VALUES[Regexp.escape(x)] : x}.map {|i| i.kind_of?(Numeric) ? i : @@UNIT_VALUES[Regexp.escape(i)][:scalar] }.compact
-      two = @denominator.map {|x| @@PREFIX_VALUES[Regexp.escape(x)] ? @@PREFIX_VALUES[Regexp.escape(x)] : x}.map {|i| i.kind_of?(Numeric) ? i : @@UNIT_VALUES[Regexp.escape(i)][:scalar] }.compact
+      one = @numerator.map {|x| @@PREFIX_VALUES[x] ? @@PREFIX_VALUES[x] : x}.map {|i| i.kind_of?(Numeric) ? i : @@UNIT_VALUES[i][:scalar] }.compact
+      two = @denominator.map {|x| @@PREFIX_VALUES[x] ? @@PREFIX_VALUES[x] : x}.map {|i| i.kind_of?(Numeric) ? i : @@UNIT_VALUES[i][:scalar] }.compact
       v = one.inject(1) {|product,n| product*n} / two.inject(1) {|product,n| product*n}
-      one = target.numerator.map {|x| @@PREFIX_VALUES[Regexp.escape(x)] ? @@PREFIX_VALUES[Regexp.escape(x)] : x}.map {|x| x.kind_of?(Numeric) ? x : @@UNIT_VALUES[Regexp.escape(x)][:scalar] }.compact
-      two = target.denominator.map {|x| @@PREFIX_VALUES[Regexp.escape(x)] ? @@PREFIX_VALUES[Regexp.escape(x)] : x}.map {|x| x.kind_of?(Numeric) ? x : @@UNIT_VALUES[Regexp.escape(x)][:scalar] }.compact
+      one = target.numerator.map {|x| @@PREFIX_VALUES[x] ? @@PREFIX_VALUES[x] : x}.map {|x| x.kind_of?(Numeric) ? x : @@UNIT_VALUES[x][:scalar] }.compact
+      two = target.denominator.map {|x| @@PREFIX_VALUES[x] ? @@PREFIX_VALUES[x] : x}.map {|x| x.kind_of?(Numeric) ? x : @@UNIT_VALUES[x][:scalar] }.compact
       y = one.inject(1) {|product,n| product*n} / two.inject(1) {|product,n| product*n}
       q = @scalar * v/y
-      Unit.new(:scalar=>q, :numerator=>target.numerator, :denominator=>target.denominator)
+      Unit.new(:scalar=>q, :numerator=>target.numerator, :denominator=>target.denominator, :signature => target.signature)
     end
   end  
   alias :>> :to
@@ -489,43 +630,46 @@ class Unit < Numeric
   
   # returns the 'unit' part of the Unit object without the scalar
   def units
-    return "" if @numerator == ["<1>"] && @denominator == ["<1>"]
+    return "" if @numerator == UNITY_ARRAY && @denominator == UNITY_ARRAY
+    return @unit_name unless @unit_name.nil?
     output_n = []
     output_d =[] 
     num = @numerator.clone.compact
     den = @denominator.clone.compact
-    if @numerator == ["<1>"]
+    if @numerator == UNITY_ARRAY
       output_n << "1"
     else
       num.each_with_index do |token,index|
-        if token && @@PREFIX_VALUES[Regexp.escape(token)] then
-          output_n << "#{@@OUTPUT_MAP[Regexp.escape(token)]}#{@@OUTPUT_MAP[Regexp.escape(num[index+1])]}"
+        if token && @@PREFIX_VALUES[token] then
+          output_n << "#{@@OUTPUT_MAP[token]}#{@@OUTPUT_MAP[num[index+1]]}"
           num[index+1]=nil
         else
-          output_n << "#{@@OUTPUT_MAP[Regexp.escape(token)]}" if token
+          output_n << "#{@@OUTPUT_MAP[token]}" if token
         end
       end
     end
-    if @denominator == ['<1>']
+    if @denominator == UNITY_ARRAY
       output_d = ['1']
     else
       den.each_with_index do |token,index|
-          if token && @@PREFIX_VALUES[Regexp.escape(token)] then
-            output_d << "#{@@OUTPUT_MAP[Regexp.escape(token)]}#{@@OUTPUT_MAP[Regexp.escape(den[index+1])]}"
+          if token && @@PREFIX_VALUES[token] then
+            output_d << "#{@@OUTPUT_MAP[token]}#{@@OUTPUT_MAP[den[index+1]]}"
             den[index+1]=nil
           else
-            output_d << "#{@@OUTPUT_MAP[Regexp.escape(token)]}" if token
+            output_d << "#{@@OUTPUT_MAP[token]}" if token
           end
         end
     end
     on = output_n.reject {|x| x.empty?}.map {|x| [x, output_n.find_all {|z| z==x}.size]}.uniq.map {|x| ("#{x[0]}".strip+ (x[1] > 1 ? "^#{x[1]}" : ''))}
     od = output_d.reject {|x| x.empty?}.map {|x| [x, output_d.find_all {|z| z==x}.size]}.uniq.map {|x| ("#{x[0]}".strip+ (x[1] > 1 ? "^#{x[1]}" : ''))}
-    "#{on.join('*')}#{od == ['1'] ? '': '/'+od.join('*')}".strip    
+    out = "#{on.join('*')}#{od == ['1'] ? '': '/'+od.join('*')}".strip    
+    @unit_name = out unless self.kind == :temperature
+    return out
   end
   
   # negates the scalar of the Unit
   def -@
-    Unit.new([-@scalar,@numerator,@denominator])    
+    Unit.new(-@scalar,@numerator,@denominator)    
   end
   
   # returns abs of scalar, without the units
@@ -534,18 +678,18 @@ class Unit < Numeric
   end
   
   def ceil
-    Unit.new([@scalar.ceil, @numerator, @denominator])    
+    Unit.new(@scalar.ceil, @numerator, @denominator)    
   end
   
   def floor
-    Unit.new([@scalar.floor, @numerator, @denominator])    
+    Unit.new(@scalar.floor, @numerator, @denominator)    
   end
 
   # changes internal scalar to an integer, but retains the units
   # if unitless, returns an int
   def to_int
     return @scalar.to_int if unitless?
-    Unit.new([@scalar.to_int, @numerator, @denominator])    
+    Unit.new(@scalar.to_int, @numerator, @denominator)    
   end
   
   # Tries to make a Time object from current unit
@@ -557,7 +701,7 @@ class Unit < Numeric
   alias :truncate :to_int
   
   def round
-    Unit.new([@scalar.round, @numerator, @denominator])    
+    Unit.new(@scalar.round, @numerator, @denominator)    
   end
    
   # true if scalar is zero
@@ -567,16 +711,16 @@ class Unit < Numeric
   
   # '5 min'.unit.ago 
   def ago
-    Time.now - self rescue DateTime.now - self
+    self.before
   end
   
   # '5 min'.before(time)
   def before(time_point = ::Time.now)
     raise ArgumentError, "Must specify a Time" unless time_point
     if String === time_point
-      time_point.time - self
+      time_point.time - self rescue time_point.datetime - self
     else
-      time_point - self
+      time_point - self rescue time_point.to_datetime - self
     end
   end
   alias :before_now :before
@@ -585,7 +729,7 @@ class Unit < Numeric
   def since(time_point = ::Time.now)
     case time_point
     when Time:      (Time.now - time_point).unit('s').to(self)
-    when DateTime:  (DateTime.now - time_point).unit('d').to(self)
+    when DateTime, Date:  (DateTime.now - time_point).unit('d').to(self)
     when String:    
       (DateTime.now - time_point.time(:context=>:past)).unit('d').to(self)
     else
@@ -597,7 +741,7 @@ class Unit < Numeric
   def until(time_point = ::Time.now)
     case time_point
     when Time:      (time_point - Time.now).unit('s').to(self)
-    when DateTime:  (time_point - DateTime.now).unit('d').to(self)
+    when DateTime, Date:  (time_point - DateTime.now).unit('d').to(self)
     when String:
       r = (time_point.time(:context=>:future) - DateTime.now)
       Time === time_point.time ? r.unit('s').to(self) : r.unit('d').to(self)
@@ -610,9 +754,9 @@ class Unit < Numeric
   def from(time_point = ::Time.now)
     raise ArgumentError, "Must specify a Time" unless time_point
     if String === time_point
-      time_point.time + self
+      time_point.time + self rescue time_point.datetime + self
     else
-      time_point + self
+      time_point + self rescue time_point.to_datetime + self
     end
   end
   alias :after :from
@@ -621,7 +765,7 @@ class Unit < Numeric
   def succ
     raise ArgumentError, "Non Integer Scalar" unless @scalar == @scalar.to_i
     q = @scalar.to_i.succ
-    Unit.new([q, @numerator, @denominator])
+    Unit.new(q, @numerator, @denominator)
   end
       
   # Protected and Private Functions that should only be called from this class
@@ -629,6 +773,7 @@ class Unit < Numeric
   
   
   def update_base_scalar
+    return @base_scalar unless @base_scalar.nil?
     if self.is_base?
       @base_scalar = @scalar
       @signature = unit_signature
@@ -653,37 +798,42 @@ class Unit < Numeric
   def unit_signature_vector
       return self.to_base.unit_signature_vector unless self.is_base?
       result = self
-      y = [:length, :time, :temperature, :mass, :current, :substance, :luminosity, :currency, :memory, :angle]
-      vector = Array.new(y.size,0)
-      y.each_with_index do |units,index|
-        vector[index] = result.numerator.compact.find_all {|x| @@UNIT_VECTORS[units].include? Regexp.escape(x)}.size
-        vector[index] -= result.denominator.compact.find_all {|x| @@UNIT_VECTORS[units].include? Regexp.escape(x)}.size  
+      vector = Array.new(SIGNATURE_VECTOR.size,0)
+      for element in @numerator
+        if r=@@ALL_UNIT_DEFINITIONS[element]
+            n = SIGNATURE_VECTOR.index(r[2])
+           vector[n] = vector[n] + 1 if n
+        end
+      end
+      for element in @denominator
+        if r=@@ALL_UNIT_DEFINITIONS[element]
+          n = SIGNATURE_VECTOR.index(r[2])
+          vector[n] = vector[n] - 1 if n
+        end
       end
       vector
   end
   
   def replace_temperature
-    return self unless self.signature == 400 && self.units =~ /temp(R|K|F|C)/
+    return self unless self.kind == :temperature && self.units =~ /temp(R|K|F|C)/
     un = $1
-    target = self.units
     @numerator = case un
-      when 'R' : ['<rankine>']
-      when 'C' : ['<celcius>']
-      when 'F' : ['<farenheit>']
-      when 'K' : ['<kelvin>']
+      when 'R' : RANKINE
+      when 'C' : CELCIUS
+      when 'F' : FARENHEIT
+      when 'K' : KELVIN
     end
+    @unit_name = nil
     r= self.to("tempK")
-    @numerator = r.numerator
-    @denominator = r.denominator
-    @scalar = r.scalar
+    copy(r)
   end
-  
-  
+    
   private
   
   def initialize_copy(other)
-    @numerator = other.numerator.clone
-    @denominator = other.denominator.clone
+    @numerator = other.numerator.dup
+    @denominator = other.denominator.dup
+    
   end
   
   # calculates the unit signature id for use in comparing compatible units and simplification
@@ -695,17 +845,18 @@ class Unit < Numeric
   #  http://ieeexplore.ieee.org/Xplore/login.jsp?url=/iel1/32/9079/00403789.pdf?isnumber=9079&prod=JNL&arnumber=403789&arSt=651&ared=661&arAuthor=Novak%2C+G.S.%2C+Jr.
   #
   def unit_signature
+    return @signature unless @signature.nil?
     vector = unit_signature_vector
     vector.each_with_index {|item,index| vector[index] = item * 20**index}
     @signature=vector.inject(0) {|sum,n| sum+n}
   end
   
   def self.eliminate_terms(q, n, d)
-    num = n.clone
-    den = d.clone
+    num = n.dup
+    den = d.dup
     
-    num.delete_if {|v| v == '<1>'}
-    den.delete_if {|v| v == '<1>'}
+    num.delete_if {|v| v == UNITY}
+    den.delete_if {|v| v == UNITY}
     combined = Hash.new(0)
  
     i = 0
@@ -718,7 +869,7 @@ class Unit < Numeric
         k = num[i]
         i += 1
       end
-      combined[k] += 1 unless k.nil? || k == '<1>'
+      combined[k] += 1 unless k.nil? || k == UNITY
     end
     
     j = 0
@@ -731,19 +882,19 @@ class Unit < Numeric
           k = den[j]
           j += 1
         end
-      combined[k] -= 1 unless k.nil? || k == '<1>'
+      combined[k] -= 1 unless k.nil? || k == UNITY
     end
  
     num = []
     den = []
-    combined.each do |key,value| 
+    for key, value in combined do 
       case 
       when value > 0 : value.times {num << key}
       when value < 0 : value.abs.times {den << key}
       end
     end
-    num = ["<1>"] if num.empty?
-    den = ["<1>"] if den.empty?
+    num = UNITY_ARRAY if num.empty?
+    den = UNITY_ARRAY if den.empty?
     {:scalar=>q, :numerator=>num.flatten.compact, :denominator=>den.flatten.compact}
   end
       
@@ -759,36 +910,47 @@ class Unit < Numeric
   #  "GPa"  -- creates a unit with scalar 1 with units 'GPa'
   #  6'4"  -- recognized as 6 feet + 4 inches
   #  8 lbs 8 oz -- recognized as 8 lbs + 8 ounces 
-  def parse(unit_string="0")
-    @numerator = ['<1>']
-    @denominator = ['<1>']
+  def parse(passed_unit_string="0")
+
+    unit_string = passed_unit_string.dup
+    if unit_string =~ /\$\s*(#{NUMBER_REGEX})/
+      unit_string = "#{$1} USD"
+    end
+    if unit_string =~ /(#{SCI_NUMBER})\s*%/
+      unit_string = "#{$1} percent"
+    end
+
+    unit_string =~ NUMBER_REGEX
+    unit = @@cached_units[$2] 
+    mult = ($1.empty? ? 1.0 : $1.to_f) rescue 1.0
+    if unit
+      copy(unit)
+      @scalar *= mult
+      @base_scalar *= mult
+      return self
+    end
+  
     unit_string.gsub!(/[<>]/,"")
      
     # Special processing for unusual unit strings
     # feet -- 6'5"
-    feet, inches = unit_string.scan(/(\d+)\s*(?:'|ft|feet)\s*(\d+)\s*(?:"|in|inches)/)[0]
+    feet, inches = unit_string.scan(FEET_INCH_REGEX)[0]
     if (feet && inches)
       result = Unit.new("#{feet} ft") + Unit.new("#{inches} inches")
-      @scalar = result.scalar
-      @numerator = result.numerator
-      @denominator = result.denominator
-      @base_scalar = result.base_scalar
+      copy(result)
       return self
     end
 
     # weight -- 8 lbs 12 oz    
-    pounds, oz = unit_string.scan(/(\d+)\s*(?:#|lbs|pounds)+[\s,]*(\d+)\s*(?:oz|ounces)/)[0]
+    pounds, oz = unit_string.scan(LBS_OZ_REGEX)[0]
     if (pounds && oz)
       result = Unit.new("#{pounds} lbs") + Unit.new("#{oz} oz")
-      @scalar = result.scalar
-      @numerator = result.numerator
-      @denominator = result.denominator
-      @base_scalar = result.base_scalar
+      copy(result)
       return self
     end
-    @scalar, top, bottom = unit_string.scan(/([\dEe+.-]*)\s*([^\/]*)\/*(.+)*/)[0]  #parse the string into parts
+    @scalar, top, bottom = unit_string.scan(UNIT_STRING_REGEX)[0]  #parse the string into parts
     
-    top.scan(/([^ \*]+)(?:\^|\*\*)([\d-]+)/).each do |item|
+    top.scan(TOP_REGEX).each do |item|
       n = item[1].to_i
       x = "#{item[0]} "
       case 
@@ -796,33 +958,27 @@ class Unit < Numeric
         when n<0 : bottom = "#{bottom} #{x * -n}"; top.gsub!(/#{item[0]}(\^|\*\*)#{n}/,"")
       end
     end 
-
-    bottom.gsub!(/([^* ]+)(?:\^|\*\*)(\d+)/) {|s| "#{$1} " * $2.to_i} if bottom
-    if @scalar.empty?
-      if top =~ /[\dEe+.-]+/
-        @scalar = top.to_f  # need this for 'number only' initialization
-      else
-        @scalar = 1         # need this for 'unit only' intialization
-      end
-    else
-      @scalar = @scalar.to_f
-    end
-            
-    @numerator = top.scan(/(#{@@PREFIX_REGEX})*?(#{@@UNIT_REGEX})\b/).delete_if {|x| x.empty?}.compact if top
-    @denominator = bottom.scan(/(#{@@PREFIX_REGEX})*?(#{@@UNIT_REGEX})\b/).delete_if {|x| x.empty?}.compact if bottom
+    bottom.gsub!(BOTTOM_REGEX) {|s| "#{$1} " * $2.to_i} if bottom
+    @scalar = @scalar.to_f unless @scalar.nil? || @scalar.empty?
+    @scalar = 1 unless @scalar.kind_of? Numeric 
+        
+    @numerator ||= UNITY_ARRAY
+    @denominator ||= UNITY_ARRAY
+    @numerator = top.scan(@@UNIT_MATCH_REGEX).delete_if {|x| x.empty?}.compact if top
+    @denominator = bottom.scan(@@UNIT_MATCH_REGEX).delete_if {|x| x.empty?}.compact if bottom
+    us = "#{(top || '' + bottom || '')}".to_s.gsub(@@UNIT_MATCH_REGEX,'').gsub(/[\d\*, "'_^\/\$]/,'')
+    raise( ArgumentError, "'#{passed_unit_string}' Unit not recognized (#{us})") unless us.empty?
 
     @numerator = @numerator.map do |item|
-      item.map {|x| Regexp.escape(x) if x}
        @@PREFIX_MAP[item[0]] ? [@@PREFIX_MAP[item[0]], @@UNIT_MAP[item[1]]] : [@@UNIT_MAP[item[1]]]
     end.flatten.compact.delete_if {|x| x.empty?}
 
     @denominator = @denominator.map do |item|
-       item.map {|x| Regexp.escape(x) if x}
        @@PREFIX_MAP[item[0]] ? [@@PREFIX_MAP[item[0]], @@UNIT_MAP[item[1]]] : [@@UNIT_MAP[item[1]]]
     end.flatten.compact.delete_if {|x| x.empty?}
 
-    @numerator = ['<1>'] if @numerator.empty?    
-    @denominator = ['<1>'] if @denominator.empty?
+    @numerator = UNITY_ARRAY if @numerator.empty? 
+    @denominator = UNITY_ARRAY if @denominator.empty?
     self
   end 
 end
@@ -832,9 +988,11 @@ end
 # Date.today + U"1 week" => gives today+1 week
 class Date
   alias :unit_date_add :+
-  def +(unit)
+  def +unit
     case unit
-    when Unit: unit_date_add(unit.to('day').scalar)
+    when Unit:
+      unit = unit.to('d').round if ['y', 'decade', 'century'].include? unit.units 
+      unit_date_add(unit.to('day').scalar)
     when Time: unit_date_add(unit.to_datetime)
     else
       unit_date_add(unit)
@@ -842,9 +1000,11 @@ class Date
   end
 
   alias :unit_date_sub :-    
-  def -(unit)
+  def -unit
     case unit
-    when Unit: unit_date_sub(unit.to('day').scalar)
+    when Unit: 
+      unit = unit.to('d').round if ['y', 'decade', 'century'].include? unit.units 
+      unit_date_sub(unit.to('day').scalar)
     when Time: unit_date_sub(unit.to_datetime)
     else
       unit_date_sub(unit)
@@ -864,9 +1024,10 @@ class Date
 end
 
 class Object
-  def Unit(other)
+  def Unit(*other)
     other.to_unit
   end
+  
   alias :U :Unit
   alias :u :Unit
 end
@@ -874,7 +1035,7 @@ end
 # make a unitless unit with a given scalar
 class Numeric
   def to_unit(other = nil)
-    other ? Unit.new(self) * Unit.new(other) : Unit.new(self)
+    other ? Unit.new(self, other) : Unit.new(self)
   end
   alias :unit :to_unit
   alias :u :to_unit
@@ -893,7 +1054,7 @@ end
 # make a string into a unit
 class String
   def to_unit(other = nil)
-    other ? Unit.new(self) >> other : Unit.new(self)
+    other ? Unit.new(self).to(other) : Unit.new(self)
   end
   alias :unit :to_unit
   alias :u :to_unit
@@ -961,6 +1122,16 @@ class String
     raise RuntimeError, "Invalid Time String" if r == DateTime.new      
     return r
   end
+  
+  def to_date(options={})
+    begin
+      r = Chronic.parse(self,options).to_date
+    rescue
+      r = Date.civil(*ParseDate.parsedate(self)[0..5].compact)
+    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)
@@ -994,6 +1165,10 @@ class Time
     DateTime.civil(1970,1,1)+(self.to_f+self.gmt_offset)/86400
   end
   
+  def to_date
+    Date.civil(1970,1,1)+(self.to_f+self.gmt_offset)/86400
+  end
+  
   def +(other)
     case other
     when Unit: unit_add(other.to('s').scalar)
@@ -1085,4 +1260,6 @@ module Math
    module_function :tan
    module_function :unit_tanh
    module_function :tanh
-end
+end
+
+Unit.setup

data/lib/units.rb

@@ -71,6 +71,7 @@ UNIT_DEFINITIONS = {
   #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>}],
@@ -87,6 +88,9 @@ UNIT_DEFINITIONS = {
   '<mph>' => [%w{mph}, 0.44704, :speed, %w{<meter>}, %w{<second>}],
   '<knot>' => [%w{kn 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 Kelvin}, 1.0, :temperature, %w{<kelvin>}],
@@ -184,15 +188,15 @@ UNIT_DEFINITIONS = {
   '<steradian>'  => [%w{sr steradian steradians}, 1.0, :solid_angle, %w{<steradian>}],
 
   #rotation
-  '<rotation>' => [%w{rotation}, 2.0*Math::PI, :rotation, %w{<radian>}],
-  '<rpm>'   =>[%w{rpm}, 2.0*Math::PI / 60.0, :rotation, %w{<radian>}, %w{<second>}],
+  '<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>}],
 
-  #money
-  '<dollar>'=>[['$','dollar','USD'], 1.0, :currency, %w{<dollar>}],
+  #currency
+  '<dollar>'=>[%w{USD dollar}, 1.0, :currency, %w{<dollar>}],
   '<cents>' =>[%w{cents}, 0.01, :currency, %w{<dollar>}],
 
   #luminosity
@@ -204,25 +208,29 @@ UNIT_DEFINITIONS = {
   '<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>}],
 
-  #radition
+  #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>}],
-  '<cpm>' => [%w{cpm}, 1.0/60.0, :radiation, %w{<1>},%w{<second>}],
-  '<dpm>' => [%w{dpm}, 1.0/60.0, :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>}],
 
   #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{<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{<centi>}],
-  '<ppm>' =>  [%w{ppm},1e-6,:prefix_only, %w{<micro>}],
-  '<ppt>' =>  [%w{ppt},1e-9,:prefix_only, %w{<nano>}],
+  '<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>}]
 

data/test/test_ruby-units.rb

@@ -1,13 +1,12 @@
 require 'test/unit'
-require 'rubygems'
 require 'ruby-units'
-require 'yaml'
 require 'uncertain'
+require 'rubygems'
+require 'yaml'
 require 'chronic'
 
 class Unit < Numeric
   @@USER_DEFINITIONS = {'<inchworm>' =>  [%w{inworm inchworm}, 0.0254, :length, %w{<meter>} ],
-                        '<cell>' => [%w{cells cell}, 1, :counting, %w{<each>}],
                         '<habenero>'   => [%{degH}, 100, :temperature, %w{<celcius>}]}
   Unit.setup
 end
@@ -226,7 +225,7 @@ class TestRubyUnits < Test::Unit::TestCase
   end
   
   def test_create_from_array
-    unit1 = Unit.new([1, "mm^2", "ul^2"])
+    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
@@ -712,8 +711,28 @@ class TestRubyUnits < Test::Unit::TestCase
   end
   
   def test_format
-    assert_equal "%0.2f" % "1 mm".unit, "1.00 mm"
-    
+    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 {a = "$1".unit}
+  end
+  
+  def test_kind
+    a = "1 mm".unit
+    assert_equal a.kind, :length
+  end
+  
+  def test_percent
+      assert_nothing_raised {
+       z = "1 percent".unit
+        a = "1%".unit
+        b = "0.01%".unit
+      }
+  end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: ruby-units
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
-date: 2006-09-22 00:00:00 -04:00
+  version: 0.3.1
+date: 2006-10-02 00:00:00 -04:00
 summary: A model that performs unit conversions and unit math
 require_paths: 
 - lib