vector_number 0.6.0 → 0.7.0

data/lib/vector_number/enumerating.rb

@@ -15,15 +15,15 @@ class VectorNumber
   # @example
   #   v = VectorNumber["a", "b", 6]
   #   units = []
-  #   v.each { |u, c| units << u unless u.is_a?(Numeric) } # => (1⋅'a' + 1⋅'b' + 6)
+  #   v.each { |u, c| units << u unless VectorNumber.numeric_unit?(u) } # => (1⋅"a" + 1⋅"b" + 6)
   #   units # => ["a", "b"]
   # @example Enumerator
   #   v.each.size # => 3
-  #   (v.each + [["d", 0]]).map(&:first) # => ["a", "b", 1, "d"]
+  #   (v.each + [["d", 0]]).map(&:first) # => ["a", "b", unit/1, "d"]
   #   v.each_pair.peek # => ["a", 1]
   #
   # @overload each
-  #   @yieldparam unit [Object]
+  #   @yieldparam unit [Any]
   #   @yieldparam coefficient [Numeric]
   #   @yieldreturn [void]
   #   @return [VectorNumber] self
@@ -35,6 +35,7 @@ class VectorNumber
   def each(&block)
     return to_enum { size } unless block_given?
 
+    # @type var block: ^([unit_type, coefficient_type]) -> untyped
     @data.each(&block)
     self
   end
@@ -44,10 +45,10 @@ class VectorNumber
   # Get a list of units with non-zero coefficients.
   #
   # @example
-  #   VectorNumber["a", "b", 6].units # => ["a", "b", 1]
+  #   VectorNumber["a", "b", 6].units # => ["a", "b", unit/1]
   #   VectorNumber.new.keys # => []
   #
-  # @return [Array<Object>]
+  # @return [Array<Any>]
   def units = @data.keys
 
   alias keys units
@@ -63,24 +64,27 @@ class VectorNumber
 
   alias values coefficients
 
-  # Get mutable hash with vector's data.
-  #
-  # Returned hash has a default value of 0.
+  # Get a list of coefficients corresponding to +units+.
   #
   # @example
-  #   VectorNumber["a", "b", 6].to_h # => {"a"=>1, "b"=>1, 1=>6}
-  #   VectorNumber["a", "b", 6].to_h["c"] # => 0
+  #   VectorNumber["a", "b", 6].coefficients_at("a", "b") # => [1, 1]
+  #   VectorNumber["a", "b", 6].coefficients_at("a", "c") # => [1, 0]
+  #   VectorNumber["a", "b", 6].coefficients_at("c", "b", "c") # => [0, 1, 0]
+  #   VectorNumber["a", "b", 6].coefficients_at) # => []
   #
-  # @return [Hash{Object => Numeric}]
-  def to_h(&block)
-    # TODO: Remove block argument.
-    if block_given?
-      @data.to_h(&block)
-    else
-      @data.dup
-    end
+  # @see #fetch_coefficients
+  #
+  # @param units [Array<Any>]
+  # @return [Array<Numeric>]
+  #
+  # @since 0.7.0
+  def coefficients_at(*units)
+    @data.values_at(*units) # : Array[coefficient_type]
   end
 
+  # @since 0.7.0
+  alias values_at coefficients_at
+
   # Get the coefficient for the unit.
   #
   # If the +unit?(unit)+ is false, 0 is returned.
@@ -89,13 +93,123 @@ class VectorNumber
   #
   # @example
   #   VectorNumber["a", "b", 6]["a"] # => 1
+  #   VectorNumber["a", "b", 6][VectorNumber::R] # => 6
   #   VectorNumber["a", "b", 6]["c"] # => 0
   #
-  # @param unit [Object]
+  # @see #assoc
+  # @see #fetch
+  #
+  # @param unit [Any]
   # @return [Numeric]
   #
   # @since 0.2.4
