ruby-units 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Kevin C. Olbrich
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,85 @@
+=Ruby Units
+
+Version: 0.1.0
+
+Kevin C. Olbrich, Ph.D.
+
+http://www.sciwerks.com
+
+Project page: http://rubyforge.org/projects/ruby-units
+
+==Introduction
+Many technical applications make use of specialized calculations at some point.  Frequently, these calculations require unit conversions to ensure accurate results.  Needless to say, this is a pain to properly keep track of, and is prone to numerous errors.
+  
+==Solution
+The 'Ruby units' gem is designed so simplify the handling of units for scientific calculations.  The units of each quantity are specified when a Unit object is created and the Unit class will handle all subsequent conversions and manipulations to ensure an accurate result.
+  
+==Installation:
+This package may be installed using:
+ gem install ruby-units
+  
+==Usage:
+ unit = Unit.new("1")             # constant only
+ unit = Unit.new("mm")            # unit only (defaults to a value of 1)
+ unit = Unit.new("1 mm")          # create a simple unit
+ unit = Unit.new("1 mm/s")        # a compound unit
+ unit = Unit.new("1 mm s^-1")     # in exponent notation
+ unit = Unit.new("1 kg*m^2/s^2")  # complex unit
+ unit = Unit.new("1 kg m^2 s^-2") # complex unit
+ unit = Unit("1 mm")              # shorthand
+ unit = "1 mm".to_unit            # convert string object
+ unit = object.to_unit            # convert any object using object.to_s
+
+==Rules:  
+1. only 1 quantity per unit (with 2 exceptions... 6'5" and '8 lbs 8 oz')
+2. use SI notation when possible
+3. avoid using spaces in unit names
+
+==Unit compatability:
+Many methods require that the units of two operands are compatible.  Compatible units are those that can be easily converted into each other, such as 'meters' and 'feet'.
+
+ unit1 =~ unit2   #=> true if units are compatible
+
+==Unit Math:
+
+<b>Method</b>::  <b>Comment</b>
+ Unit#+()::       Add. only works if units are compatible
+ Unit#-()::       Subtract. only works if units are compatible
+ Unit#*()::       Multiply.  
+ Unit#/()::       Divide.
+ Unit#**()::      Exponentiate.  Exponent must be an integer, can be positive,  negative, or zero                        
+ Unit#inverse:: Returns 1/unit
+ Unit#abs::     Returns absolute value of the unit quantity.  Strips off the  units
+ Unit#ceil::    rounds quantity to next highest integer
+ Unit#floor::   rounds quantity down to next lower integer
+ Unit#round::   rounds quantity to nearest integer
+ Unit#to_int::  returns the quantity as an integer
+ 
+Unit will coerce other objects into a Unit if used in a formula.  This means that ..
+ 
+ Unit("1 mm") + "2 mm"  == Unit("3 mm")
+ 
+This will work as expected so long as you start the formula with a Unit object. 
+
+==Conversions & comparisons
+
+Units can be converted to other units in a couple of ways.
+
+ unit1 = unit >> "ft"   # => convert to 'feet'
+ unit >>= "ft"          # => convert and overwrite original object
+ unit3 = unit1 + unit2  # => resulting object will have the units of unit1
+ unit3 = unit1 - unit2  # => resulting object will have the units of unit1
+ unit1 <=> unit2        # => does comparison on quantities in base units, throws an exception if not compatible
+ unit1 === unit2        # => true if units and quantity are the same, even if 'equivalent' by <=>
+ 
+==Text Output
+Units will display themselves nicely based on the preferred abbreviation for the units and prefixes.
+Since Unit implements a Unit#to_s, all that is needed in most cases is:
+ "#{Unit.new('1 mm')}"  #=> "1 mm"
+ 
+The to_s also accepts some options.
+ Unit.new('1.5 mm').to_s("%0.2f")  # => "1.50 mm".  Enter any valid format string
+ Unit.new('1.5 mm').to_s("in")     # => converts to inches before printing
+ Unit.new("2 m").to_s(:ft)         #=> returns 6'7"
+ Unit.new("100 kg").to_s(:lbs)     #=> returns 220 lbs, 7 oz
+ 

data/lib/ruby_units.rb

@@ -0,0 +1,596 @@
+
+# = Ruby Units
+#
+# Copyright 2006 by Kevin C. Olbrich, Ph.D.
+# 
+# See http://rubyforge.org/ruby-units/
+#
+# http://www.sciwerks.org
+#
+# mailto://kevin.olbrich+ruby-units@gmail.com
+#
+# See README for detailed usage instructions and examples
+#
+# =Unit Definition Format
+#
+#  '<name>'  => [%w{prefered_name synonyms}, conversion_to_base, :classification, %w{<base> <units> <in> <numerator>} , %w{<base> <units> <in> <denominator>} ],
+#
+# Prefixes (e.g., a :prefix classification) get special handling
+# Note: The accuracy of unit conversions depends on the precision of the conversion factor.
+# If you have more accurate estimates for particular conversion factors, please send them 
+# to me and I will incorporate them into the next release.  It is also incumbent on the end-user
+# to ensure that the accuracy of any conversions is sufficient for their intended application.
+#
+# While there are a large number of unit specified in the base package, 
+# there are also a large number of units that are not included.
+# This package covers nearly all SI, Imperial, and units commonly used
+# in the United States. If your favorite units are not listed here, send me an email
+#
+# Future versions will provide a simple interface for the end-user to specify
+# custom units.
+class Unit < Numeric
+  require 'units'
+  # pre-generate hashes from unit definitions for performance.  
+  @@USER_DEFINITIONS = {}
+  @@PREFIX_VALUES = {}
+  @@PREFIX_MAP = {}
+  @@UNIT_MAP = {}
+  @@UNIT_VALUES = {}
+  @@OUTPUT_MAP = {}
+  @@UNIT_VECTORS = {}
+
+  def self.setup
+    (UNIT_DEFINITIONS.merge!(@@USER_DEFINITIONS)).each do |key, value|
+      if value[2] == :prefix then
+        @@PREFIX_VALUES[Regexp.escape(key)]=value[1]
+        value[0].each {|x| @@PREFIX_MAP[Regexp.escape(x)]=key}    
+      else
+        @@UNIT_VALUES[Regexp.escape(key)]={}
+        @@UNIT_VALUES[Regexp.escape(key)][:quantity]=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)]
+      end
+      @@OUTPUT_MAP[Regexp.escape(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('|')
+  end
+  
+  self.setup
+  
+  include Comparable
+  attr_reader :quantity, :numerator, :denominator, :signature, :base_quantity
+
+  # Create a new Unit object.  Can be initialized using a string, or a hash
+  # Valid formats include:
+  #  "5.6 kg*m/s^2"
+  #  "5.6 kg*m*s^-2"
+  #  "5.6 kilogram*meter*second^-2"
+  #  "2.2 kPa"
+  #  "37 degC"
+  #  "1"  -- creates a unitless constant with value 1
+  #  "GPa"  -- creates a unit with quantity 1 with units 'GPa'
+  #  6'4"  -- recognized as 6 feet + 4 inches
+  #  8 lbs 8 oz -- recognized as 8 lbs + 8 ounces
+  #
+  def initialize(options)
+    if options.kind_of? String
+      parse(options)
+    elsif options.kind_of? Hash
+      @quantity = options[:quantity] || 1
+      @numerator = options[:numerator] || ["<1>"]
+      @denominator = options[:denominator] || []
+    else
+      raise ArgumentError, "Unknown Unit Specification"
+    end
+    self.update_base_quantity
+    self.unit_signature
+    self.freeze
+  end
+  
+  def initialize_copy(other)
+    @numerator = other.numerator.clone
+    @denominator = other.denominator.clone
+  end
+    
+  # Returns 'true' if the Unit is represented in base units
+  def is_base?
+    n = @numerator + @denominator
+    n.each do |x|
+      return false unless x == '<1>' || (@@UNIT_VALUES[Regexp.escape(x)] && @@UNIT_VALUES[Regexp.escape(x)][:numerator].include?(Regexp.escape(x)))
+    end
+    return true
+  end  
+  
+  #convert to base SI units
+  def to_base
+    return self if self.is_base?
+    num = []
+    den = []
+    q = @quantity.to_f
+    @numerator.each do |unit|
+        if @@PREFIX_VALUES[Regexp.escape(unit)]
+          q *= @@PREFIX_VALUES[Regexp.escape(unit)]
+        else
+          q *= @@UNIT_VALUES[Regexp.escape(unit)][:quantity] 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]
+        end
+    end
+
+    @denominator.each do |unit|
+        if @@PREFIX_MAP[Regexp.escape(unit)]
+          q /= @@PREFIX_MAP[Regexp.escape(unit)]
+        else
+          q /= @@UNIT_VALUES[Regexp.escape(unit)][:quantity] 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]
+        end
+    end
+    num = num.flatten.compact
+    den = den.flatten.compact
+    num = ['<1>'] if num.empty?
+   
+    Unit.new(Unit.eliminate_terms(q,num,den))
+  end
+  
+  # Generate human readable output.
+  # If the name of a unit is passed, the quantity will first be converted to the target unit before output.
+  # some named conversions are available
+  #
+  #  :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 >> "in").to_f
+      "#{(inches / 12).truncate}\'#{(inches % 12).round}\""
+    when :lbs:
+      ounces = (self >> "oz").to_f
+      "#{(ounces / 16).truncate} lbs, #{(ounces % 16).round} oz"
+    else
+      target_units =~ /(%[\w\d#+-.]*)*\s*(.+)*/
+      format_string = "#{$1}" if $1
+      units = $2
+      return (self >> units).to_s(format_string) if units
+      "#{(format_string || '%g') % @quantity} #{self.to_unit}".strip
+    end    
+  end
+  
+  # Compare two Unit objects. Throws an exception if they are not of compatible types.
+  # Comparisons are done based on the value of the unit in base SI units.
+  def <=>(other)
+    raise ArgumentError, "Incompatible Units" unless self =~ other
+    return self.base_quantity <=> other.base_quantity
+  end
+  
+  # check to see if units are compatible, but not the quantity part
+  # this check is done by comparing signatures for performance reasons
+  # if passed a string, it will create a unit object with the string and then do the comparison
+  # this permits a syntax like:  
+  #  unit =~ "mm"
+  # if you want to do a regexp on the unit string do this ...
+  #  unit.to_unit =~ /regexp/
+  def =~(other)
+    case other
+    when Unit : self.signature == other.signature
+    else
+      x,y = coerce(other)
+      x =~ y
+    end 
+  end
+  
+  # Compare two units.  Returns true if quantities and units match
+  #
+  # Unit("100 cm") === Unit("100 cm")   # => true
+  # Unit("100 cm") === Unit("1 m")      # => false
+  def ===(other)
+    case other
+    when Unit: (self.quantity == other.quantity) && (self.to_unit == other.to_unit)
+    else
+      x,y = coerce(other)
+      x === y
+    end
+  end
+  
+  # Add two units together.  Result is same units as receiver and quantity and base_quantity are updated appropriately
+  # throws an exception if the units are not compatible.
+  def +(other)   
+    if Unit === other 
+      if self =~ other then
+        q = @quantity + (other >> self).quantity
+        Unit.new(:quantity=>q, :numerator=>self.numerator, :denominator=>self.denominator)
+      else
+         raise ArgumentError,  "Incompatible Units"
+      end
+    else
+        x,y = coerce(other)
+        x + y
+    end
+  end
+  
+  # Subtract two units. Result is same units as receiver and quantity and base_quantity are updated appropriately
+  # throws an exception if the units are not compatible.
+  def -(other)
+    if Unit === other 
+      if self =~ other then
+        q = @quantity - (other >> self).quantity
+        Unit.new(:quantity=>q, :numerator=>self.numerator, :denominator=>self.denominator)
+      else
+         raise ArgumentError,  "Incompatible Units"
+      end
+    else
+        x,y = coerce(other)
+        x - y
+    end
+  end
+  
+  # Multiply two units.
+  # Throws an exception if multiplier is not a Unit or Numeric
+  def *(other)
+    if Unit === other
+      Unit.new(Unit.eliminate_terms(@quantity*other.quantity, @numerator + other.numerator ,@denominator + other.denominator))      
+    else
+      x,y = coerce(other)
+      x * y
+    end
+  end
+  
+  # Divide two units.
+  # Throws an exception if divisor is not a Unit or Numeric
+  def /(other)
+    if Unit === other
+      Unit.new(Unit.eliminate_terms(@quantity/other.quantity, @numerator + other.denominator ,@denominator + other.numerator))      
+    else
+      x,y = coerce(other)
+      y / x
+    end
+  end
+    
+  # Exponentiate.  Only takes integer powers. 
+  # Note that anything raised to the power of 0 results in a Unit object with a quantity of 1, and no units.
+  # Throws an exception if exponent is not an integer.
+  def **(other)
+    raise ArgumentError,  "Exponent must be Integer" unless Integer === other
+    case 
+      when other.to_i > 0  :  (1..other.to_i).inject(Unit.new("1")) {|product, n| product * self}
+      when other.to_i == 0 : Unit.new("1")
+      when other.to_i < 0  :  (1..-other.to_i).inject(Unit.new("1")) {|product, n| product / self}
+    end
+  end
+  
+  # returns inverse of Unit (1/unit)
+  def inverse
+    (Unit.new("1") / self)
+  end
+  
+  # convert to a specified unit string or to the same units as another Unit
+  # 
+  #  unit >> "kg"  will covert to kilograms
+  #  unit1 >> unit2 converts to same units as unit2 object
+  # 
+  # To convert a Unit object to match another Unit object, use:
+  #  unit1 >>= unit2
+  # Throws an exception if the requested target units are incompatible with current Unit.
+  #
+  # Special handling for temperature conversions is supported.  If the Unit object is converted
+  # from one temperature unit to another, the proper temperature offsets will be used.
+  # Supports Kelvin, Celcius, Farenheit, and Rankine scales.
+  #
+  # Note that if temperature is part of a compound unit, the temperature will be treated as a differential
+  # and the units will be scaled appropriately.
+  def >>(other)
+    case other.class.to_s
+      when 'Unit': target = other
+      when 'String': target = Unit.new(other)
+      else
+        raise ArgumentError, "Unknown target units"
+    end
+    raise ArgumentError,  "Incompatible Units" unless self =~ target
+    if target.signature == 400 then   # special handling for temperature conversions
+      q=case self.numerator[0]
+      when '<celcius>':
+        case target.numerator[0]
+          when '<celcius>'  : @quantity
+          when '<kelvin>'   : @quantity + 273.15
+          when '<farenheit>': @quantity * (9.0/5.0) + 32.0
+          when '<rankine>'  : @quantity * (9.0/5.0) + 491.67
+        else
+          raise ArgumentError, "Unknown temperature conversion requested"
+        end
+      when '<kelvin>':
+        case target.numerator[0]
+          when '<celcius>'  : @quantity - 273.15
+          when '<kelvin>'   : @quantity 
+          when '<farenheit>': @quantity * (9.0/5.0) - 459.67
+          when '<rankine>'  : @quantity * (9.0/5.0) 
+        else
+          raise ArgumentError, "Unknown temperature conversion requested"
+        end
+      when '<farenheit>':
+        case target.numerator[0]
+          when '<celcius>'  : (@quantity-32)*(5.0/9.0)
+          when '<kelvin>'   : (@quantity+459.67)*(5.0/9.0)
+          when '<farenheit>': @quantity 
+          when '<rankine>'  : @quantity  + 459.67
+        else
+          raise ArgumentError, "Unknown temperature conversion requested"
+        end
+      when '<rankine>':
+        case target.numerator[0]
+          when '<celcius>'  : @quantity*(5.0/9.0) -273.15
+          when '<kelvin>'   : @quantity*(5.0/9.0)
+          when '<farenheit>': @quantity - 459.67
+          when '<rankine>'  : @quantity
+        else
+          raise ArgumentError, "Unknown temperature conversion requested"
+        end
+      else
+        raise ArgumentError, "Unknown temperature conversion requested"
+      end
+      Unit.new(:quantity=>q, :numerator=>target.numerator, :denominator=>target.denominator)
+    else
+      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)][:quantity] }.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)][:quantity] }.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)][:quantity] }.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)][:quantity] }.compact
+      y = one.inject(1) {|product,n| product*n} / two.inject(1) {|product,n| product*n}
+      q = @quantity * v/y
+      Unit.new(:quantity=>q, :numerator=>target.numerator, :denominator=>target.denominator)
+    end
+  end  
+  
+  # calculates the unit signature vector used by unit_signature
+  def unit_signature_vector
+      result = self.to_base
+      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.find_all {|x| @@UNIT_VECTORS[units].include? Regexp.escape(x)}.size
+        vector[index] -= result.denominator.find_all {|x| @@UNIT_VECTORS[units].include? Regexp.escape(x)}.size  
+      end
+      vector
+  end
+  
+  # calculates the unit signature id for use in comparing compatible units and simplification
+  # the signature is based on a simple classification of units and is based on the following publication
+  #  
+  #  Novak, G.S., Jr. "Conversion of units of measurement", IEEE Transactions on Software Engineering,
+  #  21(8), Aug 1995, pp.651-661
+  #  doi://10.1109/32.403789
+  #  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
+    vector = unit_signature_vector
+    vector.each_with_index {|item,index| vector[index] = item * 20**index}
+    @signature=vector.inject(0) {|sum,n| sum+n}
+  end
+  
+  # Eliminates terms in the passed numerator and denominator.  Expands out prefixes and applies them to the 
+  # quantity.  Returns a hash that can be used to initialize a new Unit object. 
+  def self.eliminate_terms(q, n, d)
+    num = n.clone
+    den = d.clone
+    
+    # cancel terms in both numerator and denominator
+    num.each_with_index do |item,index| 
+      if i=den.index(item)
+        num.delete_at(index)
+        den.delete_at(i)
+      end
+    end
+    
+    num = num.flatten.compact
+    den = den.flatten.compact
+    
+    # substitute in SI prefix multipliers and numerical constants
+    num.each_with_index do |item, index|
+      if item =~ /<([\dEe+-.]+)>/
+        q *= $1.to_f
+        num.delete_at(index)
+      elsif multiplier=@@PREFIX_VALUES[Regexp.escape(item)]
+        q *= multiplier
+        num.delete_at(index)
+      end
+    end
+    
+    den.each_with_index do |item, index|
+      if item =~ /<([\dEe+-.]+)>/
+        q /= $1.to_f
+        den.delete_at(index)
+      elsif multiplier=@@PREFIX_VALUES[Regexp.escape(item)]
+        q /= multiplier
+        den.delete_at(index)
+      end
+    end
+    num = ["<1>"] if num.empty?
+    den = ["<1>"] if den.empty? 
+    {:quantity=>q, :numerator=>num, :denominator=>den}
+  end
+      
+  # returns the quantity part of the Unit
+  def to_f
+    @quantity
+  end
+  
+  # returns the 'unit' part of the Unit object without the quantity
+  def to_unit
+    return "" if @numerator == ["<1>"] && @denominator == ["<1>"]
+    output_n = [] 
+    num = @numerator.clone
+    den = @denominator.clone
+    if @numerator == ["<1>"]
+      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(@numerator[index+1])]}"
+          num[index+1]=nil
+        else
+          output_n << "#{@@OUTPUT_MAP[Regexp.escape(token)]}" if token
+        end
+      end
+    end
+    output_d = den.map do |token|
+      @@PREFIX_MAP[Regexp.escape(token)] ? @@OUTPUT_MAP[Regexp.escape(token)] : "#{@@OUTPUT_MAP[Regexp.escape(token)]} "
+    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    
+  end
+  
+  # negates the quantity of the Unit
+  def -@
+    q = -self.quantity
+    Unit.new(:quantity=>q, :numerator=>self.numerator, :denominator=>self.denominator)    
+  end
+  
+  # returns abs of quantity, without the units
+  def abs
+    return @quantity.abs
+  end
+  
+  def ceil
+    q = self.quantity.ceil
+    Unit.new(:quantity=>q, :numerator=>self.numerator, :denominator=>self.denominator)    
+  end
+  
+  def floor
+    q = self.quantity.floor
+    Unit.new(:quantity=>q, :numerator=>self.numerator, :denominator=>self.denominator)    
+  end
+  
+  def to_int
+    q = self.quantity.to_int
+    Unit.new(:quantity=>q, :numerator=>self.numerator, :denominator=>self.denominator)    
+  end
+  
+  alias :to_i :to_int
+  alias :truncate :to_int
+  
+  def round
+    q = self.quantity.round
+    Unit.new(:quantity=>q, :numerator=>self.numerator, :denominator=>self.denominator)
+  end
+   
+  # true if quantity is zero
+  def zero?
+    return @quantity.zero?
+  end
+  
+  # returns self if zero? is false, nil otherwise  
+  #def nonzero?
+  #  self.zero? ? nil : self
+  #end
+    
+  def update_base_quantity
+    @base_quantity = self.is_base? ? @quantity : self.to_base.quantity
+    self
+  end
+  
+  def coerce(other)
+    case other
+    when Unit : [other, self]
+    when String : [Unit.new(other), self]
+    else 
+      [Unit.new(other.to_s), self]
+    end
+  end
+  
+  private
+  
+  # parse a string into a unit object.
+  # Typical formats like : 
+  #  "5.6 kg*m/s^2"
+  #  "5.6 kg*m*s^-2"
+  #  "5.6 kilogram*meter*second^-2"
+  #  "2.2 kPa"
+  #  "37 degC"
+  #  "1"  -- creates a unitless constant with value 1
+  #  "GPa"  -- creates a unit with quantity 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>']
+     
+    # Special processing for unusual unit strings
+    # feet -- 6'5"
+    feet, inches = unit_string.scan(/(\d+)[\s*|'|ft|feet\s*](\d+)[\s*|"|in|inches]/)[0]
+    if (feet && inches)
+      result = Unit.new("#{feet} ft") + Unit.new("#{inches} inches")
+      @quantity = result.quantity
+      @numerator = result.numerator
+      @denominator = result.denominator
+      @base_quantity = result.base_quantity
+      return self
+    end
+
+    # weight -- 8 lbs 12 oz    
+    pounds, oz = unit_string.scan(/(\d+)[\s|#|lbs|pounds|,]+(\d+)[\s*|oz|ounces]/)[0]
+    if (pounds && oz)
+      result = Unit.new("#{pounds} lbs") + Unit.new("#{oz} oz")
+      @quantity = result.quantity
+      @numerator = result.numerator
+      @denominator = result.denominator
+      @base_quantity = result.base_quantity
+      return self
+    end
+     
+    @quantity, top, bottom = unit_string.scan(/([\dEe+.-]*)\s*([^\/]*)\/*(.+)*/)[0]  #parse the string into parts
+
+    top.scan(/([^ \*]+)\^([\d-]+)/).each do |item|
+      n = item[1].to_i
+      x = "#{item[0]} "
+      case 
+        when n>=0 : top.gsub!(/([^ \*]+)\^(\d+)/) {|s| x * n}
+        when n<0 : bottom = "#{bottom} #{x * -n}"; top.gsub!("#{item[0]}^#{item[1]}","")
+      end
+    end 
+    
+    bottom.gsub!(/([^* ]+)\^(\d+)/) {|s| "#{$1} " * $2.to_i} if bottom
+  
+    if @quantity.empty?
+      if top =~ /[\dEe+.-]+/
+        @quantity = top.to_f  # need this for 'number only' initialization
+      else
+        @quantity = 1         # need this for 'unit only' intialization
+      end
+    else
+      @quantity = @quantity.to_f
+    end
+      
+    @numerator = top.scan(/((#{@@PREFIX_REGEX})*(#{@@UNIT_REGEX}))/).delete_if {|x| x.empty?}.compact if top
+    @denominator = bottom.scan(/((#{@@PREFIX_REGEX})*(#{@@UNIT_REGEX}))/).delete_if {|x| x.empty?}.compact if bottom
+
+    @numerator = @numerator.map do |item|
+      item.map {|x| Regexp.escape(x) if x}
+      @@UNIT_MAP[item[0]] ? [@@UNIT_MAP[item[0]]] : [@@PREFIX_MAP[item[1]], @@UNIT_MAP[item[2]]]
+    end.flatten.compact.delete_if {|x| x.empty?}
+
+    @denominator = @denominator.map do |item|
+       item.map {|x| Regexp.escape(x) if x}
+       @@UNIT_MAP[item[0]] ? [@@UNIT_MAP[item[0]]] : [@@PREFIX_MAP[item[1]], @@UNIT_MAP[item[2]]]
+    end.flatten.compact.delete_if {|x| x.empty?}
+
+    @numerator = ['<1>'] if @numerator.empty?    
+    @denominator = ['<1>'] if @denominator.empty?
+    self
+  end
+    
+end
+
+class Object
+  def Unit(other)
+    Unit.new(other.to_s)
+  end
+  
+  def to_unit
+     Unit.new(self.to_s) unless Unit === self
+  end
+end