Class: Float

Inherits:
Numeric show all
Includes:
Precision
Defined in:
numeric.c

Overview

Float objects represent real numbers using the native architecture???s double-precision floating point representation.

Constant Summary collapse

ROUNDS = 
INT2FIX(FLT_ROUNDS)
RADIX = 
INT2FIX(FLT_RADIX)
MANT_DIG = 
INT2FIX(DBL_MANT_DIG)
DIG = 
INT2FIX(DBL_DIG)
MIN_EXP = 
INT2FIX(DBL_MIN_EXP)
MAX_EXP = 
INT2FIX(DBL_MAX_EXP)
MIN_10_EXP = 
INT2FIX(DBL_MIN_10_EXP)
MAX_10_EXP = 
INT2FIX(DBL_MAX_10_EXP)
MIN = 
rb_float_new(DBL_MIN)
MAX = 
rb_float_new(DBL_MAX)
EPSILON = 
rb_float_new(DBL_EPSILON)

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Precision

included, #prec, #prec_f, #prec_i

Methods inherited from Numeric

#+@, #div, #initialize_copy, #integer?, #nonzero?, #quo, #remainder, #singleton_method_added, #step

Methods included from Comparable

#between?

Class Method Details

.induced_from(obj) ⇒ Float

Convert obj to a float.

Returns:




# File 'numeric.c'

