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

Overloads:



920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
 
# File 'numeric.c', line 920

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.

Returns:



805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
 
# File 'numeric.c', line 805

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

Returns:



994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
 
# File 'numeric.c', line 994

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.

Returns:



757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
 
# File 'numeric.c', line 757

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.

Returns:



781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
 
# File 'numeric.c', line 781

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.

Returns:



744
745
746
747
748
 
# File 'numeric.c', line 744

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:



829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
 
# File 'numeric.c', line 829

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.

Returns:

  • (Boolean) 


1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
 
# File 'numeric.c', line 1256

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.

Returns:

  • (Boolean) 


1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
 
# File 'numeric.c', line 1293

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.

Returns:

  • (-1, 0, +1, nil) 


1140
1141
1142
1143
1144
1145
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
 
# File 'numeric.c', line 1140

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, rb_intern("<=>"));
    }
    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

Returns:

  • (Boolean) 


1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
 
# File 'numeric.c', line 1073

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

Returns:

  • (Boolean) 


1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
 
# File 'numeric.c', line 1073

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.

Returns:

  • (Boolean) 


1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
 
# File 'numeric.c', line 1182

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.

Returns:

  • (Boolean) 


1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
 
# File 'numeric.c', line 1219

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

Overloads:



1373
1374
1375
1376
1377
1378
 
# File 'numeric.c', line 1373

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:



2042
2043
2044
2045
2046
2047
2048
2049
2050
 
# File 'complex.c', line 2042

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:



2042
2043
2044
2045
2046
2047
2048
2049
2050
 
# File 'complex.c', line 2042

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

Returns:



1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
 
# File 'numeric.c', line 1508

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]

Returns:



731
732
733
734
735
 
# File 'numeric.c', line 731

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:



1923
1924
1925
1926
1927
1928
1929
1930
 
# File 'rational.c', line 1923

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]

Returns:



960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
 
# File 'numeric.c', line 960

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

Returns:

  • (Boolean) 


1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
 
# File 'numeric.c', line 1333

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

Overloads:



859
860
861
862
863
 
# File 'numeric.c', line 859

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

Returns:

  • (Boolean) 


1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
 
# File 'numeric.c', line 1455

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

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

Returns:



1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
 
# File 'numeric.c', line 1483

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:



1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
 
# File 'numeric.c', line 1104

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

Returns:

  • (nil, -1, +1) 


1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
 
# File 'numeric.c', line 1434

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

Overloads:



1373
1374
1375
1376
1377
1378
 
# File 'numeric.c', line 1373

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

Overloads:



920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
 
# File 'numeric.c', line 920

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

Returns:

  • (Boolean) 


1409
1410
1411
1412
1413
1414
1415
 
# File 'numeric.c', line 1409

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:



1905
1906
1907
1908
1909
1910
1911
1912
 
# File 'rational.c', line 1905

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:



2042
2043
2044
2045
2046
2047
2048
2049
2050
 
# File 'complex.c', line 2042

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

Overloads:



859
860
861
862
863
 
# File 'numeric.c', line 859

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.



2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
 
# File 'rational.c', line 2120

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

Returns:



1594
1595
1596
1597
1598
1599
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
 
# File 'numeric.c', line 1594

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.

Returns:

  • (self) 


1355
1356
1357
1358
1359
 
# File 'numeric.c', line 1355

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.

Overloads:



1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
 
# File 'numeric.c', line 1654

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.

Overloads:



1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
 
# File 'numeric.c', line 1654

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.



2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
 
# File 'rational.c', line 2030

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.

Returns:



649
650
651
652
653
654
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
 
# File 'numeric.c', line 649

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.

Overloads:



1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
 
# File 'numeric.c', line 1654

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.

Returns:

  • (Boolean) 


1388
1389
1390
1391
1392
1393
1394
1395
 
# File 'numeric.c', line 1388

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