Home Classes Methods

If the platform supports denormalized numbers, there are numbers betweenzero andFloat::MIN. 0.0.next_float returnsthe smallest positive floating point number including denormalized numbers.

MIN_10_EXP

The smallest negative exponent in a double-precision floating point where10 raised to this power minus 1.

Usually defaults to -307.

MIN_EXP

The smallest possible exponent value in a double-precision floating point.

Usually defaults to -1021.

NAN

An expression representing a value which is “not a number”.

RADIX

The base of the floating point, or number of unique digits used torepresent the number.

Usually defaults to 2 on most systems, which would represent a base-10decimal.

Public Instance Methods

float % other → floatclick to toggle source

Returns the modulo after division offloat byother.

6543.21.modulo(137)#=> 104.210000000000046543.21.modulo(137.24)#=> 92.92999999999961

                static VALUEflo_mod(VALUE x, VALUE y){    double fy;    if (RB_TYPE_P(y, T_FIXNUM)) {        fy = (double)FIX2LONG(y);    }    else if (RB_TYPE_P(y, T_BIGNUM)) {        fy = rb_big2dbl(y);    }    else if (RB_TYPE_P(y, T_FLOAT)) {        fy = RFLOAT_VALUE(y);    }    else {        return rb_num_coerce_bin(x, y, '%');    }    return DBL2NUM(ruby_float_mod(RFLOAT_VALUE(x), fy));}

float * other → floatclick to toggle source

Returns a newFloat which is the product offloat andother.

                VALUErb_float_mul(VALUE x, VALUE y){    if (RB_TYPE_P(y, T_FIXNUM)) {        return DBL2NUM(RFLOAT_VALUE(x) * (double)FIX2LONG(y));    }    else if (RB_TYPE_P(y, T_BIGNUM)) {        return DBL2NUM(RFLOAT_VALUE(x) * rb_big2dbl(y));    }    else if (RB_TYPE_P(y, T_FLOAT)) {        return DBL2NUM(RFLOAT_VALUE(x) * RFLOAT_VALUE(y));    }    else {        return rb_num_coerce_bin(x, y, '*');    }}

float ** other → floatclick to toggle source

Raisesfloat to the power ofother.

2.0**3#=> 8.0

                VALUErb_float_pow(VALUE x, VALUE y){    double dx, dy;    if (y == INT2FIX(2)) {        dx = RFLOAT_VALUE(x);        return DBL2NUM(dx * dx);    }    else if (RB_TYPE_P(y, T_FIXNUM)) {        dx = RFLOAT_VALUE(x);        dy = (double)FIX2LONG(y);    }    else if (RB_TYPE_P(y, T_BIGNUM)) {        dx = RFLOAT_VALUE(x);        dy = rb_big2dbl(y);    }    else if (RB_TYPE_P(y, T_FLOAT)) {        dx = RFLOAT_VALUE(x);        dy = RFLOAT_VALUE(y);        if (dx < 0 && dy != round(dy))            return rb_dbl_complex_new_polar_pi(pow(-dx, dy), dy);    }    else {        return rb_num_coerce_bin(x, y, idPow);    }    return DBL2NUM(pow(dx, dy));}

float + other → floatclick to toggle source

Returns a newFloat which is the sum offloat andother.

                VALUErb_float_plus(VALUE x, VALUE y){    if (RB_TYPE_P(y, T_FIXNUM)) {        return DBL2NUM(RFLOAT_VALUE(x) + (double)FIX2LONG(y));    }    else if (RB_TYPE_P(y, T_BIGNUM)) {        return DBL2NUM(RFLOAT_VALUE(x) + rb_big2dbl(y));    }    else if (RB_TYPE_P(y, T_FLOAT)) {        return DBL2NUM(RFLOAT_VALUE(x) + RFLOAT_VALUE(y));    }    else {        return rb_num_coerce_bin(x, y, '+');    }}

float - other → floatclick to toggle source

Returns a newFloat which is the difference offloat andother.

                VALUErb_float_minus(VALUE x, VALUE y){    if (RB_TYPE_P(y, T_FIXNUM)) {        return DBL2NUM(RFLOAT_VALUE(x) - (double)FIX2LONG(y));    }    else if (RB_TYPE_P(y, T_BIGNUM)) {        return DBL2NUM(RFLOAT_VALUE(x) - rb_big2dbl(y));    }    else if (RB_TYPE_P(y, T_FLOAT)) {        return DBL2NUM(RFLOAT_VALUE(x) - RFLOAT_VALUE(y));    }    else {        return rb_num_coerce_bin(x, y, '-');    }}

-float → floatclick to toggle source

Returnsfloat, negated.

                VALUErb_float_uminus(VALUE flt){    return DBL2NUM(-RFLOAT_VALUE(flt));}

float / other → floatclick to toggle source

