Class: Float

Inherits:
Numeric show all
Defined in:
numeric.c,
numeric.c

Overview

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

Float objects represent inexact real numbers 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:

- http://docs.sun.com/source/806-3568/ncg_goldberg.html
- http://wiki.github.com/rdp/ruby_tutorials_core/ruby-talk-faq#wiki-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

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 float by other.

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



926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
 
# File 'numeric.c', line 926

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

#*(other) ⇒ Float

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



811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'numeric.c', line 811

static VALUE
flo_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, '*');
    }
}

#**(other) ⇒ Float

Raises float to the power of other.

2.0**3      #=> 8.0



1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
 
# File 'numeric.c', line 1000

static VALUE
flo_pow(VALUE x, VALUE y)
{
    if (RB_TYPE_P(y, T_FIXNUM)) {
  return DBL2NUM(pow(RFLOAT_VALUE(x), (double)FIX2LONG(y)));
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
  return DBL2NUM(pow(RFLOAT_VALUE(x), rb_big2dbl(y)));
    }
    else if (RB_TYPE_P(y, 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));
  }
    }
    else {
  return rb_num_coerce_bin(x, y, rb_intern("**"));
    }
}

#+(other) ⇒ Float

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



763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
 
# File 'numeric.c', line 763

static VALUE
flo_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, '+');
    }
}

#-(other) ⇒ Float

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



787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
 
# File 'numeric.c', line 787

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

Returns float, negated.



750
751
752
753
754
 
# File 'numeric.c', line 750

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.



835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
 
# File 'numeric.c', line 835

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

    if (RB_TYPE_P(y, T_FIXNUM)) {
  f_y = FIX2LONG(y);
  return DBL2NUM(RFLOAT_VALUE(x) / (double)f_y);
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
  d = rb_big2dbl(y);
  return DBL2NUM(RFLOAT_VALUE(x) / d);
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
  return DBL2NUM(RFLOAT_VALUE(x) / RFLOAT_VALUE(y));
    }
    else {
  return rb_num_coerce_bin(x, y, '/');
    }
}

#<(real) ⇒ Boolean

Returns true if float is less than real.

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



1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
 
# File 'numeric.c', line 1262

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

#<=(real) ⇒ Boolean

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

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



1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
 
# File 'numeric.c', line 1299

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, 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 float 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.

nil is returned if the two values are incomparable.



1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
 
# File 'numeric.c', line 1146

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

#==(obj) ⇒ Boolean

Returns true only if obj has the same value as float. 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



1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
 
# File 'numeric.c', line 1079

static VALUE
flo_eq(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;
}

#==(obj) ⇒ Boolean

Returns true only if obj has the same value as float. 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



1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
 
# File 'numeric.c', line 1079

static VALUE
flo_eq(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;
}

#>(real) ⇒ Boolean

Returns true if float is greater than real.

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



1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
 
# File 'numeric.c', line 1188

static VALUE
flo_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;
}

#>=(real) ⇒ Boolean

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

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



1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
 
# File 'numeric.c', line 1225

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, 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 float.

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



1379
1380
1381
1382
1383
1384
 
# File 'numeric.c', line 1379

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.



2007
2008
2009
2010
2011
2012
2013
2014
2015
 
# File 'complex.c', line 2007

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.



2007
2008
2009
2010
2011
2012
2013
2014
2015
 
# File 'complex.c', line 2007

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

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



1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
 
# File 'numeric.c', line 1514

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 a numeric and a float represented as Float objects.

This is achieved by converting a numeric to a Float.

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



737
738
739
740
741
 
# File 'numeric.c', line 737

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.



1892
1893
1894
1895
1896
1897
1898
1899
 
# File 'rational.c', line 1892

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.

42.0.divmod 6 #=> [7, 0.0]
42.0.divmod 5 #=> [8, 2.0]



966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
 
# File 'numeric.c', line 966

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

    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, 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 float. 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



1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
 
# File 'numeric.c', line 1339

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

#fdiv(numeric) ⇒ Float #quo(numeric) ⇒ Float

Returns float / numeric, same as Float#/.



865
866
867
868
869
 
# File 'numeric.c', line 865

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

#finite? ⇒ Boolean

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



1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
 
# File 'numeric.c', line 1461

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

#if HAVE_ISFINITE
    if (!isfinite(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 float.

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



1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
 
# File 'numeric.c', line 1489

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.



1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
 
# File 'numeric.c', line 1110

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

Return values corresponding to the value of float:

finite:: nil

-Infinity

-1

+Infinity

1

For example:

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



1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
 
# 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 float.

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



1379
1380
1381
1382
1383
1384
 
# File 'numeric.c', line 1379

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 float by other.

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



926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
 
# File 'numeric.c', line 926

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

#nan? ⇒ Boolean

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

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



1415
1416
1417
1418
1419
1420
1421
 
# File 'numeric.c', line 1415

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



1874
1875
1876
1877
1878
1879
1880
1881
 
# File 'rational.c', line 1874

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.



2007
2008
2009
2010
2011
2012
2013
2014
2015
 
# File 'complex.c', line 2007

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

#fdiv(numeric) ⇒ Float #quo(numeric) ⇒ Float

Returns float / numeric, same as Float#/.



865
866
867
868
869
 
# File 'numeric.c', line 865

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.



2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
 
# File 'rational.c', line 2089

static VALUE
float_rationalize(int argc, VALUE *argv, VALUE self)
{
    VALUE e;

    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) {
        return rb_flt_rationalize_with_prec(self, e);
    }
    else {
        return rb_flt_rationalize(self);
    }
}

#round([ndigits]) ⇒ Integer, Float

Rounds float 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



1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
 
# File 'numeric.c', line 1600

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

Since float is already a float, returns self.



1361
1362
1363
1364
1365
 
# File 'numeric.c', line 1361

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

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

Returns the float truncated to an Integer.

Synonyms are #to_i, #to_int, and #truncate.



1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
 
# File 'numeric.c', line 1660

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 the float truncated to an Integer.

Synonyms are #to_i, #to_int, and #truncate.



1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
 
# File 'numeric.c', line 1660

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.



1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
 
# File 'rational.c', line 1999

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 float, the call may return NaN, Infinity, and -Infinity.



655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
 
# File 'numeric.c', line 655

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 the float truncated to an Integer.

Synonyms are #to_i, #to_int, and #truncate.



1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
 
# File 'numeric.c', line 1660

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 float is 0.0.



1394
1395
1396
1397
1398
1399
1400
1401
 
# File 'numeric.c', line 1394

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