vector_number 0.3.0 → 0.3.1

data/lib/vector_number/mathing.rb

@@ -2,11 +2,26 @@
 
 class VectorNumber
   # Methods for performing actual math.
+  #
+  # All operators (like +*+) have aliases (like +mult+)
+  # to make method chaining easier and more natural.
   module Mathing
     # The coerce method provides support for Ruby type coercion.
-    # Unlike most numeric types, VectorNumber can coerce *anything*.
+    #
+    # Unlike other numeric types, VectorNumber can coerce *anything*.
+    #
+    # @example
+    #   VectorNumber["a"].coerce(5) # => [(5), (1⋅'a')]
+    #   VectorNumber[7].coerce([]) # => [(1⋅[]), (7)]
+    #   VectorNumber["a"] + 5 # => (1⋅'a' + 5)
+    #   # Direct reverse coercion doesn't work, but Numeric types know how to call #coerce:
+    #   5.coerce(VectorNumber["a"]) # RangeError
+    #   5 + VectorNumber["a"] # => (5 + 1⋅'a')
+    #
     # @param other [Object]
     # @return [Array(VectorNumber, VectorNumber)]
+    #
+    # @since 0.2.0
     def coerce(other)
       case other
       when VectorNumber
@@ -16,44 +31,87 @@ class VectorNumber
       end
     end
 
-    # Return self.
-    # @return [VectorNumber]
-    alias +@ itself
-
-    # Return new vector with negated coefficients.
-    # This preserves order of units.
+    # Return new vector with negated coefficients (additive inverse).
+    #
+    # @example
+    #   -VectorNumber[12, "i"] # => (-12 - 1⋅'i')
+    #   VectorNumber["a", "b", "a"].neg # => (-2⋅'a' - 1⋅'b')
+    #   -VectorNumber["a"] + VectorNumber["a"] # => (0)
+    #
     # @return [VectorNumber]
+    #
+    # @since 0.2.0
     def -@
       new(&:-@)
     end
 
+    # @since 0.3.0
     alias neg -@
 
-    # Return new vector as a sum of this and other value.
+    # Return new vector as a sum of this and +other+ value.
     # This is analogous to {VectorNumber.[]}.
+    #
+    # @example
+    #   VectorNumber[5] + 10 # => (15)
+    #   VectorNumber["a"].add(VectorNumber["b"]) # => (1⋅'a' + 1⋅'b')
+    #   VectorNumber["a"] + "b" # => (1⋅'a' + 1⋅'b')
+    # @example numeric types can be added in reverse
+    #   10 + VectorNumber[5] # => (15)
+    #   10 + VectorNumber["a"] # => (10 + 1⋅'a')
+    #
     # @param other [Object]
     # @return [VectorNumber]
+    #
+    # @since 0.2.0
     def +(other)
       new([self, other])
     end
 
+    # @since 0.3.0
     alias add +
 
-    # Return new vector as a sum of this and negative of the other value.
-    # This is analogous to {VectorNumber.[]}, but allows to negate anything.
+    # Return new vector as a sum of this and additive inverse of +other+ value.
+    #
+    # This is implemented through {#+} and {#-@}.
+    #
+    # @example
+    #   VectorNumber[5] - 3 # => (2)
+    #   VectorNumber["a"].sub(VectorNumber["b"]) # => (1⋅'a' - 1⋅'b')
+    #   VectorNumber["a"] - "b" # => (1⋅'a' - 1⋅'b')
+    # @example numeric types can be subtracted in reverse
+    #   3 - VectorNumber[5] # => (-2)
+    #   3 - VectorNumber["a"] # => (3 - 1⋅'a')
+    #
     # @param other [Object]
     # @return [VectorNumber]
+    #
+    # @since 0.2.0
     def -(other)
       self + new([other], &:-@)
     end
 
+    # @since 0.3.0
     alias sub -
 
