Class: Numeric
Relationships & Source Files | |
Extension / Inclusion / Inheritance Descendants | |
Subclasses:
|
|
Super Chains via Extension / Inclusion / Inheritance | |
Instance Chain:
self,
::Comparable
|
|
Inherits: | Object |
Defined in: | numeric.c, complex.c, rational.c |
Overview
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
puts 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 and duplication.
Integer.new(1) #=> NoMethodError: undefined method `new' for Integer:Class
1.dup #=> TypeError: can't dup Fixnum
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
Instance Attribute Summary
- #integer? ⇒ Boolean readonly
-
#negative? ⇒ Boolean
readonly
Returns
true
ifnum
is less than 0. -
#nonzero? ⇒ Boolean
readonly
Returns
self
ifnum
is not zero,nil
otherwise. -
#positive? ⇒ Boolean
readonly
Returns
true
ifnum
is greater than 0. -
#real ⇒ self
readonly
Returns self.
-
#real? ⇒ Boolean
readonly
Returns
true
ifnum
is a Real number. -
#zero? ⇒ Boolean
readonly
Returns
true
ifnum
has a zero value.
Instance Method Summary
-
#modulo(numeric) ⇒ Numeric
(also: #modulo)
x.modulo(y) means x-y*(x/y).floor.
-
#+ ⇒ Numeric
Unary Plus—Returns the receiver's value.
-
#- ⇒ Numeric
Unary Minus—Returns the receiver's value, negated.
-
#<=>(other) ⇒ 0?
Returns zero if
number
equalsother
, otherwisenil
is returned if the two values are incomparable. -
#abs ⇒ Numeric
(also: #magnitude)
Returns the absolute value of
num
. -
#abs2 ⇒ Numeric
Returns square of self.
-
#angle ⇒ 0, Float
Alias for #arg.
-
#arg ⇒ 0, Float
(also: #angle, #phase)
Returns 0 if the value is positive, pi otherwise.
-
#ceil ⇒ Integer
Returns the smallest possible ::Integer that is greater than or equal to
num
. -
#coerce(numeric) ⇒ Array
If a
numeric
is the same type asnum
, returns an array containingnumeric
andnum
. -
#conj ⇒ self
(also: #conjugate)
Returns self.
-
#conjugate ⇒ self
Alias for #conj.
-
#denominator ⇒ Integer
Returns the denominator (always positive).
-
#div(numeric) ⇒ Integer
Uses
/
to perform division, then converts the result to an integer. -
#divmod(numeric) ⇒ Array
Returns an array containing the quotient and modulus obtained by dividing
num
bynumeric
. -
#eql?(numeric) ⇒ Boolean
Returns
true
ifnum
andnumeric
are the same type and have equal values. -
#fdiv(numeric) ⇒ Float
Returns float division.
-
#floor ⇒ Integer
Returns the largest integer less than or equal to
num
. -
#i ⇒ Complex(0, num)
Returns the corresponding imaginary number.
-
#imag ⇒ 0
(also: #imaginary)
Returns zero.
-
#imaginary ⇒ 0
Alias for #imag.
-
#initialize_copy(y)
Numerics are immutable values, which should not be copied.
-
#magnitude ⇒ Numeric
Alias for #abs.
-
#modulo(numeric) ⇒ Numeric
Alias for #%.
-
#numerator ⇒ Integer
Returns the numerator.
-
#phase ⇒ 0, Float
Alias for #arg.
-
#polar ⇒ Array
Returns an array; [num.abs, num.arg].
-
#quo(int_or_rat) ⇒ rat
Returns most exact division (rational for integers, float for floats).
-
#rect ⇒ Array
(also: #rectangular)
Returns an array; [num, 0].
-
#rectangular ⇒ Array
Alias for #rect.
-
#remainder(numeric) ⇒ Numeric
x.remainder(y) means x-y*(x/y).truncate.
-
#round([ndigits]) ⇒ Integer, Float
Rounds
num
to a given precision in decimal digits (default 0 digits). -
#singleton_method_added(name)
Trap attempts to add methods to
Numeric
objects. -
#step(by: step, to: limit) {|i| ... } ⇒ self
Invokes the given block with the sequence of numbers starting at
num
, incremented bystep
(defaulted to1
) on each call. -
#to_c ⇒ Complex
Returns the value as a complex.
-
#to_int ⇒ Integer
Invokes the child class's
to_i
method to convertnum
to an integer. -
#truncate ⇒ Integer
Returns
num
truncated to an ::Integer.
::Comparable - Included
#< | Compares two objects based on the receiver's #<=> method, returning true if it returns -1. |
#<= | Compares two objects based on the receiver's #<=> method, returning true if it returns -1 or 0. |
#== | Compares two objects based on the receiver's #<=> method, returning true if it returns 0. |
#> | Compares two objects based on the receiver's #<=> method, returning true if it returns 1. |
#>= | Compares two objects based on the receiver's #<=> method, returning true if it returns 0 or 1. |
#between? |
Instance Attribute Details
#integer? ⇒ Boolean
(readonly)
#negative? ⇒ Boolean
(readonly)
Returns true
if num
is less than 0.
#nonzero? ⇒ Boolean
(readonly)
Returns self
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"]
#positive? ⇒ Boolean
(readonly)
Returns true
if num
is greater than 0.
#real ⇒ self
(readonly)
Returns self.
#real? ⇒ Boolean
(readonly)
Returns true
if num
is a Real number. (i.e. not ::Complex).
#zero? ⇒ Boolean
(readonly)
Returns true
if num
has a zero value.
Instance Method Details
#modulo(numeric) ⇒ Numeric
Also known as: #modulo
#+ ⇒ Numeric
Unary Plus—Returns the receiver's value.
#- ⇒ Numeric
Unary Minus—Returns the receiver's value, negated.
#<=>(other) ⇒ 0
?
Returns zero if number
equals other
, otherwise nil
is returned if the two values are incomparable.
#abs ⇒ Numeric
#magnitude ⇒ Numeric
Also known as: #magnitude
Numeric
#magnitude ⇒ Numeric
Returns the absolute value of num
.
12.abs #=> 12
(-34.56).abs #=> 34.56
-34.56.abs #=> 34.56
#magnitude is an alias of abs
.
#abs2 ⇒ Numeric
Returns square of self.
Alias for #arg.
Also known as: #angle, #phase
Returns 0 if the value is positive, pi otherwise.
#ceil ⇒ Integer
Returns the smallest possible ::Integer that is greater than or equal to num
.
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
#coerce(numeric) ⇒ Array
If a numeric
is the same type as num
, returns an array containing numeric
and num
. Otherwise, returns an array with both a numeric
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 ⇒ self
#conjugate ⇒ self
Also known as: #conjugate
self
#conjugate ⇒ self
Returns self.
#conj ⇒ self
#conjugate ⇒ self
self
#conjugate ⇒ self
Alias for #conj.
#denominator ⇒ Integer
Returns the denominator (always positive).
#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.
Equivalent to num.divmod(numeric)[0]
.
See #divmod.
#divmod(numeric) ⇒ Array
Returns an array containing the quotient and modulus obtained by dividing num
by numeric
.
If q, r = * x.divmod(y)
, then
q = floor(x/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 | -4 | -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]
#eql?(numeric) ⇒ Boolean
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
#fdiv(numeric) ⇒ Float
Returns float division.
#floor ⇒ Integer
Returns the largest integer less than or equal to num
.
Numeric
implements this by converting an ::Integer to a ::Float and invoking Float#floor.
1.floor #=> 1
(-1).floor #=> -1
#i ⇒ Complex(0
, num
)
Returns the corresponding imaginary number. Not available for complex numbers.
#imag ⇒ 0
#imaginary ⇒ 0
Also known as: #imaginary
0
#imaginary ⇒ 0
Returns zero.
#imag ⇒ 0
#imaginary ⇒ 0
0
#imaginary ⇒ 0
Alias for #imag.
#initialize_copy(y)
Numerics are immutable values, which should not be copied.
Any attempt to use this method on a Numeric
will raise a ::TypeError.
#abs ⇒ Numeric
#magnitude ⇒ Numeric
Numeric
#magnitude ⇒ Numeric
Alias for #abs.
#modulo(numeric) ⇒ Numeric
#modulo(numeric) ⇒ Numeric
Numeric
#modulo(numeric) ⇒ Numeric
Alias for #%.
#numerator ⇒ Integer
Returns the numerator.
Alias for #arg.
#polar ⇒ Array
Returns an array; [num.abs, num.arg].
#quo(int_or_rat) ⇒ rat
#quo(flo) ⇒ flo
rat
#quo(flo) ⇒ flo
Returns most exact division (rational for integers, float for floats).
Also known as: #rectangular
Returns an array; [num, 0].
Alias for #rect.
#remainder(numeric) ⇒ Numeric
x.remainder(y) means x-y*(x/y).truncate
See #divmod.
#round([ndigits]) ⇒ Integer, Float
Rounds num
to a given precision in decimal digits (default 0 digits).
Precision may be negative. Returns a floating point number when ndigits
is more than zero.
Numeric
implements this by converting itself to a ::Float and invoking Float#round.
#singleton_method_added(name)
Trap attempts to add methods to Numeric
objects. Always raises a ::TypeError.
Numerics should be values; singleton_methods should not be added to them.
#step(by: step, to: limit) {|i| ... } ⇒ self
#step(by: step, to: limit) ⇒ Enumerator
#step(limit = nil, step = 1) {|i| ... } ⇒ self
#step(limit = nil, step = 1) ⇒ Enumerator
self
#step(by: step, to: limit) ⇒ Enumerator
#step(limit = nil, step = 1) {|i| ... } ⇒ self
#step(limit = nil, step = 1) ⇒ Enumerator
Invokes the given block with the sequence of numbers starting at num
, incremented by step
(defaulted to 1
) 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), where limit is defaulted to infinity.
In the recommended keyword argument style, either or both of step
and limit
(default infinity) can be omitted. In the fixed position argument style, zero as a step (i.e. num.step(limit, 0)) is not allowed for historical compatibility reasons.
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 the following expression:
floor(n + n*epsilon)+ 1
Where the n
is the following:
n = (limit - num)/step
Otherwise, the loop starts at num
, uses either the less-than (<) or greater-than (>) operator to compare the counter against limit
, and increments itself using the +
operator.
If no block is given, an ::Enumerator is returned instead.
For example:
p 1.step.take(4)
p 10.step(by: -1).take(4)
3.step(to: 5) { |i| print i, " " }
1.step(10, 2) { |i| print i, " " }
Math::E.step(to: Math::PI, by: 0.2) { |f| print f, " " }
Will produce:
[1, 2, 3, 4]
[10, 9, 8, 7]
3 4 5
1 3 5 7 9
2.71828182845905 2.91828182845905 3.11828182845905
#to_c ⇒ Complex
Returns the value as a complex.
#to_int ⇒ Integer
#truncate ⇒ Integer
Returns num
truncated to an ::Integer.
Numeric
implements this by converting its value to a ::Float and invoking Float#truncate.