numru-units 1.7.0

data/src/makeutab.rb

@@ -0,0 +1,87 @@
+
+SI_ABBREV = {
+    'E' => 18,		'P' => 15,		'T' => 12,
+    'G' => 9,		'M' => 6,		'k' => 3,
+    'h' => 2,		'da' => 1,
+    'd' => -1,		'c' => -2,
+    'm' => -3,		'u' => -6,		'n' => -9,
+    'p' => -12,		'f' => -15,		'a' => -18,
+}
+
+SI_PREFIX = {
+    'exa' => 18,	'peta' => 15,		'tela' => 12,
+    'giga' => 9,	'mega' => 6,		'kilo' => 3,
+    'hecto' => 2,	'deca' => 1,
+    'deci' => -1,	'centi' => -2,
+    'milli' => -3,	'micro' => -6,		'nano' => -9,
+    'pico' => -12,	'femto' => -15,		'atto' => -18,
+}
+
+def plural(string)
+    case string
+    when /^([^_]+)(_.*)/
+	pre, post = $1, $2
+	plural(pre) + post
+    when /[szoj]$/
+	string.sub(/$/, "es")
+    when /[^aeou]y$/
+	string.sub(/y$/, "ies")
+    else
+	string.sub(/$/, "s")
+    end
+end
+
+udefs = {}
+ualiases = {}
+uplurals = {}
+
+while (line = gets)
+    next if /^#/ =~ line
+    case line.strip
+    when /(\S+)\s+(\S)\s+(\S.*)/
+	name, mode, definition = $1, $2, $3
+	udefs[name] = definition
+    when /(\S+)\s+(\S)/
+	name, mode = $1, $2
+    else
+	next
+    end
+    case mode
+    when /^S/
+	for prefix, power in SI_ABBREV
+	    next if prefix + name == 'kg'
+	    ualiases[prefix + name] = [power, name]
+	end
+    when /^P/
+	pname = plural(name)
+	ualiases[pname] = [0, name]
+	uplurals[pname] = name
+	for prefix, power in SI_PREFIX
+	    ualiases[prefix + name] = [power, name]
+	end
+    end
+end
+
+def dumphash(hname, h)
+    puts "#{hname} = {"
+    s = ""
+    for name in h.keys.sort
+	a = "  #{name.dump} => #{h[name].inspect},"
+	if s.length + a.length > 72
+	    puts s
+	    s = ""
+	end
+	s += a
+    end
+    if s.length > 0
+	puts s
+	s = ""
+    end
+    puts "}"
+end
+
+puts "class NameNode"
+dumphash('UDEFS', udefs)
+dumphash('UALIASES', ualiases)
+dumphash('UPLURALS', uplurals)
+puts "end"

data/src/mulnode.rb

