Class: Float

Inherits:

Object
Numeric
Float

Defined in:: numeric.c,
numeric.c

Overview

******************************************************************

<code>Float</code> objects represent inexact real numbers using
the native architecture's double-precision floating point
representation.

Floating point has a different arithmetic and is a inexact number.
So you should know its esoteric system. see following:

- http://docs.sun.com/source/806-3568/ncg_goldberg.html
- http://wiki.github.com/rdp/ruby_tutorials_core/ruby-talk-faq#floats_imprecise
- http://en.wikipedia.org/wiki/Floating_point#Accuracy_problems

Constant Summary collapse

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

Represents the rounding mode for floating point addition.

Usually defaults to 1, rounding to the nearest number.

Other modes include

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.

INT2FIX(FLT_RADIX)

MANT_DIG = The number of base digits for the double data type. Usually defaults to 53.

INT2FIX(DBL_MANT_DIG)

DIG = The number of decimal digits in a double-precision floating point. Usually defaults to 15.

INT2FIX(DBL_DIG)

MIN_EXP = The smallest posable exponent value in a double-precision floating point. Usually defaults to -1021.

INT2FIX(DBL_MIN_EXP)

MAX_EXP = The largest possible exponent value in a double-precision floating point. Usually defaults to 1024.

INT2FIX(DBL_MAX_EXP)

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.

INT2FIX(DBL_MIN_10_EXP)

MAX_10_EXP = The largest positive exponent in a double-precision floating point where 10 raised to this power minus 1. Usually defaults to 308.

INT2FIX(DBL_MAX_10_EXP)

MIN = The smallest positive integer in a double-precision floating point. Usually defaults to 2.2250738585072014e-308.

DBL2NUM(DBL_MIN)

MAX = The largest possible integer in a double-precision floating point number. Usually defaults to 1.7976931348623157e+308.

DBL2NUM(DBL_MAX)

EPSILON = The difference between 1 and the smallest double-precision floating point number. Usually defaults to 2.2204460492503131e-16.

DBL2NUM(DBL_EPSILON)

INFINITY = An expression representing positive infinity.

DBL2NUM(INFINITY)

NAN = An expression representing a value which is "not a number".

DBL2NUM(NAN)

Instance Method Summary collapse

#% ⇒ Object

Return the modulo after division of flt by other.
#*(other) ⇒ Float

Returns a new float which is the product of float and other.
#**(other) ⇒ Float

Raises float the other power.
#+(other) ⇒ Float

Returns a new float which is the sum of float and other.
#-(other) ⇒ Float

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

Returns float, negated.
#/(other) ⇒ Float

Returns a new float which is the result of dividing float by other.
#<(real) ⇒ Boolean

true if flt is less than real.
#<=(real) ⇒ Boolean

true if flt is less than or equal to real.
#<=>(real) ⇒ -1, ...

Returns -1, 0, +1 or nil depending on whether flt is less than, equal to, or greater than real.
#==(obj) ⇒ Boolean

Returns true only if obj has the same value as flt.
#==(obj) ⇒ Boolean

Returns true only if obj has the same value as flt.
#>(real) ⇒ Boolean

true if flt is greater than real.
#>=(real) ⇒ Boolean

true if flt is greater than or equal to real.
#abs ⇒ Object

Returns the absolute value of flt.
#angle ⇒ Object

Returns 0 if the value is positive, pi otherwise.
#arg ⇒ Object

Returns 0 if the value is positive, pi otherwise.
#ceil ⇒ Integer

Returns the smallest Integer greater than or equal to flt.
#coerce(numeric) ⇒ Array

Returns an array with both aNumeric and flt represented as Float objects.
#denominator ⇒ Integer

Returns the denominator (always positive).
#divmod(numeric) ⇒ Array

See Numeric#divmod.
#eql?(obj) ⇒ Boolean

Returns true only if obj is a Float with the same value as flt.
#quo(numeric) ⇒ Float

Returns float / numeric.
#finite? ⇒ Boolean

Returns true if flt is a valid IEEE floating point number (it is not infinite, and nan? is false).
#floor ⇒ Integer

Returns the largest integer less than or equal to flt.
#hash ⇒ Integer

Returns a hash code for this float.
#infinite? ⇒ nil, ...

Returns nil, -1, or 1 depending on whether flt is finite, -infinity, or infinity.
#magnitude ⇒ Object

Returns the absolute value of flt.
#modulo ⇒ Object

Return the modulo after division of flt by other.
#nan? ⇒ Boolean

Returns true if flt is an invalid IEEE floating point number.
#numerator ⇒ Integer

Returns the numerator.
#phase ⇒ Object

Returns 0 if the value is positive, pi otherwise.
#quo(numeric) ⇒ Float

Returns float / numeric.
#rationalize([eps]) ⇒ Object

Returns a simpler approximation of the value (flt-|eps| <= result <= flt+|eps|).
#round([ndigits]) ⇒ Integer, Float

Rounds flt to a given precision in decimal digits (default 0 digits).
#to_f ⇒ self

As flt is already a float, returns self.
#to_i ⇒ Object

Returns flt truncated to an Integer.
#to_int ⇒ Object

Returns flt truncated to an Integer.
#to_r ⇒ Object

