vector_number 0.4.3 → 0.6.0

data/lib/vector_number/converting.rb

@@ -1,152 +1,142 @@
 # frozen_string_literal: true
 
 class VectorNumber
-  # Methods for converting to different number classes.
-  module Converting
-    # Return real part of the number.
-    #
-    # @example
-    #   VectorNumber[23, "a"].real # => 23
-    #   VectorNumber["a"].real # => 0
-    #
-    # @return [Integer, Float, Rational, BigDecimal]
-    #
-    # @since 0.1.0
-    def real = @data[R]
-
-    # Return imaginary part of the number.
-    #
-    # @example
-    #   VectorNumber[23, "a"].imaginary # => 0
-    #   VectorNumber["a", Complex(1, 2r)].imag # => (2/1)
-    #
-    # @return [Integer, Float, Rational, BigDecimal]
-    #
-    # @since 0.1.0
-    def imaginary = @data[I]
-
-    # @since 0.2.1
-    alias imag imaginary
-
-    # Return value as an Integer, truncating it, if only real part is non-zero.
-    #
-    # @example
-    #   VectorNumber[13.5].to_i # => 13
-    #   VectorNumber[13r/12].to_int # => 1
-    #   [1.1, 2.2, 3.3][VectorNumber[2]] # => 3.3
-    #   VectorNumber[2, 2i].to_i # RangeError
-    #   VectorNumber[2, :i].to_f # RangeError
-    #
-    #   Integer(VectorNumber[2]) # => 2
-    #   Integer(VectorNumber[2, "i"]) # RangeError
-    #
-    # @return [Integer]
-    # @raise [RangeError] if any non-real part is non-zero
-    #
-    # @since 0.1.0
-    def to_i
-      numeric?(1) ? real.to_i : raise_convert_error(Integer)
-    end
-
-    # @since 0.1.0
-    alias to_int to_i
-
-    # Return value as a Float if only real part is non-zero.
-    #
-    # @example
-    #   VectorNumber[13.5].to_f # => 13.5
-    #   VectorNumber[13r/12].to_f # => 1.0833333333333333
-    #   VectorNumber[2, 2i].to_f # RangeError
-    #   VectorNumber[2, :i].to_f # RangeError
-    #
-    #   Float(VectorNumber[2]) # => 2.0
-    #   Float(VectorNumber[2, "i"]) # RangeError
-    #
-    # @return [Float]
-    # @raise [RangeError] if any non-real part is non-zero
-    #
-    # @since 0.1.0
-    def to_f
-      numeric?(1) ? real.to_f : raise_convert_error(Float)
-    end
-
-    # Return value as a Rational if only real part is non-zero.
-    #
-    # @example
-    #   VectorNumber[13.5].to_r # => (27/2)
-    #   VectorNumber[13r/12].to_r # => (13/12)
-    #   VectorNumber[2, 2i].to_r # RangeError
-    #   VectorNumber[2, :i].to_r # RangeError
-    #
-    #   Rational(VectorNumber[2]) # => (2/1)
-    #   Rational(VectorNumber[2, "i"]) # RangeError
-    #
-    # @return [Rational]
-    # @raise [RangeError] if any non-real part is non-zero
-    #
-    # @since 0.1.0
-    def to_r
-      numeric?(1) ? real.to_r : raise_convert_error(Rational)
-    end
-
-    # Return value as a BigDecimal if only real part is non-zero.
-    #
-    # @example
-    #   VectorNumber[13.5].to_d # => 0.135e2
-    #   VectorNumber[13r/12].to_d # ArgumentError
-    #   VectorNumber[13r/12].to_d(5) # => 0.10833e1
-    #   VectorNumber[2, 2i].to_d # RangeError
-    #   VectorNumber[2, :i].to_d # RangeError
-    #
-    #   # This does't work without NumericRefinements:
-    #   BigDecimal(VectorNumber[2]) # TypeError
-    #   # #to_s can be used as a workaround if refinements aren't used:
-    #   BigDecimal(VectorNumber[2].to_s) # => 0.2e1
-    #   BigDecimal(VectorNumber[2, "i"].to_s) # => ArgumentError
-    #
-    # @param ndigits [Integer] precision
-    # @return [BigDecimal]
-    # @raise [RangeError] if any non-real part is non-zero
-    # @raise [NameError] if BigDecimal is not defined
-    #
-    # @see Kernel.BigDecimal
-    # @see NumericRefinements
-    #
-    # @since 0.1.0
-    def to_d(ndigits = nil)
-      if numeric?(1)
-        return BigDecimal(real, ndigits) if ndigits
-        return BigDecimal(real, Float::DIG) if real.is_a?(Float)
-
-        BigDecimal(real)
-      else
-        raise_convert_error(BigDecimal)
-      end
-    end
-
-    # Return value as a Complex if only real and/or imaginary parts are non-zero.
-    #
-    # @example
-    #   VectorNumber[13.5].to_c # => (13.5+0i)
-    #   VectorNumber[13r/12].to_c # => ((13/12)+0i)
-    #   VectorNumber[2, 2i].to_c # => (2+2i)
-    #   VectorNumber[2, :i].to_c # RangeError
-    #
-    #   Complex(VectorNumber[2]) # => (2+0i)
-    #   Complex(VectorNumber[2, "i"]) # RangeError
-    #
-    # @return [Complex]
-    # @raise [RangeError] if any non-real, non-imaginary part is non-zero
-    #
-    # @since 0.1.0
-    def to_c
-      numeric?(2) ? Complex(real, imaginary) : raise_convert_error(Complex)
-    end
-
-    private
-
-    def raise_convert_error(klass)
-      raise RangeError, "can't convert #{self} into #{klass}", caller
-    end
+  # @group Converting to different numeric classes
+
+  # Return real part of the number.
+  #
+  # @example
+  #   VectorNumber[23, "a"].real # => 23
+  #   VectorNumber["a"].real # => 0
+  #
+  # @return [Integer, Float, Rational, BigDecimal]
+  def real = @data[R]
+
+  # Return imaginary part of the number.
+  #
+  # @example
+  #   VectorNumber[23, "a"].imaginary # => 0
+  #   VectorNumber["a", Complex(1, 2r)].imag # => (2/1)
+  #
+  # @return [Integer, Float, Rational, BigDecimal]
+  def imaginary = @data[I]
+
+  # @since 0.2.1
+  alias imag imaginary
+
+  # Return value as an Integer, truncating it, if only real part is non-zero.
+  #
+  # @example
+  #   VectorNumber[13.5].to_i # => 13
+  #   VectorNumber[13r/12].to_int # => 1
+  #   [1.1, 2.2, 3.3][VectorNumber[2]] # => 3.3
+  #   VectorNumber[2, 2i].to_i # RangeError
+  #   VectorNumber[2, :i].to_f # RangeError
+  #
+  #   Integer(VectorNumber[2]) # => 2
+  #   Integer(VectorNumber[2, "i"]) # RangeError
+  #
+  # @return [Integer]
+  # @raise [RangeError] if any non-real part is non-zero
+  def to_i
+    raise_convert_error(Integer) unless numeric?(1)
+
+    real.to_i
+  end
+
+  alias to_int to_i
+
+  # Return value as a Float if only real part is non-zero.
+  #
+  # @example
+  #   VectorNumber[13.5].to_f # => 13.5
+  #   VectorNumber[13r/12].to_f # => 1.0833333333333333
+  #   VectorNumber[2, 2i].to_f # RangeError
+  #   VectorNumber[2, :i].to_f # RangeError
+  #
+  #   Float(VectorNumber[2]) # => 2.0
+  #   Float(VectorNumber[2, "i"]) # RangeError
+  #
+  # @return [Float]
+  # @raise [RangeError] if any non-real part is non-zero
+  def to_f
+    raise_convert_error(Float) unless numeric?(1)
+
+    real.to_f
+  end
+
+  # Return value as a Rational if only real part is non-zero.
+  #
+  # @example
+  #   VectorNumber[13.5].to_r # => (27/2)
+  #   VectorNumber[13r/12].to_r # => (13/12)
+  #   VectorNumber[2, 2i].to_r # RangeError
+  #   VectorNumber[2, :i].to_r # RangeError
+  #
+  #   Rational(VectorNumber[2]) # => (2/1)
+  #   Rational(VectorNumber[2, "i"]) # RangeError
+  #
+  # @return [Rational]
+  # @raise [RangeError] if any non-real part is non-zero
+  def to_r
+    raise_convert_error(Rational) unless numeric?(1)
+
+    real.to_r
+  end
+
+  # Return value as a BigDecimal if only real part is non-zero.
+  #
+  # @example
+  #   VectorNumber[13.5].to_d # => 0.135e2
+  #   VectorNumber[13r/12].to_d # ArgumentError
+  #   VectorNumber[13r/12].to_d(5) # => 0.10833e1
+  #   VectorNumber[2, 2i].to_d # RangeError
+  #   VectorNumber[2, :i].to_d # RangeError
+  #
+  #   # This does't work without NumericRefinements:
+  #   BigDecimal(VectorNumber[2]) # TypeError
+  #   # #to_s can be used as a workaround if refinements aren't used:
+  #   BigDecimal(VectorNumber[2].to_s) # => 0.2e1
+  #   BigDecimal(VectorNumber[2, "i"].to_s) # => ArgumentError
+  #
+  # @param ndigits [Integer] precision
+  # @return [BigDecimal]
+  # @raise [RangeError] if any non-real part is non-zero
+  # @raise [NameError] if BigDecimal is not defined
+  #
+  # @see Kernel.BigDecimal
+  # @see NumericRefinements
+  def to_d(ndigits = nil)
+    raise_convert_error(BigDecimal) unless numeric?(1)
+
+    return BigDecimal(real, ndigits) if ndigits
+    return BigDecimal(real, Float::DIG) if real.is_a?(Float)
+
+    BigDecimal(real)
+  end
+
+  # Return value as a Complex if only real and/or imaginary parts are non-zero.
+  #
+  # @example
+  #   VectorNumber[13.5].to_c # => (13.5+0i)
+  #   VectorNumber[13r/12].to_c # => ((13/12)+0i)
+  #   VectorNumber[2, 2i].to_c # => (2+2i)
+  #   VectorNumber[2, :i].to_c # RangeError
+  #
+  #   Complex(VectorNumber[2]) # => (2+0i)
+  #   Complex(VectorNumber[2, "i"]) # RangeError
+  #
+  # @return [Complex]
+  # @raise [RangeError] if any non-real, non-imaginary part is non-zero
+  def to_c
+    raise_convert_error(Complex) unless numeric?(2)
+
+    Complex(real, imaginary)
+  end
+
+  private
+
+  def raise_convert_error(klass)
+    raise RangeError, "can't convert #{self} into #{klass}", caller
   end
 end