-  def [](unit) = @data[unit]
+  def [](unit)
+    @data[unit]
+  end
+
+  # Get a 2-element array containing a given unit and associated coefficient.
+  #
+  # @example
+  #   VectorNumber["a", "b", 6].assoc("a") # => ["a", 1]
+  #   VectorNumber["a", "b", 6].assoc(VectorNumber::R) # => [unit/1, 6]
+  #   VectorNumber["a", "b", 6].assoc("c") # => ["c", 0]
+  #
+  # @see #[]
+  #
+  # @param unit [Any]
+  # @return [Array(Any, Numeric)]
+  #
+  # @since 0.7.0
+  def assoc(unit)
+    @data.assoc(unit) || [unit, 0]
+  end
+
+  # Finds and returns the object in nested objects that is specified by +identifiers+.
+  #
+  # As nested objects for a VectorNumber are numeric coefficients,
+  # digging deeper will most probably result in an error.
+  #
+  # @example
+  #   VectorNumber["a", "b", 6].dig("a") # => 1
+  #   VectorNumber["a", "b", 6].dig("c") # => 0
+  #   VectorNumber["a", "b", 6].dig("a", 1) # TypeError
+  #   { 1 => VectorNumber["a", "b", 6] }.dig(1, "a") # => 1
+  #
+  # @param identifiers [Array<Any>]
+  # @return [Numeric]
+  #
+  # @since 0.7.0
+  def dig(*identifiers)
+    @data.dig(*identifiers)
+  end
+
+  # Get the coefficient for the unit, treating 0 coefficients as missing.
+  #
+  # If +self.unit?(unit)+ is +true+, returns the associated coefficient.
+  # Otherwise:
+  # - if neither block, not +default_value+ is given, raises +KeyError+;
+  # - if block is given, returns the result of the block;
+  # - if +default_value+ is given, returns +default_value+.
+  #
+  # @example
+  #   VectorNumber["a", "b", 6].fetch("a") # => 1
+  #   VectorNumber["a", "b", 6].fetch("c") # KeyError
+  #   VectorNumber["a", "b", 6].fetch("c", "default") # => "default"
+  #   VectorNumber["a", "b", 6].fetch("c") { |u| "default #{u}" } # => "default c"
+  #
+  # @see #[]
+  # @see #fetch_coefficients
+  # @see #unit?
+  #
+  # @overload fetch(unit)
+  #   @param unit [Any]
+  #   @return [Numeric]
+  # @overload fetch(unit, default_value)
+  #   @param unit [Any]
+  #   @param default_value [Any]
+  #   @return [Any]
+  # @overload fetch(unit)
+  #   @param unit [Any]
+  #   @yieldparam unit [Any]
+  #   @yieldreturn [Any]
+  #   @return [Any]
+  # @raise [KeyError] if default value was needed, but not provided
+  #
+  # @since 0.7.0
+  def fetch(...)
+    @data.fetch(...) # steep:ignore UnresolvedOverloading
+  end
+
+  # Get coefficients for multiple units in the same way as {#fetch}.
+  #
+  # @example
+  #   VectorNumber["a", "b", 6].fetch_coefficients(VectorNumber::R, "a") # => [6, 1]
+  #   VectorNumber["a", "b", 6].fetch_coefficients("a", "c") # KeyError
+  #   VectorNumber["a", "b", 6].fetch_coefficients("a", "c") { 0 } # => [1, 0]
+  #   VectorNumber["a", "b", 6].fetch_coefficients("a", "a", "a") # => [1, 1, 1]
+  #   VectorNumber["a", "b", 6].fetch_coefficients # => []
+  #
+  # @see #coefficients_at
+  # @see #fetch
+  # @see #unit?
+  #
+  # @overload fetch_coefficients(*units)
+  #   @param units [Array<Any>]
+  #   @return [Array<Numeric>]
+  # @overload fetch_coefficients(*units)
+  #   @param units [Array<Any>]
+  #   @yieldparam unit [Any]
+  #   @yieldreturn [Any]
+  #   @return [Array<Any>]
+  # @raise [KeyError] if default value was needed, but not provided
+  #
+  # @since 0.7.0
+  def fetch_coefficients(...)
+    @data.fetch_values(...) # steep:ignore UnresolvedOverloading
+  end
+
+  # @since 0.7.0
+  alias fetch_values fetch_coefficients
 
   # Check if a unit has a non-zero coefficient.
   #
@@ -103,12 +217,113 @@ class VectorNumber
   #   VectorNumber["a", "b", 6].unit?("a") # => true
   #   VectorNumber["a", "b", 6].key?("c") # => false
   #
-  # @param unit [Object]
+  # @param unit [Any]
   # @return [Boolean]
   #
   # @since 0.2.4
