unit 0.2.0

data/README.markdown

@@ -0,0 +1,21 @@
+README
+======
+
+Units introduces computation with units to ruby.
+
+Usage
+-----
+
+    require 'unit'
+    puts 1.meter.in_kilometer
+    puts 1.MeV.in_joule
+    puts 10.KiB / 1.second
+    puts 10.KiB_per_second
+    puts Unit('1 m/s^2')
+
+See the test cases for more examples.
+
+Authors
+-------
+
+Daniel Mendler

data/Rakefile

@@ -0,0 +1,6 @@
+task :default => :test
+
+desc 'Run tests with bacon'
+task :test => FileList['test/*_test.rb'] do |t|
+  sh "bacon -q -Ilib:test #{t.prerequisites.join(' ')}"
+end

data/lib/systems/binary.yml

@@ -0,0 +1,41 @@
+units:
+  bit:
+    sym: bit
+    def: bit
+  byte:
+    sym: B
+    def: 8 * bit
+
+prefixes:
+  kibi:
+    sym:  Ki
+    base: 2
+    exp:  10
+  mebi:
+    sym:  Mi
+    base: 2
+    exp:  20
+  gibi:
+    sym:  Gi
+    base: 2
+    exp:  30
+  tebi:
+    sym:  Ti
+    base: 2
+    exp:  40
+  pebi:
+    sym:  Pi
+    base: 2
+    exp:  50
+  exbi:
+    sym:  Ei
+    base: 2
+    exp:  60
+  zebi:
+    sym:  Zi
+    base: 2
+    exp:  70
+  yobi:
+    sym:  Yi
+    base: 2
+    exp:  80

data/lib/systems/degree.yml

@@ -0,0 +1,13 @@
+units:
+  pi:
+    sym: π
+    def: 3.14159265358979323846
+  degree:
+    sym: [°, deg]
+    def: pi radiant / 180
+  arcminute:
+    sym: \'
+    def: degree / 60
+  arcsecond:
+    sym: \"
+    def: arcminute / 60

data/lib/systems/imperial.yml

@@ -0,0 +1,37 @@
+units:
+  mil:
+    sym: mil
+    def: 25400 nanometer
+  inch:
+    sym: [in, inches]
+    def: 1000 mil
+  foot:
+    sym: [ft, feet]
+    def: 12 inch
+  yard:
+    sym: yd
+    def: 3 foot
+  mile:
+    sym: mi
+    def: 5280 foot
+  nauticalmile:
+    sym: nmi
+    def: 6080 foot
+
+  acre:
+    sym: ac
+    def: 43560 foot^2
+
+  ounce:
+    sym: oz
+    def: 28349523125 nanogram
+  pound:
+    sym: lb
+    def: 16 ounce
+
+  mph:
+    sym: mph
+    def: mile / hour
+  knot:
+    sym: kt
+    def: nauticalmile / hour

data/lib/systems/misc.yml

@@ -0,0 +1,22 @@
+units:
+  are:
+    sym: a
+    def: 100 m^2
+
+  ton:
+    sym: t
+    def: 1 megagram
+  carat:
+    def: 200 milligram
+
+  liter:
+    sym: [l, L]
+    def: 1 decimeter^3
+
+  calorie:
+    sym: cal
+    def: 4184 millijoule
+
+  fahrenheit:
+    sym: [°F, ℉]
+    def: 1.8 celsius

data/lib/systems/scientific.yml

@@ -0,0 +1,25 @@
+units:
+  astronomicalunit:
+    sym: [au, AU, a.u., ua]
+    def: 149597900000 meter
+  lightsecond:
+    sym: ls
+    def: 299792500 meter
+  lightminute:
+    sym: lm
+    def: 17987550000 meter
+  lightyear:
+    sym: ly
+    def: 9460528000000000 meter
+  parsec:
+    sym: pc
+    def: 30856780000000000 meter
+  angstroem:
+    sym: Å
+    def: 100 picometer
+  electronvolt:
+    sym: eV
+    def: 1.602176487e-19 joule
+  atomicmass:
+    sym: [u, Da]
+    def: 1.660538782e-27 kilogram

data/lib/systems/si.yml

