ruby-units 2.3.2 → 3.0.0

data/lib/ruby_units/unit.rb

@@ -1,27 +1,27 @@
 require 'date'
-# Copyright 2006-2015
-# @author Kevin C. Olbrich, Ph.D.
-# @see https://github.com/olbrich/ruby-units
-#
-# @note The accuracy of unit conversions depends on the precision of the conversion factor.
-#   If you have more accurate estimates for particular conversion factors, please send them
-#   to me and I will incorporate them into the next release.  It is also incumbent on the end-user
-#   to ensure that the accuracy of any conversions is sufficient for their intended application.
-#
-# While there are a large number of unit specified in the base package,
-# there are also a large number of units that are not included.
-# This package covers nearly all SI, Imperial, and units commonly used
-# in the United States. If your favorite units are not listed here, file an issue on github.
-#
-# To add or override a unit definition, add a code block like this..
-# @example Define a new unit
-#  RubyUnits::Unit.define("foobar") do |unit|
-#    unit.aliases    = %w{foo fb foo-bar}
-#    unit.definition = RubyUnits::Unit.new("1 baz")
-#  end
-#
 module RubyUnits
-  class Unit < Numeric
+  # Copyright 2006-2022
+  # @author Kevin C. Olbrich, Ph.D.
+  # @see https://github.com/olbrich/ruby-units
+  #
+  # @note The accuracy of unit conversions depends on the precision of the conversion factor.
+  #   If you have more accurate estimates for particular conversion factors, please send them
+  #   to me and I will incorporate them into the next release.  It is also incumbent on the end-user
+  #   to ensure that the accuracy of any conversions is sufficient for their intended application.
+  #
+  # While there are a large number of unit specified in the base package,
+  # there are also a large number of units that are not included.
+  # This package covers nearly all SI, Imperial, and units commonly used
+  # in the United States. If your favorite units are not listed here, file an issue on GitHub.
+  #
+  # To add or override a unit definition, add a code block like this..
+  # @example Define a new unit
+  #  RubyUnits::Unit.define("foobar") do |unit|
+  #    unit.aliases    = %w{foo fb foo-bar}
+  #    unit.definition = RubyUnits::Unit.new("1 baz")
+  #  end
+  #
+  class Unit < ::Numeric
     @@definitions      = {}
     @@prefix_values    = {}
     @@prefix_map       = {}
@@ -31,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
@@ -73,62 +84,60 @@ module RubyUnits
       angle
     ].freeze
     @@kinds = {
-      -312_078     => :elastance,
-      -312_058     => :resistance,
-      -312_038     => :inductance,
-      -152_040     => :magnetism,
-      -152_038     => :magnetism,
-      -152_058     => :potential,
-      -7997        => :specific_volume,
-      -79          => :snap,
-      -59          => :jolt,
-      -39          => :acceleration,
-      -38          => :radiation,
-      -20          => :frequency,
-      -19          => :speed,
-      -18          => :viscosity,
-      -17          => :volumetric_flow,
-      -1           => :wavenumber,
-      0            => :unitless,
-      1            => :length,
-      2            => :area,
-      3            => :volume,
-      20           => :time,
-      400          => :temperature,
-      7941         => :yank,
-      7942         => :power,
-      7959         => :pressure,
-      7962         => :energy,
-      7979         => :viscosity,
-      7961         => :force,
-      7981         => :momentum,
-      7982         => :angular_momentum,
-      7997         => :density,
-      7998         => :area_density,
-      8000         => :mass,
-      152_020      => :radiation_exposure,
-      159_999      => :magnetism,
-      160_000      => :current,
-      160_020      => :charge,
-      312_058      => :conductance,
-      312_078      => :capacitance,
-      3_199_980    => :activity,
-      3_199_997    => :molar_concentration,
-      3_200_000    => :substance,
-      63_999_998   => :illuminance,
-      64_000_000   => :luminous_power,
+      -312_078 => :elastance,
+      -312_058 => :resistance,
+      -312_038 => :inductance,
+      -152_040 => :magnetism,
+      -152_038 => :magnetism,
+      -152_058 => :potential,
+      -7997 => :specific_volume,
+      -79 => :snap,
+      -59 => :jolt,
+      -39 => :acceleration,
+      -38 => :radiation,
+      -20 => :frequency,
+      -19 => :speed,
+      -18 => :viscosity,
+      -17 => :volumetric_flow,
+      -1 => :wavenumber,
+      0 => :unitless,
+      1 => :length,
+      2 => :area,
+      3 => :volume,
+      20 => :time,
+      400 => :temperature,
+      7941 => :yank,
+      7942 => :power,
+      7959 => :pressure,
+      7962 => :energy,
+      7979 => :viscosity,
+      7961 => :force,
+      7981 => :momentum,
+      7982 => :angular_momentum,
+      7997 => :density,
+      7998 => :area_density,
+      8000 => :mass,
+      152_020 => :radiation_exposure,
+      159_999 => :magnetism,
+      160_000 => :current,
+      160_020 => :charge,
+      312_058 => :conductance,
+      312_078 => :capacitance,
+      3_199_980 => :activity,
+      3_199_997 => :molar_concentration,
+      3_200_000 => :substance,
+      63_999_998 => :illuminance,
+      64_000_000 => :luminous_power,
       1_280_000_000 => :currency,
-      25_600_000_000  => :information,
+      25_600_000_000 => :information,
       511_999_999_980 => :angular_velocity,
       512_000_000_000 => :angle
     }.freeze
