numru-units 1.7.0

data/src/numbernode.rb

@@ -0,0 +1,53 @@
+class NumberNode < TerminalNode
+
+    def initialize(arg)
+	raise TypeError unless Numeric === arg
+	@a = arg
+    end
+
+    UNITY = NumberNode.new(1)
+    ZERO = NumberNode.new(0)
+
+    def to_s
+      if @a == @a.to_i
+        sprintf("%d",@a)
+      else
+        String(@a)
+      end
+    end
+
+    attr_reader :a
+
+    alias :value :a
+    alias :factor :a
+
+    def == (other)
+      case other
+      when NumberNode
+	@a == other.a
+      else
+	false
+      end
+    end
+
+    def add_eval(another)
+	raise TypeError unless NumberNode === another
+	NumberNode.new(@a + another.value)
+    end
+
+    def mul_eval(another)
+	case another
+	when NumberNode then NumberNode.new(@a * another.a)
+	when PowNode
+	    raise TypeError unless NumberNode === another.lhs
+	    raise TypeError unless NumberNode === another.rhs
+	    NumberNode.new(@a * Units::pow_f(another.lhs.value, another.rhs.value))
+	else raise TypeError
+	end
+    end
+
+    def name; "1"; end
+
+    def power;  UNITY;  end
+
+end

data/src/pownode.rb

@@ -0,0 +1,98 @@
+class PowNode < ContainerNode
+
+    include BinaryNode
+
+    def initialize(lhs, rhs)
+	@lhs, @rhs = lhs, rhs
+	raise TypeError unless NumberNode === @rhs
+    end
+
+    def to_s
+	lhs = @lhs.to_s
+	case lhs
+	when /\d$/, /[\d\.]/
+	    lhs = "(#{lhs})"
+	end
+	rhs = @rhs.to_s
+        if rhs == '1'
+	    lhs
+	else
+	    rhs = "^(#{rhs})" if (/\./ =~ rhs)
+	    lhs + rhs
+	end
+    end
+
+    attr_reader :lhs, :rhs
+    alias :power :rhs
+
+    def pow_eval(other)
+	case other
+	when NumberNode
+	    PowNode.new(@lhs, @rhs.mul_eval(other))
+	else
+	    super(other)
+	end
+    end
+
+    def flatten2
+	x = @lhs.flatten2
+	case x
+	when NumberNode
+	    a = @lhs.pow_eval(@rhs)
+	when TerminalNode
+	    a = self
+	when PowNode
+	    a = PowNode.new(x.lhs, x.rhs.mul_eval(@rhs))
+	when MulNode, MultiNode
+	    a = MultiNode.new()
+	    for gc in x
+		a.append(gc.pow_eval(@rhs))
+	    end
+	else
+	    raise "internal error"
+	end
+	return a
+    end
+
+    def name
+	case @lhs
+	when NumberNode, NameNode
+	    @lhs.name
+	else
+	    raise "internal error"
+	end
+    end
+
+    def value
+	case @lhs
+	when NumberNode
+	    Units::pow_f(@lhs.value, @rhs.value)
+	else
+	    raise(format('%s#value: internal error', self.class.to_s))
+	end
+    end
+
+    def mul_eval(another)
+	raise "internal error (#{name}, #{another.name})" if name != another.name
+	case @lhs
+	when NumberNode
+	    NumberNode.new(Units::pow_f(@lhs.value, @rhs.value) * another.value)
+	else
+	    self.class.new(@lhs, @rhs.add_eval(another.power))
+	end
+    end
+
+    def sort
+	case @lhs
+	when NumberNode
+	    NumberNode.new(Units::pow_f(@lhs.value, @rhs.value))
+	else
+	    self
+	end
+    end
+
+    def factor
+	Units::pow_f(@lhs.factor, @rhs.value)
+    end
+
+end

data/src/rules.rb