-    # Multiply all coefficients by a real number, returning new vector.
-    # This effectively multiplies magnitude by the specified factor.
+    # Multiply all coefficients by a real +other+, returning new vector.
+    #
+    # This effectively multiplies {#magnitude} by +other+.
+    #
+    # @example
+    #   VectorNumber[5] * 2 # => (10)
+    #   VectorNumber["a", "b", 6].mult(2) # => (2⋅'a' + 2⋅'b' + 12)
+    #   VectorNumber["a"] * VectorNumber[2] # => (2⋅'a')
+    #   # Can't multiply by a non-real:
+    #   VectorNumber["a"] * VectorNumber["b"] # RangeError
+    # @example numeric types can be multiplied in reverse
+    #   2 * VectorNumber[5] # => (10)
+    #   2 * VectorNumber["a"] # => (2⋅'a')
+    #
     # @param other [Integer, Float, Rational, BigDecimal, VectorNumber]
     # @return [VectorNumber]
     # @raise [RangeError] if +other+ is not a number or +other+ can't be multiplied by this one
+    #
+    # @since 0.2.1
     def *(other)
       if real_number?(other)
         other = other.real
@@ -67,32 +125,67 @@ class VectorNumber
       end
     end
 
+    # @since 0.3.0
     alias mult *
 
-    # Divide all coefficients by a real number, returning new vector.
-    # This effectively multiplies magnitude by reciprocal of +other+.
+    # Divide all coefficients by a real +other+, returning new vector.
+    #
+    # This effectively multiplies {#magnitude} by reciprocal of +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')
+    #   # 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)
+    #   # Can't divide by a non-real:
+    #   2 / VectorNumber["a"] # RangeError
+    #
     # @param other [Integer, Float, Rational, BigDecimal, 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.2.1
     def /(other)
       check_divisibility(other)
 
       other = other.real
       # Prevent integer division, but without loss of accuracy.
-      other = Rational(other) if other.is_a?(Integer)
+      other = Rational(other) if other.integer?
       # @type var other: Float
       new { _1 / other }
     end
 
+    # @since 0.2.6
     alias quo /
+    # to fix syntax highlighting: /
 
-    # Divide all coefficients by a real number using +fdiv+, returning new vector
-    # with Float coefficients.
+    # Divide all coefficients by a real +other+ using +fdiv+,
+    # returning new vector with Float (or BigDecimal) coefficients.
+    #
+    # There isn't much benefit to this method, as {#/} doesn't do integer division,
+    # but it is provided for consistency.
+    #
+    # @example
+    #   VectorNumber[10].fdiv(2) # => (5.0)
+    #   VectorNumber["a", "b", 6].fdiv(2) # => (0.5⋅'a' + 0.5⋅'b' + 3.0)
+    #   VectorNumber["a"].fdiv(VectorNumber[2]) # => (0.5⋅'a')
+    #   # Can't divide by a non-real:
+    #   VectorNumber["a"].fdiv(VectorNumber["b"]) # RangeError
+    # @example reverse division may return non-vector results
+    #   2.fdiv(VectorNumber[10]) # => 0.2 (Float)
+    #   2.0.fdiv(VectorNumber[10]) # => (0.2) (VectorNumber)
+    #
     # @param other [Integer, Float, Rational, BigDecimal, 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.2.1
     def fdiv(other)
       check_divisibility(other)
 
@@ -100,14 +193,30 @@ class VectorNumber
       new { _1.fdiv(other) }
     end
 
-    # Divide all coefficients by +other+, rounding results with {#floor}.
+    # Divide all coefficients by a real +other+, rounding results with +#floor+.
+    #
     # This is requal to +(self / other).floor+.
+    #
+    # @example
+    #   VectorNumber[10].div(3) # => (3)
+    #   VectorNumber["a"].div(2) # => (0⋅'a')
+    #   VectorNumber["a"].div(VectorNumber[2]) # => (0⋅'a')
+    #   # Can't divide by a non-real:
+    #   VectorNumber["a"].div(VectorNumber["b"]) # RangeError
+    # @example numeric types can be divided in reverse
+    #   2.div(VectorNumber[10]) # => (0)
+    #   # Can't divide by a non-real:
+    #   2.div(VectorNumber["a"]) # RangeError
+    #
+    # @see #divmod
+    # @see #%
+    #
     # @param other [Integer, Float, Rational, BigDecimal, VectorNumber]
     # @return [VectorNumber]
     # @raise [RangeError] if +other+ is not a number or is not a real number
     # @raise [ZeroDivisionError] if +other+ is zero
