unitwise 2.0.0 → 2.2.0

data/data/prefix.yaml

@@ -3,119 +3,119 @@
   :symbol: Y
   :primary_code: Y
   :secondary_code: YA
-  :scalar: 1e24
+  :scalar: 1000000000000000000000000
 - :names: zetta
   :symbol: Z
   :primary_code: Z
   :secondary_code: ZA
-  :scalar: 1e21
+  :scalar: 1000000000000000000000
 - :names: exa
   :symbol: E
   :primary_code: E
   :secondary_code: EX
-  :scalar: 1e18
+  :scalar: 1000000000000000000
 - :names: peta
   :symbol: P
   :primary_code: P
   :secondary_code: PT
-  :scalar: 1e15
+  :scalar: 1000000000000000
 - :names: tera
   :symbol: T
   :primary_code: T
   :secondary_code: TR
-  :scalar: 1e12
+  :scalar: 1000000000000
 - :names: giga
   :symbol: G
   :primary_code: G
   :secondary_code: GA
-  :scalar: 1e9
+  :scalar: 1000000000
 - :names: mega
   :symbol: M
   :primary_code: M
   :secondary_code: MA
-  :scalar: 1e6
+  :scalar: 1000000
 - :names: kilo
   :symbol: k
   :primary_code: k
   :secondary_code: K
-  :scalar: 1e3
+  :scalar: 1000
 - :names: hecto
   :symbol: h
   :primary_code: h
   :secondary_code: H
-  :scalar: 1e2
+  :scalar: 100
 - :names: deka
   :symbol: da
   :primary_code: da
   :secondary_code: DA
-  :scalar: 1e1
+  :scalar: 10
 - :names: deci
   :symbol: d
   :primary_code: d
   :secondary_code: D
-  :scalar: 1e-1
+  :scalar: !ruby/object:BigDecimal 18:0.1e0
 - :names: centi
   :symbol: c
   :primary_code: c
   :secondary_code: C
-  :scalar: 1e-2
+  :scalar: !ruby/object:BigDecimal 18:0.1e-1
 - :names: milli
   :symbol: m
   :primary_code: m
   :secondary_code: M
-  :scalar: 1e-3
+  :scalar: !ruby/object:BigDecimal 18:0.1e-2
 - :names: micro
-  :symbol: "μ"
+  :symbol: μ
   :primary_code: u
   :secondary_code: U
-  :scalar: 1e-6
+  :scalar: !ruby/object:BigDecimal 18:0.1e-5
 - :names: nano
   :symbol: n
   :primary_code: n
   :secondary_code: N
-  :scalar: 1e-9
+  :scalar: !ruby/object:BigDecimal 18:0.1e-8
 - :names: pico
   :symbol: p
   :primary_code: p
   :secondary_code: P
-  :scalar: 1e-12
+  :scalar: !ruby/object:BigDecimal 18:0.1e-11
 - :names: femto
   :symbol: f
   :primary_code: f
   :secondary_code: F
-  :scalar: 1e-15
+  :scalar: !ruby/object:BigDecimal 18:0.1e-14
 - :names: atto
   :symbol: a
   :primary_code: a
   :secondary_code: A
-  :scalar: 1e-18
+  :scalar: !ruby/object:BigDecimal 18:0.1e-17
 - :names: zepto
   :symbol: z
   :primary_code: z
   :secondary_code: ZO
-  :scalar: 1e-21
+  :scalar: !ruby/object:BigDecimal 18:0.1e-20
 - :names: yocto
   :symbol: y
   :primary_code: y
   :secondary_code: YO
-  :scalar: 1e-24
+  :scalar: !ruby/object:BigDecimal 18:0.1e-23
 - :names: kibi
   :symbol: Ki
   :primary_code: Ki
   :secondary_code: KIB
-  :scalar: '1024'
+  :scalar: 1024
 - :names: mebi
   :symbol: Mi
   :primary_code: Mi
   :secondary_code: MIB
-  :scalar: '1048576'
+  :scalar: 1048576
 - :names: gibi
   :symbol: Gi
   :primary_code: Gi
   :secondary_code: GIB
-  :scalar: '1073741824'
+  :scalar: 1073741824
 - :names: tebi
   :symbol: Ti
   :primary_code: Ti
   :secondary_code: TIB
