Home Classes Methods

In Files

complex.c
numeric.c
rational.c

Parent

Object

Methods

Included Modules

Comparable

Files

Class/Module Index

No matching classes.

Numeric

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

Numeric allows instantiation of heap-allocatedobjects. Other core numeric classes such asInteger are implemented as immediates, which meansthat eachInteger is a single immutable objectwhich is always passed by value.

a =11.object_id==a.object_id#=> true

There can only ever be one instance of the integer1, forexample. Ruby ensures this by preventing instantiation. If duplication isattempted, the same instance is returned.

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

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

Classes which inherit fromNumeric mustimplementcoerce, which returns a two-memberArray containing an object that has been coerced intoan instance of the new class andself (seecoerce).

Inheriting classes should also implement arithmetic operator methods(+,-,* and/) and the<=> operator (seeComparable). These methods may rely oncoerce to ensure interoperability with instances of othernumeric classes.

classTally<Numericdefinitialize(string)@string =stringenddefto_s@stringenddefto_i@string.sizeenddefcoerce(other)    [self.class.new('|'*other.to_i),self]enddef<=>(other)to_i<=>other.to_ienddef+(other)self.class.new('|'* (to_i+other.to_i))enddef-(other)self.class.new('|'* (to_i-other.to_i))enddef*(other)self.class.new('|'* (to_i*other.to_i))enddef/(other)self.class.new('|'* (to_i/other.to_i))endendtally =Tally.new('||')putstally*2#=> "||||"putstally>1#=> true

Public Instance Methods

modulo(numeric) → realclick to toggle source

x.modulo(y) meansx-y*(x/y).floor.

Equivalent tonum.divmod(numeric)[1].

See#divmod.

                static VALUEnum_modulo(VALUE x, VALUE y){    VALUE q = num_funcall1(x, id_div, y);    return rb_funcall(x, '-', 1,                      rb_funcall(y, '*', 1, q));}

+num → numclick to toggle source

Unary Plus—Returns the receiver.

                static VALUEnum_uplus(VALUE num){    return num;}

-num → numericclick to toggle source

Unary Minus—Returns the receiver, negated.

                static VALUEnum_uminus(VALUE num){    VALUE zero;    zero = INT2FIX(0);    do_coerce(&zero, &num, TRUE);    return num_funcall1(zero, '-', num);}

number<=> other → 0 or nilclick to toggle source

Returns zero ifnumber equalsother, otherwisereturnsnil.

                static VALUEnum_cmp(VALUE x, VALUE y){    if (x == y) return INT2FIX(0);    return Qnil;}

abs → numericclick to toggle source

Returns the absolute value ofnum.

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

#magnitude is an alias for#abs.

                static VALUEnum_abs(VALUE num){    if (rb_num_negative_int_p(num)) {        return num_funcall0(num, idUMinus);    }    return num;}

abs2 → realclick to toggle source

Returns square of self.

                static VALUEnumeric_abs2(VALUE self){    return f_mul(self, self);}

angle → 0 or floatclick to toggle source

Returns 0 if the value is positive, pi otherwise.

                static VALUEnumeric_arg(VALUE self){    if (f_positive_p(self))        return INT2FIX(0);    return DBL2NUM(M_PI);}

arg → 0 or floatclick to toggle source

Returns 0 if the value is positive, pi otherwise.

                static VALUEnumeric_arg(VALUE self){    if (f_positive_p(self))        return INT2FIX(0);    return DBL2NUM(M_PI);}

ceil([ndigits]) → integer or floatclick to toggle source

Returns the smallest number greater than or equal tonum witha precision ofndigits decimal digits (default: 0).

Numeric implements this by converting its valueto aFloat and invokingFloat#ceil.

                static VALUEnum_ceil(int argc, VALUE *argv, VALUE num){    return flo_ceil(argc, argv, rb_Float(num));}

clone(freeze: true) → numclick to toggle source

Returns the receiver.freeze cannot befalse.

                static VALUEnum_clone(int argc, VALUE *argv, VALUE x){    return rb_immutable_obj_clone(argc, argv, x);}

coerce(numeric) → arrayclick to toggle source

Ifnumeric is the same type asnum, returns anarray[numeric, num]. Otherwise, returns an array with bothnumeric andnum represented asFloat objects.

This coercion mechanism is used by Ruby to handle mixed-type numericoperations: it is intended to find a compatible common type between the twooperands of the operator.

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

                static VALUEnum_coerce(VALUE x, VALUE y){    if (CLASS_OF(x) == CLASS_OF(y))        return rb_assoc_new(y, x);    x = rb_Float(x);    y = rb_Float(y);    return rb_assoc_new(y, x);}