@@ -0,0 +1,65 @@
+class Units
+
+  token INT ERR SHIFT SPACE MULTIPLY DIVIDE EXPONENT REAL NAME DATE TIME ZONE
+  options no_result_var
+
+rule
+
+unit_spec:
+	/* { yyaccept; }  */  /* <-- to acccept empty unit_spec */
+	| origin_exp { yyaccept; }
+	| error { yyerrok }
+	;
+
+origin_exp:	 
+	unit_exp
+	| unit_exp SHIFT value_exp { val[0].shift(val[2]) }
+	| unit_exp SHIFT timestamp { val[0].shift(val[2]) }
+	;
+
+unit_exp: 
+	power_exp
+	| number_exp
+	| unit_exp power_exp		{ val[0].mul(val[1]) }
+	| unit_exp MULTIPLY power_exp	{ val[0].mul(val[2]) }
+	| unit_exp DIVIDE power_exp	{ val[0].divide(val[2]) }
+	| unit_exp MULTIPLY number_exp	{ val[0].mul(val[2]) }
+	| unit_exp DIVIDE number_exp	{ val[0].divide(val[2]) }
+	;
+
+power_exp:
+	NAME { NameNode.new(val[0]) }
+	| power_exp number_exp { val[0].pow(val[1]) }
+	| power_exp EXPONENT value_exp { val[0].pow(val[2]) }
+	| '(' origin_exp ')' { val[1] }
+	;
+
+value_exp:
+	number_exp
+	| '(' value_exp ')' { val[1] }
+	;
+
+number_exp:	 
+	INT { NumberNode.new(val[0]) }
+	| REAL { NumberNode.new(val[0]) }
+	;
+
+timestamp:	 
+	time_exp
+	| '(' timestamp ')' { val[1] }
+	;
+
+time_exp:
+	DATE { TimeNode.new(val[0], 0.0, 0) }
+	| DATE TIME { TimeNode.new(val[0], val[1], 0) }
+	| DATE TIME ZONE { TimeNode.new(val[0], val[1], val[2]) }
+	;
+
+end
+
+---- header
+
+require 'date'
+
+---- inner
+

data/src/shiftnode.rb

@@ -0,0 +1,63 @@
+class ShiftNode < ContainerNode
+
+    include BinaryNode
+
+    def initialize(lhs, rhs)
+	@lhs, @rhs = lhs, rhs
+    end
+
+    attr_reader :lhs, :rhs
+    alias :ref :rhs
+
+    def to_s
+	"(#{@lhs.to_s} @ #{@rhs.to_s})"
+    end
+
+    def trim2;  @lhs;  end
+    def trim
+      	self.class.new(@lhs.trim, @rhs.trim2)
+    end
+
+    def flatten2;  @lhs;  end
+    def flatten
+	lf = @lhs.flatten
+	case lf
+	when ShiftNode
+	    rf = lf.rhs.add_eval(@rhs)
+	    self.class.new(lf.lhs, rf)
+	else
+	    self.class.new(lf, @rhs.flatten)
+	end
+    end
+
+    def sort
+	self.class.new(@lhs.sort, @rhs.sort)
+    end
+
+    def ref
+	case @lhs
+	when ShiftNode
+	    @lhs.ref.add_eval(@rhs)
+	else
+	    @rhs
+	end
+    end
+
+    def deref
+	case @lhs
+	when ShiftNode
+	    @lhs.deref
+	else
+	    @lhs
+	end
+    end
+
+    def name
+	@lhs.name
+    end
+
+    def factor
+	@lhs.factor
+    end
+
+end

data/src/test.rb