-  :scalar: '1099511627776'
+  :scalar: 1099511627776

data/lib/unitwise/atom.rb

@@ -7,13 +7,13 @@ module Unitwise
     include Compatible
 
     class << self
-      # Array of hashes representing atom properties.
+      # Array of hashes representing default atom properties.
       # @api private
       def data
         @data ||= data_files.map { |file| YAML.load(File.open file) }.flatten
       end
 
-      # Data files containing atom data
+      # Data files containing default atom data
       # @api private
       def data_files
         %w(base_unit derived_unit).map { |type| Unitwise.data_file type }
@@ -103,11 +103,11 @@ module Unitwise
     # @return [Numeric]
     # @api public
     def scalar(magnitude = 1)
-      base? ? BigDecimal(magnitude.to_s) : scale.scalar(magnitude)
+      base? ? magnitude : scale.scalar(magnitude)
     end
 
     def magnitude(scalar = scalar())
-      special? ? scale.magnitude(scalar) : BigDecimal('1')
+      special? ? scale.magnitude(scalar) : 1
     end
 
     # An atom may have a complex scale with several base atoms at various
@@ -117,5 +117,34 @@ module Unitwise
       base? ? [Term.new(:atom_code => primary_code)] : scale.root_terms
     end
     memoize :root_terms
+
+
+    # A basic validator for atoms. It checks for the bare minimum properties
+    # and that it's scalar and magnitude can be resolved. Note that this method
+    # requires the units it depends on to already exist, so it is not used
+    # when loading the initial data from UCUM.
+    # @return [true] returns true if the atom is valid
+    # @raise [Unitwise::DefinitionError]
+    def validate!
+      missing_properties = %i{primary_code names scale}.select do |prop|
+        val = liner_get(prop)
+        val.nil? || (val.respond_to?(:empty) && val.empty?)
+      end
+
+      if !missing_properties.empty?
+        missing_list = missing_properties.join(',')
+        raise Unitwise::DefinitionError,
+          "Atom has missing properties: #{missing_list}."
+      end
+
+      msg = "Atom definition could not be resolved. Ensure that it is a base " \
+            "unit or is defined relative to existing units."
+
+      begin
+        !scalar.nil? && !magnitude.nil? || raise(Unitwise::DefinitionError, msg)
+      rescue Unitwise::ExpressionError
+        raise Unitwise::DefinitionError,  msg
+      end
+    end
   end
 end

data/lib/unitwise/errors.rb

@@ -1,7 +1,10 @@
 module Unitwise
-  class ExpressionError < Exception
+  class ExpressionError < StandardError
   end
 
-  class ConversionError < Exception
+  class ConversionError < StandardError
+  end
+
+  class DefinitionError < StandardError
   end
 end

data/lib/unitwise/expression/decomposer.rb

@@ -5,13 +5,7 @@ module Unitwise
     # of a string, as well as caching the results.
     class Decomposer
 
-      MODES = [:primary_code, :secondary_code, :names, :slugs, :symbol]
-
-      PARSERS = MODES.reduce({}) do |hash, mode|
-        hash[mode] = Parser.new(mode); hash
-      end
-
-      TRANSFORMER = Transformer.new
+      MODES = [:primary_code, :secondary_code, :names, :slugs, :symbol].freeze
 
       class << self
 
@@ -25,6 +19,16 @@ module Unitwise
           end
         end
 
+        def parsers
+          @parsers ||= MODES.reduce({}) do |hash, mode|
+            hash[mode] = Parser.new(mode); hash
+          end
+        end
+
+        def transformer
+          @transformer = Transformer.new
+        end
+
         private
 
         # A simple cache to prevent re-decomposing the same units
@@ -32,6 +36,14 @@ module Unitwise
         def cache
           @cache ||= {}
         end
+
+        # Reset memoized data. Allows rebuilding of parsers, transformers, and
+        # the cache after list of atoms has been modified.
+        def reset
+          @parsers = nil
+          @transformer = nil
+          @cache = nil
+        end
       end
 
       attr_reader :expression, :mode
@@ -44,7 +56,7 @@ module Unitwise
       end
 
       def parse
-        PARSERS.reduce(nil) do |_, (mode, parser)|
+        self.class.parsers.reduce(nil) do |_, (mode, parser)|
           parsed = parser.parse(expression) rescue next
           @mode = mode
           break parsed