data/lib/vector_number/enumerating.rb

@@ -1,128 +1,114 @@
 # frozen_string_literal: true
 
 class VectorNumber
-  # Methods for enumerating values of the number.
-  #
+  # @group Hash-like operations
+
   # +Enumerable+ is included so its methods can be used.
   # @example using Enumerable methods
   #   VectorNumber["a", "b", 6].include?(["a", 1]) # => true
   #   VectorNumber["a", "b", 6].select { |u, c| u.is_a?(String) } # => [["a", 1], ["b", 1]]
-  module Enumerating
-    # @since 0.1.0
-    include ::Enumerable
+  include ::Enumerable
 
-    # Iterate through every pair of unit and coefficient.
-    # Returns +Enumerator+ (with set +size+) if no block is given.
-    #
-    # @example
-    #   v = VectorNumber["a", "b", 6]
-    #   units = []
-    #   v.each { |u, c| units << u unless u.is_a?(Numeric) } # => (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_pair.peek # => ["a", 1]
-    #
-    # @overload each
-    #   @yieldparam unit [Object]
-    #   @yieldparam coefficient [Integer, Float, Rational, BigDecimal]
-    #   @yieldreturn [void]
-    #   @return [VectorNumber] self
-    # @overload each
-    #   @return [Enumerator]
-    #
-    # @see Enumerable
-    # @see Enumerator
-    #
-    # @since 0.1.0
-    def each(&block)
-      return to_enum { size } unless block_given?
+  # Iterate through every pair of unit and coefficient.
+  # Returns +Enumerator+ (with set +size+) if no block is given.
+  #
+  # @example
+  #   v = VectorNumber["a", "b", 6]
+  #   units = []
+  #   v.each { |u, c| units << u unless u.is_a?(Numeric) } # => (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_pair.peek # => ["a", 1]
+  #
+  # @overload each
+  #   @yieldparam unit [Object]
+  #   @yieldparam coefficient [Numeric]
+  #   @yieldreturn [void]
+  #   @return [VectorNumber] self
+  # @overload each
+  #   @return [Enumerator]
+  #
+  # @see Enumerable
+  # @see Enumerator
+  def each(&block)
+    return to_enum { size } unless block_given?
 
