units-system 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Javier Goizueta
+
+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.rdoc

@@ -0,0 +1,120 @@
+= Ruby Units-System
+
+Units of measure conversions for Ruby 1.9, using Ruby objects and Ruby syntax rather than text strings.
+
+There are a number of Ruby units libraries, but I don't think they take this approach (I haven't
+done much research, though.)
+
+Currently Ruby 1.9 is required because we use the feature that
+a +module.clas_eval{...}+ block can reference module's contants without qualification.
+To make this apt for Ruby 1.8 we should replace expressions such as +u{W}+ by either
++u{W()}+, +u{self.W}+ (method invocation) or +u{self::W}+ (qualified constant).
+
+Also, note that UTF-8 characters are liberally used in identifiers.
+
+= Usage examples
+
+To work with units a +units+ block can be used. Beware: in it +self+ is changed,
+so outer self methods or instance variables are not accessible, unless usigned to
+local variables.
+
+  require 'units-system'
+
+  Units.units do
+
+    # In the units environment predefined variables are available for all units and they
+    # can b combined arithmetically:
+    x = 3*m/s
+    puts x                           # => 3.0*m/s
+    # Note that SI prefixes (k for kilo, etc.) can be used as part of the unit names:
+    x += 17*km/h
+    puts x                           # => 7.72222222222222*m/s
+    puts x.to(km/h)                  # => 27.8*km/h
+    puts x.magnitude                 # => 7.72222222222222
+
+    # Let's use some unit powers: convert 3 cubic meters to litres:
+    puts (3*m**3).to(l)              # => 3000.0*l
+
+    # Now let's convert som imperial units to SI:
+    puts (100*mi/h).to_si            # => 44.704*m/s
+
+    # Note that in is a Ruby keyword, so to use inches you must use self.in:
+    puts (10*cm).to(self.in)         # => 3.93700787401575*in
+    # ...or use tha alternative nonstandard name +inch+
+    puts (10*cm).to(self.inch)       # => 3.93700787401575*inch
+
+    # Now let's use derived units, e.g. power units:
+    x = 10*kW
+    # show a verbose description of the measure:
+    puts x.describe                  # => 10.0 kiloWatt
+    # convert to base units
+    puts x.base                      # => 10000.0*(m**2*kg)/s**3
+    # a more natural notation can be used instead of the default Ruby syntax:
+    puts x.base.abr                  # => 10000.0 (m^2 kg)/s^3
+
+    # Note that unit names that start with uppercase letters are OK:
+    puts 11*W                        # => 11.0*W
+    puts (2*Mg).to(kg)               # => 2000.0*kg
+
+    # Let's use kilograms-force (kiloponds) (not a SI unit)
+    x = 10*kgf
+    puts x                           # => 10.0*kgf
+    # conversion to SI units uses the SI unit of force the newton N (which is a derived unit)
+    puts x.to_si                     # => 98.0665*N
+    # conversion to base units substitutes derived units for base units
+    puts x.base                      # => 98066.5*(g*m)/s**2
+    # but g (gram) is not a base SI unit, to get SI base units we must:
+    puts x.base.to_si                # => 98.0665*(kg*m)/s**2
+
+    # And now, for some trigonometry fun! (note the use of unicode characters)
+    x = 90*°
+    puts x                           # => 90.0*°
+    puts x.to(rad)                   # => 1.5707963267949*rad
+    puts sin(x)                      # => 1.0
+
+    puts sin(45*°+30*′+10*″)         # => 0.713284429355996
+
+    puts asin(0.5)                   # => 0.523598775598299*rad
+    puts asin(0.5).to(°)             # => 30.0*°
+    puts asin(0.5).in(°)             # => 30.0
+
+    puts atan2(10*cm, 0.1*m).to(°)   # => 45.0*°
+
+    # Temperature conversions may be absolute (convert levels of temperature)
+    # or relative (convert differences of temperature)
+    # When a measure has a single unit of temperature, conversion is absolute:
+    puts (20*°C).to(K)               # => 293.15*K
+    puts (20*°C).to(°F)              # => 67.9999999999999*°F
+    puts (20*mK).to(°C)              # => -273.13*°C
+    # In other cases conversion is relative:
+    puts (2*°C/h).to(K/h)            # => 2.0*K/h
+    puts (2*°C/h).to(°F/h)           # => 3.6*°F/h
+    # To force the relative conversion of a single temperature pass a second argument to to():
+    puts (20*°C).to(K,:relative)     # => 20.0*K
+    puts (20*°C).to(°F,:relative)    # => 36.0*°F
+    puts (20*mK).to(°C,:relative)    # => 0.02*°C
+
+  end
+
+For short expressions, the abbreviation +Units.u+ can be used instead of +Units.units+
+
+  include Units
+  puts u{60*km + 10*mi}              # => 76.09344*km
+  puts u{sin(45*°)}                  # => 0.707106781186547
+  x = u{120*km/h}
+  puts x.to(u{mi/h})                 # => 74.5645430684801*mi/h
+
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Javier Goizueta. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "units-system"
+    gem.summary = %Q{Arithmetic with units of measure}
+    gem.description = %Q{Experimental unit conversion & arithmetic for Ruby 1.9}
+    gem.required_ruby_version = '>= 1.9.1'
+    gem.email = "jgoizueta@gmail.com"
+    gem.homepage = "http://github.com/jgoizueta/units-system"
+    gem.authors = ["Javier Goizueta"]
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "units-system #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/units-system.rb