-    @@cached_units     = {}
-    @@base_unit_cache  = {}
 
     # Class Methods
 
     # setup internal arrays and hashes
-    # @return [true]
+    # @return [Boolean]
     def self.setup
       clear_cache
       @@prefix_values    = {}
@@ -139,11 +148,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
 
@@ -155,7 +164,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}>"
@@ -163,13 +172,13 @@ 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  [Block] block
+    # @param  [RubyUnits::Unit::Definition, String] unit_definition
+    # @param  [Proc] block
     # @return [RubyUnits::Unit::Definition]
     # @raise  [ArgumentError] when passed a non-string if using the block form
     # Unpack a unit definition and add it to the array of defined units
@@ -184,54 +193,62 @@ module RubyUnits
     #   RubyUnits::Unit.define(unit_definition)
     def self.define(unit_definition, &block)
       if block_given?
-        raise ArgumentError, 'When using the block form of RubyUnits::Unit.define, pass the name of the unit' unless unit_definition.instance_of?(String)
+        raise ArgumentError, 'When using the block form of RubyUnits::Unit.define, pass the name of the unit' unless unit_definition.is_a?(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 [Proc] _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]
+    # Unit cache
+    #
+    # @return [RubyUnits::Cache]
     def self.cached
-      @@cached_units
+      @cached ||= RubyUnits::Cache.new
     end
 
-    # @return [true]
+    # @return [Boolean]
     def self.clear_cache
-      @@cached_units    = {}
-      @@base_unit_cache = {}
-      RubyUnits::Unit.new(1)
+      cached.clear
+      base_unit_cache.clear
+      new(1)
       true
     end
 
-    # @return [Hash]
+    # @return [RubyUnits::Cache]
     def self.base_unit_cache
-      @@base_unit_cache
+      @base_unit_cache ||= RubyUnits::Cache.new
     end
 
     # @example parse strings
@@ -240,104 +257,75 @@ 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
+      combined = ::Hash.new(0)
 
-      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.select { |_, definition| definition.base? }.keys.map { |u| new(u) }
     end
 
-    # parse a string consisting of a number and a unit string
+    # 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,
@@ -353,9 +341,9 @@ module RubyUnits
     end
 
     # return a regex used to match units
-    # @return [RegExp]
+    # @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
@@ -365,11 +353,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('|')
@@ -378,6 +369,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
@@ -425,20 +418,16 @@ module RubyUnits
     attr_accessor :unit_name
 
     # Used to copy one unit to another
-    # @param [Unit] from Unit to copy definition from
-    # @return [Unit]
+    # @param from [RubyUnits::Unit] Unit to copy definition from
+    # @return [RubyUnits::Unit]
     def copy(from)
-      @scalar      = from.scalar
-      @numerator   = from.numerator
+      @scalar = from.scalar
+      @numerator = from.numerator
       @denominator = from.denominator
       @base = from.base?
-      @signature   = from.signature
+      @signature = from.signature
       @base_scalar = from.base_scalar
-      @unit_name = begin
-                     from.unit_name
-                   rescue
-                     nil
-                   end
+      @unit_name = from.unit_name
       self
     end
 
