ruby-units 2.4.1 → 4.0.0

data/lib/ruby_units/unit.rb

@@ -1,77 +1,106 @@
 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
-    @@definitions      = {}
-    @@prefix_values    = {}
-    @@prefix_map       = {}
-    @@unit_map         = {}
-    @@unit_values      = {}
-    @@unit_regex       = nil
-    @@unit_match_regex = nil
+  # Copyright 2006-2023
+  # @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
+    class << self
+      # return a list of all defined units
+      # @return [Hash{Symbol=>RubyUnits::Units::Definition}]
+      attr_accessor :definitions
+
+      # @return [Hash{Symbol => String}] the list of units and their prefixes
+      attr_accessor :prefix_values
+
+      # @return [Hash{Symbol => String}]
+      attr_accessor :prefix_map
+
+      # @return [Hash{Symbol => String}]
+      attr_accessor :unit_map
+
+      # @return [Hash{Symbol => String}]
+      attr_accessor :unit_values
+
+      # @return [Hash{Integer => Symbol}]
+      attr_reader :kinds
+    end
+    self.definitions = {}
+    self.prefix_values = {}
+    self.prefix_map = {}
+    self.unit_map = {}
+    self.unit_values = {}
+    @unit_regex = nil
+    @unit_match_regex = nil
     UNITY              = '<1>'.freeze
     UNITY_ARRAY        = [UNITY].freeze