-  def unit?(unit) = @data.key?(unit)
+  def unit?(unit)
+    @data.key?(unit)
+  end
 
   # @since 0.2.4
   alias key? unit?
+
+  # Return a new VectorNumber with coefficients transformed
+  # by the mapping hash and/or a block.
+  #
+  # An optional +mapping+ argument can be provided to map coefficients to new coefficients.
+  # Any coefficient not given in +mapping+ will be mapped using the provided block,
+  # or remain the same if no block is given.
+  # If neither +mapping+ nor block is given, an enumerator is returned.
+  #
+  # @example
+  #   VectorNumber["a", "b", 6].transform_coefficients { _1 * 2 } # => (2⋅"a" + 2⋅"b" + 12)
+  #   VectorNumber["a", "b", 6].transform_values(1 => 2) # => (2⋅"a" - 2⋅"b" + 6)
+  #   VectorNumber["a", "b", 6].transform_coefficients(1 => 2) { _1 / 2 } # => (2⋅"a" - 2⋅"b" + 3)
+  #   VectorNumber["a", "b", 6].transform_values # => Enumerator
+  #
+  # @overload transform_coefficients(mapping)
+  #   @param mapping [Hash{Numeric => Numeric}]
+  #   @return [VectorNumber]
+  # @overload transform_coefficients
+  #   @yieldparam coefficient [Numeric]
+  #   @yieldreturn [Numeric]
+  #   @return [VectorNumber]
+  # @overload transform_coefficients(mapping)
+  #   @param mapping [Hash{Numeric => Numeric}]
+  #   @yieldparam coefficient [Numeric]
+  #   @yieldreturn [Numeric]
+  #   @return [VectorNumber]
+  # @overload transform_coefficients
+  #   @return [Enumerator]
+  #
+  # @since 0.7.0
+  def transform_coefficients(mapping = nil, &transform)
+    if mapping
+      if block_given?
+        # @type var transform: ^(coefficient_type) -> coefficient_type
+        new { |c| mapping.fetch(c) { yield(c) } }
+      else
+        new { |c| mapping.fetch(c, c) }
+      end
+    elsif block_given?
+      # @type var transform: ^(coefficient_type) -> coefficient_type
+      new(&transform)
+    else
+      to_enum(:transform_coefficients) { size } # rubocop:disable Lint/ToEnumArguments
+    end
+  end
+
+  # @since 0.7.0
+  alias transform_values transform_coefficients
+
+  # Return a new VectorNumber with units transformed
+  # by the mapping hash and/or a block.
+  #
+  # An optional +mapping+ argument can be provided to map units to new units.
+  # Any unit not given in +mapping+ will be mapped using the provided block,
+  # or remain the same if no block is given.
+  # If neither +mapping+ nor block is given, an enumerator is returned.
+  #
+  # @example
+  #   VectorNumber["a", "b", 6].transform_units("a" => "c") # => (1⋅"c" + 1⋅"b" + 6)
+  #   VectorNumber["a", "b", 6].transform_keys { _1.is_a?(String) ? _1.to_sym : _1 }
+  #     # => (1⋅:a + 1⋅:b + 6)
+  #   VectorNumber["a", "b", 6].transform_units("a" => "c") { _1.to_s }
+  #     # => (1⋅"c" + 1⋅"b" + 6⋅"")
+  #   VectorNumber["a", "b", 6].transform_keys # => Enumerator
+  #
+  # @overload transform_units(mapping)
+  #   @param mapping [Hash{Any => Any}]
+  #   @return [VectorNumber]
+  # @overload transform_units
+  #   @yieldparam unit [Any]
+  #   @yieldreturn [Any]
+  #   @return [VectorNumber]
+  # @overload transform_units(mapping)
+  #   @param mapping [Hash{Any => Any}]
+  #   @yieldparam unit [Any]
+  #   @yieldreturn [Any]
+  #   @return [VectorNumber]
+  # @overload transform_units
+  #   @return [Enumerator]
+  #
+  # @since 0.7.0
+  def transform_units(mapping = nil, &transform)
+    if block_given?
+      # @type var transform: ^(unit_type unit) -> unit_type
+      if mapping
+        new(@data.transform_keys(mapping, &transform))
+      else
+        new(@data.transform_keys(&transform))
+      end
+    elsif mapping
+      new(@data.transform_keys(mapping))
+    else
+      to_enum(:transform_units) { size } # rubocop:disable Lint/ToEnumArguments
+    end
+  end
+
+  # @since 0.7.0
+  alias transform_keys transform_units
 end

