RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://docs.ruby-lang.org/en/3.1/Float.html below:

class Float - RDoc Documentation

class Float

A Float object represents a sometimes-inexact real number using the native architectureâs double-precision floating point representation.

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

You can create a Float object explicitly with:

A floating-point literal.

You can convert certain objects to Floats with:

Method Float.

Whatâs Here¶ ↑

First, whatâs elsewhere. Class Float:

Inherits from class Numeric.

Here, class Float provides methods for:

Querying¶ ↑

finite?

Returns whether self is finite.
hash

Returns the integer hash code for self.
infinite?

Returns whether self is infinite.
nan?

Returns whether self is a NaN (not-a-number).

Comparing¶ ↑

<

Returns whether self is less than the given value.
<=

Returns whether self is less than or equal to the given value.
<=>

Returns a number indicating whether self is less than, equal to, or greater than the given value.
== (aliased as === and eql>)

Returns whether self is equal to the given value.
>

Returns whether self is greater than the given value.
>=

Returns whether self is greater than or equal to the given value.

Converting¶ ↑

% (aliased as modulo)

Returns self modulo the given value.
*

Returns the product of self and the given value.
**

Returns the value of self raised to the power of the given value.
+

Returns the sum of self and the given value.
-

Returns the difference of self and the given value.
/

Returns the quotient of self and the given value.
ceil

Returns the smallest number greater than or equal to self.
coerce

Returns a 2-element array containing the given value converted to a Float and self
divmod

Returns a 2-element array containing the quotient and remainder results of dividing self by the given value.
fdiv

Returns the Float result of dividing self by the given value.
floor

Returns the greatest number smaller than or equal to self.
next_float

Returns the next-larger representable Float.
prev_float

Returns the next-smaller representable Float.
quo

Returns the quotient from dividing self by the given value.
round

Returns self rounded to the nearest value, to a given precision.
to_i (aliased as to_int)

Returns self truncated to an Integer.
to_s (aliased as inspect)

Returns a string containing the place-value representation of self in the given radix.
truncate

Returns self truncated to a given precision.

Constants

DIG

The minimum number of significant decimal digits in a double-precision floating point.

Usually defaults to 15.

EPSILON

The difference between 1 and the smallest double-precision floating point number greater than 1.

Usually defaults to 2.2204460492503131e-16.

INFINITY

An expression representing positive infinity.

MANT_DIG

The number of base digits for the double data type.

Usually defaults to 53.

MAX

The largest possible integer in a double-precision floating point number.

Usually defaults to 1.7976931348623157e+308.

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.

MAX_EXP

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

Usually defaults to 1024.

MIN

The smallest positive normalized number in a double-precision floating point.

Usually defaults to 2.2250738585072014e-308.

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.

Public Instance Methods

self % other → float click to toggle source

Returns self modulo other as a float.

For float f and real number r, these expressions are equivalent:

f % r
f-r*(f/r).floor
f.divmod(r)[1]

See Numeric#divmod.

Examples:

10.0 % 2              
10.0 % 3              
10.0 % 4              

10.0 % -2             
10.0 % -3             
10.0 % -4             

10.0 % 4.0            
10.0 % Rational(4, 1)

Float#modulo is an alias for Float#%.

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

    if (FIXNUM_P(y)) {
        fy = (double)FIX2LONG(y);
    }
    else if (RB_BIGNUM_TYPE_P(y)) {
        fy = rb_big2dbl(y);
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        fy = RFLOAT_VALUE(y);
    }
    else {
        return rb_num_coerce_bin(x, y, '%');
    }
    return DBL2NUM(ruby_float_mod(RFLOAT_VALUE(x), fy));
}

self * other → numeric click to toggle source

Returns a new Float which is the product of self and other:

f = 3.14
f * 2              
f * 2.0            
f * Rational(1, 2) 
f * Complex(2, 0)

VALUE
rb_float_mul(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) * (double)FIX2LONG(y));
    }
    else if (RB_BIGNUM_TYPE_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) * rb_big2dbl(y));
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) * RFLOAT_VALUE(y));
    }
    else {
        return rb_num_coerce_bin(x, y, '*');
    }
}

self ** other → numeric click to toggle source

Raises self to the power of other:

f = 3.14
f ** 2              
f ** -2             
f ** 2.1            
f ** Rational(2, 1) 
f ** Complex(2, 0)

VALUE
rb_float_pow(VALUE x, VALUE y)
{
    double dx, dy;
    if (y == INT2FIX(2)) {
        dx = RFLOAT_VALUE(x);
        return DBL2NUM(dx * dx);
    }
    else if (FIXNUM_P(y)) {
        dx = RFLOAT_VALUE(x);
        dy = (double)FIX2LONG(y);
    }
    else if (RB_BIGNUM_TYPE_P(y)) {
        dx = RFLOAT_VALUE(x);
        dy = rb_big2dbl(y);
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        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));
}

self + other → numeric click to toggle source

Returns a new Float which is the sum of self and other:

f = 3.14
f + 1                 
f + 1.0               
f + Rational(1, 1)    
f + Complex(1, 0)

VALUE
rb_float_plus(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) + (double)FIX2LONG(y));
    }
    else if (RB_BIGNUM_TYPE_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) + rb_big2dbl(y));
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) + RFLOAT_VALUE(y));
    }
    else {
        return rb_num_coerce_bin(x, y, '+');
    }
}

self - other → numeric click to toggle source

Returns a new Float which is the difference of self and other:

f = 3.14
f - 1                 
f - 1.0               
f - Rational(1, 1)    
f - Complex(1, 0)

VALUE
rb_float_minus(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) - (double)FIX2LONG(y));
    }
    else if (RB_BIGNUM_TYPE_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) - rb_big2dbl(y));
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        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.

def -@
  Primitive.attr! 'inline'
  Primitive.cexpr! 'rb_float_uminus(self)'
end

self / other → numeric click to toggle source

Returns a new Float which is the result of dividing self by other:

f = 3.14
f / 2              
f / 2.0            
f / Rational(2, 1) 
f / Complex(2, 0)

VALUE
rb_float_div(VALUE x, VALUE y)
{
    double num = RFLOAT_VALUE(x);
    double den;
    double ret;

    if (FIXNUM_P(y)) {
        den = FIX2LONG(y);
    }
    else if (RB_BIGNUM_TYPE_P(y)) {
        den = rb_big2dbl(y);
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        den = RFLOAT_VALUE(y);
    }
    else {
        return rb_num_coerce_bin(x, y, '/');
    }

    ret = double_div_double(num, den);
    return DBL2NUM(ret);
}

self < other → true or false click to toggle source

Returns true if self is numerically less than other:

2.0 < 3              
2.0 < 3.0            
2.0 < Rational(3, 1) 
2.0 < 2.0

Float::NAN < Float::NAN returns an implementation-dependent value.

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

    a = RFLOAT_VALUE(x);
    if (RB_INTEGER_TYPE_P(y)) {
        VALUE rel = rb_integer_float_cmp(y, x);
        if (FIXNUM_P(rel))
            return RBOOL(-FIX2LONG(rel) < 0);
        return Qfalse;
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        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 RBOOL(a < b);
}

self <= other → true or false click to toggle source

Returns true if self is numerically less than or equal to other:

2.0 <= 3              
2.0 <= 3.0            
2.0 <= Rational(3, 1) 
2.0 <= 2.0            
2.0 <= 1.0

Float::NAN <= Float::NAN returns an implementation-dependent value.

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

    a = RFLOAT_VALUE(x);
    if (RB_INTEGER_TYPE_P(y)) {
        VALUE rel = rb_integer_float_cmp(y, x);
        if (FIXNUM_P(rel))
            return RBOOL(-FIX2LONG(rel) <= 0);
        return Qfalse;
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        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 RBOOL(a <= b);
}

self <=> other → -1, 0, +1, or nil click to toggle source

Returns a value that depends on the numeric relation between self and other:

-1, if self is less than other.
0, if self is equal to other.
1, if self is greater than other.
nil, if the two values are incommensurate.

Examples:

2.0 <=> 2              
2.0 <=> 2.0            
2.0 <=> Rational(2, 1) 
2.0 <=> Complex(2, 0)  
2.0 <=> 1.9            
2.0 <=> 2.1            
2.0 <=> 'foo'

This is the basis for the tests in the Comparable module.