@@ -0,0 +1,122 @@
+require 'units'    # Use require "numru/units" after installation.
+include NumRu
+
+def assert(test, seikai)
+	raise "#{test.inspect} != #{seikai.inspect}" if test != seikai
+	puts "ok #{seikai.inspect}"
+end
+
+puts "=== reduce1 ==="
+
+assert Units.new('').reduce1.to_s, ""
+assert Units.new('m').reduce1.to_s, "m"
+assert Units.new('3').reduce1.to_s, "3"
+assert Units.new('3.14').reduce1.to_s, "3.14"
+assert Units.new('m2').reduce1.to_s, "m2"
+assert Units.new('m.s').reduce1.to_s, "m.s"
+assert Units.new('m/s').reduce1.to_s, "m.s-1"
+assert Units.new('kg.m/s2').reduce1.to_s, "kg.m.(s2)-1"
+assert Units.new('s @ 2003-11-29').reduce1.to_s,
+	"(s @ 2003-11-29T00:00:00.00 +00:00)"
+assert Units.new('s @ 2003-11-29T11:24').reduce1.to_s,
+	"(s @ 2003-11-29T11:24:00.00 +00:00)"
+assert Units.new('s @ 2003-11-29T11:24:11 -09:00').reduce1.to_s,
+	"(s @ 2003-11-29T11:24:11.00 -09:00)"
+
+assert Units.new('100').reduce1.to_s, "100"
+assert Units.new('(10)^2').reduce1.to_s, "(10)2"
+assert Units.new('(10)^2/100').reduce1.to_s, "(10)2.(100)-1"
+
+puts "=== reduce2 ==="
+
+assert Units.new('s @ 2003-11-29').reduce2.to_s,
+	"(s @ 2003-11-29T00:00:00.00 +00:00)"
+assert Units.new('m/(s @ 2003-11-29)').reduce2.to_s, "m.s-1"
+assert Units.new('m/((K @ 273.15) (s from 2003-11-29))').reduce2.to_s, "m.(K.s)-1"
+
+assert Units.new('(10)^2/100').reduce2.to_s, "(10)2.(100)-1"
+
+puts "=== reduce3 ==="
+
+assert Units::MultiNode.new(Units::NameNode.new('a'),  \
+	Units::NumberNode.new(1), \
+	Units::NameNode.new('b')).to_s, 'a.1 b'
+
+assert Units.new('kg').reduce3.inspect, "Units[Name[kg]]"
+assert Units.new('kg.m').reduce3.inspect, "Units[Multi[Name[kg], Name[m]]]"
+assert Units.new('kg.m.s').reduce3.inspect,
+	"Units[Multi[Name[kg], Name[m], Name[s]]]"
+
+assert Units.new('(m.s)^2').reduce3.inspect,
+	"Units[Multi[Pow[Name[m], Number[2]], Pow[Name[s], Number[2]]]]"
+assert Units.new('K @ 273.15').reduce3.inspect,
+	"Units[Shift[Name[K], Number[273.15]]]"
+assert Units.new('((a.b)^2)^2').reduce3.inspect,
+	"Units[Multi[Pow[Name[a], Number[4]], Pow[Name[b], Number[4]]]]"
+assert Units.new('((a.b)^2 c4 d)^2').reduce3.inspect,
+	"Units[Multi[Pow[Name[a], Number[4]], Pow[Name[b], Number[4]], Pow[Name[c], Number[8]], Pow[Name[d], Number[2]]]]"
+assert Units.new('((a.b)^2 c4 d)^2').reduce3.to_s,
+	"a4 b4 c8 d2"
+assert Units.new('((a.b)^2 a4 b)^2').reduce3.to_s,
+	"a4 b4 a8 b2"
+
+assert Units.new('s @ 2003-11-29').reduce3.to_s,
+	"(s @ 2003-11-29T00:00:00.00 +00:00)"
+assert Units.new('m/(s @ 2003-11-29)').reduce3.to_s, "m.s-1"
+assert Units.new('m/((K @ 273.15) (s from 2003-11-29))').reduce3.to_s, "m.K-1 s-1"
+
+assert Units.new('(10)^2/100').reduce3.to_s, "(10)2.(100)-1"
+
+puts "=== reduce4 ==="
+
+assert Units.new('((a.b)^2 a4 b @ now)^2 @ 273.15').reduce4.to_s,
+	"(a12 b6 @ 273.15)"
+
+assert Units.new('km2').reduce4.to_s, "km2"
+assert Units.new('hours.hour').reduce4.to_s, "hour2"
+assert Units.new('(10)^2').reduce4.to_s, "100"
+assert Units.new('100/10').reduce4.to_s, "10.0"
+assert Units.new('(10)^2/100').reduce4.to_s, "1.0"
+
+puts "=== reduce5 ==="
+
+assert Units.new('km2').reduce5.to_s, "1000000 m2"
+assert Units.new('(10)^2/100').reduce5.to_s, "1.0"
+
+assert Units.new('hPa').reduce5.to_s, "100 kg.m-1 s-2"
+assert Units.new('mb').reduce5.to_s, "100.0 kg.m-1 s-2"
+
+assert Units.new('hPa/mb').reduce5.to_s, "1.0"
+
+assert Units.new('(K @ 273.15)@ 10').reduce5.to_s, "(K @ 283.15)"
+
+puts "=== APPLICATIONS ==="
+
+assert Units.new('km @ 2').convert(3, Units.new('m @ 100')), 4900
+assert Units.new('degree_F').convert(32, Units.new('K')).to_s, "273.15"
+
+u1 = Units.new('m/s')
+u2 = Units.new('mm/s')
+assert((u1/u2).to_s, "m.mm-1")
+assert((u1*u2).to_s, "m.mm.s-2")
+
+u1 = Units.new('years since 1999-01-01 00:00').reduce4
+u2 = Units.new('hours since 2001-01-01 00:00').reduce4
+assert u1.convert(3, u2), 24 * 365
+u3 = Units.new('months since 2001-01-01 00:00').reduce4
+assert u1.convert(3, u3), 12.0
+
+Units.reduce_level = 3
+assert((Units.new('hours') ** 2).to_s, "hours2")
+Units.reduce_level = 4
+assert((Units.new('hours') ** 2).to_s, "hour2")
+Units.reduce_level = 5
+assert((Units.new('hours') ** 2).to_s, "12960000 s2")
+
+assert(Units.new('day') =~ Units.new('s since 2002-01-01'), true)
+assert(Units.new('m') =~ Units.new('1'), false)
+
+un1  = Units['day since 2000-01-01']
+un2 = Units['s since 2000-01-01']
+assert(un1.convert(0, un2), 0.0)
+assert(un1.convert(1, un2), 86400.0)