@@ -0,0 +1,634 @@
+# encoding: utf-8
+
+# Ruby 1.9 Units-System experiments.
+
+module Units
+
+  class Measure
+
+    def initialize(mag=1.0, units={})
+      @magnitude = mag # rename to value?
+      case units
+      when Symbol
+        uinfo = Units.unit(units)
+        if uinfo
+          if uinfo.dim
+            @units = {uinfo.dim=>[units,1]}
+          else
+            @magnitude *= uinfo.factor
+            @units = {}
+          end
+        else
+          raise ArgumentError,"Invalid symbol for Measure definition: #{units.inspect} "
+        end
+      when Measure
+        @magnitude *= units.magnitude
+        @units = units.units
+      else
+        @units = units
+      end
+    end
+
+    attr_reader :magnitude, :units
+
+    # represent in text using Ruby notation
+    def to_s
+      return @magnitude.to_s if magnitude?
+      u_descr = Units.units_descr(@units)
+      "#{@magnitude}*#{u_descr}"
+    end
+
+    # more verbose description (not grammatically perfect)
+    def describe
+      return @magnitude.to_s if magnitude?
+      u_descr = Units.units_descr(@units, true)
+      "#{@magnitude} #{u_descr}"
+    end
+
+    # more natural concise text representation
+    def abr
+      self.to_s.gsub('**','^').tr('*',' ')
+    end
+
+    # decompose compound units
+    def detailed_units(all_levels = false)
+      mag = @magnitude
+      prev_units = self.units
+      units = {}
+      loop do
+        compound = false
+        prev_units.each_pair do |dim, (unit,mul)|
+          ud = Units.unit(unit)
+          if ud.decomposition
+            compound = true
+            mag *= ud.decomposition.magnitude
+            ud.decomposition.units.each_pair do |d, (u,m)|
+              mag *= self.class.combine(units, d, u, m)
+            end
+          else
+            mag *= self.class.combine(units, dim, unit, mul)
+          end
+        end
+        if all_levels && compound
+          prev_units = units
+          units = {}
+        else
+          break
+        end
+      end
+      Measure.new mag, units    end
+
+    # decompose to base units
+    def base
+      detailed_units true
+    end
+
+    def self.combine(units, dim, unit, mult)
+      factor = 1
+      if units[dim]
+        u,m = units[dim]
+        if u!=unit
+          factor *= Units.conversion_factor(unit, u)**mult
+        end
+        units[dim] = [u, m+mult]
+      else
+        units[dim] = [unit, mult]
+      end
+      factor
+    end
+
+    def /(other)
+      self * (other.kind_of?(Numeric) ? 1.0/other : other.inverse)
+    end
+
+    def inspect
+      "Measure(#{@magnitude.inspect}, #{@units.inspect})"
+    end
+
+    def *(other)
+      case other
+      when Numeric
+        mag = self.magnitude*other
+        units = self.units
+      else
+        mag = self.magnitude*other.magnitude
+        units = {}
+        (self.units.keys | other.units.keys).each do |dim|
+          other_u = other.units[dim] || [nil,0]
+          this_u = self.units[dim] || [other_u.first,0]
+          # mag *= Units.conversion_factor(this_u.first, other_u.first) if other_u.first
+          mult = this_u.last+other_u.last
+          mag *= Units.conversion_factor(other_u.first, this_u.first)**(other_u.last) if other_u.first
+          units[dim] = [this_u.first, mult]
+        end
+      end
+      units.reject!{|dim,(u,m)| m==0}
+      Measure.new(mag, units)
+    end
+
+    def +(other)
+      Measure.new self.magnitude+other.to(self.units).magnitude, self.units
+    end
+
+    def -(other)
+      self + (-other)
+    end
+
+    def **(n)
+      raise ArgumentError,"Only integer powers are allowed for magnitudes" unless n.kind_of?(Integer)
+      units = @units.dup
+      units.each_pair do |dim, (u, m)|
+        units[dim] = [u, m*n]
+      end
+      Measure.new @magnitude, units
+    end
+
+    def inverse
+      #Measure.new(1.0/@magnitude, @units.map_hash{|unit,mult| [unit, -mult]})
+      units = {}
+      @units.each_pair do |dim, (unit, mult)|
+        units[dim] = [unit, -mult]
+      end
+      Measure.new(1.0/@magnitude, units)
+    end
+
+    def -@
+      Measure.new(-@magnitude, units)
+    end
+
+    def in(other, mode=:absolute)
+      other = Measure.new(1.0, other) unless other.kind_of?(Measure)
+      other = other.base
+      this = self.base
+      dims = this.units.keys | other.units.keys
+      mag = this.magnitude/other.magnitude
+      dims.each do |dim|
+        if !this.units[dim] || !other.units[dim] ||
+           (this.units[dim].last != other.units[dim].last)
+          raise "Inconsistent units #{Units.units_descr(this.units)} #{Units.units_descr(other.units)}"
+        end
+        this_u, mult = this.units[dim]
+        other_u = other.units[dim].first
+        mag *= Units.conversion_factor(this_u, other_u)**mult
+      end
+      if mode!=:relative && dims.size==1 && this.units[dims.first].last==1
+        # consider "level" conversion for biased units (otherwise consider interval or difference values)
+        mag += Units.conversion_bias(this.units[dims.first].first, other.units[dims.first].first)
+      end
+      mag
+    end
+
+    def to(units, mode=:absolute)
+      units = units.u if units.kind_of?(Measure)
+      Measure.new self.in(units, mode), units
+    end
+
+    def si_units
+      units = {}
+      @units.each_pair do |dim, (unit, mult)|
+        si_unit = SI_UNITS[dim]
+        if si_unit.kind_of?(Measure)
+          si_unit.units.each_pair do |d, (u,m)|
+            self.class.combine(units, d, u, m*mult)
+          end
+        else
+          self.class.combine(units, dim, si_unit, mult)
+        end
+      end
+      units
+    end
+
+    def to_si
+      to(si_units)
+    end
+
+    def coerce(other)
+      [Measure.new(other, {}), self]
+    end
+
+    def u # dimension? unit? only_units? strip_units? units_measure?
+      Measure.new(1.0, self.units)
+    end
+
+    # dimension (quantity)
+    def dimension
+      q = nil
+      u = self.base.si_units
+      SI_UNITS.each_pair do |dim, unit|
+        unit = Measure.new(1.0, unit) unless unit.kind_of?(Measure)
+        if unit.base.si_units == u
+          q = dim
+          break
+        end
+      end
+      q
+    end
+
+    def dimensionless?
+      base.units.reject{|d,(u,m)| m==0}.empty?
+    end
+
+    # less strict dimensionless condition (e.g. an angle is not a pure magnitude in this sense)
+    def magnitude?
+      self.units.reject{|d,(u,m)| m==0}.empty?
+    end
+
+  end # Measure
+
+  def Measure(*args)
+    if args.size==1
+      case args.first
+      when Numeric
+        m = args.first
+        u = {}
+      else
+        m = 1.0
+        u = args.first
+      end
+      args = [m,u]
+    end
+    Units::Measure.new(*args)
+  end
+  module_function :Measure
+
+  PREFIXES = {
+    :y=>[1E-24, 'yocto'],
+    :z=>[1E-21, 'zepto'],
+    :a=>[1E-18, 'atto'],
+    :f=>[1E-15, 'femto'],
+    :p=>[1E-12, 'pico'],
+    :n=>[1E-09, 'nano'],
+    :µ=>[1E-06, 'micro'], # ASCII alternative: u; define it?
+    :m=>[1E-03, 'milli'],
+    :c=>[1E-02, 'centi'],
+    :d=>[1E-01, 'deci'],
+    :da=>[1E1, 'deca'],
+    :h=>[1E02, 'hecto'],
+    :k=>[1E03, 'kilo'],
+    :M=>[1E06, 'mega'],
+    :G=>[1E09, 'giga'],
+    :T=>[1E12, 'tera'],
+    :P=>[1E15, 'peta'],
+    :E=>[1E18, 'exa'],
+    :Z=>[1E21, 'zetta'],
+    :Y=>[1E24, 'yotta']
+  }
+
+  def self.prefix_factor(prefix)
+    pd = PREFIXES[prefix.to_sym]
+    pd && pd.first
+  end
+
+  def self.prefix_name(prefix)
+    pd = PREFIXES[prefix.to_sym]
+    pd && pd.last
+  end
+
+  def self.prefix_factor_and_name(prefix)
+    PREFIXES[prefix]
+  end
+
+  # mathematical functions available to unit blocks are defined here
+  module Math
+  end
+
+  # unit methods and constants are defined here to be injected in units blocks
+  module System
+
+    extend Math
+
+    def self.define(unit)
+      define_var unit
+      PREFIXES.each do |prefix, (factor, name)|
+        define_var "#{prefix}#{unit}".to_sym
+      end
+    end
+
+    class <<self
+      private
+      def define_var(name)
+        name_initial = name.to_s[0,1]
+        if name_initial==name_initial.upcase && name_initial!=name_initial.downcase
+          # we could define a method with the requested name, but it would
+          # no be usable without qualification (System.X) or brackets (X())
+          # so we define a constant. But this requires Ruby 1.9 to be useful;
+          # otherwise the constant is not accesible without qualification in units blocks.
+          System.const_set name, Units.Measure(name)
+        end
+        self.class_eval do
+          define_method name do
+            Units.Measure(name)
+          end
+          module_function name
+        end
+      end
+    end
+
+  end # Units::System
+
+  def units(&blk)
+    Units::System.class_eval(&blk)
+  end
+  alias :u :units
+  module_function :units, :u
+
+  UnitDefinition = Struct.new(:dim, :factor, :name, :decomposition, :bias)
+
+  UNITS = {} # Hash.new{|h,k| h[k]=UnitDefinition.new()}
+
+  # get unit definition
+  def self.unit(unit_symbol)
+    ud = UNITS[unit_symbol]
+    if ud.nil?
+      factor = 1.0
+      if factor_name = PREFIXES[unit_symbol]
+        ud = UnitDefinition.new(nil, *factor_name)
+      else
+        u = unit_symbol.to_s
+        PREFIXES.each_pair do |prefix, (f,name)|
+          prefix = prefix.to_s
+          if u[0...prefix.length] == prefix
+            factor = f
+            ud = UNITS[u[prefix.length..-1].to_sym].dup
+            if ud
+              ud.name = "#{name}#{ud.name}"
+              break
+            end
+          end
+        end
+      end
+      ud.factor *= factor if ud
+      ud.decomposition *= factor if ud && ud.decomposition
+    end
+    raise ArgumentError,"Invalid Units #{unit_symbol}" unless ud
+    ud
+  end
+
+  # Define new units.
+  # Define a base unit (with a factor for conversion to SI units)
+  #   Units.define :unit_symbol, 'unit-name', :quantity, si_units_per_this_unit
+  # Define a unit in terms or another (valid for base or derived units)
+  #   Units.define :unit_symbol, 'unit-name', value, :in_units
+  # Define a base unit as a measure-expression
+  #   Units.define :unit_symbol, 'unit_name', u{...}
+  # Define a derived unit as a measure-expression
+  #   Units.define :unit_symbol, 'unit_name', :quantity, u{...}
+  # For base dimensions the SI unit for a quantity must also be stablished with Unit.si_units;
+  # for derived units, SI units are automatically taken to be the first define unit of the quantity
+  # with unitary value in SI base units.
+  def self.define(unit_symbol, name, *args)
+    eqhivalence = nil
+    si_unit = false
+    bias = nil
+    if args.first.kind_of?(Symbol)
+      dim = args.shift
+      if args.first.kind_of?(Numeric)
+        # unidad simple
+        factor = args.shift
+        factor_units = args.shift
+        if factor_units
+          ud = unit(factor_units)
+          if ud.dim != dim
+            raise ArgumentError, "Inconsistent units #{factor_units} in definition of #{unit_symbol}"
+          end
+          # maybe it was not simple after all...
+          equivalence = factor*ud.decomposition if ud.decomposition
+          factor *= ud.factor
+        end
+      else
+        # unidad compuesta
+        equivalence = args.shift
+        factor = equivalence.to_si.magnitude
+        si_unit = (factor==1.0) # TODO: tolerance?
+      end
+    elsif args.first.kind_of?(Numeric)
+      # unidad definida en función de otra
+      factor = args.shift
+      factor_units = args.shift
+      u = unit(factor_units)
+      dim = u.dim
+      factor *= u.factor
+      equivalence = factor*u.decomposition if u.decomposition
+      bias = args.shift
+    else
+      # unidad simple definida en función de una expressión
+      definition = args.shift
+      if definition.units.keys.size!=1
+        raise ArgumentError,"To define a compound unit a dimension must be specified"
+      end
+      dim = definition.units.keys.first
+      factor = definition.to_si.magnitude
+    end
+    unit_def = UnitDefinition.new(dim, factor, name, equivalence, bias)
+    if UNITS.has_key?(unit_symbol)
+      raise "Se ha intentando redefinir #{unit_symbol} (previamente definido como #{UNITS[unit_symbol]}) como #{unit_def}"
+    end
+    UNITS[unit_symbol] = unit_def
+    System.define unit_symbol
+    Units.si_units unit_def.dim, unit_symbol if si_unit && !SI_UNITS.has_key?(unit_def.dim)
+  end
+
+  SI_UNITS = {}
+
+  def self.si_units(dim, unit)
+    SI_UNITS[dim] = unit
+  end
+
+  def self.dimension(u)
+    unit(u).dim
+  end
+
+  def self.conversion_factor(from, to)
+    from_u = unit(from)
+    to_u = unit(to)
+    raise ArgumentError,"Inconsistent Units (#{from}, #{to})" if from_u.dim!=to_u.dim
+    from_u.factor/to_u.factor
+  end
+
+  def self.conversion_bias(from, to)
+    from_u = unit(from)
+    to_u = unit(to)
+    raise ArgumentError,"Inconsistent Units (#{from}, #{to})" if from_u.dim!=to_u.dim
+    factor = from_u.factor/to_u.factor
+    (from_u.bias||0)*factor - (to_u.bias||0)
+  end
+
+  # simple unit name
+  def self.unit_name(u)
+    uinfo = Units.unit(u)
+    uinfo && uinfo.name
+  end
+
+  def self.unit_descr(u, long=false, mult=1)
+    if long
+      u = unit_name(u)
+      if mult!=1
+        case mult
+        when 2
+          "squared #{u}"
+        when 3
+          "cubed #{u}"
+        else
+          "#{u} to the #{mult} power"
+        end
+      else
+        u
+      end
+    else
+      if mult!=1
+        "#{u}**#{mult}"
+      else
+        u.to_s
+      end
+    end
+  end
+
+  def self.units_descr(units, long=false)
+    units = units.values.sort_by{|u,m| -m}
+    pos_units = units.select{|u| u.last>0}
+    neg_units = units.select{|u| u.last<0}
+    times = long ? " " : "*"
+    num = pos_units.map{|u,m| unit_descr(u,long,m)}.join(times)
+    num = "(#{num})" if pos_units.size>1 && !neg_units.empty? && !long
+    den = neg_units.map{|u,m| unit_descr(u,long,-m)}.join("*")
+    den = "(#{den})" if neg_units.size>1 && !long
+    if pos_units.empty?
+      u_descr = "1/#{den}"
+    elsif neg_units.empty?
+      u_descr = num
+    else
+      connector = long ? " per " : "/"
+      u_descr = "#{num}#{connector}#{den}"
+    end
+    u_descr
+  end
+
+  module Math
+
+    [:sin, :cos, :tan].each do |fun|
+      define_method fun do |x|
+        x = Units.u{x.in(rad)} if x.kind_of?(Measure)
+        ::Math.send(fun, x)
+      end
+      module_function fun
+    end
+
+    [:asin, :acos, :atan].each do |fun|
+      define_method fun do |x|
+        if x.kind_of?(Measure)
+          raise ArgumentError,"Invalid dimensions for #{fun} argument" unless x.dimensionless?
+          x = x.magnitude
+        end
+        Units.u{::Math.send(fun, x)*rad}
+      end
+      module_function fun
+    end
+
+    module_function
+    def atan2(x,y)
+      if x.kind_of?(Measure)
+        if y.kind_of?(Measure)
+          if x.base.to_si.units != y.base.to_si.units
+            raise ArgumentError,"Inconsistent units for atan2 arguments #{x.u}, #{y.u}"
+          end
+          # or x = x.to_si.magnitude, y=y.to_si.magnitude
+          y = y.in(x.units)
+          x = x.magnitude
+        else
+          raise ArgumentError,"Invalid dimensions for atan2 argument #{x.u}" unless x.dimensionless?
+          x = x.magnitude
+        end
+      elsif y.kind_of?(Measure)
+        raise ArgumentError,"Invalid dimensions for atan2 argument #{y.u}" unless y.dimensionless?
+        y = y.magnitude
+      end
+      Units.u{::Math.atan2(x,y)*rad}
+    end
+
+  end
+
+  # Units definitions
+
+  # declare SI base units
+  si_units :mass,   :kg                  # m
+  si_units :length, :m                   # l
+  si_units :time,   :s                   # t
+  si_units :electric_current, :A         # I
+  si_units :temperature, :K              # T
+  si_units :luminous_intensity, :cd      # Iv
+  si_units :amount_of_substance, :mol    # n
+
+  # base units definitions
+  define :g, 'gram',   :mass, 1E-3
+  define :m, 'meter',  :length, 1.0
+  define :s, 'second', :time, 1.0
+  define :A, 'ampere', :electric_current, 1.0
+  define :K, 'kelvin', :temperature, 1.0
+  define :cd,'candela',:luminous_intensity, 1.0
+  define :mol,'mole',  :amount_of_substance, 1.0
+
+  define :min, 'minute', 60, :s
+  define :h, 'hour', 60, :min
+  define :d,  'day', 24, :h
+  define :mi, 'mile', 1.609344, :km
+  define :in, 'inch', 2.54, :cm
+  define :ft, 'foot', 0.3048, :m
+  # in is a Ruby keyword; to avoid having to use self.in we'll define:
+  define :inch, 'inch', 1, :in
+
+  # declare derived quantities without named units
+  si_units :speed, u{m/s}
+  si_units :acceleration, u{m/s**2}
+  si_units :area, u{m**2}
+  si_units :volume, u{m**3}
+
+  # named derived units
+  define :W, 'Watt', :power, u{kg*m**2/s**3} # J/s
+  define :Hz, 'herz', :frequency, u{1/s}
+  define :N, 'newton', :force, u{m*kg/s**2}
+  define :Pa, 'pascal', :pressure, u{N/m**2}
+  define :J, 'joule', :energy, u{N*m}
+  define :C, 'coulomb', :electric_charge, u{s*A}
+  define :V, 'volt', :voltage, u{W/A}
+  define :F, 'farad', :electric_capacitance, u{C/V}
+  define :Ω, 'ohm', :electric_resistance, u{V/A} # ohm: Ω  omega: Ω
+  define :S, 'siemens', :electric_condctance, u{1/Ω}
+  define :Wb,'weber', :magnetic_flux, u{J/A}
+  define :T, 'tesla', :magnetic_field, u{N/(A*m)}
+  define :H, 'henry', :inductance, u{Wb/A}
+  define :rad, 'radian', :angle, u{m/m} # maybe more useful as base unit: define :rad, 'radian', :angle, 1.0
+  define :sr, 'steradian', :solid_angle, u{m**2/m**2}
+  define :lm, 'lumen', :luminous_flux, u{cd*sr}
+  define :lx, 'lux', :illuminance, u{lm/m**2}
+  define :Bq, 'bequerel', :radioactivity, u{1/s}
+  define :Gy, 'gray', :absorbed_dose, u{J/kg}
+  define :Sv, 'sievert', :equivalent_dose, u{J/kg}
+  define :kat, 'katal', :catalytic_activity, u{mol/s}
+
+  define :°C, 'degree Celsius', 1, :K, +273.15
+  define :°F, 'degree Fahrenheit', 5.0/9.0, :K, +459.67
+  define :R, 'rankine', 5.0/9.0, :K
+
+  define :l, 'litre', :volume, u{dm**3}
+  define :L, 'litre', 1, :l
+
+  define :°, 'degree', ::Math::PI/180.0, :rad
+  define :′, 'arc-minute', ::Math::PI/180.0/60.0, :rad
+  define :″, 'arc-second', ::Math::PI/180.0/3600.0, :rad
+  # not so cool, but easier to type alternatives:
+  define :deg, 'degree', 1, :°
+  define :arcmin, 'arc-minute', 1, :′
+  define :arcsec, 'arc-second', 1, :″
+
+  define :g0, 'standard gravity', :acceleration, u{9.80665*m/s**2}
+
+  define :bar, 'bar', :pressure, u{1E5*Pa}
+  define :atm, 'atmosphere',  :pressure, u{101325.0*Pa}
+  define :mWC, 'meters of water column', :pressure, u{1E3*kg*g0/m**2}
+  define :Torr, 'torricelli', :pressure, u{atm/760}
+  define :mHg, 'mHg', :pressure, u{13.5951E3*kg*g0/m**2}
+
+  # define :kp, 'kilopond', :force, u{kg*g0} # or define pond?
+  define :gf, 'gram-force', :force, u{g*g0} # kilopond kp = kgf
+
+end # Units

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'units-system'
+
+class Test::Unit::TestCase
+end