@@ -469,29 +458,26 @@ 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
-        begin
-          cached = @@cached_units[options[1]] * options[0]
-          copy(cached)
-        rescue
-          initialize("#{options[0]} #{(begin
-                                         options[1].units
-                                       rescue
-                                         options[1]
-                                       end)}")
+        cached = self.class.cached.get(options[1])
+        if cached.nil?
+          initialize("#{options[0]} #{options[1]}")
+        else
+          copy(cached * options[0])
         end
         return
       end
       if options.size == 3
         options[1] = options[1].join if options[1].is_a?(Array)
         options[2] = options[2].join if options[2].is_a?(Array)
-        begin
-          cached = @@cached_units["#{options[1]}/#{options[2]}"] * options[0]
-          copy(cached)
-        rescue
+        cached = self.class.cached.get("#{options[1]}/#{options[2]}")
+        if cached.nil?
           initialize("#{options[0]} #{options[1]}/#{options[2]}")
+        else
+          copy(cached) * options[0]
         end
         return
       end
@@ -528,20 +514,21 @@ 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])
-        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;|\+\/-})
-          @@cached_units[opt_units] = (scalar == 1 ? self : opt_units.to_unit) if opt_units && !opt_units.empty?
+        _opt_scalar, opt_units = self.class.parse_into_numbers_and_units(options[0])
+        if !(self.class.cached.keys.include?(opt_units) ||
+                (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;|\+/-})) && (opt_units && !opt_units.empty?)
+          self.class.cached.set(opt_units, scalar == 1 ? self : opt_units.to_unit)
         end
       end