@@ -52,7 +64,7 @@ module Unitwise
       end
 
       def transform
-        @transform ||= TRANSFORMER.apply(parse, :mode => mode)
+        @transform ||= self.class.transformer.apply(parse, :mode => mode)
       end
 
       def terms

data/lib/unitwise/expression/matcher.rb

@@ -5,19 +5,15 @@ module Unitwise
     class Matcher
       class << self
         def atom(mode)
-          @atom ||= {}
-          @atom[mode] ||= new(Atom.all, mode).alternative
+          new(Atom.all, mode).alternative
         end
 
         def metric_atom(mode)
-          @metric_atom ||= {}
-          @metric_atom[mode] ||=
-            new(Atom.all.select(&:metric?), mode).alternative
+          new(Atom.all.select(&:metric?), mode).alternative
         end
 
         def prefix(mode)
-          @prefix ||= {}
-          @prefix[mode] ||= new(Prefix.all, mode).alternative
+          new(Prefix.all, mode).alternative
         end
       end
 
@@ -41,7 +37,6 @@ module Unitwise
       def alternative
         Parslet::Atoms::Alternative.new(*matchers)
       end
-
     end
   end
 end

data/lib/unitwise/expression/parser.rb

@@ -5,14 +5,21 @@ module Unitwise
     class Parser < Parslet::Parser
       attr_reader :key
       def initialize(key = :primary_code)
-        @key = key
+        @key                 = key
+        @atom_matcher        = Matcher.atom(key)
+        @metric_atom_matcher = Matcher.metric_atom(key)
+        @prefix_matcher      = Matcher.prefix(key)
       end
 
+      private
+
+      attr_reader :atom_matcher, :metric_atom_matcher, :prefix_matcher
+
       root :expression
 
-      rule (:atom) { Matcher.atom(key).as(:atom_code) }
-      rule (:metric_atom) { Matcher.metric_atom(key).as(:atom_code) }
-      rule (:prefix) { Matcher.prefix(key).as(:prefix_code) }
+      rule (:atom) { atom_matcher.as(:atom_code) }
+      rule (:metric_atom) { metric_atom_matcher.as(:atom_code) }
+      rule (:prefix) { prefix_matcher.as(:prefix_code) }
 
       rule (:simpleton) do
         (prefix.as(:prefix) >> metric_atom.as(:atom) | atom.as(:atom))

data/lib/unitwise/functional.rb

@@ -22,6 +22,14 @@ module Unitwise
       5.0 / 9.0 * (x + 459.67)
     end
 
+    def self.to_degre(x)
+      4.0 * x / 5.0 - 218.52
+    end
+
+    def self.from_degre(x)
+      5.0 / 4.0 * (x + 218.52)
+    end
+
     def self.to_hpX(x)
       -log10(x)
     end

data/lib/unitwise/measurement.rb

@@ -129,7 +129,7 @@ module Unitwise
     #   measurement.to_r # => (17/4)
     # @api public
     def to_r
-      Rational(value)
+      Number.rationalize(value)
     end
 
     # Will attempt to convert to a unit by method name.
@@ -156,10 +156,6 @@ module Unitwise
       self.class.new(*args)
     end
 
-    # Set the value for the measurement.
-    # @api private
-    attr_writer :value
-
     # Determine value of the unit after conversion to another unit
     # @api private
     def converted_value(other_unit)

data/lib/unitwise/number.rb