@@ -0,0 +1,150 @@
+
+module Kakezan
+
+    def flatten2
+	r = MultiNode.new()
+	each do |child|
+	    case child
+	    when MultiNode
+		r.append child
+	    when MulNode
+		r.append child.flatten2
+	    when ContainerNode
+		r.append child.flatten2
+	    else
+		r.append child
+	    end 
+	end
+	r
+    end
+
+    def name
+	n = nil
+	for c in @children
+	    next if NumberNode === c
+	    na = c.name
+	    if n.nil?
+		n = na
+	    else
+		raise "multiple names found" if na != n
+	    end
+	end
+	n = "1" if n.nil?
+	n
+    end
+
+    def factor
+	f = 1
+	for c in @children
+	    f *= c.factor
+	end
+	f
+    end
+
+end
+
+class MulNode < ContainerNode
+
+    include BinaryNode
+    include Kakezan
+
+    def initialize(lhs, rhs)
+	@lhs, @rhs = lhs, rhs
+    end
+
+    def to_s
+	lhs = @lhs.to_s
+	rhs = @rhs.to_s
+	if (/\d$/ =~ lhs && /^\w/ =~ rhs) then
+	    "#{lhs} #{rhs}"
+	else
+	    "#{lhs}.#{rhs}"
+	end
+    end
+
+end
+
+class MultiNode < ContainerNode
+
+    include Kakezan
+
+    def initialize(*children)
+	@children = children
+	for c in @children
+	    raise "# MultiNode.new(#{children.inspect})" unless Node === c
+	end
+    end
+
+    def to_s
+	s = @children.join(';')
+	s.gsub(/\d;\w/) { |dsw| dsw.sub(/;/, ' ') }.gsub(/;/, '.')
+    end
+
+    def each
+	@children.each {|child| yield child }
+    end
+
+    attr_reader :children
+    
+    def append(other)
+	case other
+	when MultiNode
+	    @children += other.children
+	else
+	    @children.push other
+	end
+    end
+
+    def sort
+	table = {}
+	for child in self
+	    name = child.name
+	    if (table.include?(name)) then
+		table[name] = table[name].mul_eval(child)
+	    else
+		table[name] = child
+	    end
+	end
+	list = []
+	for name in table.keys.sort
+	    candi = table[name]
+	    if PowNode === candi and NumberNode === candi.lhs then
+		v = candi.value
+		list.push NumberNode.new(v) unless v == 1
+		next
+	    end
+	    next if candi.power.value == 0
+	    list.push candi
+	end
+        if list.length > 1
+	  list.delete(NumberNode::UNITY)
+	end
+	self.class.new(*list)
+    end
+
+    def collect_hash(stopper, op)
+	list = []
+	for child in self
+	    list.push(child.send(op, stopper))
+	end
+	self.class.new(*list).flatten2
+    end
+
+    def expand(stopper)
+	collect_hash(stopper, :expand)
+    end
+
+    def unalias(stopper)
+	collect_hash(stopper, :unalias)
+    end
+
+    def foldnumber(stopper)
+	collect_hash(stopper, :foldnumber)
+    end
+
+    def value
+	raise "this is dimensional units" if (@children.size > 1)
+	@children.first ? @children.first.value : NumberNode::UNITY.value
+    end
+
+end

data/src/namenode.rb

@@ -0,0 +1,63 @@
+class NameNode < TerminalNode
+
+    def initialize(string)
+	@a = string
+    end
+
+    def to_s;  @a;  end
+
+    alias :name :to_s
+
+    def power;  NumberNode::UNITY;  end
+
+    def mul_eval(another)
+	raise "internal error (#{name}, #{another.name})" if name != another.name
+	PowNode.new(self, self.power.add_eval(another.power))
+    end
+
+    def expand(stopper) 
+	raise "circular dependency for #{@a}" if stopper[@a]
+	return self if basic?
+	return CACHE[@a] if CACHE.include?(@a)
+	CACHE[@a] = expand2(stopper)
+    end
+
+    def expand2(stopper)
+	newstopper = stopper.dup
+	newstopper[@a] = true
+	if UDEFS.include?(@a) then
+	    Units.new(UDEFS[@a]).ptree.expand(newstopper)
+	else
+	    p, n = UALIASES[@a]
+	    u = Units.new(UDEFS[n] || n).ptree.expand(newstopper)
+	    MulNode.new(u, PowNode.new(NumberNode.new(10), NumberNode.new(p)))
+	end
+    end
+
+    def unalias(stopper)
+	raise "circular dependency for #{@a}" if stopper[@a]
+	return self unless UALIASES.include?(@a)
+	p, n = UALIASES[@a]
+	u = NameNode.new(n)
+	q = PowNode.new(NumberNode.new(10), NumberNode.new(p))
+	MulNode.new(u, q)
+    end
+
+    def foldnumber(stopper)
+	return self unless UPLURALS.include?(@a)
+	n = UPLURALS[@a]
+	NameNode.new(n)
+    end
+
+    def basic?
+	not (UDEFS.include?(@a) or UALIASES.include?(@a))
+    end
+
+    CACHE = {}
+
+    def factor
+	1
+    end
+
+end
+

data/src/node.rb