-      unless @@cached_units.keys.include?(unary_unit) || (unary_unit =~ /#{RubyUnits::Unit.temp_regex}/)
-        @@cached_units[unary_unit] = (scalar == 1 ? self : unary_unit.to_unit)
+      unless self.class.cached.keys.include?(unary_unit) || (unary_unit =~ self.class.temp_regex)
+        self.class.cached.set(unary_unit, scalar == 1 ? self : unary_unit.to_unit)
       end
       [@scalar, @numerator, @denominator, @base_scalar, @signature, @base].each(&:freeze)
-      self
+      super()
     end
 
     # @todo: figure out how to handle :counting units.  This method should probably return :counting instead of :unitless for 'each'
@@ -551,9 +538,14 @@ module RubyUnits
       @@kinds[signature]
     end
 
-    # @return [Unit]
-    def to_unit
-      self
+    # Convert the unit to a Unit, possibly performing a conversion.
+    # > The ability to pass a Unit to convert to was added in v3.0.0 for
+    # > consistency with other uses of #to_unit.
+    #
+    # @param other [RubyUnits::Unit, String] unit to convert to
+    # @return [RubyUnits::Unit]
+    def to_unit(other = nil)
+      other ? convert_to(other) : self
     end
 
     alias unit to_unit
@@ -562,10 +554,11 @@ module RubyUnits
     # @return [Boolean]
     def base?
       return @base if defined? @base
+
       @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
@@ -578,6 +571,7 @@ module RubyUnits
     # @todo this is brittle as it depends on the display_name of a unit, which can be changed
     def to_base
       return self if base?
+
       if @@unit_map[units] =~ /\A<(?:temp|deg)[CRF]>\Z/
         @signature = @@kinds.key(:temperature)
         base = if temperature?
@@ -588,12 +582,8 @@ module RubyUnits
         return base
       end
 
-      cached = (begin
-                  (@@base_unit_cache[units] * scalar)
-                rescue
-                  nil
-                end)
-      return cached if cached
+      cached_unit = self.class.base_unit_cache.get(units)
+      return cached_unit * scalar unless cached_unit.nil?
 
       num = []
       den = []
@@ -620,8 +610,8 @@ 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_unit_cache[units] = base
+      base = self.class.new(self.class.eliminate_terms(q, num, den))
+      self.class.base_unit_cache.set(units, base)
       base * @scalar
     end
 
@@ -646,6 +636,7 @@ module RubyUnits
     def to_s(target_units = nil)
       out = @output[target_units]
       return out if out
+
       separator = RubyUnits.configuration.separator
       case target_units
       when :ft
@@ -661,14 +652,14 @@ module RubyUnits
         out = case target_units.strip
               when /\A\s*\Z/ # whitespace only
                 ''
-              when /(%[\-+\.\w#]+)\s*(.+)*/ # format string like '%0.2f in'
+              when /(%[\-+.\w#]+)\s*(.+)*/ # format string like '%0.2f in'
                 begin
                   if Regexp.last_match(2) # unit specified, need to convert
                     convert_to(Regexp.last_match(2)).to_s(Regexp.last_match(1))
                   else
                     "#{Regexp.last_match(1) % @scalar}#{separator}#{Regexp.last_match(2) || units}".strip
                   end
-                rescue # parse it like a strftime format string
+                rescue StandardError # parse it like a strftime format string
                   (DateTime.new(0) + self).strftime(target_units)
                 end
               when /(\S+)/ # unit only 'mm' or '1/mm'
@@ -695,6 +686,7 @@ module RubyUnits
     # @return [String]
     def inspect(dump = nil)
       return super() if dump
+
       to_s
     end
 
@@ -702,7 +694,7 @@ module RubyUnits
     # @return [Boolean]
     # @todo use unit definition to determine if it's a temperature instead of a regex
     def temperature?
-      degree? && !(@@unit_map[units] =~ /temp[CFRK]/).nil?
+      degree? && units.match?(self.class.temp_regex)
     end
 
     alias is_temperature? temperature?
@@ -720,6 +712,7 @@ module RubyUnits
     # @return [String] possible values: degC, degF, degR, or degK
     def temperature_scale
       return nil unless temperature?
+
       "deg#{@@unit_map[units][/temp([CFRK])/, 1]}"
     end
 
@@ -733,17 +726,19 @@ module RubyUnits
     # Compare two Unit objects. Throws an exception if they are not of compatible types.
     # Comparisons are done based on the value of the unit in base SI units.
     # @param [Object] other
-    # @return [-1|0|1|nil]
+    # @return [Integer,nil]
     # @raise [NoMethodError] when other does not define <=>
     # @raise [ArgumentError] when units are not compatible
     def <=>(other)
       raise NoMethodError, "undefined method `<=>' for #{base_scalar.inspect}" unless base_scalar.respond_to?(:<=>)
+
       if other.nil?
         base_scalar <=> nil
       elsif !temperature? && other.respond_to?(:zero?) && other.zero?
         base_scalar <=> 0
       elsif other.instance_of?(Unit)
         raise ArgumentError, "Incompatible Units ('#{units}' not compatible with '#{other.units}')" unless self =~ other
+
         base_scalar <=> other.base_scalar
       else
         x, y = coerce(other)
@@ -764,6 +759,7 @@ module RubyUnits
         zero?
       elsif other.instance_of?(Unit)
         return false unless self =~ other
+
         base_scalar == other.base_scalar
       else
         begin
@@ -791,9 +787,9 @@ module RubyUnits
       else
         begin
           x, y = coerce(other)
-          return x =~ y
+          x =~ y
         rescue ArgumentError
-          return false
+          false
         end
       end
     end
@@ -814,9 +810,9 @@ module RubyUnits
       else
         begin
           x, y = coerce(other)
-          return x === y
+          x === y
         rescue ArgumentError
-          return false
+          false
         end
       end
     end
@@ -839,14 +835,15 @@ module RubyUnits
           other.dup
         elsif self =~ other
           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).convert_to(self)
+            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}')"
@@ -876,19 +873,19 @@ 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).convert_to(self)
+            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}')"
         end
       when Time
-        raise ArgumentError, 'Date and Time objects represent fixed points in time and cannot be subtracted from to a Unit, which can only represent time spans'
+        raise ArgumentError, 'Date and Time objects represent fixed points in time and cannot be subtracted from a Unit'
       else
         x, y = coerce(other)
         y - x
@@ -903,11 +900,12 @@ 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
@@ -925,16 +923,18 @@ module RubyUnits
       when Unit
         raise ZeroDivisionError if other.zero?
         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
@@ -949,6 +949,7 @@ module RubyUnits
     def divmod(other)
       raise ArgumentError, "Incompatible Units ('#{self}' not compatible with '#{other}')" unless self =~ other
       return scalar.divmod(other.scalar) if units == other.units
+
       to_base.scalar.divmod(other.to_base.scalar)
     end
 
@@ -959,7 +960,7 @@ module RubyUnits
       divmod(other).last
     end
 
-    # Exponentiate.  Only takes integer powers.
+    # Exponentiation.  Only takes integer powers.
     # Note that anything raised to the power of 0 results in a Unit object with a scalar of 1, and no units.
     # Throws an exception if exponent is not an integer.
     # Ideally this routine should accept a float for the exponent
@@ -975,6 +976,7 @@ module RubyUnits
     # @raise [ArgumentError] when an invalid exponent is passed
     def **(other)
       raise ArgumentError, 'Cannot raise a temperature to a power' if temperature?
+
       if other.is_a?(Numeric)
         return inverse if other == -1
         return self if other == 1
@@ -982,14 +984,16 @@ module RubyUnits
       end
       case other
       when Rational
-        return power(other.numerator).root(other.denominator)
+        power(other.numerator).root(other.denominator)
       when Integer
-        return power(other)
+        power(other)
       when Float
         return self**other.to_i if other == other.to_i
+
         valid = (1..9).map { |n| Rational(1, n) }
         raise ArgumentError, 'Not a n-th root (1..9), use 1/n' unless valid.include? other.abs
-        return root(Rational(1, other).to_int)
+
+        root(Rational(1, other).to_int)
       when Complex
         raise ArgumentError, 'exponentiation of complex numbers is not supported.'
       else
@@ -1009,6 +1013,7 @@ module RubyUnits
       return 1 if n.zero?
       return self if n == 1
       return (1..(n - 1).to_i).inject(self) { |acc, _elem| acc * self } if n >= 0
+
       (1..-(n - 1).to_i).inject(self) { |acc, _elem| acc / self }
     end
 
@@ -1016,7 +1021,7 @@ module RubyUnits
     # if n < 0, returns 1/unit^(1/n)
     # @param [Integer] n
     # @return [Unit]
-    # @raise [ArgumentError] when attemptint to take the root of a temperature
+    # @raise [ArgumentError] when attempting to take the root of a temperature
     # @raise [ArgumentError] when n is not an integer
     # @raise [ArgumentError] when n is 0
     def root(n)
@@ -1029,6 +1034,7 @@ module RubyUnits
       vec = unit_signature_vector
       vec = vec.map { |x| x % n }
       raise ArgumentError, 'Illegal root' unless vec.max.zero?
+
       num = @numerator.dup
       den = @denominator.dup
 
@@ -1043,13 +1049,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
@@ -1060,13 +1066,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
@@ -1075,14 +1085,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
@@ -1093,36 +1112,47 @@ 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}")
+        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
 