-    # @see #divmod
-    # @see #%
+    #
+    # @since 0.2.6
     def div(other)
       check_divisibility(other)
 
@@ -115,16 +224,36 @@ class VectorNumber
       new { _1.div(other) }
     end
 
-    # Return the modulus of dividing self by +other+ as a vector.
-    # This is equal to +self - other * (self/other).floor+.
+    # Return the modulus of dividing self by a real +other+ as a vector.
+    #
+    # This is equal to +self - other * (self/other).floor+,
+    # or, alternatively, +self - other * self.div(other)+.
+    #
+    # @example
+    #   VectorNumber[10] % 3 # => (1)
+    #   VectorNumber["a", "b", 6].modulo(2) # => (1⋅'a' + 1⋅'b')
+    #   -VectorNumber["a"] % VectorNumber[2] # => (1⋅'a')
+    #   # Can't divide by a non-real:
+    #   VectorNumber["a"] % VectorNumber["b"] # RangeError
+    # @example numeric types can be divided in reverse
+    #   3 % VectorNumber[10] # => (3)
+    #   # Can't divide by a non-real:
+    #   3 % VectorNumber["a"] # RangeError
+    # @example compare to #remainder
+    #   VectorNumber[-5] % 3 # => (1)
+    #   VectorNumber[-5].remainder(3) # => (-2)
+    #
+    # @see #divmod
+    # @see #div
+    # @see #remainder
+    # @see Numeric#%
+    #
     # @param other [Integer, Float, Rational, BigDecimal, VectorNumber]
     # @return [VectorNumber]
     # @raise [RangeError] if +other+ is not a number or is not a real number
     # @raise [ZeroDivisionError] if +other+ is zero
-    # @see #divmod
-    # @see #div
-    # @see #remainder for alternative
-    # @see Numeric#% for examples
+    #
+    # @since 0.2.6
     def %(other)
       check_divisibility(other)
 
@@ -132,28 +261,63 @@ class VectorNumber
       new { _1 % other }
     end
 
+    # @since 0.2.6
     alias modulo %
 
-    # Return the quotient and modulus of dividing self by +other+.
+    # Return the quotient and modulus of dividing self by a real +other+.
     # There is no performance benefit compared to calling {#div} and {#%} separately.
+    #
+    # @example
+    #   VectorNumber[10].divmod(3) # => [(3), (1)]
+    #   VectorNumber["a"].divmod(2) # => [(0⋅'a'), (1⋅'a')]
+    #   VectorNumber["a"].divmod(VectorNumber[2]) # => [(0⋅'a'), (1⋅'a')]
+    #   # Can't divide by a non-real:
+    #   VectorNumber["a"].divmod(VectorNumber["b"]) # RangeError
+    # @example numeric types can be divided in reverse
+    #   3.divmod(VectorNumber[10]) # => [(0), (3)]
+    #   # Can't divide by a non-real:
+    #   3.divmod(VectorNumber["a"]) # RangeError
+    #
+    # @see #div
+    # @see #%
+    #
     # @param other [Integer, Float, Rational, BigDecimal, 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
-    # @see #div
-    # @see #%
+    #
+    # @since 0.2.6
     def divmod(other)
       [div(other), modulo(other)]
     end
 
-    # Return the remainder of dividing self by +other+ as a vector.
+    # Return the remainder of dividing self by a real +other+ as a vector.
+    #
     # This is equal to +self - other * (self/other).truncate+.
