units-system 0.0.5 → 0.1.0

data/lib/units/definitions.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+module Units
+
+  # 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
+
+  # define base units
+  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
+
+  # declare derived quantities with no 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}
+
+  # derived quantities with named 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}
+  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}
+
+  # Other units
+
+  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
+  define :inch, 'inch',    1, :in # alternative to avoid having to use self.in (in is a Ruby keyword)
+  define :lb,   'pound',   0.45359237, :kg
+
+  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', 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', u{9.80665*m/s**2}
+
+  define :bar,  'bar',                    1E5, :Pa
+  define :atm,  'atmosphere',             101325.0, :Pa
+  define :mWC,  'meters of water column', u{1E3*kg*g0/m**2}
+  define :Torr, 'torricelli',             u{atm/760}
+  define :mHg,  'mHg',                    u{13.5951E3*kg*g0/m**2}
+
+  # define :kp, 'kilopond', :force, u{kg*g0} # or define pond?
+  define :gf,  'gram-force',  u{g*g0} # kilopond kp = kgf
+  define :lbf, 'pound-force', u{lb*g0}
+
+  define :dyn,   'dyne', 10, :µN # u{1*g*cm/s**2}
+  define :galUS, 'U.S. liquid gallon', u{231*self.in**3}
+  define :galUK, 'Imperial gallon', 4.546092, :l
+  define :hp,    'horsepower', u{550*ft*lbf/s}
+
+  define :psi, 'pounds-force per square inch', u{lbf/self.in**2}
+
+end # Units

data/lib/units/math.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module Units
+
+  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
+
+end # Units

data/lib/units/measure.rb

@@ -0,0 +1,263 @@
+# encoding: utf-8
+
+module Units
+
+  class Measure
+
+    def initialize(*args)
+      if args.size==0
+        mag = 1.0
+        units = {}
+      elsif args.size==1
+        case args.first
+        when Numeric
+          mag = args.first
+          units = {}
+        else
+          mag = 1.0
+          units = args.first
+        end
+      elsif args.size==2
+        mag, units = args
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 0, 1 or 2)"
+      end
+
+      @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
+
+    include ModalSupport::StateEquivalent
+    include ModalSupport::BracketConstructor
+
+    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)
+    Measure[*args]
+  end
+  module_function :Measure
+
+end # Units

data/lib/units/prefixes.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Units
+
+  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'],
+    :"\302\265"=>[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
+
+end # Units