@@ -1134,6 +1164,7 @@ module RubyUnits
     # @raise [RuntimeError] when not unitless
     def to_f
       return @scalar.to_f if unitless?
+
       raise "Cannot convert '#{self}' to Float unless unitless.  Use Unit#scalar"
     end
 
@@ -1142,6 +1173,7 @@ module RubyUnits
     # @raise [RuntimeError] when not unitless
     def to_c
       return Complex(@scalar) if unitless?
+
       raise "Cannot convert '#{self}' to Complex unless unitless.  Use Unit#scalar"
     end
 
@@ -1150,6 +1182,7 @@ module RubyUnits
     # @raise [RuntimeError] when not unitless
     def to_i
       return @scalar.to_int if unitless?
+
       raise "Cannot convert '#{self}' to Integer unless unitless.  Use Unit#scalar"
     end
 
@@ -1160,6 +1193,7 @@ module RubyUnits
     # @raise [RuntimeError] when not unitless
     def to_r
       return @scalar.to_r if unitless?
+
       raise "Cannot convert '#{self}' to Rational unless unitless.  Use Unit#scalar"
     end
 
@@ -1169,52 +1203,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 { |definition, _| definition.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 { |definition, _| definition.prefix? }.to_a
         output_denominator = definitions.map { |element| element.map(&:display_name).join }
       end
 
@@ -1226,13 +1237,14 @@ 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
     # @return [Numeric,Unit]
     def -@
       return -@scalar if unitless?
+
       dup * -1
     end
 
@@ -1240,32 +1252,46 @@ 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
@@ -1274,7 +1300,8 @@ 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
@@ -1285,7 +1312,8 @@ 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.
@@ -1298,7 +1326,7 @@ module RubyUnits
 
     # convert a duration to a DateTime.  This will work so long as the duration is the duration from the zero date
     # defined by DateTime
-    # @return [DateTime]
+    # @return [::DateTime]
     def to_datetime
       DateTime.new!(convert_to('d').scalar)
     end
@@ -1325,11 +1353,11 @@ module RubyUnits
     def before(time_point = ::Time.now)
       case time_point
       when Time, Date, DateTime
-        return (begin
-                  time_point - self
-                rescue
-                  time_point.to_datetime - self
-                end)
+        (begin
+          time_point - self
+        rescue StandardError
+          time_point.to_datetime - self
+        end)
       else
         raise ArgumentError, 'Must specify a Time, Date, or DateTime'
       end
@@ -1344,9 +1372,9 @@ module RubyUnits
     def since(time_point)
       case time_point
       when Time
-        (Time.now - time_point).to_unit('s').convert_to(self)
+        self.class.new(::Time.now - time_point, 'second').convert_to(self)
       when DateTime, Date
-        (DateTime.now - time_point).to_unit('d').convert_to(self)
+        self.class.new(::DateTime.now - time_point, 'day').convert_to(self)
       else
         raise ArgumentError, 'Must specify a Time, Date, or DateTime'
       end
@@ -1358,9 +1386,9 @@ module RubyUnits
     def until(time_point)
       case time_point
       when Time
-        (time_point - Time.now).to_unit('s').convert_to(self)
+        self.class.new(time_point - ::Time.now, 'second').convert_to(self)
       when DateTime, Date
-        (time_point - DateTime.now).to_unit('d').convert_to(self)
+        self.class.new(time_point - ::DateTime.now, 'day').convert_to(self)
       else
         raise ArgumentError, 'Must specify a Time, Date, or DateTime'
       end
@@ -1374,10 +1402,10 @@ module RubyUnits
       case time_point
       when Time, DateTime, Date
         (begin
-           time_point + self
-         rescue
-           time_point.to_datetime + self
-         end)
+          time_point + self
+        rescue StandardError
+          time_point.to_datetime + self
+        end)
       else
         raise ArgumentError, 'Must specify a Time, Date, or DateTime'
       end
