Float
Parent:Numeric
当您在应用程序中需要BigDecimal时，此方法将在Float对象上可用。
浮点对象使用本机体系结构的双精度浮点表示法表示不精确的实数。
浮点有不同的算术，是一个不精确的数字。所以你应该知道它的深奥系统。见以下内容：
常量
DIG
双精度浮点中的重要小数位数的最小值。
通常默认为15。
EPSILON
1与最小双精度浮点数之间的差值大于1。
通常默认为2.2204460492503131e-16。
INFINITY
表示正无限的表达式。
MANT_DIG
double数据类型的基数位数。
通常默认为53。
MAX
双精度浮点数中最大的可能整数。
通常默认为1.7976931348623157e + 308。
MAX_10_EXP
双精度浮点中最大的正指数，其中10个提高到该功率减1。
通常默认为308。
MAX_EXP
双精度浮点中可能的最大指数值。
通常默认为1024。
MIN
双精度浮点中最小的正归一化数。
通常默认为2.2250738585072014e-308。
如果平台支持非规格化数字，则有零和Float :: MIN之间的数字。0.0.next_float返回包含非规格化数字的最小正浮点数。
MIN_10_EXP
双精度浮点中的最小负指数，其中10个上升到该功率减1。
通常默认为-307。
MIN_EXP
双精度浮点中最小的posable指数值。
通常默认为-1021。
NAN
代表“不是数字”的值的表达式。
RADIX
浮点的基数，或用于表示数字的唯一数字的数量。
通常在大多数系统中默认为2，这将表示基数为10的小数。
ROUNDS
表示浮点加法的舍入模式。
通常默认为1，四舍五入到最近的数字。
其他模式包括：
-1
无法确定
0
朝零调整
1
舍入到最近的数字
2
朝向正无穷
3
朝向负无穷的趋势
Public Instance Methods
float％other→float
分工后返回模float通过 other。
6543.21。modulo（137） ＃=> 104.21
6543.21。modulo（137.24） ＃=> 92.9299999999996 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));
}float * other → float
返回一个新的浮动是的产品float和other。
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, '*');
}
}float ** other → float
提高float到的力量other。
2.0**3 #=> 8.0 VALUE
rb_float_pow(VALUE x, VALUE y)
{
double dx, dy;
if (RB_TYPE_P(y, T_FIXNUM)) {
dx = RFLOAT_VALUE(x);
dy = (double)FIX2LONG(y);
}
else if (RB_TYPE_P(y, T_BIGNUM)) {
dx = RFLOAT_VALUE(x);
dy = rb_big2dbl(y);
}
else if (RB_TYPE_P(y, T_FLOAT)) {
dx = RFLOAT_VALUE(x);
dy = RFLOAT_VALUE(y);
if (dx < 0 && dy != round(dy))
return num_funcall1(rb_complex_raw1(x), idPow, y);
}
else {
return rb_num_coerce_bin(x, y, idPow);
}
return DBL2NUM(pow(dx, dy));
}
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(a)) return Qfalse;
#endif
return (a < b)?Qtrue:Qfalse;
} float <= real → true or false Show source Returns float + other → float
返回一个新的float，它是float和other的和。
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, '+');
}
}float - other → float
返回与float和之差的新浮点数other。
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 → float
返回float，否定。
VALUE
rb_float_uminus(VALUE flt)
{
return DBL2NUM(-RFLOAT_VALUE(flt));
}float / other → float
通过other返回一个新的float作为分割的结果float。
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, '/');
}
}float < real → true or false
返回true如果float小于 real。
结果NaN < NaN是未定义的，所以返回依赖于实现的值。
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;
}float <= real → true or false
如果float小于或等于real，则返回true。
结果NaN <= NaN是未定义的，所以返回依赖于实现的值。
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, idLE);
}
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(a)) return Qfalse;
#endif
return (a <= b)?Qtrue:Qfalse;
}float <=> real → -1, 0, +1 or nil
根据是否float小于，等于或大于，返回-1,0，+1或nil real。这是Comparable测试的基础。
结果NaN <=> NaN是未定义的，所以返回依赖于实现的值。
nil 如果两个值无法比较，则返回。
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);
}float == obj → true or false
仅当obj具有float相同的值时 返回true。与#eql对比呢？，它要求obj是一个Float。
结果NaN == NaN是未定义的，所以返回依赖于实现的值。
1.0 == 1 #=> true 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;
}float == obj → true or false
仅当obj具有float相同的值时返回true。与#eql对比呢？，它要求obj是一个Float。
结果NaN == NaN是未定义的，所以返回依赖于实现的值。
1.0 == 1 #=> true 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;
}float > real → true or false
如果float大于real，则返回true。
结果NaN > NaN是未定义的，所以返回依赖于实现的值。
VALUE
rb_float_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;
}float >= real → true or false
如果float大于real，则返回true。
结果NaN > NaN是未定义的，所以返回依赖于实现的值。
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, idGE);
}
#if defined(_MSC_VER) && _MSC_VER < 1300
if (isnan(a)) return Qfalse;
#endif
return (a >= b)?Qtrue:Qfalse;
}abs → float
返回的绝对值float。
(-34.56).abs #=> 34.56
-34.56.abs #=> 34.56 VALUE
rb_float_abs(VALUE flt)
{
double val = fabs(RFLOAT_VALUE(flt));
return DBL2NUM(val);
}angle → 0 or float
如果值为正，则返回0，否则返回pi。
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 or float
如果值为正，则返回0，否则返回pi。
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]) → integer or float
返回大于或等于float十进制数字的最小数字（默认为0位数字）。
精度可能是负面的。返回一个浮点数，当ndigits为正值时，self为零，并且为负值返回一个浮点数 。
1.2.ceil #=> 2
2.0.ceil #=> 2
(-1.2).ceil #=> -1
(-2.0).ceil #=> -2
1.234567.ceil(2) #=> 1.24
1.234567.ceil(3) #=> 1.235
1.234567.ceil(4) #=> 1.2346
1.234567.ceil(5) #=> 1.23457
34567.89.ceil(-5) #=> 100000
34567.89.ceil(-4) #=> 40000
34567.89.ceil(-3) #=> 35000
34567.89.ceil(-2) #=> 34600
34567.89.ceil(-1) #=> 34570
34567.89.ceil(0) #=> 34568
34567.89.ceil(1) #=> 34567.9
34567.89.ceil(2) #=> 34567.89
34567.89.ceil(3) #=> 34567.89coerce(numeric) → array
返回一个数组，其中a numeric和a float 表示为Float对象。
这是通过将a转换numeric为浮点来实现的。
1.2.coerce(3) #=> [3.0, 1.2]
2.5.coerce(1.1) #=> [1.1, 2.5] static VALUE
flo_coerce(VALUE x, VALUE y)
{
return rb_assoc_new(rb_Float(y), x);
}denominator → integer
返回分母（总是正数）。结果取决于机器。
见分子。
static VALUE
float_denominator(VALUE self)
{
double d = RFLOAT_VALUE(self);
if (isinf(d) || isnan(d))
return INT2FIX(1);
return nurat_denominator(float_to_r(self));
}divmod(numeric) → array
请参阅 Numeric#divmod.
42.0.divmod 6 #=> [7, 0.0]
42.0.divmod 5 #=> [8, 2.0] 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, id_divmod);
}
flodivmod(RFLOAT_VALUE(x), fy, &div, &mod);
a = dbl2ival(div);
b = DBL2NUM(mod);
return rb_assoc_new(a, b);
}eql?(obj) → true or false
仅当obj是与float值相同的Float时才返回true。将其与Float＃==进行对比，后者执行类型转换。
结果NaN.eql?(NaN)是未定义的，所以返回依赖于实现的值。
1.0.eql?(1) #=> false 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
返回 float / numeric, 和 Float#/相同。
static VALUE
flo_quo(VALUE x, VALUE y)
{
return num_funcall1(x, '/', y);
}finite? → true or false
返回trueiffloat是一个有效的IEEE浮点数（它不是无限的，＃nan？是false）。
static VALUE
flo_is_finite_p(VALUE num)
{
double value = RFLOAT_VALUE(num);
#ifdef HAVE_ISFINITE
if (!isfinite(value))
return Qfalse;
#else
if (isinf(value) || isnan(value))
return Qfalse;
#endif
return Qtrue;
}floor([ndigits]) → integer or float
返回小于或等于float十进制数字的最大数字（默认为0位数字）。
精度可能是负面的。返回一个浮点数，当ndigits为正数时 ，self为零，底层为负数。
1.2.floor #=> 1
2.0.floor #=> 2
(-1.2).floor #=> -2
(-2.0).floor #=> -2
1.234567.floor(2) #=> 1.23
1.234567.floor(3) #=> 1.234
1.234567.floor(4) #=> 1.2345
1.234567.floor(5) #=> 1.23456
34567.89.floor(-5) #=> 0
34567.89.floor(-4) #=> 30000
34567.89.floor(-3) #=> 34000
34567.89.floor(-2) #=> 34500
34567.89.floor(-1) #=> 34560
34567.89.floor(0) #=> 34567
34567.89.floor(1) #=> 34567.8
34567.89.floor(2) #=> 34567.89
34567.89.floor(3) #=> 34567.89 static VALUE
flo_floor(int argc, VALUE *argv, VALUE num)
{
double number, f;
long val;
int ndigits = 0;
if (rb_check_arity(argc, 0, 1)) {
ndigits = NUM2INT(argv[0]);
}
if (ndigits < 0) {
return rb_int_floor(flo_to_i(num), ndigits);
}
number = RFLOAT_VALUE(num);
if (ndigits > 0) {
if (float_invariant_round(number, ndigits, &num)) return num;
f = pow(10, ndigits);
f = floor(number * f) / f;
return DBL2NUM(f);
}
f = floor(number);
if (!FIXABLE(f)) {
return rb_dbl2big(f);
}
val = (long)f;
return LONG2FIX(val);
}hash → integer
返回此浮动的散列码。
另见对象＃散列。
static VALUE
flo_hash(VALUE num)
{
return rb_dbl_hash(RFLOAT_VALUE(num));
}infinite? → nil, -1, +1
返回值对应的值为float：
finite
nil
-Infinity
-1
+Infinity
1
例如：
(0.0).infinite? #=> nil
(-1.0/0.0).infinite? #=> -1
(+1.0/0.0).infinite? #=> 1 static VALUE
flo_is_infinite_p(VALUE num)
{
double value = RFLOAT_VALUE(num);
if (isinf(value)) {
return INT2FIX( value < 0 ? -1 : 1 );
}
return Qnil;
}inspect()
别名： to_s
magnitude → float
返回的绝对值float。
(-34.56).abs #=> 34.56
-34.56.abs #=> 34.56 VALUE
rb_float_abs(VALUE flt)
{
double val = fabs(RFLOAT_VALUE(flt));
return DBL2NUM(val);
}modulo(other) → float
分工后返回模float通过other。
6543.21.modulo(137) #=> 104.21
6543.21.modulo(137.24) #=> 92.9299999999996 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? → true or false
返回trueiffloat是无效的IEEE浮点数。
a = -1.0 #=> -1.0
a.nan? #=> false
a = 0.0/0.0 #=> NaN
a.nan? #=> true static VALUE
flo_is_nan_p(VALUE num)
{
double value = RFLOAT_VALUE(num);
return isnan(value) ? Qtrue : Qfalse;
}negative? → true or false
返回trueiffloat小于0。
static VALUE
flo_negative_p(VALUE num)
{
double f = RFLOAT_VALUE(num);
return f < 0.0 ? Qtrue : Qfalse;
}next_float → float
返回下一个可表示的浮点数。
Float :: MAX.next_float和Float :: INFINITY.next_float是Float :: INFINITY。
Float :: NAN.next_float是Float :: NAN。
例如：
p 0.01.next_float #=> 0.010000000000000002
p 1.0.next_float #=> 1.0000000000000002
p 100.0.next_float #=> 100.00000000000001
p 0.01.next_float - 0.01 #=> 1.734723475976807e-18
p 1.0.next_float - 1.0 #=> 2.220446049250313e-16
p 100.0.next_float - 100.0 #=> 1.4210854715202004e-14
f = 0.01; 20.times { printf "%-20a %s\n", f, f.to_s; f = f.next_float }
#=> 0x1.47ae147ae147bp-7 0.01
# 0x1.47ae147ae147cp-7 0.010000000000000002
# 0x1.47ae147ae147dp-7 0.010000000000000004
# 0x1.47ae147ae147ep-7 0.010000000000000005
# 0x1.47ae147ae147fp-7 0.010000000000000007
# 0x1.47ae147ae148p-7 0.010000000000000009
# 0x1.47ae147ae1481p-7 0.01000000000000001
# 0x1.47ae147ae1482p-7 0.010000000000000012
# 0x1.47ae147ae1483p-7 0.010000000000000014
# 0x1.47ae147ae1484p-7 0.010000000000000016
# 0x1.47ae147ae1485p-7 0.010000000000000018
# 0x1.47ae147ae1486p-7 0.01000000000000002
# 0x1.47ae147ae1487p-7 0.010000000000000021
# 0x1.47ae147ae1488p-7 0.010000000000000023
# 0x1.47ae147ae1489p-7 0.010000000000000024
# 0x1.47ae147ae148ap-7 0.010000000000000026
# 0x1.47ae147ae148bp-7 0.010000000000000028
# 0x1.47ae147ae148cp-7 0.01000000000000003
# 0x1.47ae147ae148dp-7 0.010000000000000031
# 0x1.47ae147ae148ep-7 0.010000000000000033
f = 0.0
100.times { f += 0.1 }
p f #=> 9.99999999999998 # should be 10.0 in the ideal world.
p 10-f #=> 1.9539925233402755e-14 # the floating-point error.
p(10.0.next_float-10) #=> 1.7763568394002505e-15 # 1 ulp (units in the last place).
p((10-f)/(10.0.next_float-10)) #=> 11.0 # the error is 11 ulp.
p((10-f)/(10*Float::EPSILON)) #=> 8.8 # approximation of the above.
p "%a" % f #=> "0x1.3fffffffffff5p+3" # the last hex digit is 5. 16 - 5 = 11 ulp. static VALUE
flo_next_float(VALUE vx)
{
double x, y;
x = NUM2DBL(vx);
y = nextafter(x, INFINITY);
return DBL2NUM(y);
}numerator → integer
返回分子。结果取决于机器。
n = 0.3.numerator #=> 5404319552844595
d = 0.3.denominator #=> 18014398509481984
n.fdiv(d) #=> 0.3 static VALUE
float_numerator(VALUE self)
{
double d = RFLOAT_VALUE(self);
if (isinf(d) || isnan(d))
return self;
return nurat_numerator(float_to_r(self));
}phase → 0 or float
如果值为正，则返回0，否则返回pi。
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);
}positive? → true or false
如果float大于0，则返回true。
static VALUE
flo_positive_p(VALUE num)
{
double f = RFLOAT_VALUE(num);
return f > 0.0 ? Qtrue : Qfalse;
}prev_float → float
返回前一个可表示的浮点数。
（-Float :: MAX）.prev_float和（-Float :: INFINITY）.prev_float是-Float :: INFINITY。
Float :: NAN.prev_float是Float :: NAN。
例如：
p 0.01.prev_float #=> 0.009999999999999998
p 1.0.prev_float #=> 0.9999999999999999
p 100.0.prev_float #=> 99.99999999999999
p 0.01 - 0.01.prev_float #=> 1.734723475976807e-18
p 1.0 - 1.0.prev_float #=> 1.1102230246251565e-16
p 100.0 - 100.0.prev_float #=> 1.4210854715202004e-14
f = 0.01; 20.times { printf "%-20a %s\n", f, f.to_s; f = f.prev_float }
#=> 0x1.47ae147ae147bp-7 0.01
# 0x1.47ae147ae147ap-7 0.009999999999999998
# 0x1.47ae147ae1479p-7 0.009999999999999997
# 0x1.47ae147ae1478p-7 0.009999999999999995
# 0x1.47ae147ae1477p-7 0.009999999999999993
# 0x1.47ae147ae1476p-7 0.009999999999999992
# 0x1.47ae147ae1475p-7 0.00999999999999999
# 0x1.47ae147ae1474p-7 0.009999999999999988
# 0x1.47ae147ae1473p-7 0.009999999999999986
# 0x1.47ae147ae1472p-7 0.009999999999999985
# 0x1.47ae147ae1471p-7 0.009999999999999983
# 0x1.47ae147ae147p-7 0.009999999999999981
# 0x1.47ae147ae146fp-7 0.00999999999999998
# 0x1.47ae147ae146ep-7 0.009999999999999978
# 0x1.47ae147ae146dp-7 0.009999999999999976
# 0x1.47ae147ae146cp-7 0.009999999999999974
# 0x1.47ae147ae146bp-7 0.009999999999999972
# 0x1.47ae147ae146ap-7 0.00999999999999997
# 0x1.47ae147ae1469p-7 0.009999999999999969
# 0x1.47ae147ae1468p-7 0.009999999999999967quo(numeric) → float
返回float / numeric，与Float＃/相同。
static VALUE
flo_quo(VALUE x, VALUE y)
{
return num_funcall1(x, '/', y);
}rationalize([eps]) → rational
返回值的简单近似值（flt- | eps | <= result <= flt + | eps |）。如果没有给出可选的eps，它将被自动选择。
0.3.rationalize #=> (3/10)
1.333.rationalize #=> (1333/1000)
1.333.rationalize(0.01) #=> (4/3)参见 to_r。
static VALUE
float_rationalize(int argc, VALUE *argv, VALUE self)
{
VALUE e;
double d = RFLOAT_VALUE(self);
if (d < 0.0)
return rb_rational_uminus(float_rationalize(argc, argv, DBL2NUM(-d)));
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 or float
float以十进制数字的形式舍入到给定的精度（默认为0位）。
精度可能是负面的。当ndigits大于零时返回一个浮点数 。
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如果half:给出可选关键字，则只根据该值舍入半数。这个关键字支持的值如下。
:up或者nil：结果将从零圆整
:even：结果将舍入到最接近的偶数
:down：结果将四舍五入到零
static VALUE
flo_round(int argc, VALUE *argv, VALUE num)
{
double number, f, x;
VALUE nd, opt;
int ndigits = 0;
enum ruby_num_rounding_mode mode;
if (rb_scan_args(argc, argv, "01:", &nd, &opt)) {
ndigits = NUM2INT(nd);
}
mode = rb_num_get_rounding_option(opt);
if (ndigits < 0) {
return rb_int_round(flo_to_i(num), ndigits, mode);
}
number = RFLOAT_VALUE(num);
if (ndigits == 0) {
x = ROUND_CALL(mode, round, (number, 1.0));
return dbl2ival(x);
}
if (float_invariant_round(number, ndigits, &num)) return num;
f = pow(10, ndigits);
x = ROUND_CALL(mode, round, (number, f));
return DBL2NUM(x / f);
}to_d → bigdecimal
转换flt为BigDecimal并返回。
require 'bigdecimal'
require 'bigdecimal/util'
0.5.to_d
# => 0.5e0# File ext/bigdecimal/lib/bigdecimal/util.rb, line 38
def to_d(precision=nil)
BigDecimal(self, precision || Float::DIG)
endto_f → self
既然float已经是一个浮动，返回self。
static VALUE
flo_to_f(VALUE num)
{
return num;
}to_i → integer
to_int → integer
返回float截断到一个整数。
同义词是to_i和to_int
static VALUE
flo_to_i(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_int → integer Show source
返回float截断到一个整数。
同义词是to_i和to_int
static VALUE
flo_to_i(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 → rational Show source
将该值作为理性返回。
注意：0.3.to_r与'0.3'.to_r不一样。后者相当于'3/10'to_r，但前者并非如此。
2.0.to_r #=> (2/1)
2.5.to_r #=> (5/2)
-0.75.to_r #=> (-3/4)
0.0.to_r #=> (0/1)参见rationalize。
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 rb_rational_new1(f);
if (ln > 0)
return rb_rational_new1(rb_int_lshift(f, n));
ln = -ln;
return rb_rational_new2(f, rb_int_lshift(ONE, INT2FIX(ln)));
}
#else
f = rb_int_mul(f, rb_int_pow(INT2FIX(FLT_RADIX), n));
if (RB_TYPE_P(f, T_RATIONAL))
return f;
return rb_rational_new1(f);
#endif
}to_s → string
返回一个包含self的表示的字符串。以及的固定或指数形式float，该呼叫可能会返回NaN，Infinity和-Infinity。
static VALUE
flo_to_s(VALUE flt)
{
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)) {
static const char minf[] = "-Infinity";
const int pos = (value > 0); /* skip "-" */
return rb_usascii_str_new(minf+pos, strlen(minf)-pos);
}
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;
}还有别名：inspect
truncate(ndigits) → integer or float
float以十进制数字截取给定的精度（默认为0位）。
精度可能是负面的。当ndigits大于零时返回一个浮点数。
static VALUE
flo_truncate(int argc, VALUE *argv, VALUE num)
{
if (signbit(RFLOAT_VALUE(num)))
return flo_ceil(argc, argv, num);
else
return flo_floor(argc, argv, num);
}zero? → true or false
返回true如果float是0.0。
static VALUE
flo_zero_p(VALUE num)
{
if (RFLOAT_VALUE(num) == 0.0) {
return Qtrue;
}
return Qfalse;
}本文档系腾讯云开发者社区成员共同维护，如有问题请联系 cloudcommunity@tencent.com