data/src/timenode.rb

@@ -0,0 +1,136 @@
+class XDate
+
+    def initialize(year, month, day)
+	@year, @month, @day = year.to_i, month.to_i, day.to_i
+    end
+
+    attr_reader :year, :month, :day
+
+    def to_s
+	format('%04d-%02d-%02d', @year, @month, @day)
+    end
+
+    alias :inspect :to_s
+
+    def to_time
+	Time.gm(@year, @month, @day)
+    end
+
+    def to_date
+	Date.new(@year, @month, @day)
+    end
+
+    def -(other)
+	case other
+	when XDate
+	    (to_date - other.to_date)
+	when Time
+	    to_time - other
+	when Date
+            (to_date - other.to_date)
+	else
+	    to_date - other
+	end
+    end
+
+    def +(other)
+	t = to_date + other
+	self.class.new(t.year, t.month, t.mday)
+    end
+
+end
+
+class TimeNode < TerminalNode
+
+    def initialize(date, time, zone)
+	@date, @time, @zone = date, time, zone
+	if :now === @date then
+	    now = Time.now.utc
+	    @date = XDate.new(now.year, now.month, now.day)
+	    @time = ((now.hour * 60 + now.min) * 60 + Float(now.sec))
+	else
+	    qdays = (@time / 86400).floor
+	    if not qdays.zero?
+	        @date += qdays
+	        @time -= (qdays * 86400)
+	    end
+	end
+	raise TypeError unless XDate === @date
+	@time = 0.0 unless @time
+	raise TypeError unless Float === @time
+	@zone = 0 unless @zone
+	raise TypeError unless Integer === @zone
+    end
+
+    attr_reader :date, :time, :zone
+
+    def to_s
+	hr = @time.floor / 3600
+	mi = (@time.floor / 60) % 60
+	sc = @time % 60
+	tzm = @zone.abs
+	tzh = tzm / 60
+	tzm %= 60
+	tzh = -tzh if @zone < 0
+	format("%sT%02d:%02d:%05.2f %+03d:%02d", \
+	    @date.to_s, hr, mi, sc, tzh, tzm)
+    end
+
+    def self::pentad(d)
+	(d > 25) ? 5 : ((d - 1) / 5)
+    end
+
+    def add_time(increment)
+	inc = increment.reduce5
+	case inc.name
+	when 's'
+	    t2 = @time + inc.factor
+	    d2 = @date + (t2 / 86400)
+	    t2 = t2 % 86400
+	    self.class.new(d2, t2, @zone)
+	when 'pentad'
+	    ifac = Integer(inc.factor)
+	    ipen = ifac % 6
+	    imon = ifac / 6
+	    spen = self.class.pentad(@date.day)
+	    smon = @date.month + imon + spen / 6
+	    spen = spen % 6
+	    sday = spen * 5 + (@date.day - 1) % 5 + 1
+	    syear = @date.year + (smon - 1) / 12
+	    smon = (smon - 1) % 12 + 1
+	    sdate = XDate.new(syear, smon, sday)
+	    self.class.new(sdate, @time, @zone)
+	else
+	    raise "bad time unit '#{inc.name}'"
+	end
+    end
+
+    def utcsod
+	@time - @zone * 60
+    end
+
+    def div_time(units)
+	base = units.ref
+	inc = units.deref.reduce5
+	begin
+	    incname = inc.name
+	rescue Exception
+	    incname = "(undefined)"
+	end
+	case incname
+	when 's'
+	    dif = (@date - base.date) * 86400 + (utcsod - base.utcsod)
+	    dif / inc.factor
+	when 'pentad'
+	    dif = (@date.year - base.date.year) * 72
+	    dif += (@date.month - base.date.month) * 6
+	    dif += self.class.pentad(@date.day)
+	    dif -= self.class.pentad(base.date.day)
+	    dif = Float(dif) if dif % inc.factor != 0
+	    dif / inc.factor
+	else
+	    raise "bad time unit '#{incname}'"
+	end
+    end
+
+end