phys-units 0.9.0

data/lib/phys/units/parse.y

@@ -0,0 +1,123 @@
+# parse.y
+#
+#   Copyright (c) 2001-2013 Masahiro Tanaka <masa16.tanaka@gmail.com>
+#
+#   This program is free software.
+#   You can distribute/modify this program under the terms of
+#   the GNU General Public License version 3 or later.
+
+class Parse
+
+  prechigh
+    left '|'
+    right POW
+    nonassoc '(' WORD NUMBER UFUNC
+    left '*' MULTIPLY
+    left DIV
+    left UNARY
+    left '+' '-'
+  preclow
+
+rule
+
+ target:  expr
+       |  DIV list { result = Unit.inv(val[1]) }
+       ;
+
+ expr: list
+     | '-' list = UNARY { result = -val[1] }
+     | expr '+' expr    { result = val[0] + val[2] }
+     | expr '-' expr    { result = val[0] - val[2] }
+     | expr '*' expr    { result = val[0] * val[2] }
+     | expr DIV expr    { result = val[0] / val[2] }
+     ; 
+
+ numexpr: NUMBER
+        | numexpr '|' numexpr { result = Unit.rdiv(val[0],val[2]) } 
+        ;
+
+ pexpr: '(' expr ')'          { result = val[1] }
+      ;
+
+ list: numexpr
+     | pexpr
+     | WORD	               { result = Unit.word(val[0]) }
+     | list list    = MULTIPLY { result = val[0] * val[1] }
+     | list POW list           { result = val[0]** val[2] }
+     | list POW '-' list = POW { result = val[0]**(-val[3]) }
+     | UFUNC pexpr             { result = Unit.func(val[0],val[1]) }
+     ;
+
+end
+
+---- header ----
+
+# -*- coding: utf-8 -*-
+# parse.y, parse.rb
+#
+#   by Masahiro Tanaka <masa16.tanaka@gmail.com>
+#
+module Phys
+class Unit
+---- inner ----
+
+  def build_num(ov,ud,pw)
+    if ud.nil? && pw.nil?
+      #ov.to_i
+      Rational(ov.to_i)
+    else
+      m1 = ud ? ud.size : 0
+      pw = pw ? pw.to_i : 0
+      m2 = pw-m1
+      ov = ov ? ov.to_i : 0
+      ud = ud ? ud.to_i : 0
+      a = ov*10**m1 + ud
+      b = 1
+      a *= 10**m2 if m2>0
+      b *= 10**(-m2) if m2<0
+      Rational(a,b)
+    end
+  end
+
+  def parse( str )
+    return Unit.new(str) if str.empty?
+    #p str
+    @q = []
+
+    c = Unit.unit_chars
+
+    while str.size > 0 do
+      case str
+      when /\A[\s]+/o
+      when /\A(\d+)(?:(?:\.(\d*))?(?:[eE]([+-]?\d+))?)/o
+	@q.push [:NUMBER, build_num($1,$2,$3)]
+      when /\A(sin|cos|tan|log|ln|log2)\b/o
+        @q.push [:UFUNC, $&]
+      when /\A\//o
+        @q.push [:DIV, $&]
+      when /\Aper\b/o
+        @q.push [:DIV, $&]
+      when /\A[^#{c}0-9,.-]+([^#{c}$-]*[^#{c}1-9,.])?/o
+        @q.push [:WORD, $&]
+      when /\A[%'"]'?/o
+        @q.push [:WORD, $&]
+      when /\A\^|\A\*\*/o
+        @q.push [:POW, $&]
+      when /\A./o
+        @q.push [$&,$&]
+      end
+      str = $' #'
+    end
+    @q.push [false, '$end']
+
+    do_parse
+  end
+
+  def next_token
+    @q.shift
+  end
+
+---- footer ----
+
+end
+end

data/lib/phys/units/quantity.rb

@@ -0,0 +1,252 @@
+#
+# phys/units/quantity.rb
+#
+#   Copyright (c) 2001-2013 Masahiro Tanaka <masa16.tanaka@gmail.com>
+#
+#   This program is free software.
+#   You can distribute/modify this program under the terms of
+#   the GNU General Public License version 3 or later.
+
+module Phys
+
+  def Quantity(*a)
+    Quantity.new(*a)
+  end
+
+  #== Usage
+  #   require 'phys/units'
+  #   Q=Phys::Quantity
+  #   Q[1.23,'km'] + Q[4.56,'m']    #=> Phys::Quanty[1.23456,'km']
+  #   Q[123,'mile'] / Q[2,'hr']     #=> Phys::Quanty[61,'mile/hr']
+  #   Q[61,'miles/hr'].want('m/s')  #=> Phys::Quanty[27.26944,'m/s']
+  #   Q[1.0,'are'] == Q[10,'m']**2  #=> true
+  #   Q[70,'tempF'] + Q[10,'tempC'] #=> Phys::Quantity[88,'tempF']
+  #   Q[20,'tempC'].want('tempF')   #=> Phys::Quantity[68,'tempF']
+  #   Math.cos(Q[60,'degree'].to_f) #=> 0.5
+  class Quantity
+
+    class << self
+      # Same as Quantity.new.
+      def [](*a)
+        self.new(*a)
+      end
+    end
+
+    # Initialize a new quantity.
+    # _value_: Numeric value of quantity.
+    # _expr_: Unit string. Result of Unit.parse(_expr_) is used as a unit.
+    # _unit_: (optional) Unit of quantity instead of parsing _expr_.
+    def initialize(value,expr=nil,unit=nil)
+      @val = value
+      expr = expr.to_s if Symbol===expr
+      @expr = (expr=='') ? nil : expr
+      @unit = unit
+      if @unit.nil?
+        @unit = Unit.parse(@expr||1)
+      elsif !@unit.kind_of? Unit
+        raise ArgumentError, "third arg must be Phys::Unit"
+      end
+    end
+
+    attr_reader :val
+    attr_reader :expr
+    attr_reader :unit
+
+    # Returns the value of the quantity.
+    alias value val
+
+    # Conversion to a quantity in another _expr_ unit.
+    def want(expr)
+      unit = Unit.parse(expr)
+      val  = unit.convert(self)
+      self.class.new( val, expr, unit )
+    end
+    alias convert want
+
+    # Addition of two quantities.
+    # Operation is made after the unit of _other_ is
+    # converted to the unit of _self_.
+    # Exception is raised if unit conversion is failed.
+    # Returns an instance of Quantity class in the unit of former quantity.
+    def +(other)
+      val = @val + @unit.convert_scale(other)
+      self.class.new( val, @expr, @unit )
+    end
+
+    # Subtraction of two quantities.
+    # Operation is made after the unit of _other_ is
+    # converted to the unit of _self_.
+    # Exception is raised if unit conversion is failed.
+    # Returns an instance of Quantity class in the unit of former quantity.
+    def -(other)
+      val = @val - @unit.convert_scale(other)
+      self.class.new( val, @expr, @unit )
+    end
+
+    %w[abs ceil round floor truncate].each do |s|
+      define_method(s) do
+        self.class.new( @val.send(s), @expr, @unit )
+      end
+    end
+
+    # Unary Plus. Returns self.
+    def +@ ; self.class.new(  @val, @expr, @unit ) end
+
+    # Unary Minus. Returns the negated quantity.
+    def -@ ; self.class.new( -@val, @expr, @unit ) end
+
+    # Comparison of quantities. Comparison is made after
+    # converting _other_ to a quantity in the unit of _self_.
+    def <=> (other); @val <=> @unit.convert(other) end
+
+    # Comparison of quantities. Comparison is made after
+    # converting _other_ to a quantity in the unit of _self_.
+    def  == (other); @val  == @unit.convert(other) end
+
+    # Comparison of quantities. Comparison is made after
+    # converting _other_ to a quantity in the unit of _self_.
+    def  >= (other); @val  >= @unit.convert(other) end
+
+    # Comparison of quantities. Comparison is made after
+    # converting _other_ to a quantity in the unit of _self_.
+    def  <= (other); @val  <= @unit.convert(other) end
+
+    # Comparison of quantities. Comparison is made after
+    # converting _other_ to a quantity in the unit of _self_.
+    def  <  (other); @val  <  @unit.convert(other) end
+
+    # Comparison of quantities. Comparison is made after
+    # converting _other_ to a quantity in the unit of _self_.
+    def  >  (other); @val  >  @unit.convert(other) end
+
+    # Power of a quantity.
+    # Returns an instance of Quantity class in a powerd unit.
+    def **(n)
+      if @expr.nil?
+        expr = nil
+      elsif /^[A-Za-z_]+&/o =~ @expr
+        expr = @expr+'^'+n.to_s
+      else
+        expr = '('+@expr+')^'+n.to_s+''
+      end
+      self.class.new( @val**n, expr, @unit**n )
+    end
+
+    def enclose_expr     #:nodoc:
+      return nil if @expr.nil?
+      if /\/|\||per/o =~ @expr
+        '('+@expr+')'
+      else
+        @expr
+      end
+    end
+
+    def enclose_expr_div    #:nodoc:
+      return nil if @expr.nil?
+      if /\w[^\w]+\w/o =~ @expr
+        '/('+@expr+')'
+      else
+        '/'+@expr
+      end
+    end
+
+    # Multiplication of two quantities.
+    # Returns an instance of Quantity class in a multiplied unit.
+    def *(other)
+      if Quantity===other
+        a = [self.enclose_expr, other.enclose_expr]
+        a.delete(nil)
+        self.class.new( @val*other.val, a.join(' '), @unit*other.unit )
+      else
+        self.class.new( @val*other, @expr, @unit )
+      end
+    end
+
+    # Division of two quantities.
+    # Returns an instance of Quantity class in a divided unit.
+    %w[/ div quo].each do |s|
+      define_method(s) do |other|
+        if Quantity===other
+          a = [self.enclose_expr, other.enclose_expr_div]
+          a.delete(nil)
+          self.class.new( @val.send(s,other.val), a.join, @unit/other.unit )
+        else
+          self.class.new( @val.send(s,other), @expr, @unit )
+        end
+      end
+    end
+    alias fdiv quo
+
+    %w[% remainder].each do |s|
+      define_method(s) do |other|
+        other = (Quantity===other) ? other.val : other
+        self.class.new( @val.send(s,other), @expr, @unit )
+      end
+    end
+    alias modulo %
+
+    def coerce(other)
+      [ self.class.new(other), self ]
+    end
+
+    def abs
+      self.class.new( @val.abs, @expr, @unit )
+    end
+
+    def abs2
+      self**2
+    end
+
+    # Conversion to base unit.
+    # Returns the quantity converted to a base unit.
+    def to_base_unit
+      unit = @unit.base_unit
+      val  = unit.convert(self)
+      expr = unit.unit_string
+      self.class.new( val, expr, unit )
+    end
+    alias to_si to_base_unit
+    alias to_SI to_base_unit
+
+    # Conversion to Numeric.
+    # Returns Numeric if the unit is dimensionless.
+    # Raises an Error if the unit is non-dminensionless.
+    def to_numeric
+      @unit.convert_to_numeric(@val)
+    end
+
+    def to_f
+      to_numeric.to_f
+    end
+    alias to_float to_f
+
+    def to_i
+      to_numeric.to_i
+    end
+    alias to_int to_i
+    alias to_integer to_i
+
+    def to_r
+      to_numeric.to_r
+    end
+    alias to_rational to_r
+
+    def to_s
+      if @expr
+        expr = ",'" +@expr+"'"
+      else
+        expr = ""
+      end
+      self.class.to_s+"["+Unit::Utils.num_inspect(@val)+expr+"]"
+    end
+
+    def inspect
+      if @expr
+        expr = "," +@expr.inspect
+      else
+        expr = ""
+      end
+      "#<"+self.class.to_s+" "+Unit::Utils.num_inspect(@val)+expr+", "+@unit.inspect+">"
+    end
+  end
+end

data/lib/phys/units/unit.rb

@@ -0,0 +1,446 @@
+#
+# phys/units/unit.rb
+#
+#   Copyright (c) 2001-2013 Masahiro Tanaka <masa16.tanaka@gmail.com>
+#
+#   This program is free software.
+#   You can distribute/modify this program under the terms of
+#   the GNU General Public License version 3 or later.
+
+module Phys
+
+  class Unit
+
+    LIST = {}
+    PREFIX = {}
+
+    def self.prefix_regex
+      @@prefix_regex
+    end
+
+    def initialize(arg,expr=nil,offset=nil)
+      case arg
+      when Numeric
+        arg = Rational(arg) if Integer===arg
+        @factor = arg
+        alloc_dim(expr)
+      when Phys::Unit
+        replace(arg)
+      when String
+        @name = arg
+        if expr.kind_of? Phys::Unit
+          @factor = expr.factor
+          @offset = expr.offset
+          alloc_dim expr.dim
+        else
+          @expr = expr
+        end
+      else
+        raise TypeError,"invalid argument : #{arg.inspect}"
+      end
+    end
+
+    attr_reader :name, :offset, :expr
+
+    def dim
+      use_dimension
+      @dim
+    end
+    alias dimension dim
+
+    def factor
+      use_dimension
+      @factor
+    end
+
+    def dimension_value
+      1
+    end
+
+    def replace(x)
+      @name = x.name.dup if x.name
+      @factor = x.factor
+      @offset = x.offset
+      alloc_dim x.dim
+    end
+
+    def alloc_dim(hash=nil)
+      case hash
+      when Hash
+        @dim = hash.dup
+      else
+        @dim = {}
+      end
+      @dim.default = 0
+    end
+
+    def use_dimension
+      return if @dim && @factor
+      if @expr && @dim.nil?
+        puts "unit='#{@name}', parsing '#{@expr}'..." if Unit.debug
+        unit = Unit.parse(@expr)
+        case unit
+        when Unit
+          @dim = unit.dim
+          @factor = unit.factor
+          if @dim.nil? || @factor.nil?
+            raise UnitParseError,"parse error : #{unit.inspect}"
+          end
+        when Numeric
+          @factor = unit
+          alloc_dim
+        else
+          raise UnitParseError,"parse error : #{self.inspect}"
+        end
+      else
+        raise UnitParseError,"undefined unit?: #{self.inspect}"
+      end
+    end
+
+    def inspect
+      a = [Utils.num_inspect(@factor), @dim.inspect]
+      a << "@name="+@name.inspect if @name
+      a << "@expr="+@expr.inspect if @expr
+      a << "@offset="+@offset.inspect if @offset
+      a << "@dimensionless=true" if @dimensionless
+      if @dimension_value && @dimension_value!=1
+        a << "@dimension_value="+@dimension_value.inspect
+      end
+      s = a.join(",")
+      "#<#{self.class} #{s}>"
+    end
+
+    def unit_string
+      use_dimension
+      a = []
+      a << Utils.num_inspect(@factor) if @factor!=1
+      a += @dim.map do |k,d|
+        if d==1
+          k
+        else
+          "#{k}^#{d}"
+        end
+      end
+      a.join(" ")
+    end
+    alias string_form unit_string
+
+    # Unit conversion
+
+    def conversion_factor
+      use_dimension
+      f = @factor
+      @dim.each do |k,d|
+        if d != 0
+          u = LIST[k]
+          if u.dimensionless?
+            f *= u.dimension_value**d
+          end
+        end
+      end
+      f
+    end
+
+    def scalar?
+      use_dimension
+      (@dim.nil? || @dim.empty?) && @factor==1
+    end
+
+    def dimensionless_deleted
+      use_dimension
+      hash = @dim.dup
+      hash.delete_if{|k,v| LIST[k].dimensionless?}
+    end
+
+    def dimensionless?
+      use_dimension
+      @dim.each_key.all?{|k| LIST[k].dimensionless?}
+    end
+
+    def same_dimension?(x)
+      dimensionless_deleted == x.dimensionless_deleted
+    end
+    alias same_dim? same_dimension?
+
+    def assert_dimensionless
+      if !dimensionless?
+        raise UnitConversionError,"Not dimensionless: #{self.inspect}"
+      end
+    end
+
+    def assert_same_dimension(x)
+      if !same_dimension?(x)
+        raise UnitConversionError,"Different dimension: #{self.inspect} and #{x.inspect}"
+      end
+    end
+
+    def convert(q)
+      if Quantity===q
+        assert_same_dimension(q.unit)
+        v = q.unit.convert_to_base(q.value)
+        convert_from_base(v)
+      else
+        q / to_num
+      end
+    end
+
+    def convert_scale(q)
+      convert(q)
+    end
+
+    def convert_to_base(x)
+      x * conversion_factor
+    end
+
+    def convert_from_base(x)
+      x / conversion_factor
+    end
+
+    def convert_to_numeric(x)
+      assert_dimensionless
+      x * conversion_factor
+    end
+
+    def to_num
+      assert_dimensionless
+      conversion_factor
+    end
+
+    def convert_to_float(x)
+      convert_to_numeric(x).to_f
+    end
+
+    def base_unit
+      Unit.new(1,dim)
+    end
+
+    # Unit operation
+
+    def operable?
+      true
+    end
+
+    def check_operable
+      if !operable?
+        raise UnitOperationError,"non-operable for #{inspect}"
+      end
+    end
+
+    def check_operable2(x)
+      if !(operable? && x.operable?)
+        raise UnitOperationError,"non-operable: #{inspect} and #{x.inspect}"
+      end
+    end
+
+    def dimension_binop(other)
+      x = self.dim
+      y = other.dim
+      if Hash===x
+        if Hash===y
+          keys = x.keys | y.keys
+          dims = {}
+          dims.default = 0
+          keys.each do |k| 
+            v = yield( x[k]||0, y[k]||0 )
+            dims[k] = v if v!=0
+          end
+          dims
+        else
+          x.dup
+        end
+      else
+        raise "dimensin not defined"
+      end
+    end
+
+    def dimension_uop
+      x = self.dim
+      if Hash===x
+        dims = {}
+        dims.default = 0
+        x.each do |k,d|
+          v = yield( d )
+          dims[k] = v if v!=0
+        end
+        dims
+      else
+        raise "dimensin not defined"
+      end
+    end
+
+    def +(x)
+      x = Unit.cast(x)
+      check_operable2(x)
+      assert_same_dimension(x)
+      Unit.new(@factor+x.factor,@dim.dup)
+    end
+
+    def -(x)
+      x = Unit.cast(x)
+      check_operable2(x)
+      assert_same_dimension(x)
+      Unit.new(@factor-x.factor,@dim.dup)
+    end
+
+    def -@
+      check_operable
+      use_dimension
+      Unit.new(-@factor,@dim.dup)
+    end
+
+    def +@
+      self
+    end
+
+    def *(x)
+      y = Unit.cast(x)
+      if scalar?
+        return y
+      elsif y.scalar?
+        return self
+      end
+      check_operable2(y)
+      dims = dimension_binop(y){|a,b| a+b}
+      factor = self.factor * y.factor
+      Unit.new(factor,dims)
+    end
+
+    def /(x)
+      y = Unit.cast(x)
+      if scalar?
+        return y.inv
+      elsif y.scalar?
+        return self
+      end
+      check_operable2(y)
+      dims = dimension_binop(y){|a,b| a-b}
+      factor = self.factor / y.factor
+      Unit.new(factor,dims)
+    end
+
+    def rdiv(x)
+      y = Unit.cast(x)
+      if scalar?
+        return y.inv
+      elsif y.scalar?
+        return self
+      end
+      check_operable2(y)
+      dims = dimension_binop(y){|a,b| a-b}
+      factor = Rational(self.factor,x.factor)
+      Unit.new(factor,dims)
+    end
+
+    def self.rdiv(x,y)
+      Unit.cast(x).rdiv(y)
+    end
+
+    def inv
+      check_operable
+      dims = dimension_uop{|a| -a}
+      Unit.new(Rational(1,self.factor), dims)
+    end
+
+    def **(x)
+      check_operable
+      m = Utils.as_numeric(x)
+      dims = dimension_uop{|a| a*m}
+      Unit.new(@factor**m,dims)
+    end
+
+    def self.func(fn, x)
+      fn = 'log' if fn == 'ln'
+      m = Unit.new(x).to_num
+      Unit.new( Math.send(fn,m) )
+    end
+
+    def ==(x)
+      use_dimension
+      @factor == x.factor && @dim == x.dim && 
+        offset == x.offset && dimension_value == x.dimension_value
+    end
+
+    def coerce(x)
+      [Unit.find_unit(x), self]
+    end
+
+  end # Unit
+
+
+  class BaseUnit < Unit
+    def initialize(s,dimless=false,v=nil)
+      case s
+      when String
+        @name = s
+        @factor = 1
+        @dim = {s=>1}
+        @dim.default = 0
+        @dimensionless = dimless
+        @dimension_value = v || 1
+      else
+        raise ArgumentError "BaseUnit#initialize: arg must be string: #{s}"
+      end
+    end
+
+    def replace(x)
+      super(x)
+      @dimensionless = x.dimensionless
+      @dimension_value = x.dimension_value
+    end
+
+    def use_dimension
+    end
+
+    def dimensionless?
+      @dimensionless
+    end
+
+    def dimensionless_deleted
+      if @dimensionless
+        {}
+      else
+       @dim.dup
+      end
+    end
+
+    attr_reader :dimension_value
+  end
+
+
+  class OffsetUnit < Unit
+
+    def self.define(name,unit,offset=nil)
+      LIST[name] = self.new(name,unit,offset)
+    end
+
+    def initialize(name,arg,offset)
+      super(name,arg)
+      @offset = offset
+      if offset.nil?
+        raise ArgumentError,"offset is not supplied"
+      end
+    end
+
+    def convert_to_base(x)
+      x * conversion_factor + @offset
+    end
+
+    def convert_from_base(x)
+      (x - @offset) / conversion_factor
+    end
+
+    def convert_scale(q)
+      if Quantity===q
+        assert_same_dimension(q.unit)        
+        v = q.value * q.unit.conversion_factor
+        v = v / self.conversion_factor
+      else
+        raise TypeError,"not Quantitiy: #{q.inspect}"
+      end
+    end
+
+    def operable?
+      false
+    end
+  end
+end