-      @data.each(&block)
-      self
-    end
+    @data.each(&block)
+    self
+  end
 
-    # @since 0.1.0
-    alias each_pair each
+  alias each_pair each
 
-    # Get a list of units with non-zero coefficients.
-    #
-    # @example
-    #   VectorNumber["a", "b", 6].units # => ["a", "b", 1]
-    #   VectorNumber.new.keys # => []
-    #
-    # @return [Array<Object>]
-    #
-    # @since 0.1.0
-    def units = @data.keys
+  # Get a list of units with non-zero coefficients.
+  #
+  # @example
+  #   VectorNumber["a", "b", 6].units # => ["a", "b", 1]
+  #   VectorNumber.new.keys # => []
+  #
+  # @return [Array<Object>]
+  def units = @data.keys
 
-    # @since 0.1.0
-    alias keys units
+  alias keys units
 
-    # Get a list of non-zero coefficients.
-    #
-    # @example
-    #   VectorNumber["a", "b", 6].coefficients # => [1, 1, 6]
-    #   VectorNumber.new.values # => []
-    #
-    # @return [Array<Integer, Float, Rational, BigDecimal>]
-    #
-    # @since 0.1.0
-    def coefficients = @data.values
+  # Get a list of non-zero coefficients.
+  #
+  # @example
+  #   VectorNumber["a", "b", 6].coefficients # => [1, 1, 6]
+  #   VectorNumber.new.values # => []
+  #
+  # @return [Array<Numeric>]
+  def coefficients = @data.values
 