+    #
+    # @example
+    #   VectorNumber[10].remainder(3) # => (1)
+    #   VectorNumber["a"].remainder(2) # => (1⋅'a')
+    #   -VectorNumber["a"].remainder(VectorNumber[2]) # => (-1⋅'a')
+    #   # Can't divide by a non-real:
+    #   VectorNumber["a"].remainder(VectorNumber["b"]) # RangeError
+    # @example numeric types can be divided in reverse
+    #   3.remainder(VectorNumber[10]) # => (3)
+    #   # Can't divide by a non-real:
+    #   3.remainder(VectorNumber["a"]) # RangeError
+    # @example compare to #%
+    #   VectorNumber[-5] % 3 # => (1)
+    #   VectorNumber[-5].remainder(3) # => (-2)
+    #
+    # @see #%
+    # @see Numeric#remainder
+    #
     # @param other [Integer, Float, Rational, BigDecimal, VectorNumber]
     # @return [VectorNumber]
     # @raise [RangeError] if +other+ is not a number or is not a real number
     # @raise [ZeroDivisionError] if +other+ is zero
-    # @see #% for alternative
-    # @see Numeric#remainder for examples
+    #
+    # @since 0.2.6
     def remainder(other)
       check_divisibility(other)
 
@@ -163,8 +327,18 @@ class VectorNumber
 
     private
 
+    # @param other [Object]
+    # @return [void]
+    # @raise [RangeError] unless +other+ is a real number
+    # @raise [ZeroDivisionError]
+    #
+    # @see real_number?
+    #
+    # @since 0.2.6
     def check_divisibility(other)
-      raise RangeError, "can't divide #{self} by #{other}", caller unless real_number?(other)
+      unless real_number?(other)
+        raise RangeError, "can't divide #{self} by #{other.inspect}", caller
+      end
       raise ZeroDivisionError, "divided by 0", caller if other.zero?
     end
   end

data/lib/vector_number/numeric_refinements.rb

@@ -1,21 +1,36 @@
 # frozen_string_literal: true
 
 class VectorNumber
-  # Refinements of Numeric classes to better work with VectorNumber and similar classes.
+  # Refinements of Numeric classes and Kernel to better work with VectorNumber and similar classes.
+  #
+  # These do not depend on +VectorNumber+ and can technically be used separately.
+  # Currently includes:
+  # - refinement for +Complex#<=>+ to work with classes implementing +<=>+;
+  # - refinement for +Kernel#BigDecimal+ to work with classes implementing +to_d+.
+  #
+  # @example activating refinements
+  #   require "vector_number/numeric_refinements"
+  #   using VectorNumber::NumericRefinements
+  #
+  # @since 0.2.0
   module NumericRefinements
     # Refinement module to provide a +#<=>+ method that can work backwards.
+    #
     # @note Currently only applies to Complex on *3.1*,
     #   as other numeric classes rely on +#coerce+.
+    # @example without refinements
+    #   VectorNumber[2] <=> Complex(1, 0) #=> 1
+    #   Complex(1, 0) <=> VectorNumber[2] #=> nil
+    # @example with refinements
+    #   require "vector_number/numeric_refinements"
+    #   using VectorNumber::NumericRefinements
+    #   VectorNumber[2] <=> Complex(1, 0) #=> 1
+    #   Complex(1, 0) <=> VectorNumber[2] #=> -1
+    #
+    # @since 0.2.1
     module CommutativeShuttle
       # Commutative +#<=>+.
-      # @example without refinements
-      #   Complex(1, 0) <=> VectorNumber[2] # => nil
-      #   VectorNumber[2] <=> Complex(1, 0) # => 1
-      # @example with refinements
-      #   require "vector_number/numeric_refinements"
-      #   using VectorNumber::NumericRefinements
-      #   Complex(1, 0) <=> VectorNumber[2] # => -1
-      #   VectorNumber[2] <=> Complex(1, 0) # => 1
+      # Tries to call +other <=> self+ if +self <=> other+ returns +nil+.
       def <=>(other)
         comparison = super
         return comparison if comparison || !other.respond_to?(:<=>)
@@ -30,7 +45,16 @@ class VectorNumber
     end
 
     # Refinement module to change Kernel#BigDecimal so it works with +#to_d+.
+    #
     # @note `BigDecimal` needs to be defined for this refinement to activate.
+    # @example without refinements
+    #   BigDecimal(VectorNumber[2]) # can't convert VectorNumber into BigDecimal (TypeError)
+    # @example with refinements
+    #   require "vector_number/numeric_refinements"
+    #   using VectorNumber::NumericRefinements
+    #   BigDecimal(VectorNumber[2]) #=> 0.2e1
+    #
+    # @since 0.2.1
     module BigDecimalToD
       # BigDecimal() that first tries to use #to_d.
       # @param value [Object]