conj → selfclick to toggle source

conjugate → self

Returns self.

                static VALUEnumeric_conj(VALUE self){    return self;}

conjugate → selfclick to toggle source

Returns self.

                static VALUEnumeric_conj(VALUE self){    return self;}

denominator → integerclick to toggle source

Returns the denominator (always positive).

                static VALUEnumeric_denominator(VALUE self){    return f_denominator(f_to_r(self));}

div(numeric) → integerclick to toggle source

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

Equivalent tonum.divmod(numeric)[0].

See#divmod.

                static VALUEnum_div(VALUE x, VALUE y){    if (rb_equal(INT2FIX(0), y)) rb_num_zerodiv();    return rb_funcall(num_funcall1(x, '/', y), rb_intern("floor"), 0);}

divmod(numeric) → arrayclick to toggle source

Returns an array containing the quotient and modulus obtained by dividingnum bynumeric.

Ifq, r = x.divmod(y), then

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

The quotient is rounded toward negative infinity, as shown in the followingtable:

 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]

                static VALUEnum_divmod(VALUE x, VALUE y){    return rb_assoc_new(num_div(x, y), num_modulo(x, y));}

dup → numclick to toggle source

Returns the receiver.

                static VALUEnum_dup(VALUE x){    return x;}

eql?(numeric) → true or falseclick to toggle source

Returnstrue ifnum andnumeric arethe same type and have equal values. Contrast this with Numeric#==, whichperforms type conversions.

1==1.0#=> true1.eql?(1.0)#=> false1.0.eql?(1.0)#=> true

                static VALUEnum_eql(VALUE x, VALUE y){    if (TYPE(x) != TYPE(y)) return Qfalse;    if (RB_TYPE_P(x, T_BIGNUM)) {        return rb_big_eql(x, y);    }    return rb_equal(x, y);}

fdiv(numeric) → floatclick to toggle source

Returns float division.

                static VALUEnum_fdiv(VALUE x, VALUE y){    return rb_funcall(rb_Float(x), '/', 1, y);}

finite? → true or falseclick to toggle source

Returnstrue ifnum is a finite number, otherwisereturnsfalse.

                static VALUEnum_finite_p(VALUE num){    return Qtrue;}

floor([ndigits]) → integer or floatclick to toggle source

Returns the largest number less than or equal tonum with aprecision ofndigits decimal digits (default: 0).

Numeric implements this by converting its valueto aFloat and invokingFloat#floor.

                static VALUEnum_floor(int argc, VALUE *argv, VALUE num){    return flo_floor(argc, argv, rb_Float(num));}

i → Complex(0, num)click to toggle source

Returns the corresponding imaginary number. Not available for complexnumbers.

-42.i#=> (0-42i)2.0.i#=> (0+2.0i)

                static VALUEnum_imaginary(VALUE num){    return rb_complex_new(INT2FIX(0), num);}

imag → 0click to toggle source

imaginary → 0

Returns zero.

                static VALUEnumeric_imag(VALUE self){    return INT2FIX(0);}

imaginary → 0click to toggle source

Returns zero.

                static VALUEnumeric_imag(VALUE self){    return INT2FIX(0);}

infinite? → -1, 1, or nilclick to toggle source

Returnsnil, -1, or 1 depending on whether the value isfinite,-Infinity, or+Infinity.

                static VALUEnum_infinite_p(VALUE num){    return Qnil;}

integer? → true or falseclick to toggle source

Returnstrue ifnum is anInteger.

1.0.integer?#=> false1.integer?#=> true

                static VALUEnum_int_p(VALUE num){    return Qfalse;}

magnitude → numericclick to toggle source

Returns the absolute value ofnum.

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

#magnitude is an alias for#abs.

                static VALUEnum_abs(VALUE num){    if (rb_num_negative_int_p(num)) {        return num_funcall0(num, idUMinus);    }    return num;}

modulo(numeric) → realclick to toggle source

x.modulo(y) meansx-y*(x/y).floor.

Equivalent tonum.divmod(numeric)[1].

See#divmod.

                static VALUEnum_modulo(VALUE x, VALUE y){    VALUE q = num_funcall1(x, id_div, y);    return rb_funcall(x, '-', 1,                      rb_funcall(y, '*', 1, q));}

negative? → true or falseclick to toggle source

Returnstrue ifnum is less than 0.

                static VALUEnum_negative_p(VALUE num){    return rb_num_negative_int_p(num) ? Qtrue : Qfalse;}

nonzero? → self or nilclick to toggle source

Returnsself ifnum is not zero,nilotherwise.

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"]

                static VALUEnum_nonzero_p(VALUE num){    if (RTEST(num_funcall0(num, rb_intern("zero?")))) {        return Qnil;    }    return num;}