Float::NAN <=> Float::NAN returns an implementation-dependent value.

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

    a = RFLOAT_VALUE(x);
    if (isnan(a)) return Qnil;
    if (RB_INTEGER_TYPE_P(y)) {
        VALUE rel = rb_integer_float_cmp(y, x);
        if (FIXNUM_P(rel))
            return LONG2FIX(-FIX2LONG(rel));
        return rel;
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        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);
}

self == other → true or false click to toggle source

Returns true if other has the same value as self, false otherwise:

2.0 == 2              
2.0 == 2.0            
2.0 == Rational(2, 1) 
2.0 == Complex(2, 0)

Float::NAN == Float::NAN returns an implementation-dependent value.

Related: Float#eql? (requires other to be a Float).

MJIT_FUNC_EXPORTED VALUE
rb_float_equal(VALUE x, VALUE y)
{
    volatile double a, b;

    if (RB_INTEGER_TYPE_P(y)) {
        return rb_integer_float_eq(y, x);
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        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 RBOOL(a == b);
}

===(p1)

Returns true if other has the same value as self, false otherwise:

2.0 == 2              
2.0 == 2.0            
2.0 == Rational(2, 1) 
2.0 == Complex(2, 0)

Float::NAN == Float::NAN returns an implementation-dependent value.

Related: Float#eql? (requires other to be a Float).

self > other → true or false click to toggle source

Returns true if self is numerically greater than other:

2.0 > 1              
2.0 > 1.0            
2.0 > Rational(1, 2) 
2.0 > 2.0

Float::NAN > Float::NAN returns an implementation-dependent value.

VALUE
rb_float_gt(VALUE x, VALUE y)
{
    double a, b;

    a = RFLOAT_VALUE(x);
    if (RB_INTEGER_TYPE_P(y)) {
        VALUE rel = rb_integer_float_cmp(y, x);
        if (FIXNUM_P(rel))
            return RBOOL(-FIX2LONG(rel) > 0);
        return Qfalse;
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        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 RBOOL(a > b);
}

self >= other → true or false click to toggle source

Returns true if self is numerically greater than or equal to other:

2.0 >= 1              
2.0 >= 1.0            
2.0 >= Rational(1, 2) 
2.0 >= 2.0            
2.0 >= 2.1

Float::NAN >= Float::NAN returns an implementation-dependent value.

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

    a = RFLOAT_VALUE(x);
    if (RB_TYPE_P(y, T_FIXNUM) || RB_BIGNUM_TYPE_P(y)) {
        VALUE rel = rb_integer_float_cmp(y, x);
        if (FIXNUM_P(rel))
            return RBOOL(-FIX2LONG(rel) >= 0);
        return Qfalse;
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        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 RBOOL(a >= b);
}

abs → float click to toggle source

magnitude → float

Returns the absolute value of float.

(-34.56).abs   
-34.56.abs     
34.56.abs

Float#magnitude is an alias for Float#abs.

def abs
  Primitive.attr! 'inline'
  Primitive.cexpr! 'rb_float_abs(self)'
end

angle → 0 or float

Returns 0 if the value is positive, pi otherwise.

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 = 0) → float or integer click to toggle source

Returns the smallest number greater than or equal to self with a precision of ndigits decimal digits.

When ndigits is positive, returns a float with ndigits digits after the decimal point (as available):

f = 12345.6789
f.ceil(1) 
f.ceil(3) 
f = -12345.6789
f.ceil(1) 
f.ceil(3)

When ndigits is non-positive, returns an integer with at least ndigits.abs trailing zeros:

f = 12345.6789
f.ceil(0)  
f.ceil(-3) 
f = -12345.6789
f.ceil(0)  
f.ceil(-3)

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

(2.1 / 0.7).ceil

Related: Float#floor.

static VALUE
flo_ceil(int argc, VALUE *argv, VALUE num)
{
    int ndigits = flo_ndigits(argc, argv);
    return rb_float_ceil(num, ndigits);
}

coerce(other) → array click to toggle source

Returns a 2-element array containing other converted to a Float and self:

f = 3.14                 
f.coerce(2)              
f.coerce(2.0)            
f.coerce(Rational(1, 2)) 
f.coerce(Complex(1, 0))

Raises an exception if a type conversion fails.

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.