+
+    SIGN_REGEX = /(?:[+-])?/.freeze # +, -, or nothing
+
+    # regex for matching an integer number but not a fraction
+    INTEGER_DIGITS_REGEX = %r{(?<!/)\d+(?!/)}.freeze # 1, 2, 3, but not 1/2 or -1
+    INTEGER_REGEX = /(#{SIGN_REGEX}#{INTEGER_DIGITS_REGEX})/.freeze # -1, 1, +1, but not 1/2
+    UNSIGNED_INTEGER_REGEX = /((?<!-)#{INTEGER_DIGITS_REGEX})/.freeze # 1, 2, 3, but not -1
+    DIGITS_REGEX = /\d+/.freeze # 0, 1, 2, 3
+    DECIMAL_REGEX = /\d*[.]?#{DIGITS_REGEX}/.freeze # 1, 0.1, .1
+    # Rational number, including improper fractions: 1 2/3, -1 2/3, 5/3, etc.
+    RATIONAL_NUMBER = %r{\(?(?:(?<proper>#{SIGN_REGEX}#{DECIMAL_REGEX})[ -])?(?<numerator>#{SIGN_REGEX}#{DECIMAL_REGEX})/(?<denominator>#{SIGN_REGEX}#{DECIMAL_REGEX})\)?} # 1 2/3, -1 2/3, 5/3, 1-2/3, (1/2) etc.
+    # 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+(?![.]))?)/
     # 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
+    FEET_INCH_UNITS_REGEX = /(?:'|ft|feet)\s*(?<inches>#{RATIONAL_NUMBER}|#{SCI_NUMBER})\s*(?:"|in|inch(?:es)?)/.freeze
+    FEET_INCH_REGEX    = /(?<feet>#{INTEGER_REGEX})\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
+    LBS_OZ_UNIT_REGEX  = /(?:#|lbs?|pounds?|pound-mass)+[\s,]*(?<oz>#{RATIONAL_NUMBER}|#{UNSIGNED_INTEGER_REGEX})\s*(?:ozs?|ounces?)/.freeze
+    LBS_OZ_REGEX       = /(?<pounds>#{INTEGER_REGEX})\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
+    STONE_LB_UNIT_REGEX = /(?:sts?|stones?)+[\s,]*(?<pounds>#{RATIONAL_NUMBER}|#{UNSIGNED_INTEGER_REGEX})\s*(?:#|lbs?|pounds?|pound-mass)*/.freeze
+    STONE_LB_REGEX     = /(?<stone>#{INTEGER_REGEX})\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
+    TIME_REGEX         = /(?<hour>\d+):(?<min>\d+):?(?:(?<sec>\d+))?(?:[.](?<msec>\d+))?/.freeze
     # Complex numbers: 1+2i, 1.0+2.0i, -1-1i, etc.
-    COMPLEX_NUMBER     = /#{SCI_NUMBER}?#{SCI_NUMBER}i\b/.freeze
+    COMPLEX_NUMBER     = /(?<real>#{SCI_NUMBER})?(?<imaginary>#{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
+    NUMBER_REGEX       = /(?<scalar>#{SCI_NUMBER}*)\s*(?<unit>.+)?/.freeze # a number followed by a unit
+    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
+    COMPLEX_REGEX      = /#{COMPLEX_NUMBER}\s?(?<unit>.+)?/.freeze
+    RATIONAL_REGEX     = /#{RATIONAL_NUMBER}\s?(?<unit>.+)?/.freeze
     KELVIN             = ['<kelvin>'].freeze
     FAHRENHEIT         = ['<fahrenheit>'].freeze
     RANKINE            = ['<rankine>'].freeze
     CELSIUS            = ['<celsius>'].freeze
-    @@temp_regex       = nil
-    SIGNATURE_VECTOR   = %i[
+    @temp_regex = nil
+    SIGNATURE_VECTOR = %i[
       length
       time
       temperature
@@ -83,74 +112,72 @@ module RubyUnits
       information
       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,
+    @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,
       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    = {}
-      @@prefix_map       = {}
-      @@unit_values      = {}
-      @@unit_map         = {}
-      @@unit_regex       = nil
-      @@unit_match_regex = nil
-      @@prefix_regex     = nil
-
-      @@definitions.each_value do |definition|
+      self.prefix_values = {}
+      self.prefix_map = {}
+      self.unit_map = {}
+      self.unit_values = {}
+      @unit_regex = nil
+      @unit_match_regex = nil
+      @prefix_regex = nil
+
+      definitions.each_value do |definition|
         use_definition(definition)
       end
 
@@ -162,7 +189,7 @@ module RubyUnits
     # @param [String] unit
     # @return [Boolean]
     def self.defined?(unit)
-      definitions.values.any? { |d| d.aliases.include?(unit) }
+      definitions.values.any? { _1.aliases.include?(unit) }
     end
 
     # return the unit definition for a unit
@@ -170,17 +197,11 @@ module RubyUnits
     # @return [RubyUnits::Unit::Definition, nil]
     def self.definition(unit_name)
       unit = unit_name =~ /^<.+>$/ ? unit_name : "<#{unit_name}>"
-      @@definitions[unit]
-    end
-
-    # return a list of all defined units
-    # @return [Array<RubyUnits::Units::Definition>]
-    def self.definitions
-      @@definitions
+      definitions[unit]
     end
 
     # @param  [RubyUnits::Unit::Definition, String] unit_definition
-    # @param  [Block] block
+    # @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
@@ -195,7 +216,8 @@ 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
       definitions[unit_definition.name] = unit_definition
@@ -206,7 +228,7 @@ module RubyUnits
     # 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
     # @yieldparam [RubyUnits::Unit::Definition] the definition of the unit being
     #   redefined
@@ -218,7 +240,7 @@ module RubyUnits
       raise(ArgumentError, "'#{name}' Unit not recognized") unless unit_definition
 
       yield unit_definition
-      @@definitions.delete("<#{name}>")
+      definitions.delete("<#{name}>")
       define(unit_definition)
       setup
     end
@@ -228,26 +250,28 @@ module RubyUnits
     # @param unit [String] name of unit to undefine
     # @return (see RubyUnits::Unit.setup)
     def self.undefine!(unit)
-      @@definitions.delete("<#{unit}>")
+      definitions.delete("<#{unit}>")
       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 = {}
+      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
@@ -269,12 +293,12 @@ module RubyUnits
       num.delete(UNITY)
       den.delete(UNITY)
 
-      combined = Hash.new(0)
+      combined = ::Hash.new(0)
 
       [[num, 1], [den, -1]].each do |array, increment|
         array.chunk_while { |elt_before, _| definition(elt_before).prefix? }
              .to_a
-             .each { |unit| combined[unit] += increment }
+             .each { combined[_1] += increment }
       end
 
       num = []
@@ -301,11 +325,12 @@ module RubyUnits
     # return an array of base units
     # @return [Array]
     def self.base_units
-      @@base_units ||= @@definitions.dup.delete_if { |_, defn| !defn.base? }.keys.map { |u| new(u) }
+      @base_units ||= definitions.dup.select { |_, definition| definition.base? }.keys.map { new(_1) }
     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(Numeric, String)] consisting of [number, "unit"]
     def self.parse_into_numbers_and_units(string)
@@ -335,27 +360,27 @@ module RubyUnits
     # Unit names are reverse sorted by length so the regexp matcher will prefer longer and more specific names
     # @return [String]
     def self.unit_regex
-      @@unit_regex ||= @@unit_map.keys.sort_by { |unit_name| [unit_name.length, unit_name] }.reverse.join('|')
+      @unit_regex ||= unit_map.keys.sort_by { [_1.length, _1] }.reverse.join('|')
     end
 
     # return a regex used to match units
-    # @return [RegExp]
+    # @return [Regexp]
     def self.unit_match_regex
-      @@unit_match_regex ||= /(#{prefix_regex})??(#{unit_regex})\b/
+      @unit_match_regex ||= /(#{prefix_regex})??(#{unit_regex})\b/
     end
 
     # return a regexp fragment used to match prefixes
     # @return [String]
     # @private
     def self.prefix_regex
-      @@prefix_regex ||= @@prefix_map.keys.sort_by { |prefix| [prefix.length, prefix] }.reverse.join('|')
+      @prefix_regex ||= prefix_map.keys.sort_by { [_1.length, _1] }.reverse.join('|')
     end
 
     # Generates (and memoizes) a regexp matching any of the temperature units or their aliases.
     #
-    # @return [RegExp]
+    # @return [Regexp]
     def self.temp_regex
-      @@temp_regex ||= begin
+      @temp_regex ||= begin
         temp_units = %w[tempK tempC tempF tempR degK degC degF degR]
         aliases = temp_units.map do |unit|
           d = definition(unit)
@@ -370,19 +395,19 @@ module RubyUnits
     #
     # @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
+      @unit_match_regex = nil # invalidate the unit match regex
+      @temp_regex = nil # invalidate the temp regex
       if definition.prefix?
-        @@prefix_values[definition.name] = definition.scalar
-        definition.aliases.each { |alias_name| @@prefix_map[alias_name] = definition.name }
-        @@prefix_regex = nil # invalidate the prefix regex
+        prefix_values[definition.name] = definition.scalar
+        definition.aliases.each { prefix_map[_1] = definition.name }
+        @prefix_regex = nil # invalidate the prefix regex
       else
-        @@unit_values[definition.name]          = {}
-        @@unit_values[definition.name][:scalar] = definition.scalar
-        @@unit_values[definition.name][:numerator] = definition.numerator if definition.numerator
-        @@unit_values[definition.name][:denominator] = definition.denominator if definition.denominator
-        definition.aliases.each { |alias_name| @@unit_map[alias_name] = definition.name }
-        @@unit_regex = nil # invalidate the unit regex
+        unit_values[definition.name]          = {}
+        unit_values[definition.name][:scalar] = definition.scalar
+        unit_values[definition.name][:numerator] = definition.numerator if definition.numerator
+        unit_values[definition.name][:denominator] = definition.denominator if definition.denominator
+        definition.aliases.each { unit_map[_1] = definition.name }
+        @unit_regex = nil # invalidate the unit regex
       end
     end
 
@@ -416,20 +441,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
 
@@ -464,26 +485,22 @@ module RubyUnits
       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
@@ -519,34 +536,39 @@ module RubyUnits
         raise ArgumentError, 'Invalid Unit Format'
       end
       update_base_scalar
-      raise ArgumentError, 'Temperatures must not be less than absolute zero' if temperature? && base_scalar < 0
+      raise ArgumentError, 'Temperatures must not be less than absolute zero' if temperature? && base_scalar.negative?
 
       unary_unit = units || ''
       if options.first.instance_of?(String)
         _opt_scalar, opt_units = self.class.parse_into_numbers_and_units(options[0])
-        unless  @@cached_units.keys.include?(opt_units) ||
+        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;|\+\/-})
-          @@cached_units[opt_units] = (scalar == 1 ? self : opt_units.to_unit) if opt_units && !opt_units.empty?
+                (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 =~ /#{self.class.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'
     # return the kind of the unit (:mass, :length, etc...)
     # @return [Symbol]
     def kind
-      @@kinds[signature]
+      self.class.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
@@ -555,11 +577,12 @@ module RubyUnits
     # @return [Boolean]
     def base?
       return @base if defined? @base
+
       @base = (@numerator + @denominator)
               .compact
               .uniq
-              .map { |unit| self.class.definition(unit) }
-              .all? { |element| element.unity? || element.base? }
+              .map { self.class.definition(_1) }
+              .all? { _1.unity? || _1.base? }
       @base
     end
 
@@ -571,8 +594,9 @@ 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)
+
+      if self.class.unit_map[units] =~ /\A<(?:temp|deg)[CRF]>\Z/
+        @signature = self.class.kinds.key(:temperature)
         base = if temperature?
                  convert_to('tempK')
                elsif degree?
@@ -581,32 +605,28 @@ 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 = []
       q   = Rational(1)
       @numerator.compact.each do |num_unit|
-        if @@prefix_values[num_unit]
-          q *= @@prefix_values[num_unit]
+        if self.class.prefix_values[num_unit]
+          q *= self.class.prefix_values[num_unit]
         else
-          q *= @@unit_values[num_unit][:scalar] if @@unit_values[num_unit]
-          num << @@unit_values[num_unit][:numerator] if @@unit_values[num_unit] && @@unit_values[num_unit][:numerator]
-          den << @@unit_values[num_unit][:denominator] if @@unit_values[num_unit] && @@unit_values[num_unit][:denominator]
+          q *= self.class.unit_values[num_unit][:scalar] if self.class.unit_values[num_unit]
+          num << self.class.unit_values[num_unit][:numerator] if self.class.unit_values[num_unit] && self.class.unit_values[num_unit][:numerator]
+          den << self.class.unit_values[num_unit][:denominator] if self.class.unit_values[num_unit] && self.class.unit_values[num_unit][:denominator]
         end
       end
       @denominator.compact.each do |num_unit|
-        if @@prefix_values[num_unit]
-          q /= @@prefix_values[num_unit]
+        if self.class.prefix_values[num_unit]
+          q /= self.class.prefix_values[num_unit]
         else
-          q /= @@unit_values[num_unit][:scalar] if @@unit_values[num_unit]
-          den << @@unit_values[num_unit][:numerator] if @@unit_values[num_unit] && @@unit_values[num_unit][:numerator]
-          num << @@unit_values[num_unit][:denominator] if @@unit_values[num_unit] && @@unit_values[num_unit][:denominator]
+          q /= self.class.unit_values[num_unit][:scalar] if self.class.unit_values[num_unit]
+          den << self.class.unit_values[num_unit][:numerator] if self.class.unit_values[num_unit] && self.class.unit_values[num_unit][:numerator]
+          num << self.class.unit_values[num_unit][:denominator] if self.class.unit_values[num_unit] && self.class.unit_values[num_unit][:denominator]
         end
       end
 
@@ -614,7 +634,7 @@ module RubyUnits
       den = den.flatten.compact
       num = UNITY_ARRAY if num.empty?
       base = self.class.new(self.class.eliminate_terms(q, num, den))
-      @@base_unit_cache[units] = base
+      self.class.base_unit_cache.set(units, base)
       base * @scalar
     end
 
@@ -635,33 +655,41 @@ module RubyUnits
     #
     # @note Rational scalars that are equal to an integer will be represented as integers (i.e, 6/1 => 6, 4/2 => 2, etc..)
     # @param [Symbol] target_units
+    # @param [Float] precision - the precision to use when converting to a rational
     # @return [String]
-    def to_s(target_units = nil)
+    def to_s(target_units = nil, precision: 0.0001)
       out = @output[target_units]
       return out if out
+
       separator = RubyUnits.configuration.separator
       case target_units
       when :ft
-        inches = convert_to('in').scalar.to_int
-        out    = "#{(inches / 12).truncate}\'#{(inches % 12).round}\""
+        feet, inches = convert_to('in').scalar.abs.divmod(12)
+        improper, frac = inches.divmod(1)
+        frac = frac.zero? ? '' : "-#{frac.rationalize(precision)}"
+        out = "#{negative? ? '-' : nil}#{feet}'#{improper}#{frac}\""
       when :lbs
-        ounces = convert_to('oz').scalar.to_int
-        out    = "#{(ounces / 16).truncate}#{separator}lbs, #{(ounces % 16).round}#{separator}oz"
+        pounds, ounces = convert_to('oz').scalar.abs.divmod(16)
+        improper, frac = ounces.divmod(1)
+        frac = frac.zero? ? '' : "-#{frac.rationalize(precision)}"
+        out  = "#{negative? ? '-' : nil}#{pounds}#{separator}lbs #{improper}#{frac}#{separator}oz"
       when :stone
-        pounds = convert_to('lbs').scalar.to_int
-        out = "#{(pounds / 14).truncate}#{separator}stone, #{(pounds % 14).round}#{separator}lb"
+        stone, pounds = convert_to('lbs').scalar.abs.divmod(14)
+        improper, frac = pounds.divmod(1)
+        frac = frac.zero? ? '' : "-#{frac.rationalize(precision)}"
+        out = "#{negative? ? '-' : nil}#{stone}#{separator}stone #{improper}#{frac}#{separator}lbs"
       when String
         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'
@@ -688,6 +716,7 @@ module RubyUnits
     # @return [String]
     def inspect(dump = nil)
       return super() if dump
+
       to_s
     end
 
@@ -695,7 +724,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?
@@ -713,7 +742,8 @@ 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]}"
+
+      "deg#{self.class.unit_map[units][/temp([CFRK])/, 1]}"
     end
 
     # returns true if no associated units
@@ -726,17 +756,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)
@@ -757,6 +789,7 @@ module RubyUnits
         zero?
       elsif other.instance_of?(Unit)
         return false unless self =~ other
+
         base_scalar == other.base_scalar
       else
         begin
@@ -768,9 +801,10 @@ module RubyUnits
       end
     end
 
-    # check to see if units are compatible, but not the scalar part
-    # this check is done by comparing signatures for performance reasons
-    # if passed a string, it will create a unit object with the string and then do the comparison
+    # Check to see if units are compatible, ignoring the scalar part.  This check is done by comparing unit signatures
+    # for performance reasons.  If passed a string, this will create a [Unit] object with the string and then do the
+    # comparison.
+    #
     # @example this permits a syntax like:
     #  unit =~ "mm"
     # @note if you want to do a regexp comparison of the unit string do this ...
@@ -778,17 +812,12 @@ module RubyUnits
     # @param [Object] other
     # @return [Boolean]
     def =~(other)
-      case other
-      when Unit
-        signature == other.signature
-      else
-        begin
-          x, y = coerce(other)
-          return x =~ y
-        rescue ArgumentError
-          return false
-        end
-      end
+      return signature == other.signature if other.is_a?(Unit)
+
+      x, y = coerce(other)
+      x =~ y
+    rescue ArgumentError # return false when `other` cannot be converted to a [Unit]
+      false
     end
 
     alias compatible? =~
@@ -807,9 +836,9 @@ module RubyUnits
       else
         begin
           x, y = coerce(other)
-          return x === y
+          x === y
         rescue ArgumentError
-          return false
+          false
         end
       end
     end
@@ -832,6 +861,7 @@ 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?
               self.class.new(scalar: (scalar + other.convert_to(temperature_scale).scalar), numerator: @numerator, denominator: @denominator, signature: @signature)
@@ -881,7 +911,7 @@ module RubyUnits
           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
@@ -896,6 +926,7 @@ module RubyUnits
       case other
       when Unit
         raise ArgumentError, 'Cannot multiply by temperatures' if [other, self].any?(&:temperature?)
+
         opts = self.class.eliminate_terms(@scalar * other.scalar, @numerator + other.numerator, @denominator + other.denominator)
         opts[:signature] = @signature + other.signature
         self.class.new(opts)
@@ -918,6 +949,7 @@ 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 = self.class.eliminate_terms(sc, @numerator + other.denominator, @denominator + other.numerator)
@@ -925,6 +957,7 @@ module RubyUnits
         self.class.new(opts)
       when Numeric
         raise ZeroDivisionError if other.zero?
+
         sc = Rational(@scalar, other)
         sc = sc.numerator if sc.denominator == 1
         self.class.new(scalar: sc, numerator: @numerator, denominator: @denominator, signature: @signature)
@@ -934,26 +967,50 @@ module RubyUnits
       end
     end
 
-    # divide two units and return quotient and remainder
-    # when both units are in the same units we just use divmod on the raw scalars
-    # otherwise we use the scalar of the base unit which will be a float
-    # @param [Object] other
-    # @return [Array]
+    # Returns the remainder when one unit is divided by another
+    #
+    # @param [Unit] other
+    # @return [Unit]
+    # @raise [ArgumentError] if units are not compatible
+    def remainder(other)
+      raise ArgumentError, "Incompatible Units ('#{self}' not compatible with '#{other}')" unless compatible_with?(other)
+
+      self.class.new(base_scalar.remainder(other.to_unit.base_scalar), to_base.units).convert_to(self)
+    end
+
+    # Divide two units and return quotient and remainder
+    #
+    # @param [Unit] other
+    # @return [Array(Integer, Unit)]
+    # @raise [ArgumentError] if units are not compatible
     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)
+      raise ArgumentError, "Incompatible Units ('#{self}' not compatible with '#{other}')" unless compatible_with?(other)
+
+      [quo(other).to_base.floor, self % other]
     end
 
-    # perform a modulo on a unit, will raise an exception if the units are not compatible
-    # @param [Object] other
+    # Perform a modulo on a unit, will raise an exception if the units are not compatible
+    #
+    # @param [Unit] other
     # @return [Integer]
+    # @raise [ArgumentError] if units are not compatible
     def %(other)
-      divmod(other).last
+      raise ArgumentError, "Incompatible Units ('#{self}' not compatible with '#{other}')" unless compatible_with?(other)
+
+      self.class.new(base_scalar % other.to_unit.base_scalar, to_base.units).convert_to(self)
     end
+    alias modulo %
 
-    # Exponentiate.  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.
+    # @param [Object] other
+    # @return [Unit]
+    # @raise [ZeroDivisionError] if other is zero
+    def quo(other)
+      self / other
+    end
+    alias fdiv quo
+
+    # 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
     # It should then convert the float to a rational and raise the unit by the numerator and root it by the denominator
@@ -968,6 +1025,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
@@ -975,14 +1033,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) }
+
+        valid = (1..9).map { Rational(1, _1) }
         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
@@ -1002,6 +1062,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
 
@@ -1009,7 +1070,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)
@@ -1017,22 +1078,23 @@ module RubyUnits
       raise ArgumentError, 'Exponent must an Integer' unless n.is_a?(Integer)
       raise ArgumentError, '0th root undefined' if n.zero?
       return self if n == 1
-      return root(n.abs).inverse if n < 0
+      return root(n.abs).inverse if n.negative?
 
       vec = unit_signature_vector
-      vec = vec.map { |x| x % n }
+      vec = vec.map { _1 % n }
       raise ArgumentError, 'Illegal root' unless vec.max.zero?
+
       num = @numerator.dup
       den = @denominator.dup
 
       @numerator.uniq.each do |item|
-        x = num.find_all { |i| i == item }.size
+        x = num.find_all { _1 == item }.size
         r = ((x / n) * (n - 1)).to_int
         r.times { num.delete_at(num.index(item)) }
       end
 
       @denominator.uniq.each do |item|
-        x = den.find_all { |i| i == item }.size
+        x = den.find_all { _1 == item }.size
         r = ((x / n) * (n - 1)).to_int
         r.times { den.delete_at(den.index(item)) }
       end
@@ -1089,7 +1151,7 @@ module RubyUnits
         return self if target_unit == start_unit
 
         # @type [Numeric]
-        @base_scalar ||= case @@unit_map[start_unit]
+        @base_scalar ||= case self.class.unit_map[start_unit]
                          when '<tempC>'
                            @scalar + 273.15
                          when '<tempK>'
@@ -1100,7 +1162,7 @@ module RubyUnits
                            @scalar.to_r * Rational(5, 9)
                          end
         # @type [Numeric]
-        q = case @@unit_map[target_unit]
+        q = case self.class.unit_map[target_unit]
             when '<tempC>'
               @base_scalar - 273.15
             when '<tempK>'
@@ -1110,7 +1172,7 @@ module RubyUnits
             when '<tempR>'
               @base_scalar.to_r * Rational(9, 5)
             end
-        return self.class.new("#{q} #{target_unit}")
+        self.class.new("#{q} #{target_unit}")
       else
         # @type [Unit]
         target = case other
@@ -1125,10 +1187,10 @@ module RubyUnits
 
         raise ArgumentError, "Incompatible Units ('#{self}' not compatible with '#{other}')" unless self =~ target
 
-        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
+        numerator1   = @numerator.map { self.class.prefix_values[_1] || _1 }.map { _1.is_a?(Numeric) ? _1 : self.class.unit_values[_1][:scalar] }.compact
+        denominator1 = @denominator.map { self.class.prefix_values[_1] || _1 }.map { _1.is_a?(Numeric) ? _1 : self.class.unit_values[_1][:scalar] }.compact
+        numerator2   = target.numerator.map { self.class.prefix_values[_1] || _1 }.map { _1.is_a?(Numeric) ? _1 : self.class.unit_values[_1][:scalar] }.compact
+        denominator2 = target.denominator.map { self.class.prefix_values[_1] || _1 }.map { _1.is_a?(Numeric) ? _1 : self.class.unit_values[_1][: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
@@ -1138,7 +1200,6 @@ module RubyUnits
         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
@@ -1152,6 +1213,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
 
@@ -1160,6 +1222,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
 
@@ -1168,6 +1231,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
 
@@ -1178,6 +1242,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
 
@@ -1200,26 +1265,26 @@ module RubyUnits
       den                = @denominator.clone.compact
 
       unless num == UNITY_ARRAY
-        definitions = num.map { |element| self.class.definition(element) }
+        definitions = num.map { self.class.definition(_1) }
         definitions.reject!(&:prefix?) unless with_prefix
-        definitions = definitions.chunk_while { |defn, _| defn.prefix? }.to_a
-        output_numerator = definitions.map { |element| element.map(&:display_name).join }
+        definitions = definitions.chunk_while { |definition, _| definition.prefix? }.to_a
+        output_numerator = definitions.map { _1.map(&:display_name).join }
       end
 
       unless den == UNITY_ARRAY
-        definitions = den.map { |element| self.class.definition(element) }
+        definitions = den.map { self.class.definition(_1) }
         definitions.reject!(&:prefix?) unless with_prefix
-        definitions = definitions.chunk_while { |defn, _| defn.prefix? }.to_a
-        output_denominator = definitions.map { |element| element.map(&:display_name).join }
+        definitions = definitions.chunk_while { |definition, _| definition.prefix? }.to_a
+        output_denominator = definitions.map { _1.map(&:display_name).join }
       end
 
       on  = output_numerator
             .uniq
-            .map { |x| [x, output_numerator.count(x)] }
+            .map { [_1, output_numerator.count(_1)] }
             .map { |element, power| (element.to_s.strip + (power > 1 ? "^#{power}" : '')) }
       od  = output_denominator
             .uniq
-            .map { |x| [x, output_denominator.count(x)] }
+            .map { [_1, output_denominator.count(_1)] }
             .map { |element, power| (element.to_s.strip + (power > 1 ? "^#{power}" : '')) }
       "#{on.join('*')}#{od.empty? ? '' : "/#{od.join('*')}"}".strip
     end
@@ -1228,6 +1293,7 @@ module RubyUnits
     # @return [Numeric,Unit]
     def -@
       return -@scalar if unitless?
+
       dup * -1
     end
 
@@ -1235,6 +1301,7 @@ module RubyUnits
     # @return [Numeric,Unit]
     def abs
       return @scalar.abs if unitless?
+
       self.class.new(@scalar.abs, @numerator, @denominator)
     end
 
@@ -1282,6 +1349,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
+
       self.class.new(@scalar.to_i.succ, @numerator, @denominator)
     end
 
@@ -1293,6 +1361,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
+
       self.class.new(@scalar.to_i.pred, @numerator, @denominator)
     end
 
@@ -1306,7 +1375,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
@@ -1333,11 +1402,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
@@ -1352,9 +1421,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
@@ -1366,9 +1435,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
@@ -1382,10 +1451,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
@@ -1394,29 +1463,28 @@ module RubyUnits
     alias after from
     alias from_now from
 
-    # automatically coerce objects to units when possible
-    # if an object defines a 'to_unit' method, it will be coerced using that method
+    # Automatically coerce objects to [Unit] when possible. If an object defines a '#to_unit' method, it will be coerced
+    # using that method.
+    #
     # @param other [Object, #to_unit]
-    # @return [Array]
+    # @return [Array(Unit, Unit)]
+    # @raise [ArgumentError] when `other` cannot be converted to a [Unit]
     def coerce(other)
-      return [other.to_unit, self] if other.respond_to? :to_unit
-      case other
-      when Unit
-        [other, self]
-      else
-        [self.class.new(other), self]
-      end
+      return [other.to_unit, self] if other.respond_to?(:to_unit)
+
+      [self.class.new(other), self]
     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))
+                      self.class.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))
+                      self.class.prefix_values.key(10**((::Math.log10(base_scalar) / 3.0).floor * 3))
                     end
-      to(self.class.new(@@prefix_map.key(best_prefix) + units(with_prefix: false)))
+      to(self.class.new(self.class.prefix_map.key(best_prefix) + units(with_prefix: false)))
     end
 
     # override hash method so objects with same values are considered equal
@@ -1453,18 +1521,20 @@ 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| self.class.definition(element) }.each do |definition|
+      @numerator.map { self.class.definition(_1) }.each do |definition|
         index = SIGNATURE_VECTOR.index(definition.kind)
         vector[index] += 1 if index
       end
-      @denominator.map { |element| self.class.definition(element) }.each do |definition|
+      @denominator.map { self.class.definition(_1) }.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 }
+      raise ArgumentError, 'Power out of range (-20 < net power of a unit < 20)' if vector.any? { _1.abs >= 20 }
+
       vector
     end
 
@@ -1486,8 +1556,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
@@ -1503,39 +1574,52 @@ 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
       unit_string = "#{Regexp.last_match(1)} USD" if unit_string =~ /\$\s*(#{NUMBER_REGEX})/
       unit_string.gsub!("\u00b0".force_encoding('utf-8'), 'deg') if unit_string.encoding == Encoding::UTF_8
 
-      unit_string.gsub!(/[%'"#]/, '%' => 'percent', "'" => 'feet', '"' => 'inch', '#' => 'pound')
-
-      if defined?(Complex) && unit_string =~ COMPLEX_NUMBER
-        real, imaginary, unit_s = unit_string.scan(COMPLEX_REGEX)[0]
-        result                  = self.class.new(unit_s || '1') * Complex(real.to_f, imaginary.to_f)
+      unit_string.gsub!(/[%'"#_,]/, '%' => 'percent', "'" => 'feet', '"' => 'inch', '#' => 'pound', '_' => '', ',' => '')
+      if unit_string.start_with?(COMPLEX_NUMBER)
+        match = unit_string.match(COMPLEX_REGEX)
+        real = Float(match[:real]) if match[:real]
+        imaginary = Float(match[:imaginary])
+        unit_s = match[:unit]
+        real = real.to_i if real.to_i == real
+        imaginary = imaginary.to_i if imaginary.to_i == imaginary
+        complex = Complex(real || 0, imaginary)
+        complex = complex.to_i if complex.imaginary.zero? && complex.real == complex.real.to_i
+        result = self.class.new(unit_s || 1) * complex
         copy(result)
         return
       end
 
-      if defined?(Rational) && unit_string =~ RATIONAL_NUMBER
-        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 = self.class.new(unit_s || '1') * rational
+      if unit_string.start_with?(RATIONAL_NUMBER)
+        match = unit_string.match(RATIONAL_REGEX)
+        numerator = Integer(match[:numerator])
+        denominator = Integer(match[:denominator])
+        raise ArgumentError, 'Improper fractions must have a whole number part' if !match[:proper].nil? && !match[:proper].match?(/^#{INTEGER_REGEX}$/)
+
+        proper = match[:proper].to_i
+        unit_s = match[:unit]
+        rational = if proper.negative?
+                     (proper - Rational(numerator, denominator))
+                   else
+                     (proper + Rational(numerator, denominator))
+                   end
+        rational = rational.to_int if rational.to_int == 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
+      match = unit_string.match(NUMBER_REGEX)
+      unit = self.class.cached.get(match[:unit])
+      mult = match[:scalar] == '' ? 1.0 : match[:scalar].to_f
       mult = mult.to_int if mult.to_int == mult
+
       if unit
         copy(unit)
         @scalar      *= mult
@@ -1543,52 +1627,70 @@ module RubyUnits
         return self
       end
 
-      while unit_string.gsub!(/(<#{@@unit_regex})><(#{@@unit_regex}>)/, '\1*\2')
+      while unit_string.gsub!(/(<#{self.class.unit_regex})><(#{self.class.unit_regex}>)/, '\1*\2')
         # collapse <x><y><z> into <x*y*z>...
       end
       # ... and then strip the remaining brackets for x*y*z
       unit_string.gsub!(/[<>]/, '')
 
-      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?)
+      if (match = unit_string.match(TIME_REGEX))
+        hours = match[:hour]
+        minutes = match[:min]
+        seconds = match[:sec]
+        milliseconds = match[:msec]
+        raise ArgumentError, 'Invalid Duration' if [hours, minutes, seconds, milliseconds].all?(&:nil?)
 
-        result = self.class.new("#{hours || 0} h") +
+        result = self.class.new("#{hours || 0} hours") +
                  self.class.new("#{minutes || 0} minutes") +
                  self.class.new("#{seconds || 0} seconds") +
-                 self.class.new("#{microseconds || 0} usec")
+                 self.class.new("#{milliseconds || 0} milliseconds")
         copy(result)
         return
       end
 
       # Special processing for unusual unit strings
       # feet -- 6'5"
-      feet, inches = unit_string.scan(FEET_INCH_REGEX)[0]
-      if feet && inches
-        result = self.class.new("#{feet} ft") + self.class.new("#{inches} inches")
+      if (match = unit_string.match(FEET_INCH_REGEX))
+        feet = Integer(match[:feet])
+        inches = match[:inches]
+        result = if feet.negative?
+                   self.class.new("#{feet} ft") - self.class.new("#{inches} inches")
+                 else
+                   self.class.new("#{feet} ft") + self.class.new("#{inches} inches")
+                 end
         copy(result)
         return
       end
 
       # weight -- 8 lbs 12 oz
-      pounds, oz = unit_string.scan(LBS_OZ_REGEX)[0]
-      if pounds && oz
-        result = self.class.new("#{pounds} lbs") + self.class.new("#{oz} oz")
+      if (match = unit_string.match(LBS_OZ_REGEX))
+        pounds = Integer(match[:pounds])
+        oz = match[:oz]
+        result = if pounds.negative?
+                   self.class.new("#{pounds} lbs") - self.class.new("#{oz} oz")
+                 else
+                   self.class.new("#{pounds} lbs") + self.class.new("#{oz} oz")
+                 end
         copy(result)
         return
       end
 
       # stone -- 3 stone 5, 2 stone, 14 stone 3 pounds, etc.
-      stone, pounds = unit_string.scan(STONE_LB_REGEX)[0]
-      if stone && pounds
-        result = self.class.new("#{stone} stone") + self.class.new("#{pounds} lbs")
+      if (match = unit_string.match(STONE_LB_REGEX))
+        stone = Integer(match[:stone])
+        pounds = match[:pounds]
+        result = if stone.negative?
+                   self.class.new("#{stone} stone") - self.class.new("#{pounds} lbs")
+                 else
+                   self.class.new("#{stone} stone") + self.class.new("#{pounds} lbs")
+                 end
         copy(result)
         return
       end
 
       # 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]/
+      raise(ArgumentError, "'#{passed_unit_string}' Unit not recognized #{unit_string}") 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|
@@ -1596,7 +1698,7 @@ module RubyUnits
         x = "#{item[0]} "
         if n >= 0
           top.gsub!(/#{item[0]}(\^|\*\*)#{n}/) { x * n }
-        elsif n < 0
+        elsif n.negative?
           bottom = "#{bottom} #{x * -n}"
           top.gsub!(/#{item[0]}(\^|\*\*)#{n}/, '')
         end
@@ -1627,15 +1729,15 @@ module RubyUnits
 
       # 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(self.class.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|
-        @@prefix_map[item[0]] ? [@@prefix_map[item[0]], @@unit_map[item[1]]] : [@@unit_map[item[1]]]
+        self.class.prefix_map[item[0]] ? [self.class.prefix_map[item[0]], self.class.unit_map[item[1]]] : [self.class.unit_map[item[1]]]
       end.flatten.compact.delete_if(&:empty?)
 
       @denominator = @denominator.map do |item|
-        @@prefix_map[item[0]] ? [@@prefix_map[item[0]], @@unit_map[item[1]]] : [@@unit_map[item[1]]]
+        self.class.prefix_map[item[0]] ? [self.class.prefix_map[item[0]], self.class.unit_map[item[1]]] : [self.class.unit_map[item[1]]]
       end.flatten.compact.delete_if(&:empty?)
 
       @numerator = UNITY_ARRAY if @numerator.empty?