phys-units 0.9.0

data/lib/phys/units/unit_class.rb

@@ -0,0 +1,185 @@
+# -*- coding: utf-8 -*-
+#
+# phys/units/unit_class.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
+
+    class UnitError < StandardError; end
+    class UnitParseError < UnitError; end
+    class UnitConversionError < UnitError; end
+    class UnitOperationError < UnitError; end
+
+    class << self
+
+      def debug
+        false
+      end
+
+      def define(name,expr,v=nil)
+        if !(String===name)
+          raise TypeError,"unit name should be string : #{name.inspect}"
+        end
+        if /^(.*)-$/ =~ name
+          name = $1
+          if PREFIX[name]
+            warn "prefix definition is overwritten: #{name}" if debug
+          end
+          PREFIX[name] = self.new(name,expr)
+        else
+          if LIST[name]
+            warn "unit definition is overwritten: #{name}" if debug
+          end
+          if expr.kind_of?(String) && /^!/ =~ expr
+            dimless = (expr == "!dimensionless")
+            LIST[name] = BaseUnit.new(name,dimless,v)
+          else
+            LIST[name] = self.new(name,expr,v)
+          end
+        end
+      end
+
+      def cast(x)
+        if x.kind_of?(Unit)
+          x
+        else
+          Unit.new(x) 
+        end
+      end
+
+      def word(x)
+        find_unit(x) || define(x)
+      end
+
+      def parse(x)
+        find_unit(x) || Parse.new.parse(x)
+      end
+
+      def find_unit(x)
+        if Numeric===x
+          Unit.new(x)
+        elsif x=='' || x.nil?
+          Unit.new(1)
+        else
+          x = x.to_s
+          LIST[x] || PREFIX[x] || find_prefix(x) || unit_stem(x)
+        end
+      end
+
+      alias [] find_unit
+
+      def unit_stem(x)
+        ( /(.{3,}(?:s|z|ch))es$/ =~ x && LIST[$1] ) ||
+          ( /(.{3,})s$/ =~ x && LIST[$1] )
+      end
+
+      def find_prefix(x)
+        Unit.prefix_regex =~ x
+        pre,post = $1,$2
+        if pre and pre and stem = (LIST[post] || unit_stem(post))
+          PREFIX[pre] * stem
+        end
+      end
+
+#--
+
+      def unit_chars
+        '\\s*+\\/0-9<=>()\\[\\]^{|}~\\\\'
+      end
+
+      def control_units_dat(var,skip,line)
+        case line
+        when /!\s*end(\w+)/
+          skip.delete($1)
+        when /!\s*set\s+(\w+)\s+(\w+)/
+          if skip.empty?
+            var[$1] ||= $2
+          end
+        when /!var\s+(\w+)\s+(\w+)/
+          if var[$1] != $2
+            skip << 'var'
+          end
+        when /!\s*(\w+)(?:\s+(\w+))?/
+          code = $1
+          param = $2
+          #puts " code=#{code} param=#{param}"
+          if (var[code]) ? (param && var[code]!=param) : !param
+            skip << code
+          end
+        end
+        #puts line
+        #puts "skip=#{skip.inspect} var=#{var.inspect}"
+      end
+
+      def import_units(data=nil,locale=nil)
+        str = ""
+        locale ||= ENV['LC_ALL'] || ENV['LANG']
+        if /^(\w+)\./ =~ locale
+          locale = $1
+        end
+        var = {'locale'=>locale,'utf8'=>true}
+        case ENV['UNITS_ENGLISH']
+        when /US|GB/
+          var['UNITS_ENGLISH'] = ENV['UNITS_ENGLISH']
+        end
+        skip = []
+
+        data.each_line do |line|
+          line.chomp!
+          if /^!/ =~ line
+            control_units_dat(var,skip,line)
+            next
+          end
+          next if !skip.empty?
+
+          if /([^#]*)\s*#?/ =~ line
+            line = $1
+          end
+
+          if /(.*)\\$/ =~ line
+            str.concat $1+" "
+            next
+          else
+            str.concat line
+          end
+
+          if /^([^\s()\[\]{}!*|\/^#]+)\s+([^#]+)/ =~ str
+            name,repr = $1,$2.strip
+            Unit.define(name,repr)
+          elsif !str.strip.empty?
+            puts "unrecognized definition: '#{str}'" if debug
+          end
+          str = ""
+        end
+
+        x = PREFIX.keys.sort{|a,b|
+          s = b.size-a.size
+          (s==0) ? (a<=>b) : s
+        }.join("|")
+        @@prefix_regex = /^(#{x})(.+)$/
+
+        if debug
+          LIST.dup.each do |k,v|
+            if v.kind_of? Unit
+              begin
+                v.use_dimension
+              rescue
+                puts "!! no definition: #{v.inspect} !!"
+              end
+            end
+            p [k,v]
+          end
+        end
+        puts "#{LIST.size} units, #{PREFIX.size} prefixes" if debug
+      end
+
+    end
+  end
+end

data/lib/phys/units/utils.rb

@@ -0,0 +1,91 @@
+#
+# 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
+    module Utils
+      module_function
+
+      def as_numeric(x)
+        case x
+        when Rational
+          if x.denominator==1
+            x.to_i
+          else
+            x
+          end
+        when Numeric
+          x
+        when Unit
+          x.to_num
+        else
+          raise "Not Numric or #{self.class}: #{x.inspect}"
+        end
+      end
+
+      def check_decimal(x)
+        while x%5==0
+          x/=5
+        end
+        while x%2==0
+          x/=2
+        end
+        x==1
+      end
+
+      def int_inspect(x)
+        if x.to_s.size > 5
+          "%g" % x.to_f
+        else
+          x.inspect
+        end
+      end
+
+      def n_trail_zero(x)
+        s = x.to_s
+        if /^([+-]?\d*[1-9])(0*)$/ =~ s
+          [$1.to_i, $2.size]
+        else
+          raise "cannot match with: '#{s}'"
+        end
+      end
+
+      def num_inspect(x)
+        if x.kind_of? Rational
+          d = x.denominator
+          n = x.numerator
+          if d==1
+            return int_inspect(n)
+          end
+          if check_decimal(d)
+            return x.to_f.inspect
+          end
+          if check_decimal(n)
+            if n==1
+              return "(1/"+int_inspect(d)+")"
+            else
+              return "(1/%s)" % Rational(d,n).to_f.inspect
+            end
+          end
+          ud,nd = n_trail_zero(d)
+          if nd > 3
+            return Rational(n,ud).inspect + 
+              ("*%.0e"%10**(-nd))
+          end
+          un,nn = n_trail_zero(n)
+          if nn > 3
+            return Rational(un,d).inspect + 
+              ("*%.0e"%10**(nn))
+          end
+        end
+        x.inspect
+      end
+    end
+  end
+end

data/lib/phys/units/version.rb

@@ -0,0 +1,5 @@
+module Phys
+  class Unit
+    VERSION = "0.9.0"
+  end
+end

data/phys-units.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'phys/units/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "phys-units"
+  spec.version       = Phys::Unit::VERSION
+  spec.authors       = ["Masahiro TANAKA"]
+  spec.email         = ["masa16.tanaka@gmail.com"]
+  spec.description   = %q{GNU Units-compatible library for Ruby, formarly 'Quanty' class library.}
+  spec.summary       = %q{GNU Units-compatible library for Ruby, formarly 'Quanty' class library.}
+  spec.homepage      = "https://github.com/masa16/phys-units"
+  spec.license       = "GPL"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/spec/helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require "phys/units"
+U = Phys::Unit
+Q = Phys::Quantity

data/spec/quantity_spec.rb

@@ -0,0 +1,111 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require "helper"
+
+describe "Phys::Quantity" do
+
+  context "Dimensionless" do
+    describe Q[1] do
+      it {should be_an_instance_of Phys::Quantity}
+      its(:value) {should == 1}
+      its(:unit) {should be_an_instance_of Phys::Unit}
+      its(:unit) {should == U[1]}
+    end
+    describe Q[1,""] do
+      it {should be_an_instance_of Phys::Quantity}
+      its(:value) {should == 1}
+      its(:unit) {should be_an_instance_of Phys::Unit}
+      its(:unit) {should == U['']}
+    end
+    describe Q[1,""] do
+      before {@q=Q[1,""]}
+      it {@q.want(2).value.should == 0.5}
+    end
+  end
+
+  context "Length" do
+    describe Q[1,"km"] do
+      before { @q = Q[1,"km"] }
+      it {@q.want("m").value.should == 1000}
+      it {@q.want("cm").value.should == 100000}
+    end
+    describe Q[1,"au"] do
+      it {should == Q[149597870700,"m"]}
+    end
+    describe Q[1,"parsec"] do
+      it {should == Q[3.0856775814671916e+16,"m"]}
+    end
+    describe Q[1,"lightyear"] do
+      it {should == Q[9460730472580800,"m"]}
+    end
+    describe Q[1,"lightyear"].want(:m).value do
+      it {should == 9460730472580800}
+    end
+    describe Q[1,"inch"] do
+      it {should == Q[0.0254,"m"]}
+    end
+    describe Q[1,"feet"] do
+      it {should == Q[0.3048,"m"]}
+    end
+    describe Q[1,"mile"] do
+      it {should == Q[1609.344,"m"]}
+    end
+  end
+
+  context "Temperature" do
+    describe Q[1,"tempC"] - Q[1,"tempC"] do 
+      it {should == Q[0,"tempC"]}
+    end
+    describe Q[50,"tempF"] + Q[10,"tempC"] do 
+      it {should == Q[68,"tempF"]}
+    end
+    describe Q[0,"tempC"].want("tempF") do
+      its(:value) {should == 32}
+    end
+    describe Q[32,"tempF"].want("tempC") do
+      its(:value){should == 0}
+    end
+    describe 2 * Q[2,"tempF"] do 
+      it {should == Q[4,"tempF"]}
+    end
+    describe Q[2.5,"tempC"] * 4 do
+      its(:value){should == 10}
+    end
+    describe Q[10.0,"tempC"] / 4 do
+      its(:value){should == 2.5}
+    end
+    describe "tempC*tempC" do 
+      it {expect{Q[1,"tempC"]*Q[2,"tempC"]}.to raise_error}
+    end
+    describe "tempC*K" do 
+      it {expect{Q[1,"tempC"]*Q[2,"K"]}.to raise_error}
+    end
+    describe "K*tempC" do 
+      it {expect{Q[1,"K"]*Q[2,"tempC"]}.to raise_error}
+    end
+    describe "tempC**2" do 
+      it {expect{Q[2,"tempC"]**2}.to raise_error}
+    end
+    describe "tempC/tempC" do 
+      it {expect{Q[2,"tempC"]/Q[1,"tempC"]}.to raise_error}
+    end
+  end
+
+  context "Velocity" do
+    describe Q[36,"km/hour"] do
+      its(:to_base_unit){should == Q[10,"m/s"]}
+    end
+    describe Q[36,"km/hour"].want('m/s') do 
+      its(:value){should == 10}
+    end
+  end
+
+  context "Radian" do
+    describe Q[1,"radian"].want("degree") do
+      its(:value){should be_within(1e-15).of Q[180,"1/pi"].to_f}
+    end
+    describe Math.sin(Q[30,"degree"].to_f) do
+      it{should be_within(1e-15).of 0.5 }
+    end
+  end
+
+end

data/spec/unit_spec.rb

@@ -0,0 +1,234 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require "helper"
+
+describe "Create Units" do
+
+  describe U[1] do
+    it {should be_an_instance_of Phys::Unit}
+    its(:factor) {should == 1}
+    its(:conversion_factor) {should == 1}
+    its(:name) {should be_nil}
+    its(:expr) {should be_nil}
+    its(:offset) {should be_nil}
+    its(:dimension) {should == {}}
+    its(:dimension_value) {should == 1}
+    its(:string_form) {should == ""}
+    it {should be_dimensionless}
+    it {should be_scalar}
+    it {should be_operable}
+  end
+
+  describe U[2] do
+    it {should be_an_instance_of Phys::Unit}
+    its(:factor) {should == 2}
+    its(:conversion_factor) {should == 2}
+    its(:name) {should be_nil}
+    its(:expr) {should be_nil}
+    its(:offset) {should be_nil}
+    its(:dimension) {should == {}}
+    its(:dimension_value) {should == 1}
+    its(:string_form) {should == "2"}
+    it {should be_dimensionless}
+    it {should_not be_scalar}
+    it {should be_operable}
+  end
+
+  describe U['pi'] do
+    it {should be_an_kind_of Phys::Unit}
+    its(:factor) {should == 1}
+    its(:conversion_factor) {should == Math::PI}
+    its(:name) {should == 'pi'}
+    its(:expr) {should be_nil}
+    its(:offset) {should be_nil}
+    its(:dimension) {should == {'pi'=>1}}
+    its(:dimension_value) {should == Math::PI}
+    its(:string_form) {should == "pi"}
+    it {should be_dimensionless}
+    it {should_not be_scalar}
+    it {should be_operable}
+  end
+
+  describe U['m'] do
+    it {should be_an_kind_of Phys::Unit}
+    its(:factor) {should == 1}
+    its(:conversion_factor) {should == 1}
+    its(:name) {should == 'm'}
+    its(:expr) {should be_nil}
+    its(:offset) {should be_nil}
+    its(:dimension) {should == {'m'=>1}}
+    its(:dimension_value) {should == 1}
+    its(:string_form) {should == "m"}
+    it {should_not be_dimensionless}
+    it {should_not be_scalar}
+    it {should be_operable}
+  end
+
+  describe U[:m] do 
+    it {should == U["m"]}
+  end
+
+  describe U['miles'] do
+    it {should be_an_kind_of Phys::Unit}
+    its(:factor) {should == 1609.344}
+    its(:factor) {should be_an_instance_of Rational}
+    its(:conversion_factor) {should == 1609.344}
+    its(:name) {should == 'mile'}
+    its(:expr) {should == "5280 ft"}
+    its(:offset) {should be_nil}
+    its(:dimension) {should == {'m'=>1}}
+    its(:dimension_value) {should == 1}
+    its(:string_form) {should == "1609.344 m"}
+    it {should_not be_dimensionless}
+    it {should_not be_scalar}
+    it {should be_operable}
+  end
+
+  describe 1.609344*U['km'] do
+    it {should be_an_kind_of Phys::Unit}
+    it {should == Phys::Unit[:miles]}
+    its(:factor) {should == 1609.344}
+    its(:conversion_factor) {should == 1609.344}
+    its(:name) {should be_nil}
+    its(:expr) {should be_nil}
+    its(:offset) {should be_nil}
+    its(:dimension) {should == {'m'=>1}}
+    its(:dimension_value) {should == 1}
+    its(:string_form) {should == "1609.344 m"}
+    it {should_not be_dimensionless}
+    it {should_not be_scalar}
+    it {should be_operable}
+  end
+
+  describe U['g'] do
+    it {should be_an_instance_of Phys::Unit}
+    its(:factor) {should == Rational(1,1000)}
+    its(:conversion_factor) {should == Rational(1,1000)}
+    its(:name) {should == 'g'}
+    #its(:expr) {should == 'gram'}
+    its(:offset) {should be_nil}
+    its(:dimension) {should == {'kg'=>1}}
+    its(:dimension_value) {should == 1}
+    its(:string_form) {should == "0.001 kg"}
+    it {should_not be_dimensionless}
+    it {should_not be_scalar}
+    it {should be_operable}
+  end
+
+
+  describe U['h'] do
+    it {should be_an_instance_of Phys::Unit}
+    its(:factor) {should be_within(1e-16*1e-33).of 6.626069574766962e-34}
+    its(:conversion_factor) {should be_within(1e-16*1e-33).of 6.626069574766962e-34}
+    its(:name) {should == 'h'}
+    its(:expr) {should == "4.135667516e-15 eV s"}
+    its(:offset) {should be_nil}
+    its(:dimension) {should == {'kg'=>1,'m'=>2,'s'=>-1}}
+    its(:dimension_value) {should == 1}
+    its(:string_form) {should == "6.626069574766962e-34 s^-1 kg m^2"}
+    it {should_not be_dimensionless}
+    it {should_not be_scalar}
+    it {should be_operable}
+  end
+
+  describe U['e'] do
+    it {should be_an_instance_of Phys::Unit}
+    its(:factor) {should be_within(1e-15*1e-18).of 1.602176565e-19}
+    its(:conversion_factor) {should be_within(1e-15*1e-18).of 1.602176565e-19}
+    its(:name) {should == 'e'}
+    its(:expr) {should == "1.602176565e-19 C"}
+    its(:offset) {should be_nil}
+    its(:dimension) {should == {'A'=>1,'s'=>1}}
+    its(:dimension_value) {should == 1}
+    its(:string_form) {should == "1.602176565e-19 A s"}
+    it {should_not be_dimensionless}
+    it {should_not be_scalar}
+    it {should be_operable}
+  end
+
+  describe U.parse('123.5 s') do
+    it {should be_an_instance_of Phys::Unit}
+    its(:factor) {should == 123.5}
+    its(:conversion_factor) {should == 123.5}
+    its(:name) {should be_nil}
+    its(:expr) {should be_nil}
+    its(:offset) {should be_nil}
+    its(:dimension) {should == {'s'=>1}}
+    its(:dimension_value) {should == 1}
+    its(:string_form) {should == "123.5 s"}
+    it {should_not be_dimensionless}
+    it {should_not be_scalar}
+    it {should be_operable}
+  end
+
+  describe U['m']/U['s'] do
+    it {should be_an_instance_of Phys::Unit}
+    its(:factor) {should == 1}
+    its(:conversion_factor) {should == 1}
+    its(:name) {should be_nil}
+    its(:expr) {should be_nil}
+    its(:offset) {should be_nil}
+    its(:dimension) {should == {'m'=>1, 's'=>-1}}
+    its(:dimension_value) {should == 1}
+    its(:string_form) {should == "m s^-1"}
+    it {should_not be_dimensionless}
+    it {should_not be_scalar}
+    it {should be_operable}
+  end
+
+  describe U.parse('(m/s)**2') do
+    it {should be_an_instance_of Phys::Unit}
+    its(:factor) {should == 1}
+    its(:conversion_factor) {should == 1}
+    its(:name) {should be_nil}
+    its(:expr) {should be_nil}
+    its(:offset) {should be_nil}
+    its(:dimension) {should == {'m'=>2, 's'=>-2}}
+    its(:dimension_value) {should == 1}
+    its(:string_form) {should == "m^2 s^-2"}
+    it {should_not be_dimensionless}
+    it {should_not be_scalar}
+    it {should be_operable}
+  end
+
+  describe U.parse("3.6 km/hour") do
+    its(:string_form) {should == "m s^-1"}
+  end
+
+  describe U['tempC'] do
+    it {should be_an_instance_of Phys::OffsetUnit}
+    its(:factor) {should == 1}
+    its(:conversion_factor) {should == 1}
+    its(:name) {should == 'tempC'}
+    its(:expr) {should be_nil}
+    its(:offset) {should == 273.15}
+    its(:dimension) {should == {'K'=>1}}
+    its(:dimension_value) {should == 1}
+    its(:string_form) {should == "K"}
+    it {should_not be_dimensionless}
+    it {should_not be_scalar}
+    it {should_not be_operable}
+  end
+
+  describe U['tempF'] do
+    it {should be_an_instance_of Phys::OffsetUnit}
+    its(:factor) {should == Rational(5,9)}
+    its(:factor) {should be_an_instance_of Rational}
+    its(:conversion_factor) {should == Rational(5,9)}
+    its(:name) {should == 'tempF'}
+    its(:expr) {should be_nil}
+    its(:offset) {should == Rational(45967,180)}
+    its(:dimension) {should == {'K'=>1}}
+    its(:dimension_value) {should == 1}
+    its(:string_form) {should == "(1/1.8) K"}
+    it {should_not be_dimensionless}
+    it {should_not be_scalar}
+    it {should_not be_operable}
+  end
+
+  describe "temperature unit" do
+    it "operation error" do
+      expect {U['tempC']*2}.to raise_error(Phys::Unit::UnitOperationError)
+    end
+  end
+
+end