unitwise 2.1.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: μ
   :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.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'

data/lib/unitwise/atom.rb

@@ -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

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.1.0'
+  VERSION = '2.2.0'.freeze
 end

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