ruby-units 2.3.0 → 2.4.1

data/lib/ruby_units/unit.rb

@@ -22,7 +22,6 @@ require 'date'
 #
 module RubyUnits
   class Unit < Numeric
-    VERSION            = Unit::Version::STRING
     @@definitions      = {}
     @@prefix_values    = {}
     @@prefix_map       = {}
@@ -32,30 +31,41 @@ module RubyUnits
     @@unit_match_regex = nil
     UNITY              = '<1>'.freeze
     UNITY_ARRAY        = [UNITY].freeze
-    # ideally we would like to generate this regex from the alias for a 'feet' and 'inches', but they aren't
-    # defined at the point in the code where we need this regex.
-    FEET_INCH_UNITS_REGEX = /(?:'|ft|feet)\s*(\d+)\s*(?:"|in|inch(?:es)?)/
-    FEET_INCH_REGEX    = /(\d+)\s*#{FEET_INCH_UNITS_REGEX}/
-    # ideally we would like to generate this regex from the alias for a 'pound' and 'ounce', but they aren't
-    # defined at the point in the code where we need this regex.
-    LBS_OZ_UNIT_REGEX  = /(?:#|lbs?|pounds?|pound-mass)+[\s,]*(\d+)\s*(?:ozs?|ounces?)/
-    LBS_OZ_REGEX       = /(\d+)\s*#{LBS_OZ_UNIT_REGEX}/
-    # ideally we would like to generate this regex from the alias for a 'stone' and 'pound', but they aren't
-    # defined at the point in the code where we need this regex.
-    # also note that the plural of 'stone' is still 'stone', but we accept 'stones' anyway.
-    STONE_LB_UNIT_REGEX = /(?:sts?|stones?)+[\s,]*(\d+)\s*(?:#|lbs?|pounds?|pound-mass)*/
-    STONE_LB_REGEX     = /(\d+)\s*#{STONE_LB_UNIT_REGEX}/
-    TIME_REGEX         = /(\d+)*:(\d+)*:*(\d+)*[:,]*(\d+)*/
-    SCI_NUMBER         = /([+-]?\d*[.]?\d+(?:[Ee][+-]?)?\d*)/
-    RATIONAL_NUMBER    = %r{\(?([+-])?(\d+[ -])?(\d+)\/(\d+)\)?}
-    COMPLEX_NUMBER     = /#{SCI_NUMBER}?#{SCI_NUMBER}i\b/
-    NUMBER_REGEX       = /#{SCI_NUMBER}*\s*(.+)?/
-    UNIT_STRING_REGEX  = %r{#{SCI_NUMBER}*\s*([^\/]*)\/*(.+)*}
-    TOP_REGEX          = /([^ \*]+)(?:\^|\*\*)([\d-]+)/
-    BOTTOM_REGEX       = /([^* ]+)(?:\^|\*\*)(\d+)/
-    NUMBER_UNIT_REGEX  = /#{SCI_NUMBER}?(.*)/
-    COMPLEX_REGEX      = /#{COMPLEX_NUMBER}\s?(.+)?/
-    RATIONAL_REGEX     = /#{RATIONAL_NUMBER}\s?(.+)?/
+    # ideally we would like to generate this regex from the alias for a 'feet'
+    # and 'inches', but they aren't defined at the point in the code where we
+    # need this regex.
+    FEET_INCH_UNITS_REGEX = /(?:'|ft|feet)\s*(\d+)\s*(?:"|in|inch(?:es)?)/.freeze
+    FEET_INCH_REGEX    = /(\d+)\s*#{FEET_INCH_UNITS_REGEX}/.freeze
+    # ideally we would like to generate this regex from the alias for a 'pound'
+    # and 'ounce', but they aren't defined at the point in the code where we
+    # need this regex.
+    LBS_OZ_UNIT_REGEX  = /(?:#|lbs?|pounds?|pound-mass)+[\s,]*(\d+)\s*(?:ozs?|ounces?)/.freeze
+    LBS_OZ_REGEX       = /(\d+)\s*#{LBS_OZ_UNIT_REGEX}/.freeze
+    # ideally we would like to generate this regex from the alias for a 'stone'
+    # and 'pound', but they aren't defined at the point in the code where we
+    # need this regex. also note that the plural of 'stone' is still 'stone',
+    # but we accept 'stones' anyway.
+    STONE_LB_UNIT_REGEX = /(?:sts?|stones?)+[\s,]*(\d+)\s*(?:#|lbs?|pounds?|pound-mass)*/.freeze
+    STONE_LB_REGEX     = /(\d+)\s*#{STONE_LB_UNIT_REGEX}/.freeze
+    # Time formats: 12:34:56,78, (hh:mm:ss,msec) etc.
+    TIME_REGEX         = /(?<hour>\d+):(?<min>\d+):(?:(?<sec>\d+))?(?:,(?<msec>\d+))?/.freeze
+    # Scientific notation: 1, -1, +1, 1.2, +1.2, -1.2, 123.4E5, +123.4e5,
+    #   -123.4E+5, -123.4e-5, etc.
+    SCI_NUMBER         = /([+-]?\d*[.]?\d+(?:[Ee][+-]?)?\d*)/.freeze
+    # Rational number, including improper fractions: 1 2/3, -1 2/3, 5/3, etc.
+    RATIONAL_NUMBER    = %r{\(?([+-])?(\d+[ -])?(\d+)\/(\d+)\)?}.freeze
+    # Complex numbers: 1+2i, 1.0+2.0i, -1-1i, etc.
+    COMPLEX_NUMBER     = /#{SCI_NUMBER}?#{SCI_NUMBER}i\b/.freeze
+    # Any Complex, Rational, or scientific number
+    ANY_NUMBER         = /(#{COMPLEX_NUMBER}|#{RATIONAL_NUMBER}|#{SCI_NUMBER})/.freeze
+    ANY_NUMBER_REGEX   = /(?:#{ANY_NUMBER})?\s?([^-\d.].*)?/.freeze
+    NUMBER_REGEX       = /#{SCI_NUMBER}*\s*(.+)?/.freeze
+    UNIT_STRING_REGEX  = %r{#{SCI_NUMBER}*\s*([^\/]*)\/*(.+)*}.freeze
+    TOP_REGEX          = /([^ \*]+)(?:\^|\*\*)([\d-]+)/.freeze
+    BOTTOM_REGEX       = /([^* ]+)(?:\^|\*\*)(\d+)/.freeze
+    NUMBER_UNIT_REGEX  = /#{SCI_NUMBER}?(.*)/.freeze
+    COMPLEX_REGEX      = /#{COMPLEX_NUMBER}\s?(.+)?/.freeze
+    RATIONAL_REGEX     = /#{RATIONAL_NUMBER}\s?(.+)?/.freeze
     KELVIN             = ['<kelvin>'].freeze
     FAHRENHEIT         = ['<fahrenheit>'].freeze
     RANKINE            = ['<rankine>'].freeze
@@ -140,11 +150,11 @@ module RubyUnits
       @@unit_match_regex = nil
       @@prefix_regex     = nil
 
-      @@definitions.each do |_name, definition|
+      @@definitions.each_value do |definition|
         use_definition(definition)
       end
 
-      RubyUnits::Unit.new(1)
+      new(1)
       true
     end
 
@@ -156,7 +166,7 @@ module RubyUnits
     end
 
     # return the unit definition for a unit
-    # @param [String] unit
+    # @param unit_name [String]
     # @return [RubyUnits::Unit::Definition, nil]
     def self.definition(unit_name)
       unit = unit_name =~ /^<.+>$/ ? unit_name : "<#{unit_name}>"
@@ -164,12 +174,12 @@ module RubyUnits
     end
 
     # return a list of all defined units
-    # @return [Array]
+    # @return [Array<RubyUnits::Units::Definition>]
     def self.definitions
       @@definitions
     end
 
-    # @param  [RubyUnits::Unit::Definition|String] unit_definition
+    # @param  [RubyUnits::Unit::Definition, String] unit_definition
     # @param  [Block] block
     # @return [RubyUnits::Unit::Definition]
     # @raise  [ArgumentError] when passed a non-string if using the block form
@@ -188,33 +198,38 @@ module RubyUnits
         raise ArgumentError, 'When using the block form of RubyUnits::Unit.define, pass the name of the unit' unless unit_definition.instance_of?(String)
         unit_definition = RubyUnits::Unit::Definition.new(unit_definition, &block)
       end
-      RubyUnits::Unit.definitions[unit_definition.name] = unit_definition
-      RubyUnits::Unit.use_definition(unit_definition)
+      definitions[unit_definition.name] = unit_definition
+      use_definition(unit_definition)
       unit_definition
     end
 
+    # Get the definition for a unit and allow it to be redefined
+    #
     # @param [String] name Name of unit to redefine
-    # @param [Block] block
+    # @param [Block] _block
     # @raise [ArgumentError] if a block is not given
-    # @yield [RubyUnits::Unit::Definition]
+    # @yieldparam [RubyUnits::Unit::Definition] the definition of the unit being
+    #   redefined
     # @return (see RubyUnits::Unit.define)
-    # Get the definition for a unit and allow it to be redefined
-    def self.redefine!(name)
+    def self.redefine!(name, &_block)
       raise ArgumentError, 'A block is required to redefine a unit' unless block_given?
+
       unit_definition = definition(name)
       raise(ArgumentError, "'#{name}' Unit not recognized") unless unit_definition
+
       yield unit_definition
       @@definitions.delete("<#{name}>")
       define(unit_definition)
-      RubyUnits::Unit.setup
+      setup
     end
 
-    # @param [String] name of unit to undefine
-    # @return (see RubyUnits::Unit.setup)
     # Undefine a unit.  Will not raise an exception for unknown units.
+    #
+    # @param unit [String] name of unit to undefine
+    # @return (see RubyUnits::Unit.setup)
     def self.undefine!(unit)
       @@definitions.delete("<#{unit}>")
-      RubyUnits::Unit.setup
+      setup
     end
 
     # @return [Hash]
@@ -226,7 +241,7 @@ module RubyUnits
     def self.clear_cache
       @@cached_units    = {}
       @@base_unit_cache = {}
-      RubyUnits::Unit.new(1)
+      new(1)
       true
     end
 
@@ -241,104 +256,74 @@ module RubyUnits
     # @return [Unit]
     def self.parse(input)
       first, second = input.scan(/(.+)\s(?:in|to|as)\s(.+)/i).first
-      second.nil? ? RubyUnits::Unit.new(first) : RubyUnits::Unit.new(first).convert_to(second)
+      second.nil? ? new(first) : new(first).convert_to(second)
     end
 
-    # @param [Numeric] q quantity
-    # @param [Array] n numerator
-    # @param [Array] d denominator
+    # @param q [Numeric] quantity
+    # @param n [Array] numerator
+    # @param d [Array] denominator
     # @return [Hash]
     def self.eliminate_terms(q, n, d)
       num = n.dup
       den = d.dup
+      num.delete(UNITY)
+      den.delete(UNITY)
 
-      num.delete_if { |v| v == UNITY }
-      den.delete_if { |v| v == UNITY }
       combined = Hash.new(0)
 
-      i = 0
-      loop do
-        break if i > num.size
-        if @@prefix_values.key? num[i]
-          k = [num[i], num[i + 1]]
-          i += 2
-        else
-          k = num[i]
-          i += 1
-        end
-        combined[k] += 1 unless k.nil? || k == UNITY
-      end
-
-      j = 0
-      loop do
-        break if j > den.size
-        if @@prefix_values.key? den[j]
-          k = [den[j], den[j + 1]]
-          j += 2
-        else
-          k = den[j]
-          j += 1
-        end
-        combined[k] -= 1 unless k.nil? || k == UNITY
+      [[num, 1], [den, -1]].each do |array, increment|
+        array.chunk_while { |elt_before, _| definition(elt_before).prefix? }
+             .to_a
+             .each { |unit| combined[unit] += increment }
       end
 
       num = []
       den = []
       combined.each do |key, value|
-        if value >= 0
+        if value.positive?
           value.times { num << key }
-        elsif value < 0
+        elsif value.negative?
           value.abs.times { den << key }
         end
       end
       num = UNITY_ARRAY if num.empty?
       den = UNITY_ARRAY if den.empty?
-      { scalar: q, numerator: num.flatten.compact, denominator: den.flatten.compact }
+      { scalar: q, numerator: num.flatten, denominator: den.flatten }
+    end
+
+    # Creates a new unit from the current one with all common terms eliminated.
+    #
+    # @return [RubyUnits::Unit]
+    def eliminate_terms
+      self.class.new(self.class.eliminate_terms(@scalar, @numerator, @denominator))
     end
 
     # return an array of base units
     # @return [Array]
     def self.base_units
-      @@base_units ||= @@definitions.dup.delete_if { |_, defn| !defn.base? }.keys.map { |u| RubyUnits::Unit.new(u) }
+      @@base_units ||= @@definitions.dup.delete_if { |_, defn| !defn.base? }.keys.map { |u| new(u) }
     end
 
     # parse a string consisting of a number and a unit string
     # NOTE: This does not properly handle units formatted like '12mg/6ml'
     # @param [String] string
-    # @return [Array] consisting of [Numeric, "unit"]
+    # @return [Array(Numeric, String)] consisting of [number, "unit"]
     def self.parse_into_numbers_and_units(string)
-      # scientific notation.... 123.234E22, -123.456e-10
-      sci       = /[+-]?\d*[.]?\d+(?:[Ee][+-]?)?\d*/
-      # rational numbers.... -1/3, 1/5, 20/100, -6 1/2, -6-1/2
-      rational  = %r{\(?[+-]?(?:\d+[ -])?\d+\/\d+\)?}
-      # complex numbers... -1.2+3i, +1.2-3.3i
-      complex   = /#{sci}{2,2}i/
-      anynumber = /(?:(#{complex}|#{rational}|#{sci}))?\s?([^-\d\.].*)?/
-
-      num, unit = string.scan(anynumber).first
+      num, unit = string.scan(ANY_NUMBER_REGEX).first
 
       [
         case num
-        when NilClass
+        when nil # This happens when no number is passed and we are parsing a pure unit string
           1
-        when complex
-          if num.respond_to?(:to_c)
-            num.to_c
-          else
-            #:nocov_19:
-            Complex(*num.scan(/(#{sci})(#{sci})i/).flatten.map(&:to_i))
-            #:nocov_19:
-          end
-        when rational
-          # if it has whitespace, it will be of the form '6 1/2'
-          if num =~ RATIONAL_NUMBER
-            sign = Regexp.last_match(1) == '-' ? -1 : 1
-            n = Regexp.last_match(2).to_i
-            f = Rational(Regexp.last_match(3).to_i, Regexp.last_match(4).to_i)
-            sign * (n + f)
-          else
-            Rational(*num.split('/').map(&:to_i))
-          end
+        when COMPLEX_NUMBER
+          num.to_c
+        when RATIONAL_NUMBER
+          # We use this method instead of relying on `to_r` because it does not
+          # handle improper fractions correctly.
+          sign = Regexp.last_match(1) == '-' ? -1 : 1
+          n = Regexp.last_match(2).to_i
+          f = Rational(Regexp.last_match(3).to_i, Regexp.last_match(4).to_i)
+          sign * (n + f)
         else
           num.to_f
         end,
@@ -356,7 +341,7 @@ module RubyUnits
     # return a regex used to match units
     # @return [RegExp]
     def self.unit_match_regex
-      @@unit_match_regex ||= /(#{RubyUnits::Unit.prefix_regex})??(#{RubyUnits::Unit.unit_regex})\b/
+      @@unit_match_regex ||= /(#{prefix_regex})??(#{unit_regex})\b/
     end
 
     # return a regexp fragment used to match prefixes
@@ -366,11 +351,14 @@ module RubyUnits
       @@prefix_regex ||= @@prefix_map.keys.sort_by { |prefix| [prefix.length, prefix] }.reverse.join('|')
     end
 
+    # Generates (and memoizes) a regexp matching any of the temperature units or their aliases.
+    #
+    # @return [RegExp]
     def self.temp_regex
       @@temp_regex ||= begin
         temp_units = %w[tempK tempC tempF tempR degK degC degF degR]
         aliases = temp_units.map do |unit|
-          d = RubyUnits::Unit.definition(unit)
+          d = definition(unit)
           d && d.aliases
         end.flatten.compact
         regex_str = aliases.empty? ? '(?!x)x' : aliases.join('|')
@@ -379,6 +367,8 @@ module RubyUnits
     end
 
     # inject a definition into the internal array and set it up for use
+    #
+    # @param definition [RubyUnits::Unit::Definition]
     def self.use_definition(definition)
       @@unit_match_regex = nil # invalidate the unit match regex
       @@temp_regex       = nil # invalidate the temp regex
@@ -470,6 +460,7 @@ module RubyUnits
       @signature   = nil
       @output      = {}
       raise ArgumentError, 'Invalid Unit Format' if options[0].nil?
+
       if options.size == 2
         # options[0] is the scalar
         # options[1] is a unit string
@@ -529,16 +520,17 @@ module RubyUnits
       end
       update_base_scalar
       raise ArgumentError, 'Temperatures must not be less than absolute zero' if temperature? && base_scalar < 0
+
       unary_unit = units || ''
       if options.first.instance_of?(String)
-        _opt_scalar, opt_units = RubyUnits::Unit.parse_into_numbers_and_units(options[0])
+        _opt_scalar, opt_units = self.class.parse_into_numbers_and_units(options[0])
         unless  @@cached_units.keys.include?(opt_units) ||
-                (opt_units =~ %r{\D/[\d+\.]+}) ||
-                (opt_units =~ %r{(#{RubyUnits::Unit.temp_regex})|(#{STONE_LB_UNIT_REGEX})|(#{LBS_OZ_UNIT_REGEX})|(#{FEET_INCH_UNITS_REGEX})|%|(#{TIME_REGEX})|i\s?(.+)?|&plusmn;|\+\/-})
+                (opt_units =~ %r{\D/[\d+.]+}) ||
+                (opt_units =~ %r{(#{self.class.temp_regex})|(#{STONE_LB_UNIT_REGEX})|(#{LBS_OZ_UNIT_REGEX})|(#{FEET_INCH_UNITS_REGEX})|%|(#{TIME_REGEX})|i\s?(.+)?|&plusmn;|\+\/-})
           @@cached_units[opt_units] = (scalar == 1 ? self : opt_units.to_unit) if opt_units && !opt_units.empty?
         end
       end
-      unless @@cached_units.keys.include?(unary_unit) || (unary_unit =~ /#{RubyUnits::Unit.temp_regex}/)
+      unless @@cached_units.keys.include?(unary_unit) || (unary_unit =~ /#{self.class.temp_regex}/)
         @@cached_units[unary_unit] = (scalar == 1 ? self : unary_unit.to_unit)
       end
       [@scalar, @numerator, @denominator, @base_scalar, @signature, @base].each(&:freeze)
@@ -566,7 +558,7 @@ module RubyUnits
       @base = (@numerator + @denominator)
               .compact
               .uniq
-              .map { |unit| RubyUnits::Unit.definition(unit) }
+              .map { |unit| self.class.definition(unit) }
               .all? { |element| element.unity? || element.base? }
       @base
     end
@@ -621,7 +613,7 @@ module RubyUnits
       num = num.flatten.compact
       den = den.flatten.compact
       num = UNITY_ARRAY if num.empty?
-      base = RubyUnits::Unit.new(RubyUnits::Unit.eliminate_terms(q, num, den))
+      base = self.class.new(self.class.eliminate_terms(q, num, den))
       @@base_unit_cache[units] = base
       base * @scalar
     end
@@ -842,12 +834,12 @@ module RubyUnits
           raise ArgumentError, 'Cannot add two temperatures' if [self, other].all?(&:temperature?)
           if [self, other].any?(&:temperature?)
             if temperature?
-              RubyUnits::Unit.new(scalar: (scalar + other.convert_to(temperature_scale).scalar), numerator: @numerator, denominator: @denominator, signature: @signature)
+              self.class.new(scalar: (scalar + other.convert_to(temperature_scale).scalar), numerator: @numerator, denominator: @denominator, signature: @signature)
             else
-              RubyUnits::Unit.new(scalar: (other.scalar + convert_to(other.temperature_scale).scalar), numerator: other.numerator, denominator: other.denominator, signature: other.signature)
+              self.class.new(scalar: (other.scalar + convert_to(other.temperature_scale).scalar), numerator: other.numerator, denominator: other.denominator, signature: other.signature)
             end
           else
-            RubyUnits::Unit.new(scalar: (base_scalar + other.base_scalar), numerator: base.numerator, denominator: base.denominator, signature: @signature).to(units)
+            self.class.new(scalar: (base_scalar + other.base_scalar), numerator: base.numerator, denominator: base.denominator, signature: @signature).convert_to(self)
           end
         else
           raise ArgumentError, "Incompatible Units ('#{self}' not compatible with '#{other}')"
@@ -877,13 +869,13 @@ module RubyUnits
           end
         elsif self =~ other
           if [self, other].all?(&:temperature?)
-            RubyUnits::Unit.new(scalar: (base_scalar - other.base_scalar), numerator: KELVIN, denominator: UNITY_ARRAY, signature: @signature).convert_to(temperature_scale)
+            self.class.new(scalar: (base_scalar - other.base_scalar), numerator: KELVIN, denominator: UNITY_ARRAY, signature: @signature).convert_to(temperature_scale)
           elsif temperature?
-            RubyUnits::Unit.new(scalar: (base_scalar - other.base_scalar), numerator: ['<tempK>'], denominator: UNITY_ARRAY, signature: @signature).convert_to(self)
+            self.class.new(scalar: (base_scalar - other.base_scalar), numerator: ['<tempK>'], denominator: UNITY_ARRAY, signature: @signature).convert_to(self)
           elsif other.temperature?
             raise ArgumentError, 'Cannot subtract a temperature from a differential degree unit'
           else
-            RubyUnits::Unit.new(scalar: (base_scalar - other.base_scalar), numerator: base.numerator, denominator: base.denominator, signature: @signature).to(units)
+            self.class.new(scalar: (base_scalar - other.base_scalar), numerator: base.numerator, denominator: base.denominator, signature: @signature).convert_to(self)
           end
         else
           raise ArgumentError, "Incompatible Units ('#{self}' not compatible with '#{other}')"
@@ -904,11 +896,11 @@ module RubyUnits
       case other
       when Unit
         raise ArgumentError, 'Cannot multiply by temperatures' if [other, self].any?(&:temperature?)
-        opts = RubyUnits::Unit.eliminate_terms(@scalar * other.scalar, @numerator + other.numerator, @denominator + other.denominator)
+        opts = self.class.eliminate_terms(@scalar * other.scalar, @numerator + other.numerator, @denominator + other.denominator)
         opts[:signature] = @signature + other.signature
-        RubyUnits::Unit.new(opts)
+        self.class.new(opts)
       when Numeric
-        RubyUnits::Unit.new(scalar: @scalar * other, numerator: @numerator, denominator: @denominator, signature: @signature)
+        self.class.new(scalar: @scalar * other, numerator: @numerator, denominator: @denominator, signature: @signature)
       else
         x, y = coerce(other)
         x * y
@@ -928,14 +920,14 @@ module RubyUnits
         raise ArgumentError, 'Cannot divide with temperatures' if [other, self].any?(&:temperature?)
         sc = Rational(@scalar, other.scalar)
         sc = sc.numerator if sc.denominator == 1
-        opts = RubyUnits::Unit.eliminate_terms(sc, @numerator + other.denominator, @denominator + other.numerator)
+        opts = self.class.eliminate_terms(sc, @numerator + other.denominator, @denominator + other.numerator)
         opts[:signature] = @signature - other.signature
-        RubyUnits::Unit.new(opts)
+        self.class.new(opts)
       when Numeric
         raise ZeroDivisionError if other.zero?
         sc = Rational(@scalar, other)
         sc = sc.numerator if sc.denominator == 1
-        RubyUnits::Unit.new(scalar: sc, numerator: @numerator, denominator: @denominator, signature: @signature)
+        self.class.new(scalar: sc, numerator: @numerator, denominator: @denominator, signature: @signature)
       else
         x, y = coerce(other)
         y / x
@@ -1044,13 +1036,13 @@ module RubyUnits
         r = ((x / n) * (n - 1)).to_int
         r.times { den.delete_at(den.index(item)) }
       end
-      RubyUnits::Unit.new(scalar: @scalar**Rational(1, n), numerator: num, denominator: den)
+      self.class.new(scalar: @scalar**Rational(1, n), numerator: num, denominator: den)
     end
 
     # returns inverse of Unit (1/unit)
     # @return [Unit]
     def inverse
-      RubyUnits::Unit.new('1') / self
+      self.class.new('1') / self
     end
 
     # convert to a specified unit string or to the same units as another Unit
@@ -1061,13 +1053,17 @@ module RubyUnits
     # To convert a Unit object to match another Unit object, use:
     #  unit1 >>= unit2
     #
-    # Special handling for temperature conversions is supported.  If the Unit object is converted
-    # from one temperature unit to another, the proper temperature offsets will be used.
-    # Supports Kelvin, Celsius, Fahrenheit, and Rankine scales.
+    # Special handling for temperature conversions is supported.  If the Unit
+    # object is converted from one temperature unit to another, the proper
+    # temperature offsets will be used. Supports Kelvin, Celsius, Fahrenheit,
+    # and Rankine scales.
     #
-    # @note If temperature is part of a compound unit, the temperature will be treated as a differential
-    #   and the units will be scaled appropriately.
-    # @param [Object] other
+    # @note If temperature is part of a compound unit, the temperature will be
+    #   treated as a differential and the units will be scaled appropriately.
+    # @note When converting units with Integer scalars, the scalar will be
+    #   converted to a Rational to avoid unexpected behavior caused by Integer
+    #   division.
+    # @param other [Unit, String]
     # @return [Unit]
     # @raise [ArgumentError] when attempting to convert a degree to a temperature
     # @raise [ArgumentError] when target unit is unknown
@@ -1076,14 +1072,23 @@ module RubyUnits
       return self if other.nil?
       return self if TrueClass === other
       return self if FalseClass === other
-      if (Unit === other && other.temperature?) || (String === other && other =~ /temp[CFRK]/)
+
+      if (other.is_a?(Unit) && other.temperature?) || (other.is_a?(String) && other =~ self.class.temp_regex)
         raise ArgumentError, 'Receiver is not a temperature unit' unless degree?
+
         start_unit = units
-        target_unit = begin
+        # @type [String]
+        target_unit = case other
+                      when Unit
                         other.units
-                      rescue
+                      when String
                         other
+                      else
+                        raise ArgumentError, 'Unknown target units'
                       end
+        return self if target_unit == start_unit
+
+        # @type [Numeric]
         @base_scalar ||= case @@unit_map[start_unit]
                          when '<tempC>'
                            @scalar + 273.15
@@ -1094,36 +1099,48 @@ module RubyUnits
                          when '<tempR>'
                            @scalar.to_r * Rational(5, 9)
                          end
+        # @type [Numeric]
         q = case @@unit_map[target_unit]
             when '<tempC>'
-              @base_scalar - 273.15r
+              @base_scalar - 273.15
             when '<tempK>'
               @base_scalar
             when '<tempF>'
-              @base_scalar.to_r * Rational(9, 5) - 459.67r
+              (@base_scalar.to_r * Rational(9, 5)) - 459.67r
             when '<tempR>'
               @base_scalar.to_r * Rational(9, 5)
             end
-        return RubyUnits::Unit.new("#{q} #{target_unit}")
+        return self.class.new("#{q} #{target_unit}")
       else
-        case other
-        when Unit
-          return self if other.units == units
-          target = other
-        when String
-          target = RubyUnits::Unit.new(other)
-        else
-          raise ArgumentError, 'Unknown target units'
-        end
+        # @type [Unit]
+        target = case other
+                 when Unit
+                   other
+                 when String
+                   self.class.new(other)
+                 else
+                   raise ArgumentError, 'Unknown target units'
+                 end
+        return self if target.units == units
+
         raise ArgumentError, "Incompatible Units ('#{self}' not compatible with '#{other}')" unless self =~ target
-        numerator1   = @numerator.map { |x| @@prefix_values[x] ? @@prefix_values[x] : x }.map { |i| i.is_a?(Numeric) ? i : @@unit_values[i][:scalar] }.compact
-        denominator1 = @denominator.map { |x| @@prefix_values[x] ? @@prefix_values[x] : x }.map { |i| i.is_a?(Numeric) ? i : @@unit_values[i][:scalar] }.compact
-        numerator2   = target.numerator.map { |x| @@prefix_values[x] ? @@prefix_values[x] : x }.map { |x| x.is_a?(Numeric) ? x : @@unit_values[x][:scalar] }.compact
-        denominator2 = target.denominator.map { |x| @@prefix_values[x] ? @@prefix_values[x] : x }.map { |x| x.is_a?(Numeric) ? x : @@unit_values[x][:scalar] }.compact
-
-        q = @scalar * ((numerator1 + denominator2).inject(1) { |acc, elem| acc * elem }) /
-            ((numerator2 + denominator1).inject(1) { |acc, elem| acc * elem })
-        return RubyUnits::Unit.new(scalar: q, numerator: target.numerator, denominator: target.denominator, signature: target.signature)
+
+        numerator1   = @numerator.map { |x| @@prefix_values[x] || x }.map { |i| i.is_a?(Numeric) ? i : @@unit_values[i][:scalar] }.compact
+        denominator1 = @denominator.map { |x| @@prefix_values[x] || x }.map { |i| i.is_a?(Numeric) ? i : @@unit_values[i][:scalar] }.compact
+        numerator2   = target.numerator.map { |x| @@prefix_values[x] || x }.map { |x| x.is_a?(Numeric) ? x : @@unit_values[x][:scalar] }.compact
+        denominator2 = target.denominator.map { |x| @@prefix_values[x] || x }.map { |x| x.is_a?(Numeric) ? x : @@unit_values[x][:scalar] }.compact
+
+        # If the scalar is an Integer, convert it to a Rational number so that
+        # if the value is scaled during conversion, resolution is not lost due
+        # to integer math
+        # @type [Rational, Numeric]
+        conversion_scalar = @scalar.is_a?(Integer) ? @scalar.to_r : @scalar
+        q = conversion_scalar * (numerator1 + denominator2).reduce(1, :*) / (numerator2 + denominator1).reduce(1, :*)
+        # Convert the scalar to an Integer if the result is equivalent to an
+        # integer
+
+        q = q.to_i if @scalar.is_a?(Integer) && q.to_i == q
+        self.class.new(scalar: q, numerator: target.numerator, denominator: target.denominator, signature: target.signature)
       end
     end
 
@@ -1170,52 +1187,29 @@ module RubyUnits
       to_s
     end
 
-    # returns the 'unit' part of the Unit object without the scalar
+    # Returns the 'unit' part of the Unit object without the scalar
+    #
+    # @param with_prefix [Boolean] include prefixes in output
     # @return [String]
     def units(with_prefix: true)
       return '' if @numerator == UNITY_ARRAY && @denominator == UNITY_ARRAY
+
       output_numerator   = ['1']
       output_denominator = []
       num                = @numerator.clone.compact
       den                = @denominator.clone.compact
 
       unless num == UNITY_ARRAY
-        definitions = num.map { |element| RubyUnits::Unit.definition(element) }
+        definitions = num.map { |element| self.class.definition(element) }
         definitions.reject!(&:prefix?) unless with_prefix
-        # there is a bug in jruby 9.1.6.0's implementation of chunk_while
-        # see https://github.com/jruby/jruby/issues/4410
-        # TODO: fix this after jruby fixes their bug.
-        definitions = if definitions.respond_to?(:chunk_while) && RUBY_ENGINE != 'jruby'
-                        definitions.chunk_while { |defn, _| defn.prefix? }.to_a
-                      else # chunk_while is new to ruby 2.3+, so fallback to less efficient methods for older ruby
-                        result = []
-                        enumerator = definitions.to_enum
-                        loop do
-                          first = enumerator.next
-                          result << (first.prefix? ? [first, enumerator.next] : [first])
-                        end
-                        result
-                      end
+        definitions = definitions.chunk_while { |defn, _| defn.prefix? }.to_a
         output_numerator = definitions.map { |element| element.map(&:display_name).join }
       end
 
       unless den == UNITY_ARRAY
-        definitions = den.map { |element| RubyUnits::Unit.definition(element) }
+        definitions = den.map { |element| self.class.definition(element) }
         definitions.reject!(&:prefix?) unless with_prefix
-        # there is a bug in jruby 9.1.6.0's implementation of chunk_while
-        # see https://github.com/jruby/jruby/issues/4410
-        # TODO: fix this after jruby fixes their bug.
-        definitions = if definitions.respond_to?(:chunk_while) && RUBY_ENGINE != 'jruby'
-                        definitions.chunk_while { |defn, _| defn.prefix? }.to_a
-                      else # chunk_while is new to ruby 2.3+, so fallback to less efficient methods for older ruby
-                        result = []
-                        enumerator = definitions.to_enum
-                        loop do
-                          first = enumerator.next
-                          result << (first.prefix? ? [first, enumerator.next] : [first])
-                        end
-                        result
-                      end
+        definitions = definitions.chunk_while { |defn, _| defn.prefix? }.to_a
         output_denominator = definitions.map { |element| element.map(&:display_name).join }
       end
 
@@ -1227,7 +1221,7 @@ module RubyUnits
             .uniq
             .map { |x| [x, output_denominator.count(x)] }
             .map { |element, power| (element.to_s.strip + (power > 1 ? "^#{power}" : '')) }
-      "#{on.join('*')}#{od.empty? ? '' : '/' + od.join('*')}".strip
+      "#{on.join('*')}#{od.empty? ? '' : "/#{od.join('*')}"}".strip
     end
 
     # negates the scalar of the Unit
@@ -1241,32 +1235,45 @@ module RubyUnits
     # @return [Numeric,Unit]
     def abs
       return @scalar.abs if unitless?
-      RubyUnits::Unit.new(@scalar.abs, @numerator, @denominator)
+      self.class.new(@scalar.abs, @numerator, @denominator)
     end
 
     # ceil of a unit
     # @return [Numeric,Unit]
-    def ceil
-      return @scalar.ceil if unitless?
-      RubyUnits::Unit.new(@scalar.ceil, @numerator, @denominator)
+    def ceil(*args)
+      return @scalar.ceil(*args) if unitless?
+
+      self.class.new(@scalar.ceil(*args), @numerator, @denominator)
     end
 
     # @return [Numeric,Unit]
-    def floor
-      return @scalar.floor if unitless?
-      RubyUnits::Unit.new(@scalar.floor, @numerator, @denominator)
+    def floor(*args)
+      return @scalar.floor(*args) if unitless?
+
+      self.class.new(@scalar.floor(*args), @numerator, @denominator)
     end
 
+    # Round the unit according to the rules of the scalar's class. Call this
+    # with the arguments appropriate for the scalar's class (e.g., Integer,
+    # Rational, etc..). Because unit conversions can often result in Rational
+    # scalars (to preserve precision), it may be advisable to use +to_s+ to
+    # format output instead of using +round+.
+    # @example
+    #   RubyUnits::Unit.new('21870 mm/min').convert_to('m/min').round(1) #=> 2187/100 m/min
+    #   RubyUnits::Unit.new('21870 mm/min').convert_to('m/min').to_s('%0.1f') #=> 21.9 m/min
+    #
     # @return [Numeric,Unit]
-    def round(ndigits = 0)
-      return @scalar.round(ndigits) if unitless?
-      RubyUnits::Unit.new(@scalar.round(ndigits), @numerator, @denominator)
+    def round(*args, **kwargs)
+      return @scalar.round(*args, **kwargs) if unitless?
+
+      self.class.new(@scalar.round(*args, **kwargs), @numerator, @denominator)
     end
 
     # @return [Numeric, Unit]
-    def truncate
-      return @scalar.truncate if unitless?
-      RubyUnits::Unit.new(@scalar.truncate, @numerator, @denominator)
+    def truncate(*args)
+      return @scalar.truncate(*args) if unitless?
+
+      self.class.new(@scalar.truncate(*args), @numerator, @denominator)
     end
 
     # returns next unit in a range.  '1 mm'.to_unit.succ #=> '2 mm'.to_unit
@@ -1275,7 +1282,7 @@ module RubyUnits
     # @raise [ArgumentError] when scalar is not equal to an integer
     def succ
       raise ArgumentError, 'Non Integer Scalar' unless @scalar == @scalar.to_i
-      RubyUnits::Unit.new(@scalar.to_i.succ, @numerator, @denominator)
+      self.class.new(@scalar.to_i.succ, @numerator, @denominator)
     end
 
     alias next succ
@@ -1286,7 +1293,7 @@ module RubyUnits
     # @raise [ArgumentError] when scalar is not equal to an integer
     def pred
       raise ArgumentError, 'Non Integer Scalar' unless @scalar == @scalar.to_i
-      RubyUnits::Unit.new(@scalar.to_i.pred, @numerator, @denominator)
+      self.class.new(@scalar.to_i.pred, @numerator, @denominator)
     end
 
     # Tries to make a Time object from current unit.  Assumes the current unit hold the duration in seconds from the epoch.
@@ -1389,7 +1396,7 @@ module RubyUnits
 
     # automatically coerce objects to units when possible
     # if an object defines a 'to_unit' method, it will be coerced using that method
-    # @param [Object, #to_unit]
+    # @param other [Object, #to_unit]
     # @return [Array]
     def coerce(other)
       return [other.to_unit, self] if other.respond_to? :to_unit
@@ -1397,7 +1404,7 @@ module RubyUnits
       when Unit
         [other, self]
       else
-        [RubyUnits::Unit.new(other), self]
+        [self.class.new(other), self]
       end
     end
 
@@ -1409,7 +1416,7 @@ module RubyUnits
                     else
                       @@prefix_values.key(10**((Math.log10(base_scalar) / 3.0).floor * 3))
                     end
-      to(RubyUnits::Unit.new(@@prefix_map.key(best_prefix) + units(with_prefix: false)))
+      to(self.class.new(@@prefix_map.key(best_prefix) + units(with_prefix: false)))
     end
 
     # override hash method so objects with same values are considered equal
@@ -1449,11 +1456,11 @@ module RubyUnits
       vector = Array.new(SIGNATURE_VECTOR.size, 0)
       # it's possible to have a kind that misses the array... kinds like :counting
       # are more like prefixes, so don't use them to calculate the vector
-      @numerator.map { |element| RubyUnits::Unit.definition(element) }.each do |definition|
+      @numerator.map { |element| self.class.definition(element) }.each do |definition|
         index = SIGNATURE_VECTOR.index(definition.kind)
         vector[index] += 1 if index
       end
-      @denominator.map { |element| RubyUnits::Unit.definition(element) }.each do |definition|
+      @denominator.map { |element| self.class.definition(element) }.each do |definition|
         index = SIGNATURE_VECTOR.index(definition.kind)
         vector[index] -= 1 if index
       end
@@ -1507,7 +1514,7 @@ module RubyUnits
 
       if defined?(Complex) && unit_string =~ COMPLEX_NUMBER
         real, imaginary, unit_s = unit_string.scan(COMPLEX_REGEX)[0]
-        result                  = RubyUnits::Unit.new(unit_s || '1') * Complex(real.to_f, imaginary.to_f)
+        result                  = self.class.new(unit_s || '1') * Complex(real.to_f, imaginary.to_f)
         copy(result)
         return
       end
@@ -1516,7 +1523,7 @@ module RubyUnits
         sign, proper, numerator, denominator, unit_s = unit_string.scan(RATIONAL_REGEX)[0]
         sign = sign == '-' ? -1 : 1
         rational = sign * (proper.to_i + Rational(numerator.to_i, denominator.to_i))
-        result = RubyUnits::Unit.new(unit_s || '1') * rational
+        result = self.class.new(unit_s || '1') * rational
         copy(result)
         return
       end
@@ -1542,13 +1549,14 @@ module RubyUnits
       # ... and then strip the remaining brackets for x*y*z
       unit_string.gsub!(/[<>]/, '')
 
-      if unit_string =~ /:/
+      if unit_string =~ TIME_REGEX
         hours, minutes, seconds, microseconds = unit_string.scan(TIME_REGEX)[0]
-        raise ArgumentError, 'Invalid Duration' if [hours, minutes, seconds, microseconds].all?(&:nil?)
-        result = RubyUnits::Unit.new("#{hours || 0} h") +
-                 RubyUnits::Unit.new("#{minutes || 0} minutes") +
-                 RubyUnits::Unit.new("#{seconds || 0} seconds") +
-                 RubyUnits::Unit.new("#{microseconds || 0} usec")
+        raise ArgumentError,'Invalid Duration' if [hours, minutes, seconds, microseconds].all?(&:nil?)
+
+        result = self.class.new("#{hours || 0} h") +
+                 self.class.new("#{minutes || 0} minutes") +
+                 self.class.new("#{seconds || 0} seconds") +
+                 self.class.new("#{microseconds || 0} usec")
         copy(result)
         return
       end
@@ -1557,7 +1565,7 @@ module RubyUnits
       # feet -- 6'5"
       feet, inches = unit_string.scan(FEET_INCH_REGEX)[0]
       if feet && inches
-        result = RubyUnits::Unit.new("#{feet} ft") + RubyUnits::Unit.new("#{inches} inches")
+        result = self.class.new("#{feet} ft") + self.class.new("#{inches} inches")
         copy(result)
         return
       end
@@ -1565,7 +1573,7 @@ module RubyUnits
       # weight -- 8 lbs 12 oz
       pounds, oz = unit_string.scan(LBS_OZ_REGEX)[0]
       if pounds && oz
-        result = RubyUnits::Unit.new("#{pounds} lbs") + RubyUnits::Unit.new("#{oz} oz")
+        result = self.class.new("#{pounds} lbs") + self.class.new("#{oz} oz")
         copy(result)
         return
       end
@@ -1573,7 +1581,7 @@ module RubyUnits
       # stone -- 3 stone 5, 2 stone, 14 stone 3 pounds, etc.
       stone, pounds = unit_string.scan(STONE_LB_REGEX)[0]
       if stone && pounds
-        result = RubyUnits::Unit.new("#{stone} stone") + RubyUnits::Unit.new("#{pounds} lbs")
+        result = self.class.new("#{stone} stone") + self.class.new("#{pounds} lbs")
         copy(result)
         return
       end
@@ -1581,6 +1589,7 @@ module RubyUnits
       # more than one per.  I.e., "1 m/s/s"
       raise(ArgumentError, "'#{passed_unit_string}' Unit not recognized") if unit_string.count('/') > 1
       raise(ArgumentError, "'#{passed_unit_string}' Unit not recognized") if unit_string =~ /\s[02-9]/
+
       @scalar, top, bottom = unit_string.scan(UNIT_STRING_REGEX)[0] # parse the string into parts
       top.scan(TOP_REGEX).each do |item|
         n = item[1].to_i
@@ -1613,12 +1622,12 @@ module RubyUnits
 
       @numerator   ||= UNITY_ARRAY
       @denominator ||= UNITY_ARRAY
-      @numerator = top.scan(RubyUnits::Unit.unit_match_regex).delete_if(&:empty?).compact if top
-      @denominator = bottom.scan(RubyUnits::Unit.unit_match_regex).delete_if(&:empty?).compact if bottom
+      @numerator = top.scan(self.class.unit_match_regex).delete_if(&:empty?).compact if top
+      @denominator = bottom.scan(self.class.unit_match_regex).delete_if(&:empty?).compact if bottom
 
       # eliminate all known terms from this string.  This is a quick check to see if the passed unit
       # contains terms that are not defined.
-      used = "#{top} #{bottom}".to_s.gsub(RubyUnits::Unit.unit_match_regex, '').gsub(%r{[\d\*, "'_^\/\$]}, '')
+      used = "#{top} #{bottom}".to_s.gsub(self.class.unit_match_regex, '').gsub(%r{[\d\*, "'_^\/\$]}, '')
       raise(ArgumentError, "'#{passed_unit_string}' Unit not recognized") unless used.empty?
 
       @numerator = @numerator.map do |item|