de.oddb 2.0.0

data/lib/oddb/util/money.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+# Util::Money -- de.oddb.org -- 14.11.2006 -- hwyss@ywesee.com
+
+module ODDB
+  module Util
+class Money
+  attr_reader :credits
+  attr_accessor :type, :country
+  include Comparable
+  class << self
+    def five
+      @five ||= self.new(5)
+    end
+    def ten
+      @ten ||= self.new(10)
+    end
+  end
+  def initialize(amount, type=nil, country=nil)
+    self.amount = amount
+    self.type = type
+    self.country = country
+  end
+  def amount=(amount)
+    @amount = amount.to_f
+    @credits = (@amount * 100).round
+  end
+  def country=(country)
+    @country = country.to_s.upcase
+  end
+  def is_for?(type, country)
+    @type == type.to_s.downcase && @country == country.to_s.upcase
+  end
+  def to_f
+    @amount || (@credits.to_f / 100)
+  end
+  def to_s
+    sprintf("%1.2f", to_f)
+  end
+  def type=(type)
+    @type = type.to_s.downcase
+  end
+  def +(other)
+    Money.new((@amount || to_f) + other.to_f)
+  end
+  def -(other)
+    Money.new((@amount || to_f) - other.to_f)
+  end
+  def *(other)
+    Money.new((@amount || to_f) * other.to_f)
+  end
+  def /(other)
+    Money.new((@amount || to_f) / other.to_f)
+  end
+  def <=>(other)
+    case other
+    when Money
+      @credits <=> other.credits
+    else
+      to_f <=> other.to_f
+    end
+  end
+end
+  end
+end

data/lib/oddb/util/multilingual.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+# Util::Multilingual -- de.oddb.org -- 04.09.2006 -- hwyss@ywesee.com
+
+module ODDB
+  module Util
+    module M10lMethods
+      include Comparable
+      attr_reader :canonical
+      attr_reader :synonyms
+      def initialize(canonical={})
+        @canonical = canonical
+      end
+      def all
+        @canonical.values
+      end
+      def empty?
+        @canonical.empty?
+      end
+      def method_missing(meth, *args, &block)
+        case meth.to_s
+        when /^[a-z]{2}$/
+          @canonical[meth]
+        when /^([a-z]{2})=$/
+          @canonical.store($~[1].to_sym, args.first)
+        else
+          super(meth, *args, &block)
+        end
+      end
+      def to_s
+        @canonical.values.sort.first.to_s
+      end
+      def ==(other)
+        case other
+        when String
+          @canonical.values.any? { |val| val == other } \
+            || @synonyms.any? { |val| val == other }
+        when M10lDocument
+          @canonical == other.canonical && @synonyms == other.synonyms
+        when M10lMethods
+          @canonical == other.canonical
+        else
+          false
+        end
+      end
+      def <=>(other)
+        all.sort <=> other.all.sort
+      end
+    end
+    class Multilingual
+      include M10lMethods
+      def initialize(canonical={})
+        super
+        @synonyms = []
+      end
+      def add_synonym(synonym)
+        @synonyms.push(synonym).uniq! && synonym
+      end
+      def all
+        terms = super.concat(@synonyms)
+        terms.concat(terms.collect do |term| term.gsub(/[^\w]/, '') end)
+        terms.uniq
+      end
+      def merge(other)
+        @synonyms.concat(other.all).uniq!
+      end
+    end
+  end
+end
+
+require 'oddb/util/m10l_document'

data/lib/oddb/util/quanty.rb

@@ -0,0 +1,3 @@
+require 'oddb/util/quanty/parse'
+require 'oddb/util/quanty/fact'
+require 'oddb/util/quanty/main'

data/lib/oddb/util/quanty/fact.rb