@@ -0,0 +1,175 @@
+units:
+  # SI base units
+  meter:
+    sym: m
+    def: meter
+  # use gram instead of kilogram to avoid millikilogram etc
+  gram:
+    sym: g
+    def: gram
+  second:
+    sym: s
+    def: second
+  ampere:
+    sym: A
+    def: ampere
+  kelvin:
+    sym: K
+    def: kelvin
+  mole:
+    sym: mol
+    def: mole
+  candela:
+    sym: cd
+    def: candela
+
+  # Derived SI units
+  radiant:
+    sym: [rad, radian]
+    def: 1
+  steradiant:
+    sym: sr
+    def: 1
+  hertz:
+    sym: Hz
+    def: 1 / second
+  newton:
+    sym: N
+    def: kilogram * meter / second ^ 2
+  pascal:
+    sym: Pa
+    def: newton / meter ^ 2
+  joule:
+    sym: J
+    def: newton * meter
+  watt:
+    sym: W
+    def: joule * second
+  coloumb:
+    sym: C
+    def: ampere * second
+  volt:
+    sym: V
+    def: joule / coloumb
+  farad:
+    sym: F
+    def: coloumb / volt
+  ohm:
+    sym: Ω
+    def: volt / ampere
+  siemens:
+    sym: S
+    def: 1 / ohm
+  weber:
+    sym: Wb
+    def: volt / second
+  tesla:
+    sym: T
+    def: weber / meter ^ 2
+  henry:
+    sym: H
+    def: weber / ampere
+  celsius:
+    sym: [°C, ℃]
+    def: kelvin
+  lumen:
+    sym: lm
+    def: candela * steradiant
+  lux:
+    sym: lx
+    def: lm / meter ^ 2
+  becquerel:
+    sym: Bq
+    def: hertz
+  gray:
+    sym: Gy
+    def: joule / kilogram
+  sievert:
+    sym: Sv
+    def: gray
+  katal:
+    sym: kat
+    def: mole / second
+
+prefixes:
+  # SI prefices
+  yotta:
+    sym:  Y
+    base: 10
+    exp:  24
+  zetta:
+    sym:  Z
+    base: 10
+    exp:  21
+  exa:
+    sym:  E
+    base: 10
+    exp:  18
+  peta:
+    sym:  P
+    base: 10
+    exp:  15
+  tera:
+    sym:  T
+    base: 10
+    exp:  12
+  giga:
+    sym:  G
+    base: 10
+    exp:  9
+  mega:
+    sym:  M
+    base: 10
+    exp:  6
+  kilo:
+    sym:  k
+    base: 10
+    exp:  3
+  hecto:
+    sym:  h
+    base: 10
+    exp:  2
+  deca:
+    sym:  da
+    base: 10
+    exp:  1
+  deci:
+    sym:  d
+    base: 10
+    exp:  -1
+  centi:
+    sym:  c
+    base: 10
+    exp:  -2
+  milli:
+    sym:  m
+    base: 10
+    exp:  -3
+  micro:
+    sym:  µ
+    base: 10
+    exp:  -6
+  nano:
+    sym:  n
+    base: 10
+    exp:  -9
+  pico:
+    sym:  p
+    base: 10
+    exp:  -12
+  femto:
+    sym:  f
+    base: 10
+    exp:  -15
+  atto:
+    sym:  a
+    base: 10
+    exp:  -18
+  zepto:
+    sym:  z
+    base: 10
+    exp:  -21
+  yokto:
+    sym:  y
+    base: 10
+    exp:  -24

data/lib/systems/time.yml

@@ -0,0 +1,15 @@
+units:
+  minute:
+    sym: min
+    def: 60 * second
+  hour:
+    sym: h
+    def: 60 * minute
+  day:
+    sym: d
+    def: 24 * hour
+  week:
+    def: 7 * day
+  year:
+    sym: a
+    def: 365 * day

data/lib/unit.rb

