Home Classes Methods

If the platform supports denormalized numbers, there are numbers between zero and Float::MIN. 0.0.next_float returns the smallest positive floating point number including denormalized numbers.

MIN_10_EXP

The smallest negative exponent in a double-precision floating point where 10 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 to represent the number.

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

ROUNDS

Represents the rounding mode for floating point addition.

Usually defaults to 1, rounding to the nearest number.

Other modes include:

-1: Indeterminable
0: Rounding towards zero
1: Rounding to the nearest number
2: Rounding towards positive infinity
3: Rounding towards negative infinity

Public Instance Methods

float % other → float click to toggle source

Returns the modulo after division of float by other.

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

 static VALUE
flo_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 → float click to toggle source

Returns a new Float which is the product of float and other.

 VALUE
rb_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 → float click to toggle source

Raises float to the power of other.

2.0**3 #=> 8.0

 VALUE
rb_float_pow(VALUE x, VALUE y)
{
 double dx, dy;
 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 → float click to toggle source

Returns a new Float which is the sum of float and other.

 VALUE
rb_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 → float click to toggle source

Returns a new Float which is the difference of float and other.

 static VALUE
flo_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 → float click to toggle source

Returns float, negated.

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

float / other → float click to toggle source

Returns a new Float which is the result of dividing float by other.

 static VALUE
flo_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 false click to toggle source

Returns true if float is less than real.

The result of NaN < NaN is undefined, so an implementation-dependent value is returned.

 static VALUE
flo_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 -FIX2INT(rel) < 0 ? Qtrue : Qfalse;
 return Qfalse;
 }
 else if (RB_TYPE_P(y, T_FLOAT)) {
 b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
 if (isnan(b)) return Qfalse;
#endif
 }
 else {
 return rb_num_coerce_relop(x, y, '<');
 }
#if defined(_MSC_VER) && _MSC_VER < 1300
 if (isnan(a)) return Qfalse;
#endif
 return (a < b)?Qtrue:Qfalse;
}

float <= real → true or false click to toggle source

Returns true if float is less than or equal to real.

The result of NaN <= NaN is undefined, so an implementation-dependent value is returned.

 static VALUE
flo_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 -FIX2INT(rel) <= 0 ? Qtrue : Qfalse;
 return Qfalse;
 }
 else if (RB_TYPE_P(y, T_FLOAT)) {
 b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
 if (isnan(b)) return Qfalse;
#endif
 }
 else {
 return rb_num_coerce_relop(x, y, idLE);
 }
#if defined(_MSC_VER) && _MSC_VER < 1300
 if (isnan(a)) return Qfalse;
#endif
 return (a <= b)?Qtrue:Qfalse;
}

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

Returns -1, 0, or +1 depending on whether float is less than, equal to, or greater than real. This is the basis for the tests in the Comparable module.

The result of NaN <=> NaN is undefined, so an implementation-dependent value is returned.

nil is returned if the two values are incomparable.

 static VALUE
flo_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 INT2FIX(-FIX2INT(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 false click to toggle source

Returns true only if obj has the same value as float. Contrast this with #eql?, which requires obj to be a Float.

1.0 == 1 #=> true

The result of NaN == NaN is undefined, so an implementation-dependent value is returned.

 MJIT_FUNC_EXPORTED VALUE
rb_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 defined(_MSC_VER) && _MSC_VER < 1300
 if (isnan(b)) return Qfalse;
#endif
 }
 else {
 return num_equal(x, y);
 }
 a = RFLOAT_VALUE(x);
#if defined(_MSC_VER) && _MSC_VER < 1300
 if (isnan(a)) return Qfalse;
#endif
 return (a == b)?Qtrue:Qfalse;
}

float == obj → true or false click to toggle source

Returns true only if obj has the same value as float. Contrast this with #eql?, which requires obj to be a Float.

1.0 == 1 #=> true

The result of NaN == NaN is undefined, so an implementation-dependent value is returned.

 MJIT_FUNC_EXPORTED VALUE
rb_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 defined(_MSC_VER) && _MSC_VER < 1300
 if (isnan(b)) return Qfalse;
