Numeric

Numeric is the class from which all higher-level numeric classes should inherit.

Numeric allows instantiation of heap-allocated objects. Other core numeric classes such as Integer are implemented as immediates, which means that each Integer is a single immutable object which is always passed by value.

a = 1
1.object_id == a.object_id   #=> true

There can only ever be one instance of the integer 1, for example. Ruby ensures this by preventing instantiation. If duplication is attempted, the same instance is returned.

Integer.new(1)                   #=> NoMethodError: undefined method `new' for Integer:Class
1.dup                            #=> 1
1.object_id == 1.dup.object_id   #=> true

For this reason, Numeric should be used when defining other numeric classes.

Classes which inherit from Numeric must implement coerce, which returns a two-member Array containing an object that has been coerced into an instance of the new class and self (see coerce).

Inheriting classes should also implement arithmetic operator methods (+, -, * and /) and the <=> operator (see Comparable). These methods may rely on coerce to ensure interoperability with instances of other numeric classes.

class Tally < Numeric
  def initialize(string)
    @string = string
  end

  def to_s
    @string
  end

  def to_i
    @string.size
  end

  def coerce(other)
    [self.class.new('|' * other.to_i), self]
  end

  def <=>(other)
    to_i <=> other.to_i
  end

  def +(other)
    self.class.new('|' * (to_i + other.to_i))
  end

  def -(other)
    self.class.new('|' * (to_i - other.to_i))
  end

  def *(other)
    self.class.new('|' * (to_i * other.to_i))
  end

  def /(other)
    self.class.new('|' * (to_i / other.to_i))
  end
end

tally = Tally.new('||')
puts tally * 2            #=> "||||"
puts tally > 1            #=> true

What’s Here

First, what’s elsewhere. Class Numeric:

• Inherits from class Object.

• Includes module Comparable.

Here, class Numeric provides methods for:

• Querying

• Comparing

• Converting

• Other

Querying

• finite?: Returns true unless self is infinite or not a number.

• infinite?: Returns -1, nil or +1, depending on whether self is -Infinity<tt>, finite, or <tt>+Infinity.

• integer?: Returns whether self is an integer.

• negative?: Returns whether self is negative.

• nonzero?: Returns whether self is not zero.

• positive?: Returns whether self is positive.

• real?: Returns whether self is a real value.

• zero?: Returns whether self is zero.

Comparing

• <=>: Returns:

  • -1 if self is less than the given value.

  • 0 if self is equal to the given value.

  • 1 if self is greater than the given value.

  • nil if self and the given value are not comparable.

• eql?: Returns whether self and the given value have the same value and type.

Converting

• % (aliased as modulo): Returns the remainder of self divided by the given value.

• -@: Returns the value of self, negated.

• abs (aliased as magnitude): Returns the absolute value of self.

• abs2: Returns the square of self.

• angle (aliased as arg and phase): Returns 0 if self is positive, Math::PI otherwise.

• ceil: Returns the smallest number greater than or equal to self, to a given precision.

• coerce: Returns array [coerced_self, coerced_other] for the given other value.

• conj (aliased as conjugate): Returns the complex conjugate of self.

• denominator: Returns the denominator (always positive) of the Rational representation of self.

• div: Returns the value of self divided by the given value and converted to an integer.

• divmod: Returns array [quotient, modulus] resulting from dividing self the given divisor.

• fdiv: Returns the Float result of dividing self by the given divisor.

• floor: Returns the largest number less than or equal to self, to a given precision.

• i: Returns the Complex object Complex(0, self). the given value.

• imaginary (aliased as imag): Returns the imaginary part of the self.

• numerator: Returns the numerator of the Rational representation of self; has the same sign as self.

• polar: Returns the array [self.abs, self.arg].

• quo: Returns the value of self divided by the given value.

• real: Returns the real part of self.

• rect (aliased as rectangular): Returns the array [self, 0].

• remainder: Returns self-arg*(self/arg).truncate for the given arg.

• round: Returns the value of self rounded to the nearest value for the given a precision.

• to_c: Returns the Complex representation of self.

• to_int: Returns the Integer representation of self, truncating if necessary.

• truncate: Returns self truncated (toward zero) to a given precision.

Other

• clone: Returns self; does not allow freezing.

• dup (aliased as +@): Returns self.

• step: Invokes the given block with the sequence of specified numbers.