@@ -0,0 +1,62 @@
+module Unitwise
+  class Number
+    # Attempts to coerce a value to the simplest Numeric that fully expresses
+    # it's value. For instance a value of 1.0 would return 1, a value of
+    # #<BigDecimal:7f9558d559b8,'0.45E1',18(18)> would return 4.5.
+    # @api public
+    # @param value [Integer, Float, Rational, String, BigDecimal]
+    # @return [Integer, Float, Rational, BigDecimal]
+    def self.simplify(value)
+      case value
+      when Integer
+        value
+      when Float
+        (i = value.to_i) == value ? i : value
+      when Rational
+        if (i = value.to_i) == value
+          i
+        elsif (f = value.to_f) && f.to_r == value
+          f
+        else
+          value
+        end
+      else # String, BigDecimal, Other
+        s = value.is_a?(String) ? value : value.to_s
+        d = value.is_a?(BigDecimal) ? value : BigDecimal(s)
+        if (i = d.to_i) == d
+          i
+        elsif (f = d.to_f) == d
+          f
+        else
+          d
+        end
+      end
+    end
+
+    # Coerces a string-like number to a BigDecimal or Integer as appropriate
+    # @api public
+    # @param value Something that can be represented as a string number
+    # @return [Integer, BigDecimal]
+    def self.coefficify(value)
+      d = BigDecimal.new(value.to_s)
+      if (i = d.to_i) == d
+        i
+      else
+        d
+      end
+    end
+
+    # Coerce a numeric to a Rational, but avoid inaccurate conversions by
+    # jruby. More details here: https://github.com/jruby/jruby/issues/4711.
+    # @api public
+    # @param number [Numeric]
+    # @return Rational
+    def self.rationalize(number)
+      if number.is_a?(BigDecimal) && RUBY_PLATFORM == 'java'
+        number.to_s.to_r
+      else
+        number.to_r
+      end
+    end
+  end
+end

data/lib/unitwise/prefix.rb

@@ -14,11 +14,5 @@ module Unitwise
     def self.data_file
       Unitwise.data_file 'prefix'
     end
-
-    # Set the scalar value for the prefix, always as a BigDecimal
-    # @api semipublic
-    def scalar=(value)
-      @scalar = BigDecimal(value.to_s)
-    end
   end
 end

data/lib/unitwise/scale.rb

@@ -30,10 +30,6 @@ module Unitwise
       unit.atoms
     end
 
-    def value=(value)
-      @value = BigDecimal(value.to_s)
-    end
-
     # List the terms associated with this scale's unit.
     # @return [Array]
     # @api public
@@ -56,7 +52,7 @@ module Unitwise
       if special?
         unit.scalar(magnitude)
       else
-        value * unit.scalar
+        Number.rationalize(value) * Number.rationalize(unit.scalar)
       end
     end
 
@@ -95,17 +91,7 @@ module Unitwise
     # @return [Numeric]
     # @api public
     def simplified_value
-      if value.is_a?(Integer)
-        value
-      elsif (i = Integer(value)) == value
-        i
-      elsif value.is_a?(Float) || value.is_a?(Rational)
-        value
-      elsif (f = Float(value)) == value
-        f
-      else
-        value
-      end
+      Unitwise::Number.simplify(value)
     end
     memoize :simplified_value
 

data/lib/unitwise/standard/function.rb

@@ -12,7 +12,7 @@ module Unitwise::Standard
     end
 
     def value
-      attributes["function"]["@value"].to_f
+      Unitwise::Number.simplify(attributes["function"]["@value"])
     end
 
     def unit
@@ -32,4 +32,4 @@ module Unitwise::Standard
     end
 
   end
-end
+end

data/lib/unitwise/standard/prefix.rb

@@ -6,12 +6,13 @@ module Unitwise::Standard
     end
 
     def scale
-      attributes["value"].attributes["value"]
+      Unitwise::Number.coefficify(
+        attributes.fetch('value').attributes.fetch('value')
+      )
     end
 
     def to_hash
       super().merge(:scalar => scale)
     end
-
   end
-end
+end

data/lib/unitwise/standard/scale.rb

@@ -7,7 +7,7 @@ module Unitwise::Standard
     end
 
     def value
-      nori.attributes["value"].to_f
+      Unitwise::Number.coefficify(nori.attributes.fetch('value'))
     end
 
     def primary_unit_code
@@ -22,4 +22,4 @@ module Unitwise::Standard
       {:value => value, :unit_code => primary_unit_code}
     end
   end
-end
+end

data/lib/unitwise/term.rb

@@ -59,7 +59,7 @@ module Unitwise
     # @param magnitude [Numeric] The magnitude to calculate the scalar for.
     # @return [Numeric] The unitless linear scalar value.
     # @api public
-    def scalar(magnitude = 1.0)
+    def scalar(magnitude = 1)
       calculate(atom ? atom.scalar(magnitude) : magnitude)
     end
 
@@ -68,7 +68,7 @@ module Unitwise
     # @return [Numeric] The magnitude on this scale.
     # @api public
     def magnitude(scalar = scalar())