@@ -0,0 +1,242 @@
+#
+# quanty/fact.rb
+#
+#   Copyright (c) 2001 Masahiro Tanaka <masa@ir.isas.ac.jp>
+#
+#   This program is free software.
+#   You can distribute/modify this program under the terms of
+#   the GNU General Public License version 2 or later.
+
+class Quanty
+
+  class Fact < Hash
+    Self = self
+    Parser = Parse.new
+
+    attr_reader :factor
+
+    # SI units:	Fact.new("m",true) => {"m"=>1}
+    # Derivative units:	Fact.new("km") => 1000*{"m"=>1}
+    def initialize(key=nil,si=false)
+      self.default = 0.0
+      @factor = 1.0
+      case key
+      when Numeric
+	@factor = key
+      when String
+	if si
+	  store(key, 1.0)
+	else
+	  decomp(key)
+	end
+      when Self
+	replace(key)
+      end
+    end
+
+    def []=(key,val)
+      if val == 0
+	delete(key)
+      else
+	super(key,val)
+      end
+    end
+
+    def replace(other)
+      @factor = other.factor
+      super(other)
+    end
+
+    def dup
+      Fact.new(self)
+    end
+
+    attr_writer :factor
+    protected :factor=
+
+    def find_prefix(a,n)
+      Prefix.each{ |key,factor|
+	if /^#{key}-?/ =~ a && (unit = List[b=$']) && b.size>n
+	  #p [a,b,factor]
+	  return Fact.new(b).fac!(factor)
+	end
+      }
+      nil
+    end
+
+    def decomp(a)
+      if /^([µA-Za-z_]+([A-Za-z_0-9-]+[A-Za-z_])?)$|^[$%'"]'?$/o =~ a
+      #if /^[A-Za-z_0-9$%-]+$/o =~ a
+	unit = List[a] || find_prefix(a,0) ||
+	  if a.size>3 && /chs$/o !~ a && /(.*[a-rt-y])s$/o =~ a
+	    b = $1
+	    List[b] || find_prefix(b,2) ||
+	      if a.size>4 && /(.*s|.*z|.*ch)es$/o =~ a
+		b = $1
+		List[b] || find_prefix(b,2)
+	      end
+	  end
+      else
+	unit = Parser.parse(a)
+      end
+      unless unit
+	raise "`%s': unknown unit"%a 
+      end
+      @factor *= factor if factor
+      mul!(unit)
+    end
+
+    def mul!(other)
+      raise unless other.kind_of?(Fact)
+      other.each{ |key,val| self[key] += val }
+      delete_if{ |key,val| val == 0 }
+      @factor *= other.factor
+      self
+    end
+
+    def * (other)
+      dup.mul!(other)
+    end
+
+    def div!(other)
+      raise unless other.kind_of?(Fact)
+      other.each{ |key,val| self[key] -= val }
+      delete_if{ |key,val| val == 0 }
+      @factor /= other.factor
+      self
+    end
+
+    def / (other)
+      dup.div!(other)
+    end
+
+    def pow!(other)
+      raise unless other.kind_of?(Numeric)
+      each{ |key,val| self[key] = other*val }
+      @factor **= other
+      self
+    end
+
+    def ** (other)
+      dup.pow!(other)
+    end
+  
+    def fac!(other)
+      raise unless other.kind_of?(Numeric)
+      @factor *= other
+      self
+    end
+
+    def inspect
+      @factor.to_s+"*"+super
+    end
+
+    def unit
+      a = []
+      SI.each do |k|
+        v = self[k]
+        if v && v!=0
+          if v != 1
+            v  = v.to_i if v%1 == 0
+            k += v.to_s
+          end
+          a.push(k)
+	end
+      end
+      a.join(" ")
+    end
+
+    def to_s
+      @factor.to_s+" "+unit()
+    end
+
+    def to_quanty
+      f = dup
+      f.factor = 1.0
+      Quanty(@factor, unit(), f)
+    end
+
+    def null?
+      each_value{ |val| return false if val != 0 }
+      true
+    end
+
+    alias __equal__ :==
+
+    def ==(other)
+      if other.kind_of?(Numeric)
+	null? && @factor==other
+      else
+	__equal__(other) && @factor==other.factor
+      end
+    end
+
+    # check only dimension
+    def ===(other)
+      if other.kind_of?(Numeric)
+	null?
+      else
+	__equal__(other)
+      end
+    end
+
+    def to_f
+      raise inspect + ": not null unit" unless null?
+      @factor
+    end
+
+    class << self
+      def mkdump(filename)
+	Prefix.clear
+	List.clear
+        SI.clear
+	#s = open("units.succ","w")
+	#f = open("units.fail","w")
+	open("units.dat","r").readlines.each do |str|
+	  if /^([µA-Za-z_0-9%$"'-]+)\s+([^#]+)/ =~ str #"
+	    name,repr = $1,$2.strip
+	    # conversion due to the different rule from GNU units:
+	    #   A / B C => A / (B C)
+	    if /\// =~ repr #/
+	      pre,suf = $`,$'.strip #`
+	      if /\s/ =~ suf
+		repr = pre + ' / (' + suf + ')'
+	      end
+	    end
+	    if repr=="!" # SI
+	      List[name] = Fact.new(name,true).freeze
+              SI << name
+	    elsif /-$/  =~ name
+	      Prefix[name[0..-2]] = Prefix[repr] || (List[repr] || repr).to_f
+	    else
+	      #p [name,repr]
+	      List[name] = Fact.new(repr).freeze
+	    end
+	    #s.print str
+	    #rescue
+	    #f.print str
+	  end
+	end
+	#Prefix.each{|key,val| p [key,val]}
+	#List.each{|key,val| p [key,val]}
+	Marshal.dump( [Prefix, List, SI], open(filename,"w") )
+      end
+    end
+
+  end # class Fact
+
+
+  ### Loading unit data ###
+  fn = nil
+  $:.each{ |dir|
+    fn = File.join(dir, "oddb/util/quanty/units.dump")
+    break if FileTest.exist?( fn )
+    fn = nil
+  }
+  if fn
+    Prefix, List, SI = Marshal.load(open(fn,"r"))
+  else
+    Prefix, List, SI = {},{},[]
+  end
+
+end # class Quanty

data/lib/oddb/util/quanty/main.rb

@@ -0,0 +1,164 @@
+#
+# quanty/main.rb
+#
+#   Copyright (c) 2001 Masahiro Tanaka <masa@ir.isas.ac.jp>
+#
+#   This program is free software.
+#   You can distribute/modify this program under the terms of
+#   the GNU General Public License version 2 or later.
+
+# require 'fact.rb'
+
+def Quanty(*a)
+  Quanty.new(*a)
+end
+
+class Quanty #< Numeric
+  Self = self
+  RadianUnit = Quanty::Fact.new('radian')
+
+  def initialize(*a)
+    case a.size
+    when 1
+      if String === a[0]
+	@val,@unit,@fact = 1.0, a[0], nil
+      else
+	@val,@unit,@fact = a[0], '', nil
+      end
+    when 2..3
+        @val,@unit,@fact = a
+    else
+      raise ArgumentError, 'wrong # of arguments'
+    end
+    unless Fact === @fact
+      @fact = Fact.new(@unit)
+    end
+  end
+
+  attr_reader :val
+  attr_reader :unit
+  attr_reader :fact
+  alias value val
+
+  def adjust(other)
+    if other.kind_of?(Self)
+      unless @fact === other.fact
+	raise "not same unit: %s != %s" % [@unit,other.unit]
+      end
+      other.val * ( other.fact.factor / @fact.factor )
+    else
+      raise @unit + ": not null unit" unless @fact.null?
+      other / @fact.factor
+    end
+  end
+
+  def want(unit)
+    obj = Self.new(unit)
+    val = obj.adjust(self)
+    Self.new( val, unit, obj.fact )
+  end
+
+  def + (other)
+    val = @val + adjust(other)
+    if @unit==''
+      val
+    else
+      Self.new( val, @unit, @fact )      
+    end
+  end
+
+  def - (other)
+    val = @val - adjust(other)
+    if @unit==''
+      val
+    else
+      Self.new( val, @unit, @fact )      
+    end
+  end
+
+  def +@ ; Self.new(  @val, @unit, @fact ) end
+  def -@ ; Self.new( -@val, @unit, @fact ) end
+
+  def <=> (other); @val <=> adjust(other) end
+  def  == (other); @val  == adjust(other) end
+  def  >= (other); @val  >= adjust(other) end
+  def  <= (other); @val  <= adjust(other) end
+  def  <  (other); @val  <  adjust(other) end
+  def  >  (other); @val  >  adjust(other) end
+
+  def **(n)
+    if /^[A-Za-z_]+&/o =~ @unit
+      unit = @unit+'^'+n.to_s
+    else
+      unit = '('+@unit+')^'+n.to_s+''
+    end
+    Self.new( @val**n, unit, @fact**n )
+  end
+
+  def * (other)
+    if other.kind_of?(Self)
+      unit = other.unit
+      unless @unit.empty?
+	if unit.empty?
+	  unit = @unit
+	else
+	  if /\A[A-Za-z_]/o =~ unit
+	    unit = @unit+' '+unit
+	  else
+	    unit = @unit+' ('+unit+')' 
+	  end
+	end
+      end
+      Self.new( @val*other.val, unit, @fact*other.fact )
+    else
+      Self.new( @val*other, @unit, @fact )
+    end
+  end
+
+  def / (other)
+    if other.kind_of?(Self)
+      unit = other.unit
+      if unit.empty?
+	unit = @unit
+      else
+	if /\A[A-Za-z_-]+((\^|\*\*)?[0-9.]+)?$/o =~ unit
+	  unit = '/ '+unit
+	else
+	  unit = '/ ('+unit+')' 
+	end
+	unit = @unit+' '+unit unless @unit.empty?
+      end
+      Self.new( @val/other.val, unit, @fact/other.fact )
+    else
+      Self.new( @val/other, @unit, @fact )
+    end
+  end
+
+  def coerce(other)
+    [ Self.new(other), self ]
+  end
+
+  def to_si
+    @fact.to_quanty * @val
+  end
+  alias to_SI :to_si
+
+  def to_f
+    if @fact.null?
+      @val * @fact.factor
+    elsif @fact === RadianUnit
+      want('radian').value
+    else
+      raise 'cannot convert into non-dimensional Float'
+    end
+  end
+
+  def to_s
+    @val.to_s + "[" + @unit + "]"
+  end
+
+  def inspect
+    "Quanty(" + @val.to_s + ",'" + @unit + "')"
+  end
+
+end