measure 0.1.0

data/COPYING.LIB

@@ -0,0 +1,166 @@
+		   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions. 
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version. 
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+

data/ChangeLog

@@ -0,0 +1,10 @@
+2008-08-11  Kenta Murata  <muraken@gmail.com>
+
+	* Rakefile: replace all Spec::VERSION module to Measure::VERSION.
+
+	* lib/measure.rb (Measure.dim): add Measure.dim as alias to
+	Measure.dimension.
+
+2008-08-11  Kenta Murata  <mrkn@mrkn.jp>
+
+	* version 0.1.0

data/README

@@ -0,0 +1,19 @@
+= Measure library
+
+Measure is a library to handle measurment numbers.
+
+== Installation
+
+The simplest approach is to install the gem (as root in some environments):
+
+  gem install -r measure
+
+== Building the Measure gem
+
+If you prefer to build the gem locally:
+
+  git clone git://github.com/mrkn/ruby-measure.git
+  cd ruby-measure
+  rake gem
+  gem install pkg/measure-0.x.x.gem # as root
+

data/Rakefile

@@ -0,0 +1,150 @@
+$LOAD_PATH.unshift 'lib'
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'rake/clean'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'spec/rake/spectask'
+require 'measure/version'
+dir = File.dirname(__FILE__)
+
+PKG_NAME = 'measure'
+PKG_VERSION = Measure::VERSION::STRING
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+PKG_FILES = FileList[
+  '[A-Z]*',
+  'lib/**/*.rb',
+  'spec/**/*',
+]
+
+task :default => [ :spec ]
+
+desc 'Run all specs'
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/*_spec.rb']
+  t.spec_opts = ['--options', 'spec/spec.opts']
+end
+
+desc 'Run all specs and store html output in doc/output/report.html'
+Spec::Rake::SpecTask.new('spec_html') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = [ '--format html:../../../../doc/output/report.html',
+                  '--format progress',
+                  '--backtrace' ]
+end
+
+desc 'Generate RDoc'
+rd = Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = File.join('..', 'doc', 'output', 'rdoc')
+  rdoc.options << '--title' << 'Measure' << '--line-numbers'
+  rdoc.options << '--inline-source' << '--main' << 'README'
+  rdoc.rdoc_files.include('README', 'CHANGES', 'COPYING.LIB', 'lib/**/*.rb')
+end
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.summary = Measure::VERSION::SUMMARY
+  s.description = <<-EOF
+    Measure is a library to handle measurement numbers.
+  EOF
+
+  s.files = PKG_FILES.to_a
+  s.require_path = 'lib'
+
+  s.has_rdoc = true
+  s.rdoc_options = rd.options
+  s.extra_rdoc_files = rd.rdoc_files.reject {|fn| fn =~ /\.rb$/ }.to_a
+
+  s.author = 'Kenta Murata'
+  s.email = 'measure-devel@rubyforge.org'
+  s.homepage = 'http://measure.rubyforge.org'
+  s.platform = Gem::Platform::RUBY
+  s.rubyforge_project = 'measure'
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+def egrep(pattern)
+  Dir['**/*.rb'].each do |fn|
+    count = 0
+    open(fn) do |f|
+      while l = f.gets
+        count +=1
+        puts "#{fn}:#{count}:#{line}" if line =~ pattern
+      end
+    end
+  end
+end
+
+desc 'Look for TODO and FIXME tags in the code'
+task :todo do
+  egrep /(FIXME|TODO)/
+end
+
+task :verify_user do
+  raise "RUBYFORGE_USER environment variable not set!" unless ENV['RUBYFORGE_USER']
+end
+
+desc 'Publish gem+tgz+zip on RubyForge.  You must make sure lib/version.rb is aligned with the ChangeLog file'
+task :publish_packages => [ :verify_user, :package, :pkg ] do
+  release_files = FileList[
+    File.join('pkg', "#{PKG_FILE_NAME}.gem"),
+    File.join('pkg', "#{PKG_FILE_NAME}.zip"),
+    File.join('pkg', "#{PKG_FILE_NAME}.tgz"),
+    'CHANGES'
+  ]
+  unless defined? Measure::VERSION::RELEASE_CANDIDATE and Measure::VERSION::RELEASE_CANDIDATE
+    require 'meta_project'
+    require 'rake/contrib/xforge'
+
+    project = MetaProject::Project::XForge::RubyForge.new(PKG_NAME)
+    Rake::XForge::Release.new(project) do |xf|
+      # Never hardcode user name and password in the Rakefile!
+      xf.user_name = ENV['RUBYFORGE_USER']
+      xf.files = release_files.to_a
+      xf.release_name = "Measure #{PKG_NAME}"
+    end
+  else
+    puts 'SINCE THIS IS A PRERELEASE, FILES ARE UPLOADED WITH SSH, NOT TO THE RUBYFORGE FILE SECTION'
+    puts 'YOU MUST TYPE THE PASSWORD #{release_files.length} TIMES...'
+
+    host = 'measure-website@rubyforge.org'
+    remote_dir = '/var/www/gforge-projects/#{PKG_NAME}'
+
+    publisher = Rake::SshFilePublisher.new(
+      host,
+      remote_dir,
+      File.dirname(__FILE__),
+      *release_files)
+    publisher.upload
+
+    puts 'UPLOADED THE FOLLOWING FILES:'
+    release_files.each do |fn|
+      name = File.basename(fn)
+      puts "* http://measure.rubyforge.org/#{name}"
+    end
+
+    puts "They are not linked to anywhere, so don't forget to tell people!"
+  end
+end
+
+desc 'Publish news on RubyForge'
+task :publish_news => [ :verify_user ] do
+  unless Measure::VERSION::RELEASE_CANDIDATE
+    require 'meta_project'
+    require 'rake/contrib/xforge'
+
+    project = MetaProject::Project::XForge::RubyForge.new(PKG_NAME)
+    Rake::XForge::NewsPublisher.new(project) do |news|
+      # Never hardcode user name and password in the Rakefile!
+      news.user_name = ENV['RUBYFORGE_USER']
+    end
+  else
+    puts '** Not publishing news to RubyForge because this is a prerelease'
+  end
+end