numerator → integerclick to toggle source

Returns the numerator.

                static VALUEnumeric_numerator(VALUE self){    return f_numerator(f_to_r(self));}

phase → 0 or floatclick to toggle source

Returns 0 if the value is positive, pi otherwise.

                static VALUEnumeric_arg(VALUE self){    if (f_positive_p(self))        return INT2FIX(0);    return DBL2NUM(M_PI);}

polar → arrayclick to toggle source

Returns an array; [num.abs, num.arg].

                static VALUEnumeric_polar(VALUE self){    VALUE abs, arg;    if (RB_INTEGER_TYPE_P(self)) {        abs = rb_int_abs(self);        arg = numeric_arg(self);    }    else if (RB_FLOAT_TYPE_P(self)) {        abs = rb_float_abs(self);        arg = float_arg(self);    }    else if (RB_TYPE_P(self, T_RATIONAL)) {        abs = rb_rational_abs(self);        arg = numeric_arg(self);    }    else {        abs = f_abs(self);        arg = f_arg(self);    }    return rb_assoc_new(abs, arg);}

positive? → true or falseclick to toggle source

Returnstrue ifnum is greater than 0.

                static VALUEnum_positive_p(VALUE num){    const ID mid = '>';    if (FIXNUM_P(num)) {        if (method_basic_p(rb_cInteger))            return (SIGNED_VALUE)num > (SIGNED_VALUE)INT2FIX(0) ? Qtrue : Qfalse;    }    else if (RB_TYPE_P(num, T_BIGNUM)) {        if (method_basic_p(rb_cInteger))            return BIGNUM_POSITIVE_P(num) && !rb_bigzero_p(num) ? Qtrue : Qfalse;    }    return rb_num_compare_with_zero(num, mid);}

quo(int_or_rat) → ratclick to toggle source

quo(flo) → flo

Returns the most exact division (rational for integers, float for floats).

                VALUErb_numeric_quo(VALUE x, VALUE y){    if (RB_TYPE_P(x, T_COMPLEX)) {        return rb_complex_div(x, y);    }    if (RB_FLOAT_TYPE_P(y)) {        return rb_funcallv(x, idFdiv, 1, &y);    }    x = rb_convert_type(x, T_RATIONAL, "Rational", "to_r");    return rb_rational_div(x, y);}

real → selfclick to toggle source

Returns self.

                static VALUEnumeric_real(VALUE self){    return self;}

real? → true or falseclick to toggle source

Returnstrue ifnum is a real number (i.e. notComplex).

                static VALUEnum_real_p(VALUE num){    return Qtrue;}

rect → arrayclick to toggle source

rectangular → array

Returns an array; [num, 0].

                static VALUEnumeric_rect(VALUE self){    return rb_assoc_new(self, INT2FIX(0));}

rectangular → arrayclick to toggle source

Returns an array; [num, 0].

                static VALUEnumeric_rect(VALUE self){    return rb_assoc_new(self, INT2FIX(0));}

remainder(numeric) → realclick to toggle source

x.remainder(y) meansx-y*(x/y).truncate.

See#divmod.

                static VALUEnum_remainder(VALUE x, VALUE y){    VALUE z = num_funcall1(x, '%', y);    if ((!rb_equal(z, INT2FIX(0))) &&        ((rb_num_negative_int_p(x) &&          rb_num_positive_int_p(y)) ||         (rb_num_positive_int_p(x) &&          rb_num_negative_int_p(y)))) {        return rb_funcall(z, '-', 1, y);    }    return z;}

round([ndigits]) → integer or floatclick to toggle source

Returnsnum rounded to the nearest value with a precision ofndigits decimal digits (default: 0).

Numeric implements this by converting its valueto aFloat and invokingFloat#round.

                static VALUEnum_round(int argc, VALUE* argv, VALUE num){    return flo_round(argc, argv, rb_Float(num));}

singleton_method_added(p1)click to toggle source

                static VALUE num_sadded(VALUE x, VALUE name))

step(by: step, to: limit) {|i| block } → selfclick to toggle source

step(by: step, to: limit) → an_enumerator

step(by: step, to: limit) → an_arithmetic_sequence

step(limit=nil, step=1) {|i| block } → self

step(limit=nil, step=1) → an_enumerator

step(limit=nil, step=1) → an_arithmetic_sequence

Invokes the given block with the sequence of numbers starting atnum, incremented bystep (defaulted to1) on each call.

The loop finishes when the value to be passed to the block is greater thanlimit (ifstep is positive) or less thanlimit (ifstep is negative), wherelimit is defaulted to infinity.