data/lib/vector_number/mathing.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class VectorNumber
-  # @group Mathematical operations
+  # @group Arithmetic operations
   #
   # All operators (like +*+) have aliases (like +mult+)
   # to make method chaining easier and more natural.
@@ -18,7 +18,7 @@ class VectorNumber
   #   5.coerce(VectorNumber["a"]) # RangeError
   #   5 + VectorNumber["a"] # => (5 + 1⋅"a")
   #
-  # @param other [Object]
+  # @param other [Any]
   # @return [Array(VectorNumber, VectorNumber)]
   #
   # @since 0.2.0
@@ -59,7 +59,7 @@ class VectorNumber
   #   10 + VectorNumber[5] # => (15)
   #   10 + VectorNumber["a"] # => (10 + 1⋅"a")
   #
-  # @param other [Object]
+  # @param other [Any]
   # @return [VectorNumber]
   #
   # @since 0.2.0
@@ -82,18 +82,18 @@ class VectorNumber
   #   3 - VectorNumber[5] # => (-2)
   #   3 - VectorNumber["a"] # => (3 - 1⋅"a")
   #
-  # @param other [Object]
+  # @param other [Any]
   # @return [VectorNumber]
   #
   # @since 0.2.0
   def -(other)
-    self + new([other], &:-@)
+    new([self, new([other], &:-@)])
   end
 
   # @since 0.3.0
   alias sub -
 
-  # Multiply all coefficients by a real +other+, returning new vector.
+  # Multiply all coefficients by a real +other+, returning new vector scaled by +other+.
   #
   # This effectively multiplies {#magnitude} by +other+.
   #
@@ -107,7 +107,7 @@ class VectorNumber
   #   2 * VectorNumber[5] # => (10)
   #   2 * VectorNumber["a"] # => (2⋅"a")
   #
-  # @param other [Integer, Float, Rational, BigDecimal, VectorNumber]
+  # @param other [Numeric, VectorNumber]
   # @return [VectorNumber]
   # @raise [RangeError] if +other+ is not a number or +other+ can't be multiplied by this one
   #
@@ -117,7 +117,7 @@ class VectorNumber
       other = other.real
       # @type var other: Float
       new { _1 * other }
-    elsif real_number?(self) && other.is_a?(self.class)
+    elsif real_number?(self) && VectorNumber === other
       # @type var other: untyped
       other * self
     else
@@ -128,23 +128,23 @@ class VectorNumber
   # @since 0.3.0
   alias mult *
 
-  # Divide all coefficients by a real +other+, returning new vector.
+  # Divide all coefficients by a real +other+, returning new vector scaled by reciprocal of +other+.
   #
-  # This effectively multiplies {#magnitude} by reciprocal of +other+.
+  # This effectively divides {#magnitude} by +other+.
   # @note This method never does integer division.
   #
   # @example
   #   VectorNumber[10] / 2 # => (5)
-  #   VectorNumber["a", "b", 6].quo(2) # => (1/2⋅"a" + 1/2⋅"b" + 3/1)
-  #   VectorNumber["a"] / VectorNumber[2] # => (1/2⋅"a")
+  #   VectorNumber["a", "b", 6].quo(2) # => ((1/2)⋅"a" + (1/2)⋅"b" + (3/1))
+  #   VectorNumber["a"] / VectorNumber[2] # => ((1/2)⋅"a")
   #   # Can't divide by a non-real:
   #   VectorNumber["a"] / VectorNumber["b"] # RangeError
   # @example numeric types can be divided in reverse
-  #   2 / VectorNumber[10] # => (1/5)
+  #   2 / VectorNumber[10] # => ((1/5))
   #   # Can't divide by a non-real:
   #   2 / VectorNumber["a"] # RangeError
   #
-  # @param other [Integer, Float, Rational, BigDecimal, VectorNumber]
+  # @param other [Numeric, VectorNumber]
   # @return [VectorNumber]
   # @raise [RangeError] if +other+ is not a number or is not a real number
   # @raise [ZeroDivisionError] if +other+ is zero