Returns the value as a rational.
#to_s ⇒ String (also: #inspect)

Returns a string containing a representation of self.
#truncate ⇒ Object

Returns flt truncated to an Integer.
#zero? ⇒ Boolean

Returns true if flt is 0.0.

Methods inherited from Numeric

#+@, #abs2, #conj, #conjugate, #div, #i, #imag, #imaginary, #initialize_copy, #integer?, #nonzero?, #polar, #real, #real?, #rect, #rectangular, #remainder, #singleton_method_added, #step, #to_c

Methods included from Comparable

#between?

Instance Method Details

#%(other) ⇒ `Float` #modulo(other) ⇒ `Float`

Return the modulo after division of flt by other.

6543.21.modulo(137)      #=> 104.21
6543.21.modulo(137.24)   #=> 92.9299999999996

Overloads:

#%(other) ⇒ Float
Returns:
- (Float)
#modulo(other) ⇒ Float
Returns:
- (Float)

# File 'numeric.c', line 911

static VALUE
flo_mod(VALUE x, VALUE y)
{
    double fy;

    switch (TYPE(y)) {
      case T_FIXNUM:
	fy = (double)FIX2LONG(y);
	break;
      case T_BIGNUM:
	fy = rb_big2dbl(y);
	break;
      case T_FLOAT:
	fy = RFLOAT_VALUE(y);
	break;
      default:
	return rb_num_coerce_bin(x, y, '%');
    }
    return DBL2NUM(ruby_float_mod(RFLOAT_VALUE(x), fy));
}

#*(other) ⇒ `Float`

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

Returns:

(Float)

# File 'numeric.c', line 800

static VALUE
flo_mul(VALUE x, VALUE y)
{
    switch (TYPE(y)) {
      case T_FIXNUM:
	return DBL2NUM(RFLOAT_VALUE(x) * (double)FIX2LONG(y));
      case T_BIGNUM:
	return DBL2NUM(RFLOAT_VALUE(x) * rb_big2dbl(y));
      case T_FLOAT:
	return DBL2NUM(RFLOAT_VALUE(x) * RFLOAT_VALUE(y));
      default:
	return rb_num_coerce_bin(x, y, '*');
    }
}

#**(other) ⇒ `Float`

Raises float the other power.

2.0**3      #=> 8.0

Returns:

(Float)

# File 'numeric.c', line 984

static VALUE
flo_pow(VALUE x, VALUE y)
{
    switch (TYPE(y)) {
      case T_FIXNUM:
	return DBL2NUM(pow(RFLOAT_VALUE(x), (double)FIX2LONG(y)));
      case T_BIGNUM:
	return DBL2NUM(pow(RFLOAT_VALUE(x), rb_big2dbl(y)));
      case T_FLOAT:
	{
	    double dx = RFLOAT_VALUE(x);
	    double dy = RFLOAT_VALUE(y);
	    if (dx < 0 && dy != round(dy))
		return rb_funcall(rb_complex_raw1(x), rb_intern("**"), 1, y);
	    return DBL2NUM(pow(dx, dy));
	}
      default:
	return rb_num_coerce_bin(x, y, rb_intern("**"));
    }
}

#+(other) ⇒ `Float`

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

Returns:

(Float)

# File 'numeric.c', line 754

static VALUE
flo_plus(VALUE x, VALUE y)
{
    switch (TYPE(y)) {
      case T_FIXNUM:
	return DBL2NUM(RFLOAT_VALUE(x) + (double)FIX2LONG(y));
      case T_BIGNUM:
	return DBL2NUM(RFLOAT_VALUE(x) + rb_big2dbl(y));
      case T_FLOAT:
	return DBL2NUM(RFLOAT_VALUE(x) + RFLOAT_VALUE(y));
      default:
	return rb_num_coerce_bin(x, y, '+');
    }
}

#-(other) ⇒ `Float`

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

Returns:

(Float)

# File 'numeric.c', line 777

static VALUE
flo_minus(VALUE x, VALUE y)
{
    switch (TYPE(y)) {
      case T_FIXNUM:
	return DBL2NUM(RFLOAT_VALUE(x) - (double)FIX2LONG(y));
      case T_BIGNUM:
	return DBL2NUM(RFLOAT_VALUE(x) - rb_big2dbl(y));
      case T_FLOAT:
	return DBL2NUM(RFLOAT_VALUE(x) - RFLOAT_VALUE(y));
      default:
	return rb_num_coerce_bin(x, y, '-');
    }
}

#- ⇒ `Float`

Returns float, negated.

Returns:

(Float)

# File 'numeric.c', line 740

static VALUE
flo_uminus(VALUE flt)
{
    return DBL2NUM(-RFLOAT_VALUE(flt));
}

#/(other) ⇒ `Float`

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

Returns:

(Float)

# File 'numeric.c', line 823

static VALUE
flo_div(VALUE x, VALUE y)
{
    long f_y;
    double d;

    switch (TYPE(y)) {
      case T_FIXNUM:
	f_y = FIX2LONG(y);
	return DBL2NUM(RFLOAT_VALUE(x) / (double)f_y);
      case T_BIGNUM:
	d = rb_big2dbl(y);
	return DBL2NUM(RFLOAT_VALUE(x) / d);
      case T_FLOAT:
	return DBL2NUM(RFLOAT_VALUE(x) / RFLOAT_VALUE(y));
      default:
	return rb_num_coerce_bin(x, y, '/');
    }
}