-    # @since 0.1.0
-    alias values coefficients
+  alias values coefficients
 
-    # Get mutable hash with vector's data.
-    #
-    # Returned hash has a default value of 0.
-    #
-    # @example
-    #   VectorNumber["a", "b", 6].to_h # => {"a"=>1, "b"=>1, 1=>6}
-    #   VectorNumber["a", "b", 6].to_h["c"] # => 0
-    #
-    # @return [Hash{Object => Integer, Float, Rational, BigDecimal}]
-    #
-    # @since 0.1.0
-    def to_h(&block)
-      # TODO: Remove block argument.
-      if block_given?
-        @data.to_h(&block)
-      else
-        @data.dup
-      end
+  # Get mutable hash with vector's data.
+  #
+  # Returned hash has a default value of 0.
+  #
+  # @example
+  #   VectorNumber["a", "b", 6].to_h # => {"a"=>1, "b"=>1, 1=>6}
+  #   VectorNumber["a", "b", 6].to_h["c"] # => 0
+  #
+  # @return [Hash{Object => Numeric}]
+  def to_h(&block)
+    # TODO: Remove block argument.
+    if block_given?
+      @data.to_h(&block)
+    else
+      @data.dup
     end
+  end
 
-    # Get the coefficient for the unit.
-    #
-    # If the +unit?(unit)+ is false, 0 is returned.
-    # Note that units for real and imaginary parts are
-    # VectorNumber::R and VectorNumber::I respectively.
-    #
-    # @example
-    #   VectorNumber["a", "b", 6]["a"] # => 1
-    #   VectorNumber["a", "b", 6]["c"] # => 0
-    #
-    # @param unit [Object]
-    # @return [Integer, Float, Rational, BigDecimal]
-    #
-    # @since 0.2.4
-    def [](unit) = @data[unit]
+  # Get the coefficient for the unit.
+  #
+  # If the +unit?(unit)+ is false, 0 is returned.
+  # Note that units for real and imaginary parts are
+  # VectorNumber::R and VectorNumber::I respectively.
+  #
+  # @example
+  #   VectorNumber["a", "b", 6]["a"] # => 1
+  #   VectorNumber["a", "b", 6]["c"] # => 0
+  #
+  # @param unit [Object]
+  # @return [Numeric]
+  #
+  # @since 0.2.4
+  def [](unit) = @data[unit]
 
-    # Check if a unit has a non-zero coefficient.
-    #
-    # @example
-    #   VectorNumber["a", "b", 6].unit?("a") # => true
-    #   VectorNumber["a", "b", 6].key?("c") # => false
-    #
-    # @param unit [Object]
-    # @return [Boolean]
-    #
-    # @since 0.2.4
-    def unit?(unit) = @data.key?(unit)
+  # Check if a unit has a non-zero coefficient.
+  #
+  # @example
+  #   VectorNumber["a", "b", 6].unit?("a") # => true
+  #   VectorNumber["a", "b", 6].key?("c") # => false
+  #
+  # @param unit [Object]
+  # @return [Boolean]
+  #
+  # @since 0.2.4
+  def unit?(unit) = @data.key?(unit)
 
-    # @since 0.2.4
-    alias key? unit?
-  end
+  # @since 0.2.4
+  alias key? unit?
 end