@@ -0,0 +1,210 @@
+=begin
+= class Node
+Node is a parent class for classes of parse tree node.
+This is not expected to be instanciated directly.
+=end
+
+class Node
+
+    def initialize(*args)
+	raise "#{self.class} is virtual."
+    end
+
+    def to_s(*args)
+	raise "#{self.class}#to_s is virtual."
+    end
+
+=begin
+--- pow other
+    simply constructs a PowNode object.
+    No reduction is performed.
+=end
+
+    def pow(other)
+	PowNode.new(self, other)
+    end
+
+=begin
+--- mul other
+    simply constructs a MulNode object.
+    No reduction is performed.
+=end
+
+    def mul(other)
+	other = NumberNode.new(other) if Numeric === other
+	MulNode.new(self, other)
+    end
+
+=begin
+--- divide other
+    simply constructs a MulNode object.
+    No reduction is performed.
+=end
+
+    def divide(other)
+	MulNode.new(self, PowNode.new(other, NumberNode.new(-1)))
+    end
+
+=begin
+--- shift other
+    simply constructs a ShiftNode object.
+    No reduction is performed.
+=end
+
+    def shift(other)
+	ShiftNode.new(self, other)
+    end
+
+=begin
+--- pow_eval other
+    similar to ((<pow other>)), but reduces PowNode[PowNode[...]] into
+    single PowNode[...], so overriden at PowNode class.
+=end
+
+    def pow_eval(other)
+	pow(other)
+    end
+
+=begin
+--- inspect
+=end
+
+    def inspect2;  "#{self.class}[#{to_s}]";  end
+
+    def inspect;  inspect2.gsub(/Units::/, '').gsub(/NumRu::/, '').gsub(/Node\[/, '[');  end
+
+=begin
+--- trim
+    in most subclasses, "trim" is redirected into "trim2".
+=end
+
+    def trim
+	trim2
+    end
+
+=begin
+--- flatten
+    in most subclasses, "flatten" is redirected into "flatten2".
+=end
+
+    def flatten
+	flatten2
+    end
+
+=begin
+--- sort
+=end
+
+    def sort
+	raise "#{self.class}#sort is virtual: call after flatten"
+    end
+
+=begin
+--- reduce1
+--- reduce2
+--- reduce3
+--- reduce4
+--- reduce5
+=end
+
+    def reduce1
+	self
+    end
+
+    def reduce2
+	trim
+    end
+
+    def reduce3
+	trim.flatten
+    end
+
+    def reduce4
+	# unalias(Hash.new).trim.flatten.sort
+	foldnumber(nil).trim.flatten.sort
+    end
+
+    def reduce5
+	expand(Hash.new).trim.flatten.sort
+    end
+
+=begin
+--- ref
+    to be overriden at ShiftNode
+--- deref
+    to be overriden at ShiftNode
+=end
+
+    def ref
+	NumberNode::ZERO
+    end
+
+    def deref
+	self
+    end
+
+end
+
+class ErrorNode < Node
+
+    def initialize(string)
+	@a = string
+    end
+
+    def to_s;  @a;  end
+
+end
+
+class ContainerNode < Node
+
+    def trim2
+	x = []
+	for child in self
+	    x.push child.trim2
+	end
+	self.class.new(*x)
+    end
+
+    def inspect2
+	a = []
+	for child in self
+	    a.push child.inspect2
+	end
+      	"#{self.class}[#{a.join(', ')}]"
+    end
+
+end
+
+module BinaryNode
+
+    def each
+	yield @lhs
+	yield @rhs
+    end
+
+    def expand(stopper)
+	self.class.new(@lhs.expand(stopper), @rhs.expand(stopper))
+    end
+
+    def unalias(stopper)
+	self.class.new(@lhs.unalias(stopper), @rhs.unalias(stopper))
+    end
+
+    def foldnumber(stopper)
+	self.class.new(@lhs.foldnumber(stopper), @rhs.foldnumber(stopper))
+    end
+
+end
+
+class TerminalNode < Node
+
+    def trim2;  self;  end
+    def flatten2;  self;  end
+
+    def expand(stopper);  self;  end
+    alias :unalias :expand
+    alias :foldnumber :expand
+
+    def sort;  self;  end
+
+end