@@ -0,0 +1,482 @@
+# encoding: utf-8
+require 'yaml'
+
+class Unit < Numeric
+  VERSION = '0.2.0'
+
+  attr_reader :numerator, :denominator, :unit, :normalized, :system
+
+  def initialize(numerator,  denominator, unit, system)
+    @system = system
+    @numerator = numerator
+    @denominator = denominator
+    @unit = unit.dup
+    @normalized = nil
+    reduce!
+  end
+
+  def initialize_copy(other)
+    @system = other.system
+    @numerator = other.numerator
+    @denominator = other.denominator
+    @unit = other.unit.dup
+    @normalized = other.normalized
+  end
+
+  # Converts to base units
+  def normalize
+    @normalized ||= dup.normalize!
+  end
+
+  # Converts to base units
+  def normalize!
+    if @normalized != self
+      begin
+        last_unit = @unit
+        @unit = []
+        last_unit.each do |prefix, unit, exp|
+          if prefix != :one
+            if exp >= 0
+              @numerator *= @system.prefix[prefix][:value] ** exp
+            else
+              @denominator *= @system.prefix[prefix][:value] ** -exp
+            end
+          end
+          if @system.unit[unit]
+            @unit += Unit.power_unit(@system.unit[unit][:def], exp)
+          else
+            @unit << [:one, unit, exp]
+          end
+        end
+      end while last_unit != @unit
+      reduce!
+      @normalized = self
+    end
+    self
+  end
+
+  def *(other)
+    a, b = coerce(other)
+    Unit.new(a.numerator * b.numerator, a.denominator * b.denominator, a.unit + b.unit, system)
+  end
+
+  def /(other)
+    a, b = coerce(other)
+    Unit.new(a.numerator * b.denominator, a.denominator * b.numerator, a.unit + Unit.power_unit(b.unit, -1), system)
+  end
+
+  def +(other)
+    raise TypeError, 'Incompatible units' if !compatible?(other)
+    a, b = coerce(other)
+    a, b = a.normalize, b.normalize
+    Unit.new(a.numerator * b.denominator + b.numerator * a.denominator, a.denominator * b.denominator, a.unit, system).in(self)
+  end
+
+  def **(exp)
+    raise TypeError if Unit === exp
+    Unit.new(numerator ** exp, denominator ** exp, Unit.power_unit(unit, exp), system)
+  end
+
+  def -(other)
+    self + (-other)
+  end
+
+  def -@
+    Unit.new(-numerator, denominator, unit, system)
+  end
+
+  def ==(other)
+    a, b = coerce(other)
+    a, b = a.normalize, b.normalize
+    a.numerator == b.numerator && a.denominator == b.denominator && a.unit == b.unit
+  end
+
+  # Number without dimension
+  def dimensionless?
+    normalize.unit.empty?
+  end
+
+  alias unitless? dimensionless?
+
+  # Compatible units can be added
+  def compatible?(other)
+    a, b = coerce(other)
+    a, b = a.normalize, b.normalize
+    (a.unit == b.unit) || (a == 0 || b == 0)
+  end
+
+  alias compatible_with? compatible?
+
+  # Convert to other unit
+  def in(unit)
+    unit = unit.to_unit(system)
+    (self / unit).normalize * unit
+  end
+
+  def inspect
+    unit.empty? ? %{Unit("#{number_string}")} : %{Unit("#{number_string} #{unit_string('.')}")}
+  end
+
+  def to_s
+    unit.empty? ? number_string : "#{number_string} #{unit_string('·')}"
+  end
+
+  def to_tex
+    unit.empty? ? number_string : "\SI{#{number_string}}{#{unit_string('.')}}"
+  end
+
+  def to_i
+    (@numerator / @denominator).to_i
+  end
+
+  def to_f
+    @numerator.to_f / @denominator.to_f
+  end
+
+  def approx
+    to_f.unit(unit)
+  end
+
+  def to_unit(system = nil)
+    system ||= Unit::System::DEFAULT
+    raise TypeError, 'Different unit system' if @system != system
+    self
+  end
+
+  def coerce(val)
+    raise TypeError, 'No unit support' if !val.respond_to? :to_unit
+    [self, val.to_unit(system)]
+  end
+
+  def method_missing(name)
+    if name.to_s[0..2] == 'in_'
+      self.in(Unit.method_name_to_unit(name))
+    else
+      super
+    end
+  end
+
+  def self.method_name_to_unit(name)
+    name.to_s.sub(/^in_/, '').sub(/^per_/, '1/').gsub('_per_', '/').gsub('_', ' ')
+  end
+
+  private
+
+  def number_string
+    @numerator.to_s << (@denominator == 1 ? '' : "/#{@denominator}")
+  end
+
+  def unit_string(sep)
+    (unit_list(@unit.select {|prefix, name, exp| exp >= 0 }) +
+     unit_list(@unit.select {|prefix, name, exp| exp < 0 })).join(sep)
+  end
+
+  def unit_list(list)
+    units = []
+    list.each do |prefix, name, exp|
+      unit = ''
+      unit << (@system.prefix[prefix] ? @system.prefix[prefix][:symbol] : prefix.to_s) if prefix != :one
+      unit << (@system.unit[name] ? @system.unit[name][:symbol] : name.to_s)
+      unit << '^' << exp.to_s if exp != 1
+      units << unit
+    end
+    units.sort
+  end
+
+  def self.power_unit(unit, pow)
+    unit.map {|prefix, name, exp| [prefix, name, exp * pow] }
+  end
+
+  # Reduce units and prefixes
+  def reduce!
+    # Remove numbers from units
+    numbers = @unit.select {|prefix, unit, exp| Numeric === unit }
+    @unit -= numbers
+    numbers.each do |prefix, number, exp|
+       raise RuntimeError, 'Numeric unit with prefix' if prefix != :one
+       if exp >= 0
+         @numerator *= number ** exp
+       else
+         @denominator *= number ** -exp
+       end
+    end
+
+    # Reduce number
+    if Integer === @numerator && Integer === @denominator
+      r = Rational(@numerator, @denominator)
+      @numerator = r.numerator
+      @denominator = r.denominator
+    else
+      r = @numerator / @denominator
+      if Rational === r
+        @numerator = r.numerator
+        @denominator = r.denominator
+      else
+        @numerator = r
+        @denominator = 1
+      end
+    end
+
+    if @numerator == 0
+      @denominator = 1
+      @unit.clear
+    end
+
+    # Reduce units
+    @unit.sort!
+    i, current = 1, 0
+    while i < @unit.size do
+      while i < @unit.size && @unit[current][0] == @unit[i][0] && @unit[current][1] == @unit[i][1]
+        @unit[current] = @unit[current].dup
+        @unit[current][2] += @unit[i][2]
+        i += 1
+      end
+      if @unit[current][2] == 0
+        @unit.slice!(current, i - current)
+      else
+        @unit.slice!(current + 1, i - current - 1)
+        current += 1
+      end
+      i = current + 1
+    end
+
+    # Reduce prefixes
+    @unit.each_with_index do |(prefix1, unit1, exp1), k|
+      next if exp1 < 0
+      @unit.each_with_index do |(prefix2, unit2, exp2), j|
+        if exp2 < 0 && exp2 == -exp1
+          q, r = @system.prefix[prefix1][:value].divmod @system.prefix[prefix2][:value]
+          if r == 0 && new_prefix = @system.prefix_value[q]
+            @unit[k] = @unit[k].dup
+            @unit[j] = @unit[j].dup
+            @unit[k][0] = new_prefix
+            @unit[j][0] = :one
+          end
+        end
+      end
+    end
+
+    self
+  end
+
+  public
+
+  class System
+    attr_reader :name, :unit, :unit_symbol, :prefix, :prefix_symbol, :prefix_value
+
+    def initialize(name, &block)
+      @name = name
+      @unit = {}
+      @unit_symbol = {}
+
+      # one is internal trivial prefix
+      @prefix = {:one => {:symbol => 'one', :value => 1} }
+      @prefix_symbol = {'one' => :one}
+      @prefix_value = {1 => :one}
+
+      block.call(self) if block
+    end
+
+    def load(filename)
+      data = YAML.load_file(File.join(File.dirname(__FILE__), 'systems', "#{filename}.yml"))
+
+      (data['prefixes'] || {}).each do |name, prefix|
+        name = name.to_sym
+        symbols = [prefix['sym'] || []].flatten
+        base = prefix['base']
+        exp = prefix['exp']
+        value = base ** exp
+        $stderr.puts "Prefix #{name} already defined" if @prefix[name]
+        @prefix[name] = { :symbol => symbols.first, :value => value }
+        symbols.each do |sym|
+          $stderr.puts "Prefix symbol #{sym} for #{name} already defined" if @prefix_symbol[name]
+          @prefix_symbol[sym] = name
+        end
+        @prefix_symbol[name.to_s] = @prefix_value[value] = name
+      end
+
+      (data['units'] || {}).each do |name, unit|
+        name = name.to_sym
+        symbols = [unit['sym'] || []].flatten
+        $stderr.puts "Unit #{name} already defined" if @unit[name]
+        @unit[name] = { :symbol => symbols.first, :def => parse_unit(unit['def'])  }
+        symbols.each do |sym|
+          $stderr.puts "Unit symbol #{sym} for #{name} already defined" if @unit_symbol[name]
+          @unit_symbol[sym] = name
+        end
+        @unit_symbol[name.to_s] = name
+      end
+
+      @unit.each {|name, unit| validate_unit(unit[:def]) }
+    end
+
+    def validate_unit(units)
+      units.each do |prefix, unit, exp|
+        #raise TypeError, 'Prefix must be symbol' if !(Symbol === prefix)
+        #raise TypeError, 'Unit must be symbol' if !(Numeric === unit || Symbol === unit)
+        #raise TypeError, 'Exponent must be numeric' if !(Numeric === exp)
+        raise TypeError, "Undefined prefix #{prefix}" if !@prefix[prefix]
+        raise TypeError, "Undefined unit #{unit}" if !(Numeric === unit || @unit[unit])
+      end
+    end
+
+    def parse_unit(expr)
+      stack, result, implicit_mul = [], [], false
+      expr.to_s.scan(TOKENIZER).each do |tok|
+        if tok == '('
+          stack << '('
+          implicit_mul = false
+        elsif tok == ')'
+          compute(result, stack.pop) while !stack.empty? && stack.last != '('
+          raise(SyntaxError, 'Unexpected token )') if stack.empty?
+          stack.pop
+          implicit_mul = true
+        elsif OPERATOR.key?(tok)
+          compute(result, stack.pop) while !stack.empty? && stack.last != '(' && OPERATOR[stack.last][1] >= OPERATOR[tok][1]
+          stack << OPERATOR[tok][0]
+          implicit_mul = false
+        else
+          val = case tok
+                when REAL   then [[:one, tok.to_f, 1]]
+                when DEC    then [[:one, tok.to_i, 1]]
+                when SYMBOL then symbol_to_unit(tok)
+                end
+          stack << '*' if implicit_mul
+          implicit_mul = true
+          result << val
+        end
+      end
+      compute(result, stack.pop) while !stack.empty?
+      result.last
+    end
+
+    private
+
+    REAL   = /^-?(?:(?:\d*\.\d+|\d+\.\d*)(?:[eE][-+]?\d+)?|\d+[eE][-+]?\d+)$/
+    DEC    = /^-?\d+$/
+    SYMBOL = /^[a-zA-Z_°'"][\w_°'"]*$/
+    OPERATOR = { '/' => ['/', 1], '*' => ['*', 1], '·' => ['*', 1], '^' => ['^', 2], '**' => ['^', 2] }
+    OPERATOR_TOKENS = OPERATOR.keys.sort_by {|x| -x.size }. map {|x| Regexp.quote(x) }
+    VALUE_TOKENS = [REAL.source[1..-2], DEC.source[1..-2], SYMBOL.source[1..-2]]
+    TOKENIZER = Regexp.new((OPERATOR_TOKENS + VALUE_TOKENS + ['\\(', '\\)']).join('|'))
+
+    def lookup_symbol(symbol)
+      if unit_symbol[symbol]
+        [[:one, unit_symbol[symbol], 1]]
+      else
+        found = prefix_symbol.keys.find do |sym|
+          symbol[0..sym.size-1] == sym && unit_symbol[symbol[sym.size..-1]]
+        end
+        [[prefix_symbol[found], unit_symbol[symbol[found.size..-1]], 1]] if found
+      end
+    end
+
+    def symbol_to_unit(symbol)
+      lookup_symbol(symbol) ||
+        (symbol[-1..-1] == 's' ? lookup_symbol(symbol[0..-2]) : nil) || # Try english plural
+        [[:one, symbol.to_sym, 1]]
+    end
+
+    def compute(result, op)
+      b = result.pop
+      a = result.pop
+      result << case op
+                when '*' then a + b
+                when '/' then a + Unit.power_unit(b, -1)
+                when '^' then Unit.power_unit(a, b[0][1])
+                else raise SyntaxError, "Unexpected token #{op}"
+                end
+    end
+
+    public
+
+    SI = new('SI') do |system|
+      system.load(:si)
+      system.load(:binary)
+      system.load(:degree)
+      system.load(:time)
+    end
+
+    DEFAULT = SI
+  end
+end
+
+def Unit(*args)
+  numerator = Numeric === args.first ? args.shift : 1
+  denominator = Numeric === args.first ? args.shift : 1
+
+  system = args.index {|x| Unit::System === x }
+  system = system ? args.delete_at(system) : Unit::System::DEFAULT
+
+  unit = args.index {|x| String === x }
+  unit = system.parse_unit(args.delete_at(unit)) if unit
+
+  unless unit
+    unit = args.index {|x| Array === x }
+    unit = args.delete_at(unit) if unit
+  end
+
+  unit ||= []
+  system.validate_unit(unit)
+
+  raise ArgumentError, 'wrong number of arguments' unless args.empty?
+
+  Unit.new(numerator, denominator, unit, system)
+end
+
+class Numeric
+  def to_unit(system = nil)
+    system ||= Unit::System::DEFAULT
+    Unit.new(self, 1, [], system)
+  end
+
+  def method_missing(name, *args)
+    Unit.method_name_to_unit(name).to_unit(*args) * self
+  rescue TypeError => ex
+    super
+  end
+
+  def unit(unit, system = nil)
+    unit.to_unit(system) * self
+  end
+end
+
+class Rational
+  def to_unit(system = nil)
+    system ||= Unit::System::DEFAULT
+    Unit.new(numerator, denominator, [], system)
+  end
+end
+
+class String
+  def to_unit(system = nil)
+    system ||= Unit::System::DEFAULT
+    unit = system.parse_unit(self)
+    system.validate_unit(unit)
+    Unit.new(1, 1, unit, system)
+  end
+end
+
+class Symbol
+  def to_unit(system = nil)
+    to_s.to_unit(system)
+  end
+end
+
+class Array
+  def to_unit(system = nil)
+    system ||= Unit::System::DEFAULT
+    system.validate_unit(self)
+    Unit.new(1, 1, self, system)
+  end
+end
+
+# Units use symbols which must be sortable (Fix for Ruby 1.8)
+if !:test.respond_to? :<=>
+  class Symbol
+    include Comparable
+    def <=>(other)
+      self.to_i <=> other.to_i
+    end
+  end
+end

data/lib/units.rb

@@ -0,0 +1 @@
+require 'unit'

data/test/unit_test.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+require 'unit'
+
+Unit::System::DEFAULT.load(:scientific)
+Unit::System::DEFAULT.load(:imperial)
+Unit::System::DEFAULT.load(:misc)
+
+describe 'Unit' do
+  it 'should support multiplication' do
+    (Unit(2, 'm') * Unit(3, 'm')).should.equal Unit(6, 'm^2')
+    (Unit(2, 'm') * 3).should.equal Unit(6, 'm')
+    (Unit(2, 'm') * Rational(3, 4)).should.equal Unit(3, 2, 'm')
+    (Unit(2, 'm') * 0.5).should.equal Unit(1.0, 'm')
+  end
+
+  it 'should support division' do
+    (Unit(2, 'm') / Unit(3, 'm^2')).should.equal Unit(2, 3, '1/m')
+    (Unit(2, 'm') / 3).should.equal Unit(2, 3, 'm')
+    (Unit(2, 'm') / Rational(3, 4)).should.equal Unit(8, 3, 'm')
+    (Unit(2, 'm') / 0.5).should.equal Unit(4.0, 'm')
+  end
+
+  it 'should support addition' do
+    (Unit(42, 'm') + Unit(1, 'km')).should.equal Unit(1042, 'm')
+    (Unit(1, 'm') - Unit(1, 'cm')).should.equal Unit(99, 100, 'm')
+  end
+
+  it 'should check unit compatiblity' do
+    should.raise TypeError do
+      (Unit(42, 'm') + Unit(1, 's'))
+    end
+    should.raise TypeError do
+      (Unit(42, 'g') + Unit(1, 'm'))
+    end
+  end
+
+  it 'should support exponentiation' do
+    (Unit(2, 'm') ** 3).should.equal Unit(8, 'm^3')
+    (Unit(9, 'm^2') ** 0.5).should.equal Unit(3.0, 'm')
+    (Unit(9, 'm^2') ** Rational(1, 2)).should.equal Unit(3, 'm')
+    (Unit(2, 'm') ** 1.3).should.equal Unit(2 ** 1.3, 'm^1.3')
+  end
+
+  it 'should not allow units as exponent' do
+    should.raise TypeError do
+      Unit(42, 'g') ** Unit(1, 'm')
+    end
+  end
+
+  it 'should provide method sugar' do
+    1.meter.should.equal Unit('1 meter')
+    1.meter_per_second.should.equal Unit('1 m/s')
+    1.meter.in_kilometer.should.equal Unit('1 m').in('km')
+    1.unit('°C').should.equal Unit(1, '°C')
+  end
+
+  it 'should have a normalizer' do
+    1.joule.normalize.should.equal Unit(1000, 'gram meter^2 / second^2')
+    unit = 1.joule.normalize!
+    unit.should.equal unit.normalized
+  end
+
+  it 'should convert units' do
+    1.MeV.in_joule.should.equal Unit(1.602176487e-13, 'joule')
+    1.kilometer.in_meter.should.equal Unit(1000, 'meter')
+    1.liter.in('meter^3').should.equal Unit(1, 1000, 'meter^3')
+    1.kilometer_per_hour.in_meter_per_second.should.equal Unit(5, 18, 'meter/second')
+  end
+
+  it 'should have a working compatible? method' do
+    7.meter.compatible?('kilogram').should.equal false
+    3.parsec.compatible_with?('meter').should.equal true
+  end
+
+  it 'should have a pretty string representation' do
+    7.joule.normalize.to_s.should.equal '7000 g·m^2·s^-2'
+  end
+
+  it 'should parse units' do
+    Unit(1, 'KiB s^-1').unit.should.equal [[:kibi, :byte, 1], [:one, :second, -1]].sort
+    Unit(1, 'KiB/s').unit.should.equal [[:kibi, :byte, 1], [:one, :second, -1]].sort
+    Unit(1, 'kilometer^2 / megaelectronvolt^7 * gram centiliter').unit.should.equal [[:kilo, :meter, 2], [:mega, :electronvolt, -7],
+                                                                                     [:one, :gram, 1], [:centi, :liter, 1]].sort
+  end
+
+  it 'should reduce units' do
+    1.joule_per_kilogram.normalize.unit.should.equal [[:one, :meter, 2], [:one, :second, -2]].sort
+    1.megaton_per_kilometer.unit.should.equal [[:kilo, :ton, 1], [:one, :meter, -1]].sort
+  end
+
+  it 'should work with floating point values' do
+    #w = (5.2).kilogram
+    w = 5.2 * Unit('kilogram')
+    w.in_pounds.to_int.should.equal 11
+  end
+
+  it 'should have dimensionless? method' do
+    100.meter.per_km.should.be.dimensionless
+    100.meter.per_km.should.be.unitless
+    42.meter.per_second.should.not.be.unitless
+    100.meter.per_km.should.equal Rational(1, 10).to_unit
+  end
+
+  it 'should be equal to rational if dimensionless' do
+    100.meter.per_km.should.equal Rational(1, 10)
+    100.meter.per_km.approx.should.equal 0.1
+  end
+end
+

data/unit.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/lib/unit'
+
+Gem::Specification.new do |s|
+  s.name = %q{unit}
+  s.version = Unit::VERSION
+
+  s.authors = ["Daniel Mendler"]
+  s.date = %q{2009-05-17}
+  s.email = ["mail@daniel-mendler.de"]
+  s.extra_rdoc_files = []
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = %w(lib)
+
+  s.has_rdoc = true
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = s.name
+  s.summary = 'Scientific unit support for ruby for calculations'
+  s.homepage = %q{http://github.com/minad/si}
+
+  s.add_development_dependency('bacon')
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: unit
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Daniel Mendler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-17 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bacon
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: 
+email: 
+- mail@daniel-mendler.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.markdown
+- Rakefile
+- lib/systems/binary.yml
+- lib/systems/degree.yml
+- lib/systems/imperial.yml
+- lib/systems/misc.yml
+- lib/systems/scientific.yml
+- lib/systems/si.yml
+- lib/systems/time.yml
+- lib/unit.rb
+- lib/units.rb
+- test/unit_test.rb
+- unit.gemspec
+has_rdoc: true
+homepage: http://github.com/minad/si
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: unit
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Scientific unit support for ruby for calculations
+test_files: []
+