data/TODO

@@ -0,0 +1,13 @@
+= Current version
+
+- To write a spec for Measure#convert method with a unit same as receiver's one.
+- To write specs for Measure#to_{a,i,f,s}.
+- To write a spec for Measure#coerce.
+- To write specs for binary operation.
+- To write specs for comparison methods.
+- To write RDoc documents.
+
+= Future works
+
+- To support composite dimension.
+- To define well-known physical constants.

data/lib/measure.rb

@@ -0,0 +1,348 @@
+# = Measure
+#
+# Author::    Kenta Murata
+# Copyright:: Copyright (C) 2008 Kenta Murata
+# License::   LGPL version 3.0
+
+class Measure
+  class UnitRedefinitionError < StandardError; end
+  class InvalidUnitError < StandardError; end
+  class CompatibilityError < StandardError; end
+
+  @@units = []
+  @@dimension_map = {}
+  @@conversion_map = {}
+  @@alias_map = {}
+
+  class << self
+    def conversion_map
+      @@conversion_map
+    end
+
+    def has_unit?(unit)
+      unit = resolve_alias unit
+      return @@units.include? unit
+    end
+    alias defined? has_unit?
+
+    def compatible?(u1, u2)
+      u1 = resolve_alias u1
+      raise InvalidUnitError, "unknown unit: #{u1}" unless self.defined? u1
+      u2 = resolve_alias u2
+      raise InvalidUnitError, "unknown unit: #{u2}" unless self.defined? u2
+      return true if u1 == u2
+      return true if @@conversion_map.has_key? u1 and @@conversion_map[u1].has_key? u2
+      return true if @@conversion_map.has_key? u2 and @@conversion_map[u2].has_key? u1
+      return false
+    end
+
+    def clear_units
+      @@units.clear
+      @@dimension_map.clear
+      @@conversion_map.clear
+      @@alias_map.clear
+      return nil
+    end
+
+    def units(dimension=nil)
+      return @@units.dup if dimension.nil?
+      @@dimension_map.select {|k, v| v == dimension }.collect{|k, v| k }
+    end
+
+    def num_units
+      return @@units.length
+    end
+
+    def define_unit(unit, dimension=1)
+      if @@units.include?(unit)
+        if self.dimension(unit) != dimension
+          raise UnitRedefinitionError, "unit [#{unit}] is already defined"
+        end
+      else
+        @@units << unit
+        @@dimension_map[unit] = dimension
+      end
+    end
+
+    def define_alias(unit, base)
+      if self.defined?(unit)
+        raise UnitRedefinitionError, "unit [#{unit}] is already defined"
+      end
+      raise InvalidUnitError, "unknown unit: #{base}" unless self.defined? base
+      @@alias_map[unit] = base
+    end
+
+    def define_conversion(base, conversion)
+      base = resolve_alias base
+      raise InvalidUnitError, "unknown unit: #{base}" unless self.defined? base
+      @@conversion_map[base] ||= {}
+      conversion.each {|unit, factor|
+        unit = resolve_alias unit
+        raise InvalidUnitError, "unknown unit: #{unit}" unless self.defined? unit
+        @@conversion_map[base][unit] = factor
+      }
+      return nil
+    end
+
+    def dimension(unit)
+      return @@dimension_map[resolve_alias unit]
+    end
+    alias dim dimension
+
+    def resolve_alias(unit)
+      while @@alias_map.has_key? unit
+        unit = @@alias_map[unit]
+      end
+      return unit
+    end
+
+    def find_multi_hop_conversion(u1, u2)
+      visited = []
+      queue = [[u1]]
+      while route = queue.shift
+        next if visited.include? route.last
+        visited.push route.last
+        return route if route.last == u2
+        neighbors(route.last).each{|u|
+          queue.push(route + [u]) unless visited.include? u }
+      end
+      return nil
+    end
+
+#     def encode_dimension(dim)
+#       case dim
+#       when Symbol
+#         return dim.to_s
+#       else
+#         units = dim.sort {|a, b| a[1] <=> b[1] }.reverse
+#         nums = []
+#         units.select {|u, e| e > 0 }.each {|u, e| nums << "#{u}^#{e}" }
+#         dens = []
+#         units.select {|u, e| e < 0 }.each {|u, e| dens << "#{u}^#{-e}" }
+#         return nums.join(' ') + ' / ' + dens.join(' ')
+#       end
+#     end
+
+    private
+
+    def neighbors(unit)
+      res = []
+      if @@conversion_map.has_key?(unit)
+        res += @@conversion_map[unit].keys
+      end
+      @@conversion_map.each {|k, v| res << k if v.has_key? unit }
+      return res
+    end
+  end # class << self
+
+  def initialize(value, unit)
+    @value, @unit = value, unit
+    return nil
+  end
+
+  attr_reader :value, :unit
+
+  def <(other)
+    case other
+    when Measure
+      if self.unit == other.unit
+        return self.value < other.value
+      else
+        return self < other.convert(self.value)
+      end
+    when Numeric
+      return self.value < other
+    else
+      raise ArgumentError, 'unable to compare with #{other.inspect}'
+    end
+  end
+
+  def >(other)
+    case other
+    when Measure
+      if self.unit == other.unit
+        return self.value > other.value
+      else
+        return self > other.convert(self.value)
+      end
+    when Numeric
+      return self.value > other
+    else
+      raise ArgumentError, 'unable to compare with #{other.inspect}'
+    end
+  end
+
+  def ==(other)
+    return self.value == other.value if self.unit == other.unit
+    if Measure.compatible? self.unit, other.unit
+      return self == other.convert(self.unit)
+    elsif Measure.compatible? other.unit, self.unit
+      return self.convert(other.unit) == other
+    else
+      return false
+    end
+  end
+
+  def +(other)
+    case other
+    when Measure
+      if self.unit == other.unit
+        return Measure(self.value + other.value, self.unit)
+      elsif Measure.dim(self.unit) == Measure.dim(other.unit)
+        return Measure(self.value + other.convert(self.unit).value, self.unit)
+      else
+        raise TypeError, "incompatible dimensions: " +
+          "#{Measure.dim(self.unit)} and #{Measure.dim(other.unit)}"
+      end
+    when Numeric
+      return Measure(self.value + other, self.unit)
+    else
+      check_coercable other
+      a, b = other.coerce self
+      return a + b
+    end
+  end
+
+  def -(other)
+    case other
+    when Measure
+      if self.unit == other.unit
+        return Measure(self.value - other.value, self.unit)
+      elsif Measure.dim(self.unit) == Measure.dim(other.unit)
+        return Measure(self.value - other.convert(self.unit).value, self.unit)
+      else
+        raise TypeError, "incompatible dimensions: " +
+          "#{Measure.dim(self.unit)} and #{Measure.dim(other.unit)}"
+      end
+    when Numeric
+      return Measure(self.value - other, self.unit)
+    else
+      check_coerecable other
+      a, b = other.coerce self
+      return a - b
+    end
+  end
+
+  def *(other)
+    case other
+    when Measure
+      # TODO: dimension
+      return other * self.value if self.unit == 1
+      raise NotImplementedError, "this feature has not implemented yet"
+#       if self.unit == other.unit
+#         return Measure(self.value * other.value, self.unit)
+#       elsif Measure.dim(self.unit) == Measure.dim(other.unit)
+#         return Measure(self.value - other.convert(self.unit).value, self.unit)
+#       else
+#         return Measure(self.value * other.convert(self.unit).value, self.unit)
+#       end
+    when Numeric
+      return Measure(self.value * other, self.unit)
+    else
+      check_coercable other
+      a, b = other.coerce self
+      return a * b
+    end
+  end
+
+  def /(other)
+    case other
+    when Measure
+      # TODO: dimension
+      raise NotImplementedError, "this feature has not implemented yet"
+#       if self.unit == other.unit
+#         return Measure(self.value / other.value, self.unit)
+#       else
+#         return Measure(self.value / other.convert(self.unit).value, self.unit)
+#       end
+    when Numeric
+      return Measure(self.value / other, self.unit)
+    else
+      check_coercable other
+      a, b = other.coerce self
+      return a / b
+    end
+  end
+
+  def coerce(other)
+    case other
+    when Numeric
+      return [Measure(other, 1), self]
+    else
+      raise TypeError, "#{other.class} can't convert into #{self.class}"
+    end
+  end
+
+  def abs
+    return Measure(self.value.abs, self.unit)
+  end
+
+  def to_s
+    return "#{self.value} [#{self.unit}]"
+  end
+
+  def to_i
+    return self.value.to_i
+  end
+
+  def to_f
+    return self.value.to_f
+  end
+
+  def to_a
+    return [self.value, self.unit]
+  end
+
+  def convert(unit)
+    return self if unit == self.unit
+    to_unit = Measure.resolve_alias unit
+    raise InvalidUnitError, "unknown unit: #{unit}" unless Measure.defined? unit
+    from_unit = Measure.resolve_alias self.unit
+    if Measure.compatible? from_unit, to_unit
+      # direct conversion
+      if @@conversion_map.has_key? from_unit and @@conversion_map[from_unit].has_key? to_unit
+        value = self.value * @@conversion_map[from_unit][to_unit]
+      else
+        value = self.value / @@conversion_map[to_unit][from_unit].to_f
+      end
+    elsif route = Measure.find_multi_hop_conversion(from_unit, to_unit)
+      u1 = route.shift
+      value = self.value
+      while u2 = route.shift
+        if @@conversion_map.has_key? u1 and @@conversion_map[u1].has_key? u2
+          value *= @@conversion_map[u1][u2]
+        else
+          value /= @@conversion_map[u2][u1].to_f
+        end
+        u1 = u2
+      end
+    else
+      raise CompatibilityError, "units not compatible: #{self.unit} and #{unit}"
+    end
+    # Second 
+    return Measure.new(value, unit)
+  end
+
+  alias saved_method_missing method_missing
+  private_methods :saved_method_missing
+
+  def method_missing(name, *args)
+    if /^as_(\w+)/.match(name.to_s)
+      unit = $1.to_sym
+      return convert(unit)
+    end
+    return saved_method_missing(name, *args)
+  end
+
+  private
+
+  def check_coercable(other)
+    unless other.respond_to? :coerce
+      raise TypeError, "#{other.class} can't be coerced into #{self.class}"
+    end
+  end
+end
+
+def Measure(value, unit=1)
+  return Measure.new(value, unit)
+end