#endif
 }
 else {
 return num_equal(x, y);
 }
 a = RFLOAT_VALUE(x);
#if defined(_MSC_VER) && _MSC_VER < 1300
 if (isnan(a)) return Qfalse;
#endif
 return (a == b)?Qtrue:Qfalse;
}

float > real → true or false click to toggle source

Returns true if float is greater than real.

The result of NaN > NaN is undefined, so an implementation-dependent value is returned.

 VALUE
rb_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 -FIX2INT(rel) > 0 ? Qtrue : Qfalse;
 return Qfalse;
 }
 else if (RB_TYPE_P(y, T_FLOAT)) {
 b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
 if (isnan(b)) return Qfalse;
#endif
 }
 else {
 return rb_num_coerce_relop(x, y, '>');
 }
#if defined(_MSC_VER) && _MSC_VER < 1300
 if (isnan(a)) return Qfalse;
#endif
 return (a > b)?Qtrue:Qfalse;
}

float >= real → true or false click to toggle source

Returns true if float is greater than or equal to real.

The result of NaN >= NaN is undefined, so an implementation-dependent value is returned.

 static VALUE
flo_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 -FIX2INT(rel) >= 0 ? Qtrue : Qfalse;
 return Qfalse;
 }
 else if (RB_TYPE_P(y, T_FLOAT)) {
 b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
 if (isnan(b)) return Qfalse;
#endif
 }
 else {
 return rb_num_coerce_relop(x, y, idGE);
 }
#if defined(_MSC_VER) && _MSC_VER < 1300
 if (isnan(a)) return Qfalse;
#endif
 return (a >= b)?Qtrue:Qfalse;
}

abs → float click to toggle source

Returns the absolute value of float.

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

#magnitude is an alias for #abs.

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

angle → 0 or float click to toggle source

Returns 0 if the value is positive, pi otherwise.

 static VALUE
float_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 float click to toggle source

Returns 0 if the value is positive, pi otherwise.

 static VALUE
float_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 float click to toggle source

Returns the smallest number greater than or equal to float with a precision of ndigits decimal digits (default: 0).

When the precision is negative, the returned value is an integer with at least ndigits.abs trailing zeros.

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

1.2.ceil #=> 2
2.0.ceil #=> 2
(-1.2).ceil #=> -1
(-2.0).ceil #=> -2
1.234567.ceil(2) #=> 1.24
1.234567.ceil(3) #=> 1.235
1.234567.ceil(4) #=> 1.2346
1.234567.ceil(5) #=> 1.23457
34567.89.ceil(-5) #=> 100000
34567.89.ceil(-4) #=> 40000
34567.89.ceil(-3) #=> 35000
34567.89.ceil(-2) #=> 34600
34567.89.ceil(-1) #=> 34570
34567.89.ceil(0) #=> 34568
34567.89.ceil(1) #=> 34567.9
34567.89.ceil(2) #=> 34567.89
34567.89.ceil(3) #=> 34567.89

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

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

 static VALUE
flo_ceil(int argc, VALUE *argv, VALUE num)
{
 double number, f;
 int ndigits = 0;
 if (rb_check_arity(argc, 0, 1)) {
 ndigits = NUM2INT(argv[0]);
 }
 number = RFLOAT_VALUE(num);
 if (number == 0.0) {
 return ndigits > 0 ? DBL2NUM(number) : INT2FIX(0);
 }
 if (ndigits > 0) {
 int binexp;
 frexp(number, &binexp);
 if (float_round_overflow(ndigits, binexp)) return num;
 if (number < 0.0 && float_round_underflow(ndigits, binexp))
 return DBL2NUM(0.0);
 f = pow(10, ndigits);
 f = ceil(number * f) / f;
 return DBL2NUM(f);
 }
 else {
 num = dbl2ival(ceil(number));
 if (ndigits < 0) num = rb_int_ceil(num, ndigits);
 return num;
 }
}

coerce(numeric) → array click to toggle source

Returns an array with both numeric and float represented as Float objects.

This is achieved by converting numeric to a Float.

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

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

denominator → integer click to toggle source

Returns the denominator (always positive). The result is machine dependent.