-      calculate(atom ? atom.magnitude(scalar) : 1.0)
+      calculate(atom ? atom.magnitude(scalar) : 1)
     end
 
     # The base units this term is derived from

data/lib/unitwise/unit.rb

@@ -86,8 +86,8 @@ module Unitwise
     # @param magnitude [Numeric] An optional magnitude on this unit's scale.
     # @return [Numeric] A scalar value on a linear scale
     # @api public
-    def scalar(magnitude = 1.0)
-      terms.reduce(1.0) do |prod, term|
+    def scalar(magnitude = 1)
+      terms.reduce(1) do |prod, term|
         prod * term.scalar(magnitude)
       end
     end
@@ -98,7 +98,7 @@ module Unitwise
     # @return [Numeric] The equivalent magnitude on this scale
     # @api public
     def magnitude(scalar = scalar())
-      terms.reduce(1.0) do |prod, term|
+      terms.reduce(1) do |prod, term|
         prod * term.magnitude(scalar)
       end
     end

data/lib/unitwise/version.rb

@@ -1,3 +1,3 @@
 module Unitwise
-  VERSION = '2.0.0'
+  VERSION = '2.2.0'.freeze
 end

data/lib/unitwise.rb

@@ -8,6 +8,7 @@ require 'bigdecimal'
 require 'unitwise/version'
 require 'unitwise/base'
 require 'unitwise/compatible'
+require 'unitwise/number'
 require 'unitwise/expression'
 require 'unitwise/scale'
 require 'unitwise/functional'
@@ -43,7 +44,19 @@ module Unitwise
       false
     end
   end
-  
+
+  # Add additional atoms. Useful for registering uncommon or custom units.
+  # @param properties [Hash] Properties of the atom
+  # @return [Unitwise::Atom] The newly created atom
+  # @raise [Unitwise::DefinitionError]
+  def self.register(atom_hash)
+    atom = Unitwise::Atom.new(atom_hash)
+    atom.validate!
+    Unitwise::Atom.all.push(atom)
+    Unitwise::Expression::Decomposer.send(:reset)
+    atom
+  end
+
   # The system path for the installed gem
   # @api private
   def self.path

data/test/support/scale_tests.rb

@@ -86,32 +86,26 @@ module ScaleTests
       end
 
       describe "#simplified_value" do
-        describe "when the value is equivalent to an Integer" do
-          it "should convert from a Rational" do
-            result = described_class.new(Rational(20,2), 'foot').simplified_value
-            result.must_equal 10
-            result.must_be_kind_of(Integer)
-          end
-          it "should convert from a Float" do
-            result = described_class.new(4.0, 'foot').simplified_value
-            result.must_equal 4
-            result.must_be_kind_of(Integer)
-          end
-          it "should convert from a BigDecimal" do
-            result = described_class.new(BigDecimal("4.5"), "volt").simplified_value
-            result.must_equal 4.5
-            result.must_be_kind_of(Float)
-          end
+        it "must simplify to an Integer" do
+          result = described_class.new(4.0, 'foot').simplified_value
+          result.must_equal 4
+          result.must_be_kind_of(Integer)
         end
-        describe "when the value is equivalent to a Float" do
-          it "should convert from a BigDecimal" do
-            result = described_class.new(BigDecimal("1.5"), 'foot').simplified_value
-            result.must_equal 1.5
-            result.must_be_kind_of(Float)
-          end
+
+        it "must simplify to a Float" do
+          result = described_class.new(BigDecimal("1.5"), 'foot').simplified_value
+          result.must_equal 1.5
+          result.must_be_kind_of(Float)
         end
       end
 
+      describe "#inspect" do
+        it "must show the unit and value" do
+          result = described_class.new(12, 'meter').inspect
+          result.must_include("value=12")
+          result.must_include("unit=meter")
+        end
+      end
     end
   end
 end

data/test/test_helper.rb

@@ -9,9 +9,8 @@ require 'minitest/pride'
 require 'unitwise'
 
 module Minitest::Assertions
-  def assert_almost_equal(expected, actual)
+  def assert_almost_equal(expected, actual, range=0.0001)
     message = "Expected #{actual} to be almost equal to #{expected}"
-    range   = 0.00001
     assert expected + range > actual && expected - range < actual, message
   end
 end