Unary Plus—Returns the receiver’s value.

Unary Minus—Returns the receiver’s value, negated.

Returns zero if num equals other, nil otherwise.

Returns the absolute value of num.

   12.abs         #=> 12
   (-34.56).abs   #=> 34.56
   -34.56.abs     #=> 34.56

Alias for arg

See Complex#arg.

Returns the smallest Integer greater than or equal to num. Class Numeric achieves this by converting itself to a Float then invoking Float#ceil.

   1.ceil        #=> 1
   1.2.ceil      #=> 2
   (-1.2).ceil   #=> -1
   (-1.0).ceil   #=> -1

If aNumeric is the same type as num, returns an array containing aNumeric and num. Otherwise, returns an array with both aNumeric and num represented as Float objects. This coercion mechanism is used by Ruby to handle mixed-type numeric operations: it is intended to find a compatible common type between the two operands of the operator.

   1.coerce(2.5)   #=> [2.5, 1.0]
   1.2.coerce(3)   #=> [3.0, 1.2]
   1.coerce(2)     #=> [2, 1]

Alias for conjugate

See Complex#conjugate (short answer: returns self).

Uses / to perform division, then converts the result to an integer. Numeric does not define the / operator; this is left to subclasses.

Returns an array containing the quotient and modulus obtained by dividing num by aNumeric. If q, r = x.divmod(y), then

    q = floor(float(x)/float(y))
    x = q*y + r

The quotient is rounded toward -infinity, as shown in the following table:

   a    |  b  |  a.divmod(b)  |   a/b   | a.modulo(b) | a.remainder(b)
  ------+-----+---------------+---------+-------------+---------------
   13   |  4  |   3,    1     |   3     |    1        |     1
  ------+-----+---------------+---------+-------------+---------------
   13   | -4  |  -4,   -3     |  -3     |   -3        |     1
  ------+-----+---------------+---------+-------------+---------------
  -13   |  4  |  -4,    3     |  -4     |    3        |    -1
  ------+-----+---------------+---------+-------------+---------------
  -13   | -4  |   3,   -1     |   3     |   -1        |    -1
  ------+-----+---------------+---------+-------------+---------------
   11.5 |  4  |   2.0,  3.5   |   2.875 |    3.5      |     3.5
  ------+-----+---------------+---------+-------------+---------------
   11.5 | -4  |  -3.0, -0.5   |  -2.875 |   -0.5      |     3.5
  ------+-----+---------------+---------+-------------+---------------
  -11.5 |  4  |  -3.0   0.5   |  -2.875 |    0.5      |    -3.5
  ------+-----+---------------+---------+-------------+---------------
  -11.5 | -4  |   2.0  -3.5   |   2.875 |   -3.5      |    -3.5

Examples

   11.divmod(3)         #=> [3, 2]
   11.divmod(-3)        #=> [-4, -1]
   11.divmod(3.5)       #=> [3.0, 0.5]
   (-11).divmod(3.5)    #=> [-4.0, 3.0]
   (11.5).divmod(3.5)   #=> [3.0, 1.0]

Returns true if num and numeric are the same type and have equal values.

   1 == 1.0          #=> true
   1.eql?(1.0)       #=> false
   (1.0).eql?(1.0)   #=> true

Returns the largest integer less than or equal to num. Numeric implements this by converting anInteger to a Float and invoking Float#floor.

   1.floor      #=> 1
   (-1).floor   #=> -1

Returns a Complex number (0,self).

Alias for image

The imaginary part of a complex number, i.e. 0.

Returns true if num is an Integer (including Fixnum and Bignum).

Equivalent to num.divmod(aNumeric)[1].

Returns num if num is not zero, nil otherwise. This behavior is useful when chaining comparisons:

   a = %w( z Bb bB bb BB a aA Aa AA A )
   b = a.sort {|a,b| (a.downcase <=> b.downcase).nonzero? || a <=> b }
   b   #=> ["A", "a", "AA", "Aa", "aA", "BB", "Bb", "bB", "bb", "z"]

See Complex#polar.

Equivalent to Numeric#/, but overridden in subclasses.

The real part of a complex number, i.e. self.

If num and numeric have different signs, returns mod-numeric; otherwise, returns mod. In both cases mod is the value num.modulo(numeric). The differences between remainder and modulo (%) are shown in the table under Numeric#divmod.

Rounds num to the nearest integer. Numeric implements this by converting itself to a Float and invoking Float#round.

Trap attempts to add methods to Numeric objects. Always raises a TypeError

Invokes block with the sequence of numbers starting at num, incremented by step on each call. The loop finishes when the value to be passed to the block is greater than limit (if step is positive) or less than limit (if step is negative). If all the arguments are integers, the loop operates using an integer counter. If any of the arguments are floating point numbers, all are converted to floats, and the loop is executed floor(n + n*epsilon)+ 1 times, where n = (limit - num)/step. Otherwise, the loop starts at num, uses either the < or > operator to compare the counter against limit, and increments itself using the + operator.

   1.step(10, 2) { |i| print i, " " }
   Math::E.step(Math::PI, 0.2) { |f| print f, " " }

produces:

   1 3 5 7 9
   2.71828182845905 2.91828182845905 3.11828182845905

Invokes the child class’s to_i method to convert num to an integer.

Returns num truncated to an integer. Numeric implements this by converting its value to a float and invoking Float#truncate.

Returns true if num has a zero value.