data/test/test_units-system.rb

@@ -0,0 +1,71 @@
+require 'helper'
+
+class TestUnitsSystem < Test::Unit::TestCase
+
+  should "be possible to define Measures with a units block" do
+    assert_equal Units::Measure, Units.units{m}.class
+    assert_equal 1.0, Units.units{m}.magnitude
+    assert_equal [:m, 1], Units.units{m}.units[:length]
+  end
+
+  should "be possible to define Measures with a shorthand u block" do
+    assert_equal Units::Measure, Units.u{m}.class
+    assert_equal 1.0, Units.u{m}.magnitude
+    assert_equal [:m, 1], Units.u{m}.units[:length]
+  end
+
+  should "determine units dimension correctly" do
+    assert_equal :length, Units.u{m}.dimension
+    assert_equal :length, Units.u{mi}.dimension
+    assert_equal :mass, Units.u{g}.dimension
+    assert_equal :time, Units.u{s}.dimension
+    assert_equal :electric_current, Units.u{A}.dimension
+    assert_equal :temperature, Units.u{K}.dimension
+    assert_equal :luminous_intensity, Units.u{cd}.dimension
+    assert_equal :amount_of_substance, Units.u{mol}.dimension
+    assert_equal :power, Units.u{W}.dimension
+    assert_equal :pressure, Units.u{Pa}.dimension
+    assert_equal :mass, Units.u{kg}.dimension
+    assert_equal :length, Units.u{km}.dimension
+    assert_equal :length, Units.u{mm}.dimension
+    assert_equal :length, Units.u{Mm}.dimension
+  end
+
+  should "allow unit arithmetic" do
+    assert_equal :speed, Units.u{m/s}.dimension
+    assert_equal :length, Units.u{m**2/m}.dimension
+    assert_equal :length, Units.u{(m*m)/m}.dimension
+    assert_equal :volume, Units.u{m*m**2}.dimension
+    assert_equal :force, Units.u{m*kg/s**2}.dimension
+  end
+
+  should "convert simple units correctly" do
+    assert_equal 1E5, Units.u{100*km.in(m)}
+    assert_equal 10, Units.u{10000*m.in(km)}
+    assert_equal 254, Units.u{100*self.in.in(cm)}
+  end
+
+  should "convert compound units correctly" do
+    assert_equal 75, Units.u{(270*km/h).in(m/s)}
+    assert_equal 270, Units.u{(75*m/s).in(km/h)}
+  end
+
+  should "add units correctly" do
+    assert_equal 5, Units.u{3*m+2*m}.magnitude
+    assert_equal 5, Units.u{3*kg+2*kg}.magnitude
+  end
+
+  should "add units correctly with implied conversions" do
+    assert_equal 5, Units.u{3*m+200*cm}.magnitude
+    assert_equal [:m,1],Units.u{3*m+200*cm}.units[:length]
+    assert_equal 85, Units.u{10*m/s +  270*km/h}.magnitude
+  end
+
+  should "choke on inconsistent units" do
+    assert_raise(RuntimeError){Units.units{m+kg}}
+    assert_raise(RuntimeError){Units.units{m/s+m/s**2}}
+    assert_raise(RuntimeError){Units.units{(m).to(kg)}}
+    assert_raise(RuntimeError){Units.units{(m/s).to(m/s**2)}}
+  end
+
+end

data/units-system.gemspec

@@ -0,0 +1,55 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{units-system}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Javier Goizueta"]
+  s.date = %q{2009-12-18}
+  s.description = %q{Experimental unit conversion & arithmetic for Ruby 1.9}
+  s.email = %q{jgoizueta@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/units-system.rb",
+     "test/helper.rb",
+     "test/test_units-system.rb",
+     "units-system.gemspec"
+  ]
+  s.homepage = %q{http://github.com/jgoizueta/units-system}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.required_ruby_version = Gem::Requirement.new(">= 1.9.1")
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Arithmetic with units of measure}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_units-system.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    else
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: units-system
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Javier Goizueta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-18 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Experimental unit conversion & arithmetic for Ruby 1.9
+email: jgoizueta@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/units-system.rb
+- test/helper.rb
+- test/test_units-system.rb
+- units-system.gemspec
+has_rdoc: true
+homepage: http://github.com/jgoizueta/units-system
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.1
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Arithmetic with units of measure
+test_files: 
+- test/helper.rb
+- test/test_units-system.rb