Returns a newFloat which is the result ofdividingfloat byother.

                VALUErb_float_div(VALUE x, VALUE y){    double num = RFLOAT_VALUE(x);    double den;    double ret;    if (RB_TYPE_P(y, T_FIXNUM)) {        den = FIX2LONG(y);    }    else if (RB_TYPE_P(y, T_BIGNUM)) {        den = rb_big2dbl(y);    }    else if (RB_TYPE_P(y, T_FLOAT)) {        den = RFLOAT_VALUE(y);    }    else {        return rb_num_coerce_bin(x, y, '/');    }    ret = double_div_double(num, den);    return DBL2NUM(ret);}

float< real → true or falseclick to toggle source

Returnstrue iffloat is less thanreal.

The result ofNaN < NaN is undefined, so animplementation-dependent value is returned.

                static VALUEflo_lt(VALUE x, VALUE y){    double a, b;    a = RFLOAT_VALUE(x);    if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {        VALUE rel = rb_integer_float_cmp(y, x);        if (FIXNUM_P(rel))            return -FIX2LONG(rel) < 0 ? Qtrue : Qfalse;        return Qfalse;    }    else if (RB_TYPE_P(y, T_FLOAT)) {        b = RFLOAT_VALUE(y);#if MSC_VERSION_BEFORE(1300)        if (isnan(b)) return Qfalse;#endif    }    else {        return rb_num_coerce_relop(x, y, '<');    }#if MSC_VERSION_BEFORE(1300)    if (isnan(a)) return Qfalse;#endif    return (a < b)?Qtrue:Qfalse;}

float<= real → true or falseclick to toggle source

Returnstrue iffloat is less than or equal toreal.

The result ofNaN <= NaN is undefined, so animplementation-dependent value is returned.

                static VALUEflo_le(VALUE x, VALUE y){    double a, b;    a = RFLOAT_VALUE(x);    if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {        VALUE rel = rb_integer_float_cmp(y, x);        if (FIXNUM_P(rel))            return -FIX2LONG(rel) <= 0 ? Qtrue : Qfalse;        return Qfalse;    }    else if (RB_TYPE_P(y, T_FLOAT)) {        b = RFLOAT_VALUE(y);#if MSC_VERSION_BEFORE(1300)        if (isnan(b)) return Qfalse;#endif    }    else {        return rb_num_coerce_relop(x, y, idLE);    }#if MSC_VERSION_BEFORE(1300)    if (isnan(a)) return Qfalse;#endif    return (a <= b)?Qtrue:Qfalse;}

float<=> real → -1, 0, +1, or nilclick to toggle source

Returns -1, 0, or +1 depending on whetherfloat is less than,equal to, or greater thanreal. This is the basis for thetests in theComparable module.

The result ofNaN <=> NaN is undefined, so animplementation-dependent value is returned.

nil is returned if the two values are incomparable.

                static VALUEflo_cmp(VALUE x, VALUE y){    double a, b;    VALUE i;    a = RFLOAT_VALUE(x);    if (isnan(a)) return Qnil;    if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {        VALUE rel = rb_integer_float_cmp(y, x);        if (FIXNUM_P(rel))            return LONG2FIX(-FIX2LONG(rel));        return rel;    }    else if (RB_TYPE_P(y, T_FLOAT)) {        b = RFLOAT_VALUE(y);    }    else {        if (isinf(a) && (i = rb_check_funcall(y, rb_intern("infinite?"), 0, 0)) != Qundef) {            if (RTEST(i)) {                int j = rb_cmpint(i, x, y);                j = (a > 0.0) ? (j > 0 ? 0 : +1) : (j < 0 ? 0 : -1);                return INT2FIX(j);            }            if (a > 0.0) return INT2FIX(1);            return INT2FIX(-1);        }        return rb_num_coerce_cmp(x, y, id_cmp);    }    return rb_dbl_cmp(a, b);}

float == obj → true or falseclick to toggle source

Returnstrue only ifobj has the same value asfloat. Contrast this with#eql?, which requiresobj to be aFloat.

1.0==1#=> true

The result ofNaN == NaN is undefined, so animplementation-dependent value is returned.

                MJIT_FUNC_EXPORTED VALUErb_float_equal(VALUE x, VALUE y){    volatile double a, b;    if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {        return rb_integer_float_eq(y, x);    }    else if (RB_TYPE_P(y, T_FLOAT)) {        b = RFLOAT_VALUE(y);#if MSC_VERSION_BEFORE(1300)        if (isnan(b)) return Qfalse;#endif    }    else {        return num_equal(x, y);    }    a = RFLOAT_VALUE(x);#if MSC_VERSION_BEFORE(1300)    if (isnan(a)) return Qfalse;#endif    return (a == b)?Qtrue:Qfalse;}

float == obj → true or falseclick to toggle source

Returnstrue only ifobj has the same value asfloat. Contrast this with#eql?, which requiresobj to be aFloat.

1.0==1#=> true

The result ofNaN == NaN is undefined, so animplementation-dependent value is returned.

                MJIT_FUNC_EXPORTED VALUErb_float_equal(VALUE x, VALUE y){    volatile double a, b;    if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {        return rb_integer_float_eq(y, x);    }    else if (RB_TYPE_P(y, T_FLOAT)) {        b = RFLOAT_VALUE(y);#if MSC_VERSION_BEFORE(1300)        if (isnan(b)) return Qfalse;#endif    }    else {        return num_equal(x, y);    }    a = RFLOAT_VALUE(x);#if MSC_VERSION_BEFORE(1300)    if (isnan(a)) return Qfalse;#endif    return (a == b)?Qtrue:Qfalse;}

float > real → true or falseclick to toggle source

Returnstrue iffloat is greater thanreal.

The result ofNaN > NaN is undefined, so animplementation-dependent value is returned.

                VALUErb_float_gt(VALUE x, VALUE y){    double a, b;    a = RFLOAT_VALUE(x);    if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {        VALUE rel = rb_integer_float_cmp(y, x);        if (FIXNUM_P(rel))            return -FIX2LONG(rel) > 0 ? Qtrue : Qfalse;        return Qfalse;    }    else if (RB_TYPE_P(y, T_FLOAT)) {        b = RFLOAT_VALUE(y);#if MSC_VERSION_BEFORE(1300)        if (isnan(b)) return Qfalse;#endif    }    else {        return rb_num_coerce_relop(x, y, '>');    }#if MSC_VERSION_BEFORE(1300)    if (isnan(a)) return Qfalse;#endif    return (a > b)?Qtrue:Qfalse;}

float >= real → true or falseclick to toggle source

Returnstrue iffloat is greater than or equal toreal.

The result ofNaN >= NaN is undefined, so animplementation-dependent value is returned.

                static VALUEflo_ge(VALUE x, VALUE y){    double a, b;    a = RFLOAT_VALUE(x);    if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {        VALUE rel = rb_integer_float_cmp(y, x);        if (FIXNUM_P(rel))            return -FIX2LONG(rel) >= 0 ? Qtrue : Qfalse;        return Qfalse;    }    else if (RB_TYPE_P(y, T_FLOAT)) {        b = RFLOAT_VALUE(y);#if MSC_VERSION_BEFORE(1300)        if (isnan(b)) return Qfalse;#endif    }    else {        return rb_num_coerce_relop(x, y, idGE);    }#if MSC_VERSION_BEFORE(1300)    if (isnan(a)) return Qfalse;#endif    return (a >= b)?Qtrue:Qfalse;}

abs → floatclick to toggle source

Returns the absolute value offloat.

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

#magnitude is an alias for#abs.

                VALUErb_float_abs(VALUE flt){    double val = fabs(RFLOAT_VALUE(flt));    return DBL2NUM(val);}

angle → 0 or floatclick to toggle source

Returns 0 if the value is positive, pi otherwise.

                static VALUEfloat_arg(VALUE self){    if (isnan(RFLOAT_VALUE(self)))        return self;    if (f_tpositive_p(self))        return INT2FIX(0);    return rb_const_get(rb_mMath, id_PI);}

arg → 0 or floatclick to toggle source

Returns 0 if the value is positive, pi otherwise.

                static VALUEfloat_arg(VALUE self){    if (isnan(RFLOAT_VALUE(self)))        return self;    if (f_tpositive_p(self))        return INT2FIX(0);    return rb_const_get(rb_mMath, id_PI);}

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

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

When the precision is negative, the returned value is an integer with atleastndigits.abs trailing zeros.

Returns a floating point number whenndigits is positive,otherwise returns an integer.

1.2.ceil#=> 22.0.ceil#=> 2(-1.2).ceil#=> -1(-2.0).ceil#=> -21.234567.ceil(2)#=> 1.241.234567.ceil(3)#=> 1.2351.234567.ceil(4)#=> 1.23461.234567.ceil(5)#=> 1.2345734567.89.ceil(-5)#=> 10000034567.89.ceil(-4)#=> 4000034567.89.ceil(-3)#=> 3500034567.89.ceil(-2)#=> 3460034567.89.ceil(-1)#=> 3457034567.89.ceil(0)#=> 3456834567.89.ceil(1)#=> 34567.934567.89.ceil(2)#=> 34567.8934567.89.ceil(3)#=> 34567.89

Note that the limited precision of floating point arithmetic might lead tosurprising results:

(2.1/0.7).ceil#=> 4 (!)

                static VALUEflo_ceil(int argc, VALUE *argv, VALUE num){    int ndigits = 0;    if (rb_check_arity(argc, 0, 1)) {        ndigits = NUM2INT(argv[0]);    }    return rb_float_ceil(num, ndigits);}

coerce(numeric) → arrayclick to toggle source

Returns an array with bothnumeric andfloatrepresented asFloat objects.

This is achieved by convertingnumeric to aFloat.

1.2.coerce(3)#=> [3.0, 1.2]2.5.coerce(1.1)#=> [1.1, 2.5]

                static VALUEflo_coerce(VALUE x, VALUE y){    return rb_assoc_new(rb_Float(y), x);}

denominator → integerclick to toggle source

Returns the denominator (always positive). The result is machinedependent.

Movatterモバイル変換

HomeClassesMethods

In Files

Parent

Methods

Files

Class/Module Index

Float

Constants

Public Instance Methods

Home Classes Methods