#<(real) ⇒ `Boolean`

true if flt is less than real. The result of NaN < NaN is undefined, so the implementation-dependent value is returned.

Returns:

(Boolean)

# File 'numeric.c', line 1256

static VALUE
flo_lt(VALUE x, VALUE y)
{
    double a, b;

    a = RFLOAT_VALUE(x);
    switch (TYPE(y)) {
      case T_FIXNUM:
      case T_BIGNUM:
      {
        VALUE rel = rb_integer_float_cmp(y, x);
        if (FIXNUM_P(rel))
            return -FIX2INT(rel) < 0 ? Qtrue : Qfalse;
        return Qfalse;
      }

      case T_FLOAT:
	b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
	if (isnan(b)) return Qfalse;
#endif
	break;

      default:
	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;
}

#<=(real) ⇒ `Boolean`

true if flt is less than or equal to real. The result of NaN <= NaN is undefined, so the implementation-dependent value is returned.

Returns:

(Boolean)

# File 'numeric.c', line 1298

static VALUE
flo_le(VALUE x, VALUE y)
{
    double a, b;

    a = RFLOAT_VALUE(x);
    switch (TYPE(y)) {
      case T_FIXNUM:
      case T_BIGNUM:
      {
        VALUE rel = rb_integer_float_cmp(y, x);
        if (FIXNUM_P(rel))
            return -FIX2INT(rel) <= 0 ? Qtrue : Qfalse;
        return Qfalse;
      }

      case T_FLOAT:
	b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
	if (isnan(b)) return Qfalse;
#endif
	break;

      default:
	return rb_num_coerce_relop(x, y, rb_intern("<="));
    }
#if defined(_MSC_VER) && _MSC_VER < 1300
    if (isnan(a)) return Qfalse;
#endif
    return (a <= b)?Qtrue:Qfalse;
}

#<=>(real) ⇒ `-1`, ...

Returns -1, 0, +1 or nil depending on whether flt is less than, equal to, or greater than real. This is the basis for the tests in Comparable. The result of NaN <=> NaN is undefined, so the implementation-dependent value is returned.

Returns:

(-1, 0, +1, nil)

# File 'numeric.c', line 1127

static VALUE
flo_cmp(VALUE x, VALUE y)
{
    double a, b;
    VALUE i;

    a = RFLOAT_VALUE(x);
    if (isnan(a)) return Qnil;
    switch (TYPE(y)) {
      case T_FIXNUM:
      case T_BIGNUM:
      {
        VALUE rel = rb_integer_float_cmp(y, x);
        if (FIXNUM_P(rel))
            return INT2FIX(-FIX2INT(rel));
        return rel;
      }

      case T_FLOAT:
	b = RFLOAT_VALUE(y);
	break;

      default:
	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, rb_intern("<=>"));
    }
    return rb_dbl_cmp(a, b);
}

#==(obj) ⇒ `Boolean`

Returns true only if obj has the same value as flt. Contrast this with Float#eql?, which requires obj to be a Float. The result of NaN == NaN is undefined, so the implementation-dependent value is returned.

1.0 == 1   #=> true

Returns:

(Boolean)

# File 'numeric.c', line 1061