static VALUE
rb_flo_induced_from(klass, x)
VALUE klass, x;
{
switch (TYPE(x)) {
case T_FIXNUM:
case T_BIGNUM:
   return rb_funcall(x, rb_intern("to_f"), 0);
case T_FLOAT:
   return x;
default:
   rb_raise(rb_eTypeError, "failed to convert %s into Float",
            rb_obj_classname(x));
}

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:




# File 'numeric.c'

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

switch (TYPE(y)) {
  case T_FIXNUM:
fy = (double)FIX2LONG(y);
break;
  case T_BIGNUM:
fy = rb_big2dbl(y);
break;
  case T_FLOAT:
fy = RFLOAT(y)->value;
break;
  default:
return rb_num_coerce_bin(x, y);
}

#*(other) ⇒ Float

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

Returns:




# File 'numeric.c'

static VALUE
flo_mul(x, y)
VALUE x, y;
{
switch (TYPE(y)) {
  case T_FIXNUM:
return rb_float_new(RFLOAT(x)->value * (double)FIX2LONG(y));
  case T_BIGNUM:
return rb_float_new(RFLOAT(x)->value * rb_big2dbl(y));
  case T_FLOAT:
return rb_float_new(RFLOAT(x)->value * RFLOAT(y)->value);
  default:
return rb_num_coerce_bin(x, y);
}

#**(other) ⇒ Float

Raises float the other power.

Returns:




# File 'numeric.c'

static VALUE
flo_pow(x, y)
VALUE x, y;
{
switch (TYPE(y)) {
  case T_FIXNUM:
    return rb_float_new(pow(RFLOAT(x)->value, (double)FIX2LONG(y)));
  case T_BIGNUM:
return rb_float_new(pow(RFLOAT(x)->value, rb_big2dbl(y)));
  case T_FLOAT:
    return rb_float_new(pow(RFLOAT(x)->value, RFLOAT(y)->value));
  default:
    return rb_num_coerce_bin(x, y);
}

#+(other) ⇒ Float

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

Returns:




# File 'numeric.c'

static VALUE
flo_plus(x, y)
VALUE x, y;
{
switch (TYPE(y)) {
  case T_FIXNUM:
return rb_float_new(RFLOAT(x)->value + (double)FIX2LONG(y));
  case T_BIGNUM:
return rb_float_new(RFLOAT(x)->value + rb_big2dbl(y));
  case T_FLOAT:
return rb_float_new(RFLOAT(x)->value + RFLOAT(y)->value);
  default:
return rb_num_coerce_bin(x, y);
}

#+(other) ⇒ Float

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

Returns:




# File 'numeric.c'

static VALUE
flo_minus(x, y)
VALUE x, y;
{
switch (TYPE(y)) {
  case T_FIXNUM:
return rb_float_new(RFLOAT(x)->value - (double)FIX2LONG(y));
  case T_BIGNUM:
return rb_float_new(RFLOAT(x)->value - rb_big2dbl(y));
  case T_FLOAT:
return rb_float_new(RFLOAT(x)->value - RFLOAT(y)->value);
  default:
return rb_num_coerce_bin(x, y);
}

#- ⇒ Float

Returns float, negated.

Returns:




# File 'numeric.c'

static VALUE
flo_uminus(flt)
    VALUE flt;
{
    return rb_float_new(-RFLOAT(flt)->value);
}

#/(other) ⇒ Float

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

Returns:




# File 'numeric.c'

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

switch (TYPE(y)) {
  case T_FIXNUM:
f_y = FIX2LONG(y);
return rb_float_new(RFLOAT(x)->value / (double)f_y);
  case T_BIGNUM:
d = rb_big2dbl(y);
return rb_float_new(RFLOAT(x)->value / d);
  case T_FLOAT:
return rb_float_new(RFLOAT(x)->value / RFLOAT(y)->value);
  default:
return rb_num_coerce_bin(x, y);
}

#<(other) ⇒ Boolean

true if flt is less than other.

Returns:

  • (Boolean) 



# File 'numeric.c'

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

a = RFLOAT(x)->value;
switch (TYPE(y)) {
  case T_FIXNUM:
b = (double)FIX2LONG(y);
break;

  case T_BIGNUM:
b = rb_big2dbl(y);
break;

  case T_FLOAT:
b = RFLOAT(y)->value;
if (isnan(b)) return Qfalse;
break;

  default:
return rb_num_coerce_relop(x, y);
}

#<=(other) ⇒ Boolean

true if flt is less than or equal to other.

Returns:

  • (Boolean) 



# File 'numeric.c'

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

a = RFLOAT(x)->value;
switch (TYPE(y)) {
  case T_FIXNUM:
b = (double)FIX2LONG(y);
break;

  case T_BIGNUM:
b = rb_big2dbl(y);
break;

  case T_FLOAT:
b = RFLOAT(y)->value;
if (isnan(b)) return Qfalse;
break;

  default:
return rb_num_coerce_relop(x, y);
}

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

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

Returns:

  • (-1, 0, +1) 



# File 'numeric.c'

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

a = RFLOAT(x)->value;
switch (TYPE(y)) {
  case T_FIXNUM:
b = (double)FIX2LONG(y);
break;

  case T_BIGNUM:
if (isinf(a)) {
    if (a > 0.0) return INT2FIX(1);
    else return INT2FIX(-1);
}

#==(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.

1.0 == 1   #=> true

Returns:

  • (Boolean) 



# File 'numeric.c'

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

switch (TYPE(y)) {
  case T_FIXNUM:
b = FIX2LONG(y);
break;
  case T_BIGNUM:
b = rb_big2dbl(y);
break;
  case T_FLOAT:
b = RFLOAT(y)->value;
if (isnan(b)) return Qfalse;
break;
  default:
return num_equal(x, y);
}

#>(other) ⇒ Boolean

true if flt is greater than other.

Returns:

  • (Boolean) 



# File 'numeric.c'

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

a = RFLOAT(x)->value;
switch (TYPE(y)) {
  case T_FIXNUM:
b = (double)FIX2LONG(y);
break;

  case T_BIGNUM:
b = rb_big2dbl(y);
break;

  case T_FLOAT:
b = RFLOAT(y)->value;
if (isnan(b)) return Qfalse;
break;

  default:
return rb_num_coerce_relop(x, y);
}

#>=(other) ⇒ Boolean

true if flt is greater than or equal to other.

Returns:

  • (Boolean) 



# File 'numeric.c'

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

a = RFLOAT(x)->value;
switch (TYPE(y)) {
  case T_FIXNUM:
b = (double)FIX2LONG(y);
break;

  case T_BIGNUM:
b = rb_big2dbl(y);
break;

  case T_FLOAT:
b = RFLOAT(y)->value;
if (isnan(b)) return Qfalse;
break;

  default:
return rb_num_coerce_relop(x, y);
}

#abs ⇒ Float

Returns the absolute value of flt.

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

Returns:




# File 'numeric.c'

static VALUE
flo_abs(flt)
    VALUE flt;
{
    double val = fabs(RFLOAT(flt)->value);
    return rb_float_new(val);
}

#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:




# File 'numeric.c'

static VALUE
flo_ceil(num)
VALUE num;
{
double f = ceil(RFLOAT(num)->value);
long val;

if (!FIXABLE(f)) {
return rb_dbl2big(f);
}

#coerce ⇒ Object

MISSING: documentation




# File 'numeric.c'

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

#divmod(numeric) ⇒ Array

See Numeric#divmod.

Returns:




# File 'numeric.c'

static VALUE
flo_divmod(x, y)
VALUE x, y;
{
double fy, div, mod, val;
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(y)->value;
break;
  default:
return rb_num_coerce_bin(x, y);
}

#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.

1.0.eql?(1)   #=> false

Returns:

  • (Boolean) 



# File 'numeric.c'

static VALUE
flo_eql(x, y)
VALUE x, y;
{
if (TYPE(y) == T_FLOAT) {
double a = RFLOAT(x)->value;
double b = RFLOAT(y)->value;

if (isnan(a) || isnan(b)) return Qfalse;
if (a == b) return Qtrue;
}

#finite? ⇒ Boolean

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

Returns:

  • (Boolean) 



# File 'numeric.c'

static VALUE
flo_is_finite_p(num)
     VALUE num;
{     
    double value = RFLOAT(num)->value;

#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:




# File 'numeric.c'

static VALUE
flo_floor(num)
VALUE num;
{
double f = floor(RFLOAT(num)->value);
long val;

if (!FIXABLE(f)) {
return rb_dbl2big(f);
}

#hash ⇒ Integer

Returns a hash code for this float.

Returns:




# File 'numeric.c'

static VALUE
flo_hash(num)
VALUE num;
{
double d;
char *c;
int i, hash;

d = RFLOAT(num)->value;
if (d == 0) d = fabs(d);
c = (char*)&d;
for (hash=0, i=0; i<sizeof(double);i++) {
hash = (hash * 971) ^ (unsigned char)c[i];
}

#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) 



# File 'numeric.c'

static VALUE
flo_is_infinite_p(num)
 VALUE num;
{     
double value = RFLOAT(num)->value;

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

#%(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:




# File 'numeric.c'

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

switch (TYPE(y)) {
  case T_FIXNUM:
fy = (double)FIX2LONG(y);
break;
  case T_BIGNUM:
fy = rb_big2dbl(y);
break;
  case T_FLOAT:
fy = RFLOAT(y)->value;
break;
  default:
return rb_num_coerce_bin(x, y);
}

#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) 



# File 'numeric.c'

static VALUE
flo_is_nan_p(num)
     VALUE num;
{     
    double value = RFLOAT(num)->value;

    return isnan(value) ? Qtrue : Qfalse;
}

#round ⇒ Integer

Rounds flt to the nearest integer. Equivalent to:

def round
  return (self+0.5).floor if self > 0.0
  return (self-0.5).ceil  if self < 0.0
  return 0
end

1.5.round      #=> 2
(-1.5).round   #=> -2

Returns:




# File 'numeric.c'

static VALUE
flo_round(num)
VALUE num;
{
double f = RFLOAT(num)->value;
long val;

f = round(f);

if (!FIXABLE(f)) {
return rb_dbl2big(f);
}

#to_f ⇒ Object

As flt is already a float, returns self.




# File 'numeric.c'

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

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

Returns flt truncated to an Integer.

Overloads:




# File 'numeric.c'

static VALUE
flo_truncate(num)
VALUE num;
{
double f = RFLOAT(num)->value;
long val;

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

if (!FIXABLE(f)) {
return rb_dbl2big(f);
}

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

Returns flt truncated to an Integer.

Overloads:




# File 'numeric.c'

static VALUE
flo_truncate(num)
VALUE num;
{
double f = RFLOAT(num)->value;
long val;

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

if (!FIXABLE(f)) {
return rb_dbl2big(f);
}

#to_s ⇒ String

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:




# File 'numeric.c'

static VALUE
flo_to_s(flt)
VALUE flt;
{
char buf[32];
double value = RFLOAT(flt)->value;
char *p, *e;

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

sprintf(buf, "%#.15g", value); /* ensure to print decimal point */
if (!(e = strchr(buf, 'e'))) {
e = buf + strlen(buf);
}

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

Returns flt truncated to an Integer.

Overloads:




# File 'numeric.c'

static VALUE
flo_truncate(num)
VALUE num;
{
double f = RFLOAT(num)->value;
long val;

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

if (!FIXABLE(f)) {
return rb_dbl2big(f);
}

#zero? ⇒ Boolean

Returns true if flt is 0.0.

Returns:

  • (Boolean) 



# File 'numeric.c'

static VALUE
flo_zero_p(num)
VALUE num;
{
if (RFLOAT(num)->value == 0.0) {
return Qtrue;
}