- Inheritance
- < Object
- Included Modules
- Comparable
Numeric is a built-in class on which Fixnum, Bignum, etc., are based. Here some methods are added so that all number types can be treated to some extent as Complex numbers.
Methods
Instance
| Visibility | Signature |
|---|---|
| public | +@ () |
| public | -@ () |
| public | <=> (p1) |
| public | abs () |
| public | angle () |
| public | arg () |
| public | ceil () |
| public | coerce (p1) |
| public | conj () |
| public | conjugate () |
| public | div (p1) |
| public | divmod (p1) |
| public | eql? (p1) |
| public | fdiv (p1) |
| public | floor () |
| public | im () |
| public | imag () |
| public | image () |
| public | integer? () |
| public | modulo (p1) |
| public | nonzero? () |
| public | polar () |
| public | quo (p1) |
| public | real () |
| public | remainder (p1) |
| public | round () |
| public | singleton_method_added (p1) |
| public | step (...) |
| public | to_int () |
| public | truncate () |
| public | zero? () |
Instance Method Detail
+num => num
Unary Plus—Returns the receiver‘s value.
-num => numeric
Unary Minus—Returns the receiver‘s value, negated.
num <=> other → 0 or nil
Returns zero if num equals other, nil otherwise.
num.abs => num or numeric
Returns the absolute value of num.
12.abs #=> 12 (-34.56).abs #=> 34.56 -34.56.abs #=> 34.56
angle()
Alias for arg
arg()
See Complex#arg.
num.ceil => integer
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
num.coerce(numeric) => array
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]
conj()
Alias for conjugate
conjugate()
See Complex#conjugate (short answer: returns self).
num.div(numeric) => integer
Uses / to perform division, then converts the result to an integer. Numeric does not define the / operator; this is left to subclasses.
num.divmod( aNumeric ) → anArray
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, 3.5 | 2.875 | 3.5 | 3.5 ------+-----+---------------+---------+-------------+--------------- 11.5 | -4 | -3, -0.5 | -2.875 | -0.5 | 3.5 ------+-----+---------------+---------+-------------+--------------- -11.5 | 4 | -3, 0.5 | -2.875 | 0.5 | -3.5 ------+-----+---------------+---------+-------------+--------------- -11.5 | -4 | 2 -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.5] (-11).divmod(3.5) #=> [-4, 3.0] (11.5).divmod(3.5) #=> [3, 1.0]
num.eql?(numeric) => true or false
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
num.quo(numeric) => result
num.fdiv(numeric) => result
Equivalent to Numeric#/, but overridden in subclasses.
num.floor => integer
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
im()
Returns a Complex number (0,self).
imag()
Alias for image
image()
The imaginary part of a complex number, i.e. 0.
num.integer? → true or false
num.modulo(numeric) => result
Equivalent to num.divmod(aNumeric)[1].
num.nonzero? => num or nil
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"]
polar()
See Complex#polar.
num.quo(numeric) => result
num.fdiv(numeric) => result
Equivalent to Numeric#/, but overridden in subclasses.
real()
The real part of a complex number, i.e. self.
num.remainder(numeric) => result
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.
num.round => integer
Rounds num to the nearest integer. Numeric implements this by converting itself to a Float and invoking Float#round.
singleton_method_added(p1)
num.step(limit, step ) {|i| block } => num
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
num.to_int => integer
Invokes the child class‘s to_i method to convert num to an integer.
num.truncate => integer
Returns num truncated to an integer. Numeric implements this by converting its value to a float and invoking Float#truncate.
num.zero? => true or false
Returns true if num has a zero value.