static VALUE
flo_eq(VALUE x, VALUE y)
{
    volatile double a, b;

    switch (TYPE(y)) {
      case T_FIXNUM:
      case T_BIGNUM:
        return rb_integer_float_eq(y, x);
      case T_FLOAT:
	b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
	if (isnan(b)) return Qfalse;
#endif
	break;
      default:
	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;
}

#==(obj) ⇒ `Boolean`

1.0 == 1   #=> true

Returns:

(Boolean)

# File 'numeric.c', line 1061

static VALUE
flo_eq(VALUE x, VALUE y)
{
    volatile double a, b;

    switch (TYPE(y)) {
      case T_FIXNUM:
      case T_BIGNUM:
        return rb_integer_float_eq(y, x);
      case T_FLOAT:
	b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
	if (isnan(b)) return Qfalse;
#endif
	break;
      default:
	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;
}

#>(real) ⇒ `Boolean`

true if flt is greater than real. The result of NaN > NaN is undefined, so the implementation-dependent value is returned.

Returns:

(Boolean)

# File 'numeric.c', line 1173

static VALUE
flo_gt(VALUE x, VALUE y)
{
    double a, b;

    a = RFLOAT_VALUE(x);
    switch (TYPE(y)) {
      case T_FIXNUM:
      case T_BIGNUM:
      {
        VALUE rel = rb_integer_float_cmp(y, x);
        if (FIXNUM_P(rel))
            return -FIX2INT(rel) > 0 ? Qtrue : Qfalse;
        return Qfalse;
      }

      case T_FLOAT:
	b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
	if (isnan(b)) return Qfalse;
#endif
	break;

      default:
	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;
}

#>=(real) ⇒ `Boolean`

true if flt is greater than or equal to real. The result of NaN >= NaN is undefined, so the implementation-dependent value is returned.

Returns:

(Boolean)

# File 'numeric.c', line 1215

static VALUE
flo_ge(VALUE x, VALUE y)
{
    double a, b;

    a = RFLOAT_VALUE(x);
    switch (TYPE(y)) {
      case T_FIXNUM:
      case T_BIGNUM:
      {
        VALUE rel = rb_integer_float_cmp(y, x);
        if (FIXNUM_P(rel))
            return -FIX2INT(rel) >= 0 ? Qtrue : Qfalse;
        return Qfalse;
      }

      case T_FLOAT:
	b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
	if (isnan(b)) return Qfalse;
#endif
	break;

      default:
	return rb_num_coerce_relop(x, y, rb_intern(">="));
    }
#if defined(_MSC_VER) && _MSC_VER < 1300
    if (isnan(a)) return Qfalse;
#endif
    return (a >= b)?Qtrue:Qfalse;
}

#abs ⇒ `Float` #magnitude ⇒ `Float`

Returns the absolute value of flt.

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

Overloads:

#abs ⇒ Float
Returns:
- (Float)
#magnitude ⇒ Float
Returns:
- (Float)

# File 'numeric.c', line 1383

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

#arg ⇒ `0`, `Float` #angle ⇒ `0`, `Float` #phase ⇒ `0`, `Float`

Returns 0 if the value is positive, pi otherwise.

Overloads:

#arg ⇒ 0, Float
Returns:
- (0, Float)
#angle ⇒ 0, Float
Returns:
- (0, Float)
#phase ⇒ 0, Float
Returns:
- (0, Float)

# File 'complex.c', line 2039

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`, `Float` #angle ⇒ `0`, `Float` #phase ⇒ `0`, `Float`

Returns 0 if the value is positive, pi otherwise.

Overloads:

#arg ⇒ 0, Float
Returns:
- (0, Float)
#angle ⇒ 0, Float
Returns:
- (0, Float)
#phase ⇒ 0, Float
Returns:
- (0, Float)

# File 'complex.c', line 2039

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 ⇒ `Integer`

Returns the smallest Integer greater than or equal to flt.

1.2.ceil      #=> 2
2.0.ceil      #=> 2
(-1.2).ceil   #=> -1
(-2.0).ceil   #=> -2

Returns:

(Integer)

# File 'numeric.c', line 1516

static VALUE
flo_ceil(VALUE num)
{
    double f = ceil(RFLOAT_VALUE(num));
    long val;

    if (!FIXABLE(f)) {
	return rb_dbl2big(f);
    }
    val = (long)f;
    return LONG2FIX(val);
}

#coerce(numeric) ⇒ `Array`

Returns an array with both aNumeric and flt represented as Float objects. This is achieved by converting aNumeric to a Float.

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

Returns:

(Array)

# File 'numeric.c', line 727

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

#denominator ⇒ `Integer`

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

See numerator.

Returns:

(Integer)

# File 'rational.c', line 1825

static VALUE
float_denominator(VALUE self)
{
    double d = RFLOAT_VALUE(self);
    if (isinf(d) || isnan(d))
	return INT2FIX(1);
    return rb_call_super(0, 0);
}

#divmod(numeric) ⇒ `Array`

See Numeric#divmod.

Returns:

(Array)

# File 'numeric.c', line 949

static VALUE
flo_divmod(VALUE x, VALUE y)
{
    double fy, div, mod;
    volatile VALUE a, b;

    switch (TYPE(y)) {
      case T_FIXNUM:
	fy = (double)FIX2LONG(y);
	break;
      case T_BIGNUM:
	fy = rb_big2dbl(y);
	break;
      case T_FLOAT:
	fy = RFLOAT_VALUE(y);
	break;
      default:
	return rb_num_coerce_bin(x, y, rb_intern("divmod"));
    }
    flodivmod(RFLOAT_VALUE(x), fy, &div, &mod);
    a = dbl2ival(div);
    b = DBL2NUM(mod);
    return rb_assoc_new(a, b);
}

#eql?(obj) ⇒ `Boolean`

Returns true only if obj is a Float with the same value as flt. Contrast this with Float#==, which performs type conversions. The result of NaN.eql?(NaN) is undefined, so the implementation-dependent value is returned.

1.0.eql?(1)   #=> false

Returns:

(Boolean)

Returns:

(Boolean)

# File 'numeric.c', line 1343

static VALUE
flo_eql(VALUE x, VALUE y)
{
    if (RB_TYPE_P(y, T_FLOAT)) {
	double a = RFLOAT_VALUE(x);
	double b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
	if (isnan(a) || isnan(b)) return Qfalse;
#endif
	if (a == b)
	    return Qtrue;
    }
    return Qfalse;
}

#quo(numeric) ⇒ `Float`

Returns float / numeric.

Returns:

(Float)

# File 'numeric.c', line 850

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

#finite? ⇒ `Boolean`

Returns true if flt is a valid IEEE floating point number (it is not infinite, and nan? is false).

Returns:

(Boolean)

Returns:

(Boolean)

# File 'numeric.c', line 1462

static VALUE
flo_is_finite_p(VALUE num)
{
    double value = RFLOAT_VALUE(num);

#if HAVE_FINITE
    if (!finite(value))
	return Qfalse;
#else
    if (isinf(value) || isnan(value))
	return Qfalse;
#endif

    return Qtrue;
}

#floor ⇒ `Integer`

Returns the largest integer less than or equal to flt.

1.2.floor      #=> 1
2.0.floor      #=> 2
(-1.2).floor   #=> -2
(-2.0).floor   #=> -2

Returns:

(Integer)

# File 'numeric.c', line 1490

static VALUE
flo_floor(VALUE num)
{
    double f = floor(RFLOAT_VALUE(num));
    long val;

    if (!FIXABLE(f)) {
	return rb_dbl2big(f);
    }
    val = (long)f;
    return LONG2FIX(val);
}

#hash ⇒ `Integer`

Returns a hash code for this float.

Returns:

(Integer)

# File 'numeric.c', line 1093

static VALUE
flo_hash(VALUE num)
{
    double d;
    st_index_t hash;

    d = RFLOAT_VALUE(num);
    /* normalize -0.0 to 0.0 */
    if (d == 0.0) d = 0.0;
    hash = rb_memhash(&d, sizeof(d));
    return LONG2FIX(hash);
}

#infinite? ⇒ `nil`, ...

Returns nil, -1, or 1 depending on whether flt is finite, -infinity, or infinity.

(0.0).infinite?        #=> nil
(-1.0/0.0).infinite?   #=> -1
(+1.0/0.0).infinite?   #=> 1

Returns:

(nil, -1, +1)

Returns:

(Boolean)

# File 'numeric.c', line 1440

static VALUE
flo_is_infinite_p(VALUE num)
{
    double value = RFLOAT_VALUE(num);

    if (isinf(value)) {
	return INT2FIX( value < 0 ? -1 : 1 );
    }

    return Qnil;
}

#abs ⇒ `Float` #magnitude ⇒ `Float`

Returns the absolute value of flt.

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

Overloads:

#abs ⇒ Float
Returns:
- (Float)
#magnitude ⇒ Float
Returns:
- (Float)

# File 'numeric.c', line 1383

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

#%(other) ⇒ `Float` #modulo(other) ⇒ `Float`

Return the modulo after division of flt by other.

6543.21.modulo(137)      #=> 104.21
6543.21.modulo(137.24)   #=> 92.9299999999996

Overloads:

#%(other) ⇒ Float
Returns:
- (Float)
#modulo(other) ⇒ Float
Returns:
- (Float)

# File 'numeric.c', line 911

static VALUE
flo_mod(VALUE x, VALUE y)
{
    double fy;

    switch (TYPE(y)) {
      case T_FIXNUM:
	fy = (double)FIX2LONG(y);
	break;
      case T_BIGNUM:
	fy = rb_big2dbl(y);
	break;
      case T_FLOAT:
	fy = RFLOAT_VALUE(y);
	break;
      default:
	return rb_num_coerce_bin(x, y, '%');
    }
    return DBL2NUM(ruby_float_mod(RFLOAT_VALUE(x), fy));
}

#nan? ⇒ `Boolean`

Returns true if flt is an invalid IEEE floating point number.

a = -1.0      #=> -1.0
a.nan?        #=> false
a = 0.0/0.0   #=> NaN
a.nan?        #=> true

Returns:

(Boolean)

Returns:

(Boolean)

# File 'numeric.c', line 1420

static VALUE
flo_is_nan_p(VALUE num)
{
    double value = RFLOAT_VALUE(num);

    return isnan(value) ? Qtrue : Qfalse;
}

#numerator ⇒ `Integer`

Returns the numerator. The result is machine dependent.

n = 0.3.numerator    #=> 5404319552844595
d = 0.3.denominator  #=> 18014398509481984
n.fdiv(d)            #=> 0.3

Returns:

(Integer)

# File 'rational.c', line 1807

static VALUE
float_numerator(VALUE self)
{
    double d = RFLOAT_VALUE(self);
    if (isinf(d) || isnan(d))
	return self;
    return rb_call_super(0, 0);
}

#arg ⇒ `0`, `Float` #angle ⇒ `0`, `Float` #phase ⇒ `0`, `Float`

Returns 0 if the value is positive, pi otherwise.

Overloads:

#arg ⇒ 0, Float
Returns:
- (0, Float)
#angle ⇒ 0, Float
Returns:
- (0, Float)
#phase ⇒ 0, Float
Returns:
- (0, Float)

# File 'complex.c', line 2039

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);
}

#quo(numeric) ⇒ `Float`

Returns float / numeric.

Returns:

(Float)

# File 'numeric.c', line 850

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

#rationalize([eps]) ⇒ `Object`

Returns a simpler approximation of the value (flt-|eps| <= result <= flt+|eps|). if the optional eps is not given, it will be chosen automatically.

0.3.rationalize          #=> (3/10)
1.333.rationalize        #=> (1333/1000)
1.333.rationalize(0.01)  #=> (4/3)

See to_r.

# File 'rational.c', line 1968

static VALUE
float_rationalize(int argc, VALUE *argv, VALUE self)
{
    VALUE e, a, b, p, q;

    if (f_negative_p(self))
	return f_negate(float_rationalize(argc, argv, f_abs(self)));

    rb_scan_args(argc, argv, "01", &e);

    if (argc != 0) {
	e = f_abs(e);
	a = f_sub(self, e);
	b = f_add(self, e);
    }
    else {
	VALUE f, n;

	float_decode_internal(self, &f, &n);
	if (f_zero_p(f) || f_positive_p(n))
	    return rb_rational_new1(f_lshift(f, n));

#if FLT_RADIX == 2
	{
	    VALUE two_times_f, den;

	    two_times_f = f_mul(TWO, f);
	    den = f_lshift(ONE, f_sub(ONE, n));

	    a = rb_rational_new2(f_sub(two_times_f, ONE), den);
	    b = rb_rational_new2(f_add(two_times_f, ONE), den);
	}
#else
	{
	    VALUE radix_times_f, den;

	    radix_times_f = f_mul(INT2FIX(FLT_RADIX), f);
	    den = f_expt(INT2FIX(FLT_RADIX), f_sub(ONE, n));

	    a = rb_rational_new2(f_sub(radix_times_f, INT2FIX(FLT_RADIX - 1)), den);
	    b = rb_rational_new2(f_add(radix_times_f, INT2FIX(FLT_RADIX - 1)), den);
	}
#endif
    }

    if (f_eqeq_p(a, b))
	return f_to_r(self);

    nurat_rationalize_internal(a, b, &p, &q);
    return rb_rational_new2(p, q);
}

#round([ndigits]) ⇒ `Integer`, `Float`

Rounds flt 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.

1.4.round      #=> 1
1.5.round      #=> 2
1.6.round      #=> 2
(-1.5).round   #=> -2

1.234567.round(2)  #=> 1.23
1.234567.round(3)  #=> 1.235
1.234567.round(4)  #=> 1.2346
1.234567.round(5)  #=> 1.23457

34567.89.round(-5) #=> 0
34567.89.round(-4) #=> 30000
34567.89.round(-3) #=> 35000
34567.89.round(-2) #=> 34600
34567.89.round(-1) #=> 34570
34567.89.round(0)  #=> 34568
34567.89.round(1)  #=> 34567.9
34567.89.round(2)  #=> 34567.89
34567.89.round(3)  #=> 34567.89

Returns:

(Integer, Float)

# File 'numeric.c', line 1601

static VALUE
flo_round(int argc, VALUE *argv, VALUE num)
{
    VALUE nd;
    double number, f;
    int ndigits = 0;
    int binexp;
    enum {float_dig = DBL_DIG+2};

    if (argc > 0 && rb_scan_args(argc, argv, "01", &nd) == 1) {
	ndigits = NUM2INT(nd);
    }
    if (ndigits < 0) {
	return int_round_0(flo_truncate(num), ndigits);
    }
    number  = RFLOAT_VALUE(num);
    if (ndigits == 0) {
	return dbl2ival(number);
    }
    frexp(number, &binexp);

/* Let `exp` be such that `number` is written as:"0.#{digits}e#{exp}",
   i.e. such that  10 ** (exp - 1) <= |number| < 10 ** exp
   Recall that up to float_dig digits can be needed to represent a double,
   so if ndigits + exp >= float_dig, the intermediate value (number * 10 ** ndigits)
   will be an integer and thus the result is the original number.
   If ndigits + exp <= 0, the result is 0 or "1e#{exp}", so
   if ndigits + exp < 0, the result is 0.
   We have:
	2 ** (binexp-1) <= |number| < 2 ** binexp
	10 ** ((binexp-1)/log_2(10)) <= |number| < 10 ** (binexp/log_2(10))
	If binexp >= 0, and since log_2(10) = 3.322259:
	   10 ** (binexp/4 - 1) < |number| < 10 ** (binexp/3)
	   floor(binexp/4) <= exp <= ceil(binexp/3)
	If binexp <= 0, swap the /4 and the /3
	So if ndigits + floor(binexp/(4 or 3)) >= float_dig, the result is number
	If ndigits + ceil(binexp/(3 or 4)) < 0 the result is 0
*/
    if (isinf(number) || isnan(number) ||
	(ndigits >= float_dig - (binexp > 0 ? binexp / 4 : binexp / 3 - 1))) {
	return num;
    }
    if (ndigits < - (binexp > 0 ? binexp / 3 + 1 : binexp / 4)) {
	return DBL2NUM(0);
    }
    f = pow(10, ndigits);
    return DBL2NUM(round(number * f) / f);
}

#to_f ⇒ `self`

As flt is already a float, returns self.

Returns:

(self)

# File 'numeric.c', line 1365

static VALUE
flo_to_f(VALUE num)
{
    return num;
}

#to_i ⇒ `Integer` #to_int ⇒ `Integer` #truncate ⇒ `Integer`

Returns flt truncated to an Integer.

Overloads:

#to_i ⇒ Integer
Returns:
- (Integer)
#to_int ⇒ Integer
Returns:
- (Integer)
#truncate ⇒ Integer
Returns:
- (Integer)

# File 'numeric.c', line 1659

static VALUE
flo_truncate(VALUE num)
{
    double f = RFLOAT_VALUE(num);
    long val;

    if (f > 0.0) f = floor(f);
    if (f < 0.0) f = ceil(f);

    if (!FIXABLE(f)) {
	return rb_dbl2big(f);
    }
    val = (long)f;
    return LONG2FIX(val);
}

#to_i ⇒ `Integer` #to_int ⇒ `Integer` #truncate ⇒ `Integer`

Returns flt truncated to an Integer.

Overloads:

#to_i ⇒ Integer
Returns:
- (Integer)
#to_int ⇒ Integer
Returns:
- (Integer)
#truncate ⇒ Integer
Returns:
- (Integer)

# File 'numeric.c', line 1659

static VALUE
flo_truncate(VALUE num)
{
    double f = RFLOAT_VALUE(num);
    long val;

    if (f > 0.0) f = floor(f);
    if (f < 0.0) f = ceil(f);

    if (!FIXABLE(f)) {
	return rb_dbl2big(f);
    }
    val = (long)f;
    return LONG2FIX(val);
}

#to_r ⇒ `Object`

Returns the value as a rational.

NOTE: 0.3.to_r isn't the same as '0.3'.to_r. The latter is equivalent to '3/10'.to_r, but the former isn't so.

2.0.to_r    #=> (2/1)
2.5.to_r    #=> (5/2)
-0.75.to_r  #=> (-3/4)
0.0.to_r    #=> (0/1)

See rationalize.

# File 'rational.c', line 1932

static VALUE
float_to_r(VALUE self)
{
    VALUE f, n;

    float_decode_internal(self, &f, &n);
#if FLT_RADIX == 2
    {
	long ln = FIX2LONG(n);

	if (ln == 0)
	    return f_to_r(f);
	if (ln > 0)
	    return f_to_r(f_lshift(f, n));
	ln = -ln;
	return rb_rational_new2(f, f_lshift(ONE, INT2FIX(ln)));
    }
#else
    return f_to_r(f_mul(f, f_expt(INT2FIX(FLT_RADIX), n)));
#endif
}

#to_s ⇒ `String` Also known as: inspect

Returns a string containing a representation of self. As well as a fixed or exponential form of the number, the call may return "NaN", "Infinity", and "-Infinity".

Returns:

(String)

# File 'numeric.c', line 646

static VALUE
flo_to_s(VALUE flt)
{
    char *ruby_dtoa(double d_, int mode, int ndigits, int *decpt, int *sign, char **rve);
    enum {decimal_mant = DBL_MANT_DIG-DBL_DIG};
    enum {float_dig = DBL_DIG+1};
    char buf[float_dig + (decimal_mant + CHAR_BIT - 1) / CHAR_BIT + 10];
    double value = RFLOAT_VALUE(flt);
    VALUE s;
    char *p, *e;
    int sign, decpt, digs;

    if (isinf(value))
	return rb_usascii_str_new2(value < 0 ? "-Infinity" : "Infinity");
    else if (isnan(value))
	return rb_usascii_str_new2("NaN");

    p = ruby_dtoa(value, 0, 0, &decpt, &sign, &e);
    s = sign ? rb_usascii_str_new_cstr("-") : rb_usascii_str_new(0, 0);
    if ((digs = (int)(e - p)) >= (int)sizeof(buf)) digs = (int)sizeof(buf) - 1;
    memcpy(buf, p, digs);
    xfree(p);
    if (decpt > 0) {
	if (decpt < digs) {
	    memmove(buf + decpt + 1, buf + decpt, digs - decpt);
	    buf[decpt] = '.';
	    rb_str_cat(s, buf, digs + 1);
	}
	else if (decpt <= DBL_DIG) {
	    long len;
	    char *ptr;
	    rb_str_cat(s, buf, digs);
	    rb_str_resize(s, (len = RSTRING_LEN(s)) + decpt - digs + 2);
	    ptr = RSTRING_PTR(s) + len;
	    if (decpt > digs) {
		memset(ptr, '0', decpt - digs);
		ptr += decpt - digs;
	    }
	    memcpy(ptr, ".0", 2);
	}
	else {
	    goto exp;
	}
    }
    else if (decpt > -4) {
	long len;
	char *ptr;
	rb_str_cat(s, "0.", 2);
	rb_str_resize(s, (len = RSTRING_LEN(s)) - decpt + digs);
	ptr = RSTRING_PTR(s);
	memset(ptr += len, '0', -decpt);
	memcpy(ptr -= decpt, buf, digs);
    }
    else {
      exp:
	if (digs > 1) {
	    memmove(buf + 2, buf + 1, digs - 1);
	}
	else {
	    buf[2] = '0';
	    digs++;
	}
	buf[1] = '.';
	rb_str_cat(s, buf, digs + 1);
	rb_str_catf(s, "e%+03d", decpt - 1);
    }
    return s;
}

#to_i ⇒ `Integer` #to_int ⇒ `Integer` #truncate ⇒ `Integer`

Returns flt truncated to an Integer.

Overloads:

#to_i ⇒ Integer
Returns:
- (Integer)
#to_int ⇒ Integer
Returns:
- (Integer)
#truncate ⇒ Integer
Returns:
- (Integer)

# File 'numeric.c', line 1659

static VALUE
flo_truncate(VALUE num)
{
    double f = RFLOAT_VALUE(num);
    long val;

    if (f > 0.0) f = floor(f);
    if (f < 0.0) f = ceil(f);

    if (!FIXABLE(f)) {
	return rb_dbl2big(f);
    }
    val = (long)f;
    return LONG2FIX(val);
}

#zero? ⇒ `Boolean`

Returns true if flt is 0.0.

Returns:

(Boolean)

Returns:

(Boolean)

# File 'numeric.c', line 1398

static VALUE
flo_zero_p(VALUE num)
{
    if (RFLOAT_VALUE(num) == 0.0) {
	return Qtrue;
    }
    return Qfalse;
}

Class: Float

Overview

Constant Summary collapse

Instance Method Summary collapse

Methods inherited from Numeric

Methods included from Comparable

Instance Method Details

#%(other) ⇒ Float #modulo(other) ⇒ Float

#*(other) ⇒ Float

#**(other) ⇒ Float

#+(other) ⇒ Float

#-(other) ⇒ Float

#- ⇒ Float

#/(other) ⇒ Float

#<(real) ⇒ Boolean

#<=(real) ⇒ Boolean

#<=>(real) ⇒ -1, ...

#==(obj) ⇒ Boolean

#==(obj) ⇒ Boolean

#>(real) ⇒ Boolean

#>=(real) ⇒ Boolean

#abs ⇒ Float #magnitude ⇒ Float

#arg ⇒ 0, Float #angle ⇒ 0, Float #phase ⇒ 0, Float

#arg ⇒ 0, Float #angle ⇒ 0, Float #phase ⇒ 0, Float

#ceil ⇒ Integer

#coerce(numeric) ⇒ Array

#denominator ⇒ Integer

#divmod(numeric) ⇒ Array

#eql?(obj) ⇒ Boolean

#quo(numeric) ⇒ Float

#finite? ⇒ Boolean

#floor ⇒ Integer

#hash ⇒ Integer

#infinite? ⇒ nil, ...

#abs ⇒ Float #magnitude ⇒ Float

#%(other) ⇒ Float #modulo(other) ⇒ Float

#nan? ⇒ Boolean

#numerator ⇒ Integer

#arg ⇒ 0, Float #angle ⇒ 0, Float #phase ⇒ 0, Float

#quo(numeric) ⇒ Float

#rationalize([eps]) ⇒ Object

#round([ndigits]) ⇒ Integer, Float

#to_f ⇒ self

#to_i ⇒ Integer #to_int ⇒ Integer #truncate ⇒ Integer

#to_i ⇒ Integer #to_int ⇒ Integer #truncate ⇒ Integer

#to_r ⇒ Object

#to_s ⇒ String Also known as: inspect

#to_i ⇒ Integer #to_int ⇒ Integer #truncate ⇒ Integer

#zero? ⇒ Boolean

#%(other) ⇒ `Float` #modulo(other) ⇒ `Float`

#*(other) ⇒ `Float`

#**(other) ⇒ `Float`

#+(other) ⇒ `Float`

#-(other) ⇒ `Float`

#- ⇒ `Float`

#/(other) ⇒ `Float`

#<(real) ⇒ `Boolean`

#<=(real) ⇒ `Boolean`

#<=>(real) ⇒ `-1`, ...

#==(obj) ⇒ `Boolean`

#==(obj) ⇒ `Boolean`

#>(real) ⇒ `Boolean`

#>=(real) ⇒ `Boolean`

#abs ⇒ `Float` #magnitude ⇒ `Float`

#arg ⇒ `0`, `Float` #angle ⇒ `0`, `Float` #phase ⇒ `0`, `Float`

#arg ⇒ `0`, `Float` #angle ⇒ `0`, `Float` #phase ⇒ `0`, `Float`

#ceil ⇒ `Integer`

#coerce(numeric) ⇒ `Array`

#denominator ⇒ `Integer`

#divmod(numeric) ⇒ `Array`

#eql?(obj) ⇒ `Boolean`

#quo(numeric) ⇒ `Float`

#finite? ⇒ `Boolean`

#floor ⇒ `Integer`

#hash ⇒ `Integer`

#infinite? ⇒ `nil`, ...

#abs ⇒ `Float` #magnitude ⇒ `Float`

#%(other) ⇒ `Float` #modulo(other) ⇒ `Float`

#nan? ⇒ `Boolean`

#numerator ⇒ `Integer`

#arg ⇒ `0`, `Float` #angle ⇒ `0`, `Float` #phase ⇒ `0`, `Float`

#quo(numeric) ⇒ `Float`

#rationalize([eps]) ⇒ `Object`

#round([ndigits]) ⇒ `Integer`, `Float`

#to_f ⇒ `self`

#to_i ⇒ `Integer` #to_int ⇒ `Integer` #truncate ⇒ `Integer`

#to_i ⇒ `Integer` #to_int ⇒ `Integer` #truncate ⇒ `Integer`

#to_r ⇒ `Object`

#to_s ⇒ `String` Also known as: inspect

#to_i ⇒ `Integer` #to_int ⇒ `Integer` #truncate ⇒ `Integer`

#zero? ⇒ `Boolean`