data/lib/vector_number/querying.rb

@@ -5,12 +5,21 @@ class VectorNumber
   # Mostly modeled after {::Complex}.
   module Querying
     # Whether this VectorNumber can be considered strictly numeric, e.g. real or complex.
+    #
+    # @example
+    #   VectorNumber[2].numeric? # => true
+    #   VectorNumber[2, 3i].numeric? # => true
+    #   VectorNumber[2, "a"].numeric? # => false
+    #   VectorNumber[2, 3i].numeric?(1) # => false
+    #
     # @param dimensions [Integer] number of dimensions to consider "numeric"
     #   - 0 — zero
     #   - 1 — real number
     #   - 2 — complex number, etc.
     # @return [Boolean]
     # @raise [ArgumentError] if +dimensions+ is negative
+    #
+    # @since 0.2.0
     def numeric?(dimensions = 2)
       raise ArgumentError, "`dimensions` must be non-negative" unless dimensions >= 0
 
@@ -18,64 +27,124 @@ class VectorNumber
     end
 
     # Whether this VectorNumber contains any non-numeric parts.
+    #
+    # @example
+    #   VectorNumber[2].nonnumeric? # => false
+    #   VectorNumber[2, 3i].nonnumeric? # => false
+    #   VectorNumber[2, "a"].nonnumeric? # => true
+    #   VectorNumber[2, 3i].nonnumeric?(1) # => true
+    #
     # @param (see #numeric?)
     # @return (see #numeric?)
     # @raise (see #numeric?)
-    def nonnumeric?(dimensions = 2)
-      raise ArgumentError, "`dimensions` must be non-negative" unless dimensions >= 0
-
-      !numeric?(dimensions)
-    end
+    #
+    # @since 0.2.1
+    def nonnumeric?(dimensions = 2) = !numeric?(dimensions)
 
     # Returns +true+ if all coefficients are finite, +false+ otherwise.
+    #
+    # @example
+    #   VectorNumber[2].finite? # => true
+    #   VectorNumber[Float::NAN].finite? # => false
+    #   VectorNumber["a"].mult(Float::INFINITY).finite? # => false
+    #
     # @return [Boolean]
+    #
+    # @since 0.1.0
     def finite?
       all? { |_u, v| v.finite? }
     end
 
     # Returns +1+ if any coefficients are infinite, +nil+ otherwise.
+    #
+    # This behavior is the same as +Complex+'s.
+    #
+    # @example
+    #   VectorNumber[2].infinite? # => nil
+    #   VectorNumber[Float::NAN].infinite? # => 1
+    #   VectorNumber["a"].mult(-Float::INFINITY).infinite? # => 1
+    #
     # @return [1, nil]
+    #
+    # @since 0.1.0
     def infinite?
       finite? ? nil : 1 # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
     end
 
     # Returns +true+ if there are no non-zero coefficients, and +false+ otherwise.
+    #
+    # @example
+    #   VectorNumber["c"].zero? # => false
+    #   VectorNumber[].zero? # => true
+    #
     # @return [Boolean]
-    def zero?
-      size.zero?
-    end
+    #
+    # @since 0.1.0
+    def zero? = size.zero?
 
     # Returns +self+ if there are any non-zero coefficients, +nil+ otherwise.
+    #
+    # This behavior is the same as +Numeric+'s.
+    #
+    # @example
+    #   VectorNumber["ab", "cd"].nonzero? # => (1⋅'ab' + 1⋅'cd')
+    #   VectorNumber[].nonzero? # => nil
+    #
     # @return [VectorNumber, nil]
+    #
+    # @since 0.1.0
     def nonzero?
       zero? ? nil : self # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
     end
 
     # Returns +true+ if number is non-zero and all non-zero coefficients are positive,
     # and +false+ otherwise.
+    #
+    # @example
+    #   VectorNumber["a"].positive? # => true
+    #   VectorNumber[2].neg.positive? # => false
+    #   (VectorNumber["1"] - VectorNumber[1]).positive? # => false
+    #   VectorNumber[0].positive? # => false
+    #
     # @return [Boolean]