In the recommended keyword argument style, either or both ofstep andlimit (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 historicalcompatibility reasons.

If all the arguments are integers, the loop operates using an integercounter.

If any of the arguments are floating point numbers, all are converted tofloats, and the loop is executedfloor(n + n*Float::EPSILON) + 1times, wheren = (limit - num)/step.

Otherwise, the loop starts atnum, uses either the less-than(<) or greater-than (>) operator to comparethe counter againstlimit, and increments itself using the+ operator.

If no block is given, anEnumerator isreturned instead. Especially, the enumerator is anEnumerator::ArithmeticSequenceif bothlimit andstep are kind ofNumeric ornil.

For example:

p1.step.take(4)p10.step(by:-1).take(4)3.step(to:5) {|i|printi," " }1.step(10,2) {|i|printi," " }Math::E.step(to:Math::PI,by:0.2) {|f|printf," " }

Will produce:

[1, 2, 3, 4][10, 9, 8, 7]3 4 51 3 5 7 92.718281828459045 2.9182818284590453 3.118281828459045

                static VALUEnum_step(int argc, VALUE *argv, VALUE from){    VALUE to, step;    int desc, inf;    if (!rb_block_given_p()) {        VALUE by = Qundef;        num_step_extract_args(argc, argv, &to, &step, &by);        if (by != Qundef) {            step = by;        }        if (NIL_P(step)) {            step = INT2FIX(1);        }        else if (rb_equal(step, INT2FIX(0))) {            rb_raise(rb_eArgError, "step can't be 0");        }        if ((NIL_P(to) || rb_obj_is_kind_of(to, rb_cNumeric)) &&            rb_obj_is_kind_of(step, rb_cNumeric)) {            return rb_arith_seq_new(from, ID2SYM(rb_frame_this_func()), argc, argv,                                    num_step_size, from, to, step, FALSE);        }        return SIZED_ENUMERATOR(from, 2, ((VALUE [2]){to, step}), num_step_size);    }    desc = num_step_scan_args(argc, argv, &to, &step, TRUE, FALSE);    if (rb_equal(step, INT2FIX(0))) {        inf = 1;    }    else if (RB_TYPE_P(to, T_FLOAT)) {        double f = RFLOAT_VALUE(to);        inf = isinf(f) && (signbit(f) ? desc : !desc);    }    else inf = 0;    if (FIXNUM_P(from) && (inf || FIXNUM_P(to)) && FIXNUM_P(step)) {        long i = FIX2LONG(from);        long diff = FIX2LONG(step);        if (inf) {            for (;; i += diff)                rb_yield(LONG2FIX(i));        }        else {            long end = FIX2LONG(to);            if (desc) {                for (; i >= end; i += diff)                    rb_yield(LONG2FIX(i));            }            else {                for (; i <= end; i += diff)                    rb_yield(LONG2FIX(i));            }        }    }    else if (!ruby_float_step(from, to, step, FALSE, FALSE)) {        VALUE i = from;        if (inf) {            for (;; i = rb_funcall(i, '+', 1, step))                rb_yield(i);        }        else {            ID cmp = desc ? '<' : '>';            for (; !RTEST(rb_funcall(i, cmp, 1, to)); i = rb_funcall(i, '+', 1, step))                rb_yield(i);        }    }    return from;}

to_c → complexclick to toggle source

Returns the value as a complex.

                static VALUEnumeric_to_c(VALUE self){    return rb_complex_new1(self);}

to_int → integerclick to toggle source

Invokes the child class'sto_i method to convertnum to an integer.

1.0.class#=> Float1.0.to_int.class#=> Integer1.0.to_i.class#=> Integer

                static VALUEnum_to_int(VALUE num){    return num_funcall0(num, id_to_i);}

truncate([ndigits]) → integer or floatclick to toggle source

Returnsnum truncated (toward zero) to a precision ofndigits decimal digits (default: 0).

Numeric implements this by converting its valueto aFloat and invokingFloat#truncate.

                static VALUEnum_truncate(int argc, VALUE *argv, VALUE num){    return flo_truncate(argc, argv, rb_Float(num));}

zero? → true or falseclick to toggle source

Returnstrue ifnum has a zero value.

                static VALUEnum_zero_p(VALUE num){    if (rb_equal(num, INT2FIX(0))) {        return Qtrue;    }    return Qfalse;}

This page was generated for Ruby 3.0.0

Generated with Ruby-doc Rdoc Generator 0.42.0.

Movatterモバイル変換

HomeClassesMethods

In Files

Parent

Methods

Included Modules

Files

Class/Module Index

Numeric

Public Instance Methods

Home Classes Methods