@@ -1388,27 +1416,29 @@ 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
+
       case other
       when Unit
         [other, self]
       else
-        [RubyUnits::Unit.new(other), self]
+        [self.class.new(other), self]
       end
     end
 
     # returns a new unit that has been scaled to be more in line with typical usage.
     def best_prefix
       return to_base if scalar.zero?
+
       best_prefix = if kind == :information
-                      @@prefix_values.key(2**((Math.log(base_scalar, 2) / 10.0).floor * 10))
+                      @@prefix_values.key(2**((::Math.log(base_scalar, 2) / 10.0).floor * 10))
                     else
-                      @@prefix_values.key(10**((Math.log10(base_scalar) / 3.0).floor * 3))
+                      @@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
@@ -1445,18 +1475,19 @@ module RubyUnits
     # @raise [ArgumentError] when exponent associated with a unit is > 20 or < -20
     def unit_signature_vector
       return to_base.unit_signature_vector unless base?
-      vector = Array.new(SIGNATURE_VECTOR.size, 0)
+      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
       raise ArgumentError, 'Power out of range (-20 < net power of a unit < 20)' if vector.any? { |x| x.abs >= 20 }
+
       vector
     end
 
@@ -1478,8 +1509,9 @@ module RubyUnits
     # @return [Array]
     def unit_signature
       return @signature unless @signature.nil?
+
       vector = unit_signature_vector
-      vector.each_with_index { |item, index| vector[index] = item * 20**index }
+      vector.each_with_index { |item, index| vector[index] = item * (20**index) }
       @signature = vector.inject(0) { |acc, elem| acc + elem }
       @signature
     end
@@ -1495,7 +1527,7 @@ module RubyUnits
     #  "GPa"  -- creates a unit with scalar 1 with units 'GPa'
     #  6'4"  -- recognized as 6 feet + 4 inches
     #  8 lbs 8 oz -- recognized as 8 lbs + 8 ounces
-    # @return [nil | Unit]
+    # @return [nil,RubyUnits::Unit]
     # @todo This should either be a separate class or at least a class method
     def parse(passed_unit_string = '0')
       unit_string = passed_unit_string.dup
@@ -1506,7 +1538,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
@@ -1515,19 +1547,16 @@ 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
 
       unit_string =~ NUMBER_REGEX
-      unit = @@cached_units[Regexp.last_match(2)]
-      mult = begin
-               (Regexp.last_match(1).empty? ? 1.0 : Regexp.last_match(1).to_f)
-             rescue
-               1.0
-             end
+      unit = self.class.cached.get(Regexp.last_match(2))
+      mult = Regexp.last_match(1).nil? ? 1.0 : Regexp.last_match(1).to_f
       mult = mult.to_int if mult.to_int == mult
+
       if unit
         copy(unit)
         @scalar      *= mult
@@ -1541,13 +1570,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")
+
+        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
@@ -1556,7 +1586,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
@@ -1564,7 +1594,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
@@ -1572,7 +1602,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
@@ -1580,6 +1610,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
@@ -1612,12 +1643,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|