+    #
+    # @since 0.1.0
     def positive?
       !zero? && all? { |_u, c| c.positive? }
     end
 
     # Returns +true+ if number is non-zero and all non-zero coefficients are negative,
     # and +false+ otherwise.
+    #
+    # @example
+    #   VectorNumber["a"].neg.negative? # => true
+    #   VectorNumber[-2].neg.negative? # => false
+    #   (VectorNumber["1"] - VectorNumber[1]).negative? # => false
+    #   VectorNumber[0].negative? # => false
+    #
     # @return [Boolean]
+    #
+    # @since 0.1.0
     def negative?
       !zero? && all? { |_u, c| c.negative? }
     end
 
-    # Always returns +false+, as vectors are never real numbers.
+    # Always returns +false+, as vectors are not real numbers.
+    #
+    # This behavior is the same as +Complex+'s.
+    #
     # @see #numeric?
+    #
     # @return [false]
-    def real?
-      false
-    end
+    #
+    # @since 0.1.0
+    def real? = false
 
     # Always returns +false+, as vectors are not +Integer+s.
+    #
     # @return [false]
-    def integer?
-      false
-    end
+    #
+    # @since 0.2.1
+    def integer? = false
   end
 end

data/lib/vector_number/stringifying.rb

@@ -4,21 +4,37 @@ class VectorNumber
   # Methods and options for string representation.
   module Stringifying
     # Predefined symbols for multiplication to display between unit and coefficient.
+    #
     # @return [Hash{Symbol => String}]
+    #
+    # @since 0.1.0
     MULT_STRINGS = {
       asterisk: "*", # U+002A
       cross: "×", # U+00D7
       dot: "⋅", # U+22C5
       invisible: "⁢", # U+2062, zero-width multiplication operator
       space: " ",
-      none: ""
+      none: "",
     }.freeze
 
+    # Get a string representation of the vector.
+    #
+    # @example
+    #   VectorNumber[5, "s"].to_s # => "5 + 1⋅'s'"
+    #   VectorNumber["s", 5].to_s # => "1⋅'s' + 5"
+    # @example with :mult argument
+    #   VectorNumber[5, "s"].to_s(mult: :asterisk) # => "5 + 1*'s'"
+    # @example :mult option specified for the vector
+    #   VectorNumber[5, "s", mult: :none].to_s # => "5 + 1's'"
+    #
     # @param mult [Symbol, String]
     #   text to use between coefficient and unit,
     #   can be one of the keys in {MULT_STRINGS} or an arbitrary string
     # @return [String]
-    # @raise [ArgumentError] if +mult+ is not in {MULT_STRINGS}'s keys
+    # @raise [ArgumentError]
+    #   if +mult+ is not a String and is not in {MULT_STRINGS}'s keys
+    #
+    # @since 0.1.0
     def to_s(mult: options[:mult])
       return "0" if zero?
 
@@ -34,7 +50,18 @@ class VectorNumber
       result
     end
 
+    # Get a string representation of the vector.
+    #
+    # This is similar to +Complex#inspect+: it returns result of {#to_s} in round brackets.
+    #
+    # @example
+    #   VectorNumber[5, "s"].inspect # => "(5 + 1⋅'s')"
+    #
     # @return [String]
+    #
+    # @see to_s
+    #
+    # @since 0.1.0
     def inspect
       # TODO: Probably make this independent of options.
       "(#{self})"
@@ -47,6 +74,8 @@ class VectorNumber
     # @param mult [Symbol, String]
     # @return [String]
     # @raise [ArgumentError] if +mult+ is not in {MULT_STRINGS}'s keys
+    #
+    # @since 0.1.0
     def value_to_s(unit, coefficient, mult:)
       if !mult.is_a?(String) && !MULT_STRINGS.key?(mult)
         raise ArgumentError, "unknown key #{mult.inspect}", caller

data/lib/vector_number/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class VectorNumber # rubocop:disable Style/StaticClass
+class VectorNumber
   # @return [String]
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end