@@ -180,7 +180,7 @@ class VectorNumber
   #   2.fdiv(VectorNumber[10]) # => 0.2 (Float)
   #   2.0.fdiv(VectorNumber[10]) # => (0.2) (VectorNumber)
   #
-  # @param other [Integer, Float, Rational, BigDecimal, VectorNumber]
+  # @param other [Numeric, VectorNumber]
   # @return [VectorNumber]
   # @raise [RangeError] if +other+ is not a number or is not a real number
   # @raise [ZeroDivisionError] if +other+ is zero
@@ -190,18 +190,19 @@ class VectorNumber
     check_divisibility(other)
 
     other = other.real
-    new { _1.fdiv(other) }
+    new { _1.fdiv(other) } # steep:ignore BlockBodyTypeMismatch
   end
 
   # Divide all coefficients by a real +other+,
   # converting results to integers using +#floor+.
   #
-  # This is requal to +(self / other).floor+.
+  # This is equal to +(self / other).floor+.
   #
   # @example
   #   VectorNumber[10].div(3) # => (3)
   #   VectorNumber["a"].div(2) # => (0)
   #   VectorNumber["a"].div(VectorNumber[2]) # => (0)
+  #   VectorNumber[-10, "string"].div(100) # => (-1)
   #   # Can't divide by a non-real:
   #   VectorNumber["a"].div(VectorNumber["b"]) # RangeError
   # @example numeric types can be divided in reverse
@@ -213,7 +214,7 @@ class VectorNumber
   # @see #%
   # @see #floor
   #
-  # @param other [Integer, Float, Rational, BigDecimal, VectorNumber]
+  # @param other [Numeric, VectorNumber]
   # @return [VectorNumber]
   # @raise [RangeError] if +other+ is not a number or is not a real number
   # @raise [ZeroDivisionError] if +other+ is zero
@@ -223,9 +224,42 @@ class VectorNumber
     check_divisibility(other)
 
     other = other.real
+    # @type var other: Float
     new { _1.div(other) }
   end
 
+  # Divide all coefficients by a real +other+,
+  # converting results to integers using +#ceil+.
+  #
+  # This is equal to +(self / other).ceil+.
+  #
+  # @example
+  #   VectorNumber[10].ceildiv(3) # => (4)
+  #   VectorNumber["a"].ceildiv(2) # => (1⋅"a")
+  #   (VectorNumber["a"] - 3).ceildiv(2) # => (1⋅"a" - 1)
+  #   VectorNumber[-10, "string"].ceildiv(100) # => (1⋅"string")
+  #   # Can't divide by a non-real:
+  #   VectorNumber["a"].ceildiv(VectorNumber["b"]) # RangeError
+  #
+  # @see #div
+  # @see #ceil
+  # @see Integer#ceildiv
+  #
+  # @param other [Numeric, VectorNumber]
+  # @return [VectorNumber]
+  # @raise [RangeError] if +other+ is not a number or is not a real number
+  # @raise [ZeroDivisionError] if +other+ is zero
+  #
+  # @since 0.7.0
+  def ceildiv(other)
+    check_divisibility(other)
+
+    other = other.real
+    other = Rational(other) if other.integer?
+    # @type var other: Float
+    new { (_1 / other).ceil }
+  end
+
   # Return the modulus of dividing self by a real +other+ as a vector.
   #
   # This is equal to +self - other * (self/other).floor+,
@@ -250,7 +284,7 @@ class VectorNumber
   # @see #remainder
   # @see Numeric#%
   #
-  # @param other [Integer, Float, Rational, BigDecimal, VectorNumber]
+  # @param other [Numeric, VectorNumber]
   # @return [VectorNumber]
   # @raise [RangeError] if +other+ is not a number or is not a real number
   # @raise [ZeroDivisionError] if +other+ is zero
@@ -260,6 +294,7 @@ class VectorNumber
     check_divisibility(other)
 
     other = other.real
+    # @type var other: Float
     new { _1 % other }
   end
 
@@ -283,7 +318,7 @@ class VectorNumber
   # @see #div
   # @see #%
   #
-  # @param other [Integer, Float, Rational, BigDecimal, VectorNumber]
+  # @param other [Numeric, VectorNumber]
   # @return [Array(VectorNumber, VectorNumber)]
   # @raise [RangeError] if +other+ is not a number or is not a real number
   # @raise [ZeroDivisionError] if +other+ is zero
@@ -314,7 +349,7 @@ class VectorNumber
   # @see #%
   # @see Numeric#remainder
   #
-  # @param other [Integer, Float, Rational, BigDecimal, VectorNumber]
+  # @param other [Numeric, VectorNumber]
   # @return [VectorNumber]
   # @raise [RangeError] if +other+ is not a number or is not a real number
   # @raise [ZeroDivisionError] if +other+ is zero
@@ -324,6 +359,7 @@ class VectorNumber
     check_divisibility(other)
 
     other = other.real
+    # @type var other: Float
     new { _1.remainder(other) }
   end
 
@@ -332,7 +368,11 @@ class VectorNumber
   # @raise [RangeError] unless +other+ is a real number
   # @raise [ZeroDivisionError]
   def check_divisibility(other)
-    raise RangeError, "can't divide #{self} by #{other.inspect}", caller unless real_number?(other)
+    unless real_number?(other)
+      raise RangeError,
+            "can't divide #{self} by #{Kernel.instance_method(:inspect).bind_call(other)}",
+            caller
+    end
     raise ZeroDivisionError, "divided by 0", caller if other.zero?
   end
 end

data/lib/vector_number/querying.rb

@@ -47,7 +47,9 @@ class VectorNumber
   # @raise (see #numeric?)
   #
   # @since 0.2.1
-  def nonnumeric?(dimensions = 2) = !numeric?(dimensions)
+  def nonnumeric?(dimensions = 2)
+    !numeric?(dimensions)
+  end
 
   # Returns +true+ if all coefficients are finite, +false+ otherwise.
   #

data/lib/vector_number/{math_converting.rb → rounding.rb}

@@ -1,37 +1,7 @@
 # frozen_string_literal: true
 
 class VectorNumber
-  # @group Mathematical operations
-
-  # Calculate the absolute value of the vector (its length).
-  #
-  # @example
-  #   VectorNumber[5.3].abs # => 5.3
-  #   VectorNumber[-5.3i].magnitude # => 5.3
-  #   VectorNumber[-5.3i, "i"].abs # => 5.3935146240647205
-  #
-  # @return [Float]
-  #
-  # @since 0.2.2
-  def abs
-    Math.sqrt(abs2)
-  end
-
-  alias magnitude abs
-
-  # Calculate the square of absolute value.
-  #
-  # @example
-  #   VectorNumber[5.3].abs2 # => 5.3
-  #   VectorNumber[-5.3i].abs2 # => 5.3
-  #   VectorNumber[-5.3i, "i"].abs2 # => 29.09
-  #
-  # @return [Float]
-  #
-  # @since 0.2.2
-  def abs2
-    coefficients.sum(&:abs2)
-  end
+  # @group Rounding
 
   # Return a new vector with every coefficient truncated using their +#truncate+.
   #
@@ -81,7 +51,8 @@ class VectorNumber
   #
   # @since 0.2.2
   def floor(digits = 0)
-    new { _1.floor(digits) }
+    # Why is there a problem here, but not in #truncate and #ceil? I dunno.
+    new { _1.floor(digits) } # steep:ignore BlockBodyTypeMismatch
   end
 
   # Return a new vector with every coefficient rounded using their +#round+.
@@ -107,7 +78,7 @@ class VectorNumber
   # @see Float#round
   #
   # @since 0.2.2
-  def round(digits = 0, half: :up)
+  def round(digits = 0, half: :up) # rubocop:disable Metrics/MethodLength
     if defined?(BigDecimal)
       bd_mode =
         case half
@@ -115,10 +86,16 @@ class VectorNumber
         when :even then :half_even
         else :half_up
         end
-      new { _1.is_a?(BigDecimal) ? _1.round(digits, bd_mode) : _1.round(digits, half: half) }
+      new do |c|
+        if BigDecimal === c
+          c.round(digits, bd_mode)
+        else
+          c.round(digits, half: half) # steep:ignore UnresolvedOverloading
+        end
+      end
     # :nocov:
     else
-      new { _1.round(digits, half: half) }
+      new { _1.round(digits, half: half) } # steep:ignore UnresolvedOverloading
     end
     # :nocov:
   end