1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

* include/ruby/ruby.h: introduce 2 macros:

Browse Source 
RFLOAT_VALUE(v), DOUBLE2NUM(dbl).
  Rename RFloat#value -> RFloat#double_value.
  Do not touch RFloat#double_value directly.
* bignum.c, insns.def, marshal.c, math.c, numeric.c, object.c,
  pack.c, parse.y, process.c, random.c, sprintf.c, string.c,
  time.c: apply above changes.
* ext/dl/mkcallback.rb, ext/json/ext/generator/generator.c:
  ditto.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@13913 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
ko1 2007-11-13 16:00:53 +00:00
parent c4af7f51b7
commit 25c0cb981a
17 changed files with 213 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
ChangeLog
View File

@ -1,3 +1,17 @@
Wed Nov 14 00:33:49 2007 Koichi Sasada <ko1@atdot.net>
* include/ruby/ruby.h: introduce 2 macros:
RFLOAT_VALUE(v), DOUBLE2NUM(dbl).
Rename RFloat#value -> RFloat#double_value.
Do not touch RFloat#double_value directly.
* bignum.c, insns.def, marshal.c, math.c, numeric.c, object.c,
pack.c, parse.y, process.c, random.c, sprintf.c, string.c,
time.c: apply above changes.
* ext/dl/mkcallback.rb, ext/json/ext/generator/generator.c:
ditto.
Wed Nov 14 00:15:37 2007 Nobuyoshi Nakada <nobu@ruby-lang.org> Wed Nov 14 00:15:37 2007 Nobuyoshi Nakada <nobu@ruby-lang.org>
* tool/ytab.sed: get rid of GNU sed feature. a patch from Laurent * tool/ytab.sed: get rid of GNU sed feature. a patch from Laurent

26
bignum.c
View File

@ -1147,7 +1147,7 @@ rb_big2dbl(VALUE x)
static VALUE static VALUE
rb_big_to_f(VALUE x) rb_big_to_f(VALUE x)
{ {
return rb_float_new(rb_big2dbl(x)); return DOUBLE2NUM(rb_big2dbl(x));
} }
/* /*
@ -1174,7 +1174,7 @@ rb_big_cmp(VALUE x, VALUE y)
break; break;
case T_FLOAT: case T_FLOAT:
return rb_dbl_cmp(rb_big2dbl(x), RFLOAT(y)->value); return rb_dbl_cmp(rb_big2dbl(x), RFLOAT_VALUE(y));
default: default:
return rb_num_coerce_cmp(x, y); return rb_num_coerce_cmp(x, y);
@ -1218,7 +1218,7 @@ rb_big_eq(VALUE x, VALUE y)
{ {
volatile double a, b; volatile double a, b;
a = RFLOAT(y)->value; a = RFLOAT_VALUE(y);
if (isnan(a)) return Qfalse; if (isnan(a)) return Qfalse;
b = rb_big2dbl(x); b = rb_big2dbl(x);
return (a == b)?Qtrue:Qfalse; return (a == b)?Qtrue:Qfalse;
@ -1409,7 +1409,7 @@ rb_big_plus(VALUE x, VALUE y)
return bignorm(bigadd(x, y, 1)); return bignorm(bigadd(x, y, 1));
case T_FLOAT: case T_FLOAT:
return rb_float_new(rb_big2dbl(x) + RFLOAT(y)->value); return DOUBLE2NUM(rb_big2dbl(x) + RFLOAT_VALUE(y));
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
@ -1434,7 +1434,7 @@ rb_big_minus(VALUE x, VALUE y)
return bignorm(bigadd(x, y, 0)); return bignorm(bigadd(x, y, 0));
case T_FLOAT: case T_FLOAT:
return rb_float_new(rb_big2dbl(x) - RFLOAT(y)->value); return DOUBLE2NUM(rb_big2dbl(x) - RFLOAT_VALUE(y));
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
@ -1458,7 +1458,7 @@ rb_big_mul0(VALUE x, VALUE y)
break; break;
case T_FLOAT: case T_FLOAT:
return rb_float_new(rb_big2dbl(x) * RFLOAT(y)->value); return DOUBLE2NUM(rb_big2dbl(x) * RFLOAT_VALUE(y));
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
@ -1664,7 +1664,7 @@ rb_big_div(VALUE x, VALUE y)
break; break;
case T_FLOAT: case T_FLOAT:
return rb_float_new(rb_big2dbl(x) / RFLOAT(y)->value); return DOUBLE2NUM(rb_big2dbl(x) / RFLOAT_VALUE(y));
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
@ -1834,10 +1834,10 @@ rb_big_quo(VALUE x, VALUE y)
if (ey) y = big_shift(y, ey); if (ey) y = big_shift(y, ey);
bignum: bignum:
bigdivrem(x, y, &z, 0); bigdivrem(x, y, &z, 0);
return rb_float_new(ldexp(big2dbl(z), ex - ey)); return DOUBLE2NUM(ldexp(big2dbl(z), ex - ey));
} }
case T_FLOAT: case T_FLOAT:
y = dbl2big(ldexp(frexp(RFLOAT(y)->value, &ey), DBL_MANT_DIG)); y = dbl2big(ldexp(frexp(RFLOAT_VALUE(y), &ey), DBL_MANT_DIG));
ey -= DBL_MANT_DIG; ey -= DBL_MANT_DIG;
goto bignum; goto bignum;
} }
@ -1852,13 +1852,13 @@ rb_big_quo(VALUE x, VALUE y)
break; break;
case T_FLOAT: case T_FLOAT:
dy = RFLOAT(y)->value; dy = RFLOAT_VALUE(y);
break; break;
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
} }
return rb_float_new(dx / dy); return DOUBLE2NUM(dx / dy);
} }
static VALUE static VALUE
@ -1930,7 +1930,7 @@ rb_big_pow(VALUE x, VALUE y)
if (y == INT2FIX(0)) return INT2FIX(1); if (y == INT2FIX(0)) return INT2FIX(1);
switch (TYPE(y)) { switch (TYPE(y)) {
case T_FLOAT: case T_FLOAT:
d = RFLOAT(y)->value; d = RFLOAT_VALUE(y);
break; break;
case T_BIGNUM: case T_BIGNUM:
@ -1965,7 +1965,7 @@ rb_big_pow(VALUE x, VALUE y)
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
} }
return rb_float_new(pow(rb_big2dbl(x), d)); return DOUBLE2NUM(pow(rb_big2dbl(x), d));
} }
/* /*

4
ext/dl/mkcallback.rb
View File

@ -70,12 +70,12 @@ DLTYPE = {
FLOAT => { FLOAT => {
:name => 'float', :name => 'float',
:type => 'float', :type => 'float',
:conv => 'RFLOAT(%s)->value', :conv => 'RFLOAT_VALUE(%s)',
}, },
DOUBLE => { DOUBLE => {
:name => 'double', :name => 'double',
:type => 'double', :type => 'double',
:conv => 'RFLOAT(%s)->value', :conv => 'RFLOAT_VALUE(%s)',
}, },
VOIDP => { VOIDP => {
:name => 'ptr', :name => 'ptr',

2
ext/json/ext/generator/generator.c
View File

@ -275,7 +275,7 @@ static VALUE mFloat_to_json(int argc, VALUE *argv, VALUE self)
{ {
JSON_Generator_State *state = NULL; JSON_Generator_State *state = NULL;
VALUE Vstate, rest, tmp; VALUE Vstate, rest, tmp;
double value = RFLOAT(self)->value; double value = RFLOAT_VALUE(self);
rb_scan_args(argc, argv, "01*", &Vstate, &rest); rb_scan_args(argc, argv, "01*", &Vstate, &rest);
if (!NIL_P(Vstate)) Data_Get_Struct(Vstate, JSON_Generator_State, state); if (!NIL_P(Vstate)) Data_Get_Struct(Vstate, JSON_Generator_State, state);
if (isinf(value)) { if (isinf(value)) {

4
include/ruby/ruby.h
View File

@ -451,8 +451,10 @@ struct RClass {
struct RFloat { struct RFloat {
struct RBasic basic; struct RBasic basic;
double value; double double_value;
}; };
#define RFLOAT_VALUE(v) (RFLOAT(v)->double_value)
#define DOUBLE2NUM(dbl) rb_float_new(dbl)
#define ELTS_SHARED FL_USER2 #define ELTS_SHARED FL_USER2

16
insns.def
View File

@ -1391,7 +1391,7 @@ opt_plus
else if (HEAP_CLASS_OF(recv) == rb_cFloat && else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
HEAP_CLASS_OF(obj) == rb_cFloat && HEAP_CLASS_OF(obj) == rb_cFloat &&
BASIC_OP_UNREDEFINED_P(BOP_PLUS)) { BASIC_OP_UNREDEFINED_P(BOP_PLUS)) {
val = rb_float_new(RFLOAT(recv)->value + RFLOAT(obj)->value); val = DOUBLE2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj));
} }
#endif #endif
@ -1492,7 +1492,7 @@ opt_mult
else if (HEAP_CLASS_OF(recv) == rb_cFloat && else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
HEAP_CLASS_OF(obj) == rb_cFloat && HEAP_CLASS_OF(obj) == rb_cFloat &&
BASIC_OP_UNREDEFINED_P(BOP_MULT)) { BASIC_OP_UNREDEFINED_P(BOP_MULT)) {
val = rb_float_new(RFLOAT(recv)->value * RFLOAT(obj)->value); val = DOUBLE2NUM(RFLOAT_VALUE(recv) * RFLOAT_VALUE(obj));
} }
#endif #endif
else { else {
@ -1556,7 +1556,7 @@ opt_div
else if (HEAP_CLASS_OF(recv) == rb_cFloat && else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
HEAP_CLASS_OF(obj) == rb_cFloat && HEAP_CLASS_OF(obj) == rb_cFloat &&
BASIC_OP_UNREDEFINED_P(BOP_DIV)) { BASIC_OP_UNREDEFINED_P(BOP_DIV)) {
val = rb_float_new(RFLOAT(recv)->value / RFLOAT(obj)->value); val = DOUBLE2NUM(RFLOAT_VALUE(recv) / RFLOAT_VALUE(obj));
} }
#endif #endif
else { else {
@ -1620,8 +1620,8 @@ opt_mod
else if (HEAP_CLASS_OF(recv) == rb_cFloat && else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
HEAP_CLASS_OF(obj) == rb_cFloat && HEAP_CLASS_OF(obj) == rb_cFloat &&
BASIC_OP_UNREDEFINED_P(BOP_MOD)) { BASIC_OP_UNREDEFINED_P(BOP_MOD)) {
double x = RFLOAT(recv)->value; double x = RFLOAT_VALUE(recv);
double y = RFLOAT(obj)->value; double y = RFLOAT_VALUE(obj);
double div, mod; double div, mod;
{ {
@ -1636,7 +1636,7 @@ opt_mod
mod += y; mod += y;
div -= 1.0; div -= 1.0;
} }
val = rb_float_new(mod); val = DOUBLE2NUM(mod);
} }
else { else {
goto INSN_LABEL(normal_dispatch); goto INSN_LABEL(normal_dispatch);
@ -1678,8 +1678,8 @@ opt_eq
else if (HEAP_CLASS_OF(recv) == rb_cFloat && else if (HEAP_CLASS_OF(recv) == rb_cFloat &&
HEAP_CLASS_OF(obj) == rb_cFloat && HEAP_CLASS_OF(obj) == rb_cFloat &&
BASIC_OP_UNREDEFINED_P(BOP_EQ)) { BASIC_OP_UNREDEFINED_P(BOP_EQ)) {
double a = RFLOAT(recv)->value; double a = RFLOAT_VALUE(recv);
double b = RFLOAT(obj)->value; double b = RFLOAT_VALUE(obj);
if (isnan(a) || isnan(b)) { if (isnan(a) || isnan(b)) {
val = Qfalse; val = Qfalse;

4
marshal.c
View File

@ -637,7 +637,7 @@ w_object(VALUE obj, struct dump_arg *arg, int limit)
case T_FLOAT: case T_FLOAT:
w_byte(TYPE_FLOAT, arg); w_byte(TYPE_FLOAT, arg);
w_float(RFLOAT(obj)->value, arg); w_float(RFLOAT_VALUE(obj), arg);
break; break;
case T_BIGNUM: case T_BIGNUM:
@ -1239,7 +1239,7 @@ r_object0(struct load_arg *arg, int *ivp, VALUE extmod)
d = strtod(ptr, &e); d = strtod(ptr, &e);
d = load_mantissa(d, e, RSTRING_LEN(str) - (e - ptr)); d = load_mantissa(d, e, RSTRING_LEN(str) - (e - ptr));
} }
v = rb_float_new(d); v = DOUBLE2NUM(d);
v = r_entry(v, arg); v = r_entry(v, arg);
v = r_leave(v, arg); v = r_leave(v, arg);
} }

74
math.c
View File

@ -55,7 +55,7 @@ static VALUE
math_atan2(VALUE obj, VALUE y, VALUE x) math_atan2(VALUE obj, VALUE y, VALUE x)
{ {
Need_Float2(y, x); Need_Float2(y, x);
return rb_float_new(atan2(RFLOAT(y)->value, RFLOAT(x)->value)); return DOUBLE2NUM(atan2(RFLOAT_VALUE(y), RFLOAT_VALUE(x)));
} }
@ -71,7 +71,7 @@ static VALUE
math_cos(VALUE obj, VALUE x) math_cos(VALUE obj, VALUE x)
{ {
Need_Float(x); Need_Float(x);
return rb_float_new(cos(RFLOAT(x)->value)); return DOUBLE2NUM(cos(RFLOAT_VALUE(x)));
} }
/* /*
@ -87,7 +87,7 @@ math_sin(VALUE obj, VALUE x)
{ {
Need_Float(x); Need_Float(x);
return rb_float_new(sin(RFLOAT(x)->value)); return DOUBLE2NUM(sin(RFLOAT_VALUE(x)));
} }
@ -103,7 +103,7 @@ math_tan(VALUE obj, VALUE x)
{ {
Need_Float(x); Need_Float(x);
return rb_float_new(tan(RFLOAT(x)->value)); return DOUBLE2NUM(tan(RFLOAT_VALUE(x)));
} }
/* /*
@ -120,9 +120,9 @@ math_acos(VALUE obj, VALUE x)
Need_Float(x); Need_Float(x);
errno = 0; errno = 0;
d = acos(RFLOAT(x)->value); d = acos(RFLOAT_VALUE(x));
domain_check(d, "acos"); domain_check(d, "acos");
return rb_float_new(d); return DOUBLE2NUM(d);
} }
/* /*
@ -139,9 +139,9 @@ math_asin(VALUE obj, VALUE x)
Need_Float(x); Need_Float(x);
errno = 0; errno = 0;
d = asin(RFLOAT(x)->value); d = asin(RFLOAT_VALUE(x));
domain_check(d, "asin"); domain_check(d, "asin");
return rb_float_new(d); return DOUBLE2NUM(d);
} }
/* /*
@ -155,7 +155,7 @@ static VALUE
math_atan(VALUE obj, VALUE x) math_atan(VALUE obj, VALUE x)
{ {
Need_Float(x); Need_Float(x);
return rb_float_new(atan(RFLOAT(x)->value)); return DOUBLE2NUM(atan(RFLOAT_VALUE(x)));
} }
#ifndef HAVE_COSH #ifndef HAVE_COSH
@ -178,7 +178,7 @@ math_cosh(VALUE obj, VALUE x)
{ {
Need_Float(x); Need_Float(x);
return rb_float_new(cosh(RFLOAT(x)->value)); return DOUBLE2NUM(cosh(RFLOAT_VALUE(x)));
} }
#ifndef HAVE_SINH #ifndef HAVE_SINH
@ -201,7 +201,7 @@ static VALUE
math_sinh(VALUE obj, VALUE x) math_sinh(VALUE obj, VALUE x)
{ {
Need_Float(x); Need_Float(x);
return rb_float_new(sinh(RFLOAT(x)->value)); return DOUBLE2NUM(sinh(RFLOAT_VALUE(x)));
} }
#ifndef HAVE_TANH #ifndef HAVE_TANH
@ -224,7 +224,7 @@ static VALUE
math_tanh(VALUE obj, VALUE x) math_tanh(VALUE obj, VALUE x)
{ {
Need_Float(x); Need_Float(x);
return rb_float_new(tanh(RFLOAT(x)->value)); return DOUBLE2NUM(tanh(RFLOAT_VALUE(x)));
} }
/* /*
@ -241,9 +241,9 @@ math_acosh(VALUE obj, VALUE x)
Need_Float(x); Need_Float(x);
errno = 0; errno = 0;
d = acosh(RFLOAT(x)->value); d = acosh(RFLOAT_VALUE(x));
domain_check(d, "acosh"); domain_check(d, "acosh");
return rb_float_new(d); return DOUBLE2NUM(d);
} }
/* /*
@ -257,7 +257,7 @@ static VALUE
math_asinh(VALUE obj, VALUE x) math_asinh(VALUE obj, VALUE x)
{ {
Need_Float(x); Need_Float(x);
return rb_float_new(asinh(RFLOAT(x)->value)); return DOUBLE2NUM(asinh(RFLOAT_VALUE(x)));
} }
/* /*
@ -274,9 +274,9 @@ math_atanh(VALUE obj, VALUE x)
Need_Float(x); Need_Float(x);
errno = 0; errno = 0;
d = atanh(RFLOAT(x)->value); d = atanh(RFLOAT_VALUE(x));
domain_check(d, "atanh"); domain_check(d, "atanh");
return rb_float_new(d); return DOUBLE2NUM(d);
} }
/* /*
@ -290,7 +290,7 @@ static VALUE
math_exp(VALUE obj, VALUE x) math_exp(VALUE obj, VALUE x)
{ {
Need_Float(x); Need_Float(x);
return rb_float_new(exp(RFLOAT(x)->value)); return DOUBLE2NUM(exp(RFLOAT_VALUE(x)));
} }
#if defined __CYGWIN__ #if defined __CYGWIN__
@ -321,13 +321,13 @@ math_log(int argc, VALUE *argv)
rb_scan_args(argc, argv, "11", &x, &base); rb_scan_args(argc, argv, "11", &x, &base);
Need_Float(x); Need_Float(x);
errno = 0; errno = 0;
d = log(RFLOAT(x)->value); d = log(RFLOAT_VALUE(x));
if (!NIL_P(base)) { if (!NIL_P(base)) {
Need_Float(base); Need_Float(base);
d /= log(RFLOAT(base)->value); d /= log(RFLOAT_VALUE(base));
} }
domain_check(d, "log"); domain_check(d, "log");
return rb_float_new(d); return DOUBLE2NUM(d);
} }
#ifndef log2 #ifndef log2
@ -356,11 +356,11 @@ math_log2(VALUE obj, VALUE x)
Need_Float(x); Need_Float(x);
errno = 0; errno = 0;
d = log2(RFLOAT(x)->value); d = log2(RFLOAT_VALUE(x));
if (errno) { if (errno) {
rb_sys_fail("log2"); rb_sys_fail("log2");
} }
return rb_float_new(d); return DOUBLE2NUM(d);
} }
/* /*
@ -377,9 +377,9 @@ math_log10(VALUE obj, VALUE x)
Need_Float(x); Need_Float(x);
errno = 0; errno = 0;
d = log10(RFLOAT(x)->value); d = log10(RFLOAT_VALUE(x));
domain_check(d, "log10"); domain_check(d, "log10");
return rb_float_new(d); return DOUBLE2NUM(d);
} }
/* /*
@ -396,9 +396,9 @@ math_sqrt(VALUE obj, VALUE x)
Need_Float(x); Need_Float(x);
errno = 0; errno = 0;
d = sqrt(RFLOAT(x)->value); d = sqrt(RFLOAT_VALUE(x));
domain_check(d, "sqrt"); domain_check(d, "sqrt");
return rb_float_new(d); return DOUBLE2NUM(d);
} }
/* /*
@ -421,8 +421,8 @@ math_frexp(VALUE obj, VALUE x)
Need_Float(x); Need_Float(x);
d = frexp(RFLOAT(x)->value, &exp); d = frexp(RFLOAT_VALUE(x), &exp);
return rb_assoc_new(rb_float_new(d), INT2NUM(exp)); return rb_assoc_new(DOUBLE2NUM(d), INT2NUM(exp));
} }
/* /*
@ -439,7 +439,7 @@ static VALUE
math_ldexp(VALUE obj, VALUE x, VALUE n) math_ldexp(VALUE obj, VALUE x, VALUE n)
{ {
Need_Float(x); Need_Float(x);
return rb_float_new(ldexp(RFLOAT(x)->value, NUM2INT(n))); return DOUBLE2NUM(ldexp(RFLOAT_VALUE(x), NUM2INT(n)));
} }
/* /*
@ -456,7 +456,7 @@ static VALUE
math_hypot(VALUE obj, VALUE x, VALUE y) math_hypot(VALUE obj, VALUE x, VALUE y)
{ {
Need_Float2(x, y); Need_Float2(x, y);
return rb_float_new(hypot(RFLOAT(x)->value, RFLOAT(y)->value)); return DOUBLE2NUM(hypot(RFLOAT_VALUE(x), RFLOAT_VALUE(y)));
} }
/* /*
@ -470,7 +470,7 @@ static VALUE
math_erf(VALUE obj, VALUE x) math_erf(VALUE obj, VALUE x)
{ {
Need_Float(x); Need_Float(x);
return rb_float_new(erf(RFLOAT(x)->value)); return DOUBLE2NUM(erf(RFLOAT_VALUE(x)));
} }
/* /*
@ -484,7 +484,7 @@ static VALUE
math_erfc(VALUE obj, VALUE x) math_erfc(VALUE obj, VALUE x)
{ {
Need_Float(x); Need_Float(x);
return rb_float_new(erfc(RFLOAT(x)->value)); return DOUBLE2NUM(erfc(RFLOAT_VALUE(x)));
} }
/* /*
@ -501,15 +501,15 @@ Init_Math(void)
rb_mMath = rb_define_module("Math"); rb_mMath = rb_define_module("Math");
#ifdef M_PI #ifdef M_PI
rb_define_const(rb_mMath, "PI", rb_float_new(M_PI)); rb_define_const(rb_mMath, "PI", DOUBLE2NUM(M_PI));
#else #else
rb_define_const(rb_mMath, "PI", rb_float_new(atan(1.0)*4.0)); rb_define_const(rb_mMath, "PI", DOUBLE2NUM(atan(1.0)*4.0));
#endif #endif
#ifdef M_E #ifdef M_E
rb_define_const(rb_mMath, "E", rb_float_new(M_E)); rb_define_const(rb_mMath, "E", DOUBLE2NUM(M_E));
#else #else
rb_define_const(rb_mMath, "E", rb_float_new(exp(1.0))); rb_define_const(rb_mMath, "E", DOUBLE2NUM(exp(1.0)));
#endif #endif
rb_define_module_function(rb_mMath, "atan2", math_atan2, 2); rb_define_module_function(rb_mMath, "atan2", math_atan2, 2);

176
numeric.c
View File

@ -465,7 +465,7 @@ rb_float_new(double d)
NEWOBJ(flt, struct RFloat); NEWOBJ(flt, struct RFloat);
OBJSETUP(flt, rb_cFloat, T_FLOAT); OBJSETUP(flt, rb_cFloat, T_FLOAT);
flt->value = d; flt->double_value = d;
return (VALUE)flt; return (VALUE)flt;
} }
@ -483,7 +483,7 @@ static VALUE
flo_to_s(VALUE flt) flo_to_s(VALUE flt)
{ {
char buf[32]; char buf[32];
double value = RFLOAT(flt)->value; double value = RFLOAT_VALUE(flt);
char *p, *e; char *p, *e;
if (isinf(value)) if (isinf(value))
@ -528,7 +528,7 @@ flo_coerce(VALUE x, VALUE y)
static VALUE static VALUE
flo_uminus(VALUE flt) flo_uminus(VALUE flt)
{ {
return rb_float_new(-RFLOAT(flt)->value); return DOUBLE2NUM(-RFLOAT_VALUE(flt));
} }
/* /*
@ -544,11 +544,11 @@ flo_plus(VALUE x, VALUE y)
{ {
switch (TYPE(y)) { switch (TYPE(y)) {
case T_FIXNUM: case T_FIXNUM:
return rb_float_new(RFLOAT(x)->value + (double)FIX2LONG(y)); return DOUBLE2NUM(RFLOAT_VALUE(x) + (double)FIX2LONG(y));
case T_BIGNUM: case T_BIGNUM:
return rb_float_new(RFLOAT(x)->value + rb_big2dbl(y)); return DOUBLE2NUM(RFLOAT_VALUE(x) + rb_big2dbl(y));
case T_FLOAT: case T_FLOAT:
return rb_float_new(RFLOAT(x)->value + RFLOAT(y)->value); return DOUBLE2NUM(RFLOAT_VALUE(x) + RFLOAT_VALUE(y));
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
} }
@ -567,11 +567,11 @@ flo_minus(VALUE x, VALUE y)
{ {
switch (TYPE(y)) { switch (TYPE(y)) {
case T_FIXNUM: case T_FIXNUM:
return rb_float_new(RFLOAT(x)->value - (double)FIX2LONG(y)); return DOUBLE2NUM(RFLOAT_VALUE(x) - (double)FIX2LONG(y));
case T_BIGNUM: case T_BIGNUM:
return rb_float_new(RFLOAT(x)->value - rb_big2dbl(y)); return DOUBLE2NUM(RFLOAT_VALUE(x) - rb_big2dbl(y));
case T_FLOAT: case T_FLOAT:
return rb_float_new(RFLOAT(x)->value - RFLOAT(y)->value); return DOUBLE2NUM(RFLOAT_VALUE(x) - RFLOAT_VALUE(y));
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
} }
@ -590,11 +590,11 @@ flo_mul(VALUE x, VALUE y)
{ {
switch (TYPE(y)) { switch (TYPE(y)) {
case T_FIXNUM: case T_FIXNUM:
return rb_float_new(RFLOAT(x)->value * (double)FIX2LONG(y)); return DOUBLE2NUM(RFLOAT_VALUE(x) * (double)FIX2LONG(y));
case T_BIGNUM: case T_BIGNUM:
return rb_float_new(RFLOAT(x)->value * rb_big2dbl(y)); return DOUBLE2NUM(RFLOAT_VALUE(x) * rb_big2dbl(y));
case T_FLOAT: case T_FLOAT:
return rb_float_new(RFLOAT(x)->value * RFLOAT(y)->value); return DOUBLE2NUM(RFLOAT_VALUE(x) * RFLOAT_VALUE(y));
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
} }
@ -617,12 +617,12 @@ flo_div(VALUE x, VALUE y)
switch (TYPE(y)) { switch (TYPE(y)) {
case T_FIXNUM: case T_FIXNUM:
f_y = FIX2LONG(y); f_y = FIX2LONG(y);
return rb_float_new(RFLOAT(x)->value / (double)f_y); return DOUBLE2NUM(RFLOAT_VALUE(x) / (double)f_y);
case T_BIGNUM: case T_BIGNUM:
d = rb_big2dbl(y); d = rb_big2dbl(y);
return rb_float_new(RFLOAT(x)->value / d); return DOUBLE2NUM(RFLOAT_VALUE(x) / d);
case T_FLOAT: case T_FLOAT:
return rb_float_new(RFLOAT(x)->value / RFLOAT(y)->value); return DOUBLE2NUM(RFLOAT_VALUE(x) / RFLOAT_VALUE(y));
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
} }
@ -681,13 +681,13 @@ flo_mod(VALUE x, VALUE y)
fy = rb_big2dbl(y); fy = rb_big2dbl(y);
break; break;
case T_FLOAT: case T_FLOAT:
fy = RFLOAT(y)->value; fy = RFLOAT_VALUE(y);
break; break;
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
} }
flodivmod(RFLOAT(x)->value, fy, 0, &mod); flodivmod(RFLOAT_VALUE(x), fy, 0, &mod);
return rb_float_new(mod); return DOUBLE2NUM(mod);
} }
/* /*
@ -711,12 +711,12 @@ flo_divmod(VALUE x, VALUE y)
fy = rb_big2dbl(y); fy = rb_big2dbl(y);
break; break;
case T_FLOAT: case T_FLOAT:
fy = RFLOAT(y)->value; fy = RFLOAT_VALUE(y);
break; break;
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
} }
flodivmod(RFLOAT(x)->value, fy, &div, &mod); flodivmod(RFLOAT_VALUE(x), fy, &div, &mod);
if (FIXABLE(div)) { if (FIXABLE(div)) {
#ifdef HVAE_ROUND #ifdef HVAE_ROUND
val = round(div); val = round(div);
@ -731,7 +731,7 @@ flo_divmod(VALUE x, VALUE y)
else { else {
a = rb_dbl2big(div); a = rb_dbl2big(div);
} }
b = rb_float_new(mod); b = DOUBLE2NUM(mod);
return rb_assoc_new(a, b); return rb_assoc_new(a, b);
} }
@ -748,11 +748,11 @@ flo_pow(VALUE x, VALUE y)
{ {
switch (TYPE(y)) { switch (TYPE(y)) {
case T_FIXNUM: case T_FIXNUM:
return rb_float_new(pow(RFLOAT(x)->value, (double)FIX2LONG(y))); return DOUBLE2NUM(pow(RFLOAT_VALUE(x), (double)FIX2LONG(y)));
case T_BIGNUM: case T_BIGNUM:
return rb_float_new(pow(RFLOAT(x)->value, rb_big2dbl(y))); return DOUBLE2NUM(pow(RFLOAT_VALUE(x), rb_big2dbl(y)));
case T_FLOAT: case T_FLOAT:
return rb_float_new(pow(RFLOAT(x)->value, RFLOAT(y)->value)); return DOUBLE2NUM(pow(RFLOAT_VALUE(x), RFLOAT_VALUE(y)));
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
} }
@ -825,13 +825,13 @@ flo_eq(VALUE x, VALUE y)
b = rb_big2dbl(y); b = rb_big2dbl(y);
break; break;
case T_FLOAT: case T_FLOAT:
b = RFLOAT(y)->value; b = RFLOAT_VALUE(y);
if (isnan(b)) return Qfalse; if (isnan(b)) return Qfalse;
break; break;
default: default:
return num_equal(x, y); return num_equal(x, y);
} }
a = RFLOAT(x)->value; a = RFLOAT_VALUE(x);
if (isnan(a)) return Qfalse; if (isnan(a)) return Qfalse;
return (a == b)?Qtrue:Qfalse; return (a == b)?Qtrue:Qfalse;
} }
@ -849,7 +849,7 @@ flo_hash(VALUE num)
double d; double d;
int hash; int hash;
d = RFLOAT(num)->value; d = RFLOAT_VALUE(num);
hash = rb_memhash(&d, sizeof(d)); hash = rb_memhash(&d, sizeof(d));
return INT2FIX(hash); return INT2FIX(hash);
} }
@ -878,7 +878,7 @@ flo_cmp(VALUE x, VALUE y)
{ {
double a, b; double a, b;
a = RFLOAT(x)->value; a = RFLOAT_VALUE(x);
switch (TYPE(y)) { switch (TYPE(y)) {
case T_FIXNUM: case T_FIXNUM:
b = (double)FIX2LONG(y); b = (double)FIX2LONG(y);
@ -889,7 +889,7 @@ flo_cmp(VALUE x, VALUE y)
break; break;
case T_FLOAT: case T_FLOAT:
b = RFLOAT(y)->value; b = RFLOAT_VALUE(y);
break; break;
default: default:
@ -910,7 +910,7 @@ flo_gt(VALUE x, VALUE y)
{ {
double a, b; double a, b;
a = RFLOAT(x)->value; a = RFLOAT_VALUE(x);
switch (TYPE(y)) { switch (TYPE(y)) {
case T_FIXNUM: case T_FIXNUM:
b = (double)FIX2LONG(y); b = (double)FIX2LONG(y);
@ -921,7 +921,7 @@ flo_gt(VALUE x, VALUE y)
break; break;
case T_FLOAT: case T_FLOAT:
b = RFLOAT(y)->value; b = RFLOAT_VALUE(y);
if (isnan(b)) return Qfalse; if (isnan(b)) return Qfalse;
break; break;
@ -945,7 +945,7 @@ flo_ge(VALUE x, VALUE y)
{ {
double a, b; double a, b;
a = RFLOAT(x)->value; a = RFLOAT_VALUE(x);
switch (TYPE(y)) { switch (TYPE(y)) {
case T_FIXNUM: case T_FIXNUM:
b = (double)FIX2LONG(y); b = (double)FIX2LONG(y);
@ -956,7 +956,7 @@ flo_ge(VALUE x, VALUE y)
break; break;
case T_FLOAT: case T_FLOAT:
b = RFLOAT(y)->value; b = RFLOAT_VALUE(y);
if (isnan(b)) return Qfalse; if (isnan(b)) return Qfalse;
break; break;
@ -979,7 +979,7 @@ flo_lt(VALUE x, VALUE y)
{ {
double a, b; double a, b;
a = RFLOAT(x)->value; a = RFLOAT_VALUE(x);
switch (TYPE(y)) { switch (TYPE(y)) {
case T_FIXNUM: case T_FIXNUM:
b = (double)FIX2LONG(y); b = (double)FIX2LONG(y);
@ -990,7 +990,7 @@ flo_lt(VALUE x, VALUE y)
break; break;
case T_FLOAT: case T_FLOAT:
b = RFLOAT(y)->value; b = RFLOAT_VALUE(y);
if (isnan(b)) return Qfalse; if (isnan(b)) return Qfalse;
break; break;
@ -1014,7 +1014,7 @@ flo_le(VALUE x, VALUE y)
{ {
double a, b; double a, b;
a = RFLOAT(x)->value; a = RFLOAT_VALUE(x);
switch (TYPE(y)) { switch (TYPE(y)) {
case T_FIXNUM: case T_FIXNUM:
b = (double)FIX2LONG(y); b = (double)FIX2LONG(y);
@ -1025,7 +1025,7 @@ flo_le(VALUE x, VALUE y)
break; break;
case T_FLOAT: case T_FLOAT:
b = RFLOAT(y)->value; b = RFLOAT_VALUE(y);
if (isnan(b)) return Qfalse; if (isnan(b)) return Qfalse;
break; break;
@ -1051,8 +1051,8 @@ static VALUE
flo_eql(VALUE x, VALUE y) flo_eql(VALUE x, VALUE y)
{ {
if (TYPE(y) == T_FLOAT) { if (TYPE(y) == T_FLOAT) {
double a = RFLOAT(x)->value; double a = RFLOAT_VALUE(x);
double b = RFLOAT(y)->value; double b = RFLOAT_VALUE(y);
if (isnan(a) || isnan(b)) return Qfalse; if (isnan(a) || isnan(b)) return Qfalse;
if (a == b) return Qtrue; if (a == b) return Qtrue;
@ -1087,8 +1087,8 @@ flo_to_f(VALUE num)
static VALUE static VALUE
flo_abs(VALUE flt) flo_abs(VALUE flt)
{ {
double val = fabs(RFLOAT(flt)->value); double val = fabs(RFLOAT_VALUE(flt));
return rb_float_new(val); return DOUBLE2NUM(val);
} }
/* /*
@ -1102,7 +1102,7 @@ flo_abs(VALUE flt)
static VALUE static VALUE
flo_zero_p(VALUE num) flo_zero_p(VALUE num)
{ {
if (RFLOAT(num)->value == 0.0) { if (RFLOAT_VALUE(num) == 0.0) {
return Qtrue; return Qtrue;
} }
return Qfalse; return Qfalse;
@ -1124,7 +1124,7 @@ flo_zero_p(VALUE num)
static VALUE static VALUE
flo_is_nan_p(VALUE num) flo_is_nan_p(VALUE num)
{ {
double value = RFLOAT(num)->value; double value = RFLOAT_VALUE(num);
return isnan(value) ? Qtrue : Qfalse; return isnan(value) ? Qtrue : Qfalse;
} }
@ -1144,7 +1144,7 @@ flo_is_nan_p(VALUE num)
static VALUE static VALUE
flo_is_infinite_p(VALUE num) flo_is_infinite_p(VALUE num)
{ {
double value = RFLOAT(num)->value; double value = RFLOAT_VALUE(num);
if (isinf(value)) { if (isinf(value)) {
return INT2FIX( value < 0 ? -1 : 1 ); return INT2FIX( value < 0 ? -1 : 1 );
@ -1166,7 +1166,7 @@ flo_is_infinite_p(VALUE num)
static VALUE static VALUE
flo_is_finite_p(VALUE num) flo_is_finite_p(VALUE num)
{ {
double value = RFLOAT(num)->value; double value = RFLOAT_VALUE(num);
#if HAVE_FINITE #if HAVE_FINITE
if (!finite(value)) if (!finite(value))
@ -1194,7 +1194,7 @@ flo_is_finite_p(VALUE num)
static VALUE static VALUE
flo_floor(VALUE num) flo_floor(VALUE num)
{ {
double f = floor(RFLOAT(num)->value); double f = floor(RFLOAT_VALUE(num));
long val; long val;
if (!FIXABLE(f)) { if (!FIXABLE(f)) {
@ -1220,7 +1220,7 @@ flo_floor(VALUE num)
static VALUE static VALUE
flo_ceil(VALUE num) flo_ceil(VALUE num)
{ {
double f = ceil(RFLOAT(num)->value); double f = ceil(RFLOAT_VALUE(num));
long val; long val;
if (!FIXABLE(f)) { if (!FIXABLE(f)) {
@ -1253,7 +1253,7 @@ flo_round(int argc, VALUE *argv, VALUE num)
if (rb_scan_args(argc, argv, "01", &nd) == 1) { if (rb_scan_args(argc, argv, "01", &nd) == 1) {
ndigits = NUM2INT(nd); ndigits = NUM2INT(nd);
} }
number = RFLOAT(num)->value; number = RFLOAT_VALUE(num);
f = 1.0; f = 1.0;
i = abs(ndigits); i = abs(ndigits);
while (--i >= 0) while (--i >= 0)
@ -1266,7 +1266,7 @@ flo_round(int argc, VALUE *argv, VALUE num)
if (ndigits < 0) number *= f; if (ndigits < 0) number *= f;
else number /= f; else number /= f;
if (ndigits > 0) return rb_float_new(number); if (ndigits > 0) return DOUBLE2NUM(number);
if (!FIXABLE(number)) { if (!FIXABLE(number)) {
return rb_dbl2big(number); return rb_dbl2big(number);
@ -1287,7 +1287,7 @@ flo_round(int argc, VALUE *argv, VALUE num)
static VALUE static VALUE
flo_truncate(VALUE num) flo_truncate(VALUE num)
{ {
double f = RFLOAT(num)->value; double f = RFLOAT_VALUE(num);
long val; long val;
if (f > 0.0) f = floor(f); if (f > 0.0) f = floor(f);
@ -1455,7 +1455,7 @@ num_step(int argc, VALUE *argv, VALUE from)
if (err>0.5) err=0.5; if (err>0.5) err=0.5;
n = floor(n + err) + 1; n = floor(n + err) + 1;
for (i=0; i<n; i++) { for (i=0; i<n; i++) {
rb_yield(rb_float_new(i*unit+beg)); rb_yield(DOUBLE2NUM(i*unit+beg));
} }
} }
else { else {
@ -1488,15 +1488,15 @@ rb_num2long(VALUE val)
switch (TYPE(val)) { switch (TYPE(val)) {
case T_FLOAT: case T_FLOAT:
if (RFLOAT(val)->value <= (double)LONG_MAX if (RFLOAT_VALUE(val) <= (double)LONG_MAX
&& RFLOAT(val)->value >= (double)LONG_MIN) { && RFLOAT_VALUE(val) >= (double)LONG_MIN) {
return (SIGNED_VALUE)(RFLOAT(val)->value); return (SIGNED_VALUE)(RFLOAT_VALUE(val));
} }
else { else {
char buf[24]; char buf[24];
char *s; char *s;
sprintf(buf, "%-.10g", RFLOAT(val)->value); sprintf(buf, "%-.10g", RFLOAT_VALUE(val));
if ((s = strchr(buf, ' ')) != 0) *s = '\0'; if ((s = strchr(buf, ' ')) != 0) *s = '\0';
rb_raise(rb_eRangeError, "float %s out of range of integer", buf); rb_raise(rb_eRangeError, "float %s out of range of integer", buf);
} }
@ -1636,15 +1636,15 @@ rb_num2ll(VALUE val)
switch (TYPE(val)) { switch (TYPE(val)) {
case T_FLOAT: case T_FLOAT:
if (RFLOAT(val)->value <= (double)LLONG_MAX if (RFLOAT_VALUE(val) <= (double)LLONG_MAX
&& RFLOAT(val)->value >= (double)LLONG_MIN) { && RFLOAT_VALUE(val) >= (double)LLONG_MIN) {
return (LONG_LONG)(RFLOAT(val)->value); return (LONG_LONG)(RFLOAT_VALUE(val));
} }
else { else {
char buf[24]; char buf[24];
char *s; char *s;
sprintf(buf, "%-.10g", RFLOAT(val)->value); sprintf(buf, "%-.10g", RFLOAT_VALUE(val));
if ((s = strchr(buf, ' ')) != 0) *s = '\0'; if ((s = strchr(buf, ' ')) != 0) *s = '\0';
rb_raise(rb_eRangeError, "float %s out of range of long long", buf); rb_raise(rb_eRangeError, "float %s out of range of long long", buf);
} }
@ -2027,7 +2027,7 @@ fix_plus(VALUE x, VALUE y)
case T_BIGNUM: case T_BIGNUM:
return rb_big_plus(y, x); return rb_big_plus(y, x);
case T_FLOAT: case T_FLOAT:
return rb_float_new((double)FIX2LONG(x) + RFLOAT(y)->value); return DOUBLE2NUM((double)FIX2LONG(x) + RFLOAT_VALUE(y));
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
} }
@ -2061,7 +2061,7 @@ fix_minus(VALUE x, VALUE y)
x = rb_int2big(FIX2LONG(x)); x = rb_int2big(FIX2LONG(x));
return rb_big_minus(x, y); return rb_big_minus(x, y);
case T_FLOAT: case T_FLOAT:
return rb_float_new((double)FIX2LONG(x) - RFLOAT(y)->value); return DOUBLE2NUM((double)FIX2LONG(x) - RFLOAT_VALUE(y));
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
} }
@ -2120,7 +2120,7 @@ fix_mul(VALUE x, VALUE y)
case T_BIGNUM: case T_BIGNUM:
return rb_big_mul(y, x); return rb_big_mul(y, x);
case T_FLOAT: case T_FLOAT:
return rb_float_new((double)FIX2LONG(x) * RFLOAT(y)->value); return DOUBLE2NUM((double)FIX2LONG(x) * RFLOAT_VALUE(y));
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
} }
@ -2170,13 +2170,13 @@ static VALUE
fix_quo(VALUE x, VALUE y) fix_quo(VALUE x, VALUE y)
{ {
if (FIXNUM_P(y)) { if (FIXNUM_P(y)) {
return rb_float_new((double)FIX2LONG(x) / (double)FIX2LONG(y)); return DOUBLE2NUM((double)FIX2LONG(x) / (double)FIX2LONG(y));
} }
switch (TYPE(y)) { switch (TYPE(y)) {
case T_BIGNUM: case T_BIGNUM:
return rb_float_new((double)FIX2LONG(y) / rb_big2dbl(y)); return DOUBLE2NUM((double)FIX2LONG(y) / rb_big2dbl(y));
case T_FLOAT: case T_FLOAT:
return rb_float_new((double)FIX2LONG(x) / RFLOAT(y)->value); return DOUBLE2NUM((double)FIX2LONG(x) / RFLOAT_VALUE(y));
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
} }
@ -2197,10 +2197,10 @@ fix_divide(VALUE x, VALUE y, int flo)
return rb_big_div(x, y); return rb_big_div(x, y);
case T_FLOAT: case T_FLOAT:
if (flo) { if (flo) {
return rb_float_new((double)FIX2LONG(x) / RFLOAT(y)->value); return DOUBLE2NUM((double)FIX2LONG(x) / RFLOAT_VALUE(y));
} }
else { else {
long div = (double)FIX2LONG(x) / RFLOAT(y)->value; long div = (double)FIX2LONG(x) / RFLOAT_VALUE(y);
return LONG2NUM(div); return LONG2NUM(div);
} }
default: default:
@ -2262,8 +2262,8 @@ fix_mod(VALUE x, VALUE y)
{ {
double mod; double mod;
flodivmod((double)FIX2LONG(x), RFLOAT(y)->value, 0, &mod); flodivmod((double)FIX2LONG(x), RFLOAT_VALUE(y), 0, &mod);
return rb_float_new(mod); return DOUBLE2NUM(mod);
} }
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
@ -2295,9 +2295,9 @@ fix_divmod(VALUE x, VALUE y)
double div, mod; double div, mod;
volatile VALUE a, b; volatile VALUE a, b;
flodivmod((double)FIX2LONG(x), RFLOAT(y)->value, &div, &mod); flodivmod((double)FIX2LONG(x), RFLOAT_VALUE(y), &div, &mod);
a = rb_float_new(div); a = DOUBLE2NUM(div);
b = rb_float_new(mod); b = DOUBLE2NUM(mod);
return rb_assoc_new(a, b); return rb_assoc_new(a, b);
} }
default: default:
@ -2366,7 +2366,7 @@ fix_pow(VALUE x, VALUE y)
if (b == 1) return x; if (b == 1) return x;
if (a == 0) { if (a == 0) {
if (b > 0) return INT2FIX(0); if (b > 0) return INT2FIX(0);
return rb_float_new(1.0 / zero); return DOUBLE2NUM(1.0 / zero);
} }
if (a == 1) return INT2FIX(1); if (a == 1) return INT2FIX(1);
if (a == -1) { if (a == -1) {
@ -2378,7 +2378,7 @@ fix_pow(VALUE x, VALUE y)
if (b > 0) { if (b > 0) {
return int_pow(a, b); return int_pow(a, b);
} }
return rb_float_new(pow((double)a, (double)b)); return DOUBLE2NUM(pow((double)a, (double)b));
} }
switch (TYPE(y)) { switch (TYPE(y)) {
case T_BIGNUM: case T_BIGNUM:
@ -2391,12 +2391,12 @@ fix_pow(VALUE x, VALUE y)
x = rb_int2big(FIX2LONG(x)); x = rb_int2big(FIX2LONG(x));
return rb_big_pow(x, y); return rb_big_pow(x, y);
case T_FLOAT: case T_FLOAT:
if (RFLOAT(y)->value == 0.0) return rb_float_new(1.0); if (RFLOAT_VALUE(y) == 0.0) return DOUBLE2NUM(1.0);
if (a == 0) { if (a == 0) {
return rb_float_new(RFLOAT(y)->value < 0 ? (1.0 / zero) : 0.0); return DOUBLE2NUM(RFLOAT_VALUE(y) < 0 ? (1.0 / zero) : 0.0);
} }
if (a == 1) return rb_float_new(1.0); if (a == 1) return DOUBLE2NUM(1.0);
return rb_float_new(pow((double)a, RFLOAT(y)->value)); return DOUBLE2NUM(pow((double)a, RFLOAT_VALUE(y)));
default: default:
return rb_num_coerce_bin(x, y); return rb_num_coerce_bin(x, y);
} }
@ -2422,7 +2422,7 @@ fix_equal(VALUE x, VALUE y)
case T_BIGNUM: case T_BIGNUM:
return rb_big_eq(y, x); return rb_big_eq(y, x);
case T_FLOAT: case T_FLOAT:
return (double)FIX2LONG(x) == RFLOAT(y)->value ? Qtrue : Qfalse; return (double)FIX2LONG(x) == RFLOAT_VALUE(y) ? Qtrue : Qfalse;
default: default:
return num_equal(x, y); return num_equal(x, y);
} }
@ -2449,7 +2449,7 @@ fix_cmp(VALUE x, VALUE y)
case T_BIGNUM: case T_BIGNUM:
return rb_big_cmp(rb_int2big(FIX2LONG(x)), y); return rb_big_cmp(rb_int2big(FIX2LONG(x)), y);
case T_FLOAT: case T_FLOAT:
return rb_dbl_cmp((double)FIX2LONG(x), RFLOAT(y)->value); return rb_dbl_cmp((double)FIX2LONG(x), RFLOAT_VALUE(y));
default: default:
return rb_num_coerce_cmp(x, y); return rb_num_coerce_cmp(x, y);
} }
@ -2474,7 +2474,7 @@ fix_gt(VALUE x, VALUE y)
case T_BIGNUM: case T_BIGNUM:
return FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(x)), y)) > 0 ? Qtrue : Qfalse; return FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(x)), y)) > 0 ? Qtrue : Qfalse;
case T_FLOAT: case T_FLOAT:
return (double)FIX2LONG(x) > RFLOAT(y)->value ? Qtrue : Qfalse; return (double)FIX2LONG(x) > RFLOAT_VALUE(y) ? Qtrue : Qfalse;
default: default:
return rb_num_coerce_relop(x, y); return rb_num_coerce_relop(x, y);
} }
@ -2499,7 +2499,7 @@ fix_ge(VALUE x, VALUE y)
case T_BIGNUM: case T_BIGNUM:
return FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(x)), y)) >= 0 ? Qtrue : Qfalse; return FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(x)), y)) >= 0 ? Qtrue : Qfalse;
case T_FLOAT: case T_FLOAT:
return (double)FIX2LONG(x) >= RFLOAT(y)->value ? Qtrue : Qfalse; return (double)FIX2LONG(x) >= RFLOAT_VALUE(y) ? Qtrue : Qfalse;
default: default:
return rb_num_coerce_relop(x, y); return rb_num_coerce_relop(x, y);
} }
@ -2524,7 +2524,7 @@ fix_lt(VALUE x, VALUE y)
case T_BIGNUM: case T_BIGNUM:
return FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(x)), y)) < 0 ? Qtrue : Qfalse; return FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(x)), y)) < 0 ? Qtrue : Qfalse;
case T_FLOAT: case T_FLOAT:
return (double)FIX2LONG(x) < RFLOAT(y)->value ? Qtrue : Qfalse; return (double)FIX2LONG(x) < RFLOAT_VALUE(y) ? Qtrue : Qfalse;
default: default:
return rb_num_coerce_relop(x, y); return rb_num_coerce_relop(x, y);
} }
@ -2549,7 +2549,7 @@ fix_le(VALUE x, VALUE y)
case T_BIGNUM: case T_BIGNUM:
return FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(x)), y)) <= 0 ? Qtrue : Qfalse; return FIX2INT(rb_big_cmp(rb_int2big(FIX2LONG(x)), y)) <= 0 ? Qtrue : Qfalse;
case T_FLOAT: case T_FLOAT:
return (double)FIX2LONG(x) <= RFLOAT(y)->value ? Qtrue : Qfalse; return (double)FIX2LONG(x) <= RFLOAT_VALUE(y) ? Qtrue : Qfalse;
default: default:
return rb_num_coerce_relop(x, y); return rb_num_coerce_relop(x, y);
} }
@ -2753,7 +2753,7 @@ fix_to_f(VALUE num)
val = (double)FIX2LONG(num); val = (double)FIX2LONG(num);
return rb_float_new(val); return DOUBLE2NUM(val);
} }
/* /*
@ -3183,9 +3183,9 @@ Init_Numeric(void)
rb_define_const(rb_cFloat, "MAX_EXP", INT2FIX(DBL_MAX_EXP)); rb_define_const(rb_cFloat, "MAX_EXP", INT2FIX(DBL_MAX_EXP));
rb_define_const(rb_cFloat, "MIN_10_EXP", INT2FIX(DBL_MIN_10_EXP)); rb_define_const(rb_cFloat, "MIN_10_EXP", INT2FIX(DBL_MIN_10_EXP));
rb_define_const(rb_cFloat, "MAX_10_EXP", INT2FIX(DBL_MAX_10_EXP)); rb_define_const(rb_cFloat, "MAX_10_EXP", INT2FIX(DBL_MAX_10_EXP));
rb_define_const(rb_cFloat, "MIN", rb_float_new(DBL_MIN)); rb_define_const(rb_cFloat, "MIN", DOUBLE2NUM(DBL_MIN));
rb_define_const(rb_cFloat, "MAX", rb_float_new(DBL_MAX)); rb_define_const(rb_cFloat, "MAX", DOUBLE2NUM(DBL_MAX));
rb_define_const(rb_cFloat, "EPSILON", rb_float_new(DBL_EPSILON)); rb_define_const(rb_cFloat, "EPSILON", DOUBLE2NUM(DBL_EPSILON));
rb_define_method(rb_cFloat, "to_s", flo_to_s, 0); rb_define_method(rb_cFloat, "to_s", flo_to_s, 0);
rb_define_method(rb_cFloat, "coerce", flo_coerce, 1); rb_define_method(rb_cFloat, "coerce", flo_coerce, 1);

20
object.c
View File

@ -755,7 +755,7 @@ nil_to_i(VALUE obj)
static VALUE static VALUE
nil_to_f(VALUE obj) nil_to_f(VALUE obj)
{ {
return rb_float_new(0.0); return DOUBLE2NUM(0.0);
} }
/* /*
@ -1950,11 +1950,11 @@ rb_Integer(VALUE val)
switch (TYPE(val)) { switch (TYPE(val)) {
case T_FLOAT: case T_FLOAT:
if (RFLOAT(val)->value <= (double)FIXNUM_MAX if (RFLOAT_VALUE(val) <= (double)FIXNUM_MAX
&& RFLOAT(val)->value >= (double)FIXNUM_MIN) { && RFLOAT_VALUE(val) >= (double)FIXNUM_MIN) {
break; break;
} }
return rb_dbl2big(RFLOAT(val)->value); return rb_dbl2big(RFLOAT_VALUE(val));
case T_FIXNUM: case T_FIXNUM:
case T_BIGNUM: case T_BIGNUM:
@ -2094,16 +2094,16 @@ rb_Float(VALUE val)
{ {
switch (TYPE(val)) { switch (TYPE(val)) {
case T_FIXNUM: case T_FIXNUM:
return rb_float_new((double)FIX2LONG(val)); return DOUBLE2NUM((double)FIX2LONG(val));
case T_FLOAT: case T_FLOAT:
return val; return val;
case T_BIGNUM: case T_BIGNUM:
return rb_float_new(rb_big2dbl(val)); return DOUBLE2NUM(rb_big2dbl(val));
case T_STRING: case T_STRING:
return rb_float_new(rb_str_to_dbl(val, Qtrue)); return DOUBLE2NUM(rb_str_to_dbl(val, Qtrue));
case T_NIL: case T_NIL:
rb_raise(rb_eTypeError, "can't convert nil into Float"); rb_raise(rb_eTypeError, "can't convert nil into Float");
@ -2112,7 +2112,7 @@ rb_Float(VALUE val)
default: default:
{ {
VALUE f = rb_convert_type(val, T_FLOAT, "Float", "to_f"); VALUE f = rb_convert_type(val, T_FLOAT, "Float", "to_f");
if (isnan(RFLOAT(f)->value)) { if (isnan(RFLOAT_VALUE(f))) {
rb_raise(rb_eArgError, "invalid value for Float()"); rb_raise(rb_eArgError, "invalid value for Float()");
} }
return f; return f;
@ -2143,7 +2143,7 @@ rb_num2dbl(VALUE val)
{ {
switch (TYPE(val)) { switch (TYPE(val)) {
case T_FLOAT: case T_FLOAT:
return RFLOAT(val)->value; return RFLOAT_VALUE(val);
case T_STRING: case T_STRING:
rb_raise(rb_eTypeError, "no implicit conversion to float from string"); rb_raise(rb_eTypeError, "no implicit conversion to float from string");
@ -2157,7 +2157,7 @@ rb_num2dbl(VALUE val)
break; break;
} }
return RFLOAT(rb_Float(val))->value; return RFLOAT_VALUE(rb_Float(val));
} }
char* char*

24
pack.c
View File

@ -768,7 +768,7 @@ pack_pack(VALUE ary, VALUE fmt)
float f; float f;
from = NEXTFROM; from = NEXTFROM;
f = RFLOAT(rb_Float(from))->value; f = RFLOAT_VALUE(rb_Float(from));
rb_str_buf_cat(res, (char*)&f, sizeof(float)); rb_str_buf_cat(res, (char*)&f, sizeof(float));
} }
break; break;
@ -779,7 +779,7 @@ pack_pack(VALUE ary, VALUE fmt)
FLOAT_CONVWITH(ftmp); FLOAT_CONVWITH(ftmp);
from = NEXTFROM; from = NEXTFROM;
f = RFLOAT(rb_Float(from))->value; f = RFLOAT_VALUE(rb_Float(from));
f = HTOVF(f,ftmp); f = HTOVF(f,ftmp);
rb_str_buf_cat(res, (char*)&f, sizeof(float)); rb_str_buf_cat(res, (char*)&f, sizeof(float));
} }
@ -791,7 +791,7 @@ pack_pack(VALUE ary, VALUE fmt)
DOUBLE_CONVWITH(dtmp); DOUBLE_CONVWITH(dtmp);
from = NEXTFROM; from = NEXTFROM;
d = RFLOAT(rb_Float(from))->value; d = RFLOAT_VALUE(rb_Float(from));
d = HTOVD(d,dtmp); d = HTOVD(d,dtmp);
rb_str_buf_cat(res, (char*)&d, sizeof(double)); rb_str_buf_cat(res, (char*)&d, sizeof(double));
} }
@ -803,7 +803,7 @@ pack_pack(VALUE ary, VALUE fmt)
double d; double d;
from = NEXTFROM; from = NEXTFROM;
d = RFLOAT(rb_Float(from))->value; d = RFLOAT_VALUE(rb_Float(from));
rb_str_buf_cat(res, (char*)&d, sizeof(double)); rb_str_buf_cat(res, (char*)&d, sizeof(double));
} }
break; break;
@ -814,7 +814,7 @@ pack_pack(VALUE ary, VALUE fmt)
FLOAT_CONVWITH(ftmp); FLOAT_CONVWITH(ftmp);
from = NEXTFROM; from = NEXTFROM;
f = RFLOAT(rb_Float(from))->value; f = RFLOAT_VALUE(rb_Float(from));
f = HTONF(f,ftmp); f = HTONF(f,ftmp);
rb_str_buf_cat(res, (char*)&f, sizeof(float)); rb_str_buf_cat(res, (char*)&f, sizeof(float));
} }
@ -826,7 +826,7 @@ pack_pack(VALUE ary, VALUE fmt)
DOUBLE_CONVWITH(dtmp); DOUBLE_CONVWITH(dtmp);
from = NEXTFROM; from = NEXTFROM;
d = RFLOAT(rb_Float(from))->value; d = RFLOAT_VALUE(rb_Float(from));
d = HTOND(d,dtmp); d = HTOND(d,dtmp);
rb_str_buf_cat(res, (char*)&d, sizeof(double)); rb_str_buf_cat(res, (char*)&d, sizeof(double));
} }
@ -1634,7 +1634,7 @@ pack_unpack(VALUE str, VALUE fmt)
float tmp; float tmp;
memcpy(&tmp, s, sizeof(float)); memcpy(&tmp, s, sizeof(float));
s += sizeof(float); s += sizeof(float);
UNPACK_PUSH(rb_float_new((double)tmp)); UNPACK_PUSH(DOUBLE2NUM((double)tmp));
} }
PACK_ITEM_ADJUST(); PACK_ITEM_ADJUST();
break; break;
@ -1648,7 +1648,7 @@ pack_unpack(VALUE str, VALUE fmt)
memcpy(&tmp, s, sizeof(float)); memcpy(&tmp, s, sizeof(float));
s += sizeof(float); s += sizeof(float);
tmp = VTOHF(tmp,ftmp); tmp = VTOHF(tmp,ftmp);
UNPACK_PUSH(rb_float_new((double)tmp)); UNPACK_PUSH(DOUBLE2NUM((double)tmp));
} }
PACK_ITEM_ADJUST(); PACK_ITEM_ADJUST();
break; break;
@ -1662,7 +1662,7 @@ pack_unpack(VALUE str, VALUE fmt)
memcpy(&tmp, s, sizeof(double)); memcpy(&tmp, s, sizeof(double));
s += sizeof(double); s += sizeof(double);
tmp = VTOHD(tmp,dtmp); tmp = VTOHD(tmp,dtmp);
UNPACK_PUSH(rb_float_new(tmp)); UNPACK_PUSH(DOUBLE2NUM(tmp));
} }
PACK_ITEM_ADJUST(); PACK_ITEM_ADJUST();
break; break;
@ -1674,7 +1674,7 @@ pack_unpack(VALUE str, VALUE fmt)
double tmp; double tmp;
memcpy(&tmp, s, sizeof(double)); memcpy(&tmp, s, sizeof(double));
s += sizeof(double); s += sizeof(double);
UNPACK_PUSH(rb_float_new(tmp)); UNPACK_PUSH(DOUBLE2NUM(tmp));
} }
PACK_ITEM_ADJUST(); PACK_ITEM_ADJUST();
break; break;
@ -1688,7 +1688,7 @@ pack_unpack(VALUE str, VALUE fmt)
memcpy(&tmp, s, sizeof(float)); memcpy(&tmp, s, sizeof(float));
s += sizeof(float); s += sizeof(float);
tmp = NTOHF(tmp,ftmp); tmp = NTOHF(tmp,ftmp);
UNPACK_PUSH(rb_float_new((double)tmp)); UNPACK_PUSH(DOUBLE2NUM((double)tmp));
} }
PACK_ITEM_ADJUST(); PACK_ITEM_ADJUST();
break; break;
@ -1702,7 +1702,7 @@ pack_unpack(VALUE str, VALUE fmt)
memcpy(&tmp, s, sizeof(double)); memcpy(&tmp, s, sizeof(double));
s += sizeof(double); s += sizeof(double);
tmp = NTOHD(tmp,dtmp); tmp = NTOHD(tmp,dtmp);
UNPACK_PUSH(rb_float_new(tmp)); UNPACK_PUSH(DOUBLE2NUM(tmp));
} }
PACK_ITEM_ADJUST(); PACK_ITEM_ADJUST();
break; break;

4
parse.y
View File

@ -6694,7 +6694,7 @@ parser_yylex(struct parser_params *parser)
rb_warnS("Float %s out of range", tok()); rb_warnS("Float %s out of range", tok());
errno = 0; errno = 0;
} }
set_yylval_literal(rb_float_new(d)); set_yylval_literal(DOUBLE2NUM(d));
return tFLOAT; return tFLOAT;
} }
set_yylval_literal(rb_cstr_to_inum(tok(), 10, Qfalse)); set_yylval_literal(rb_cstr_to_inum(tok(), 10, Qfalse));
@ -8269,7 +8269,7 @@ negate_lit(NODE *node)
node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0); node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
break; break;
case T_FLOAT: case T_FLOAT:
RFLOAT(node->nd_lit)->value = -RFLOAT(node->nd_lit)->value; RFLOAT(node->nd_lit)->double_value = -RFLOAT_VALUE(node->nd_lit);
break; break;
default: default:
break; break;

8
process.c
View File

@ -3780,10 +3780,10 @@ rb_proc_times(VALUE obj)
times(&buf); times(&buf);
return rb_struct_new(S_Tms, return rb_struct_new(S_Tms,
utime = rb_float_new(buf.tms_utime / hertz), utime = DOUBLE2NUM(buf.tms_utime / hertz),
stime = rb_float_new(buf.tms_stime / hertz), stime = DOUBLE2NUM(buf.tms_stime / hertz),
cutime = rb_float_new(buf.tms_cutime / hertz), cutime = DOUBLE2NUM(buf.tms_cutime / hertz),
sctime = rb_float_new(buf.tms_cstime / hertz)); sctime = DOUBLE2NUM(buf.tms_cstime / hertz));
#else #else
rb_notimplement(); rb_notimplement();
#endif #endif

14
random.c
View File

@ -437,14 +437,14 @@ rb_f_rand(int argc, VALUE *argv, VALUE obj)
rb_scan_args(argc, argv, "01", &vmax); rb_scan_args(argc, argv, "01", &vmax);
switch (TYPE(vmax)) { switch (TYPE(vmax)) {
case T_FLOAT: case T_FLOAT:
if (RFLOAT(vmax)->value <= LONG_MAX && RFLOAT(vmax)->value >= LONG_MIN) { if (RFLOAT_VALUE(vmax) <= LONG_MAX && RFLOAT_VALUE(vmax) >= LONG_MIN) {
max = (long)RFLOAT(vmax)->value; max = (long)RFLOAT_VALUE(vmax);
break; break;
} }
if (RFLOAT(vmax)->value < 0) if (RFLOAT_VALUE(vmax) < 0)
vmax = rb_dbl2big(-RFLOAT(vmax)->value); vmax = rb_dbl2big(-RFLOAT_VALUE(vmax));
else else
vmax = rb_dbl2big(RFLOAT(vmax)->value); vmax = rb_dbl2big(RFLOAT_VALUE(vmax));
/* fall through */ /* fall through */
case T_BIGNUM: case T_BIGNUM:
bignum: bignum:
@ -457,7 +457,7 @@ rb_f_rand(int argc, VALUE *argv, VALUE obj)
limit = (struct RBignum *)rb_big_minus((VALUE)limit, INT2FIX(1)); limit = (struct RBignum *)rb_big_minus((VALUE)limit, INT2FIX(1));
if (FIXNUM_P((VALUE)limit)) { if (FIXNUM_P((VALUE)limit)) {
if (FIX2LONG((VALUE)limit) == -1) if (FIX2LONG((VALUE)limit) == -1)
return rb_float_new(genrand_real()); return DOUBLE2NUM(genrand_real());
return LONG2NUM(limited_rand(FIX2LONG((VALUE)limit))); return LONG2NUM(limited_rand(FIX2LONG((VALUE)limit)));
} }
return limited_big_rand(limit); return limited_big_rand(limit);
@ -474,7 +474,7 @@ rb_f_rand(int argc, VALUE *argv, VALUE obj)
} }
if (max == 0) { if (max == 0) {
return rb_float_new(genrand_real()); return DOUBLE2NUM(genrand_real());
} }
if (max < 0) max = -max; if (max < 0) max = -max;
val = limited_rand(max-1); val = limited_rand(max-1);

8
sprintf.c
View File

@ -550,11 +550,11 @@ rb_str_format(int argc, const VALUE *argv, VALUE fmt)
bin_retry: bin_retry:
switch (TYPE(val)) { switch (TYPE(val)) {
case T_FLOAT: case T_FLOAT:
if (FIXABLE((long)RFLOAT(val)->value)) { if (FIXABLE((long)RFLOAT_VALUE(val))) {
val = LONG2FIX((long)RFLOAT(val)->value); val = LONG2FIX((long)RFLOAT_VALUE(val));
goto bin_retry; goto bin_retry;
} }
val = rb_dbl2big(RFLOAT(val)->value); val = rb_dbl2big(RFLOAT_VALUE(val));
if (FIXNUM_P(val)) goto bin_retry; if (FIXNUM_P(val)) goto bin_retry;
bignum = 1; bignum = 1;
break; break;
@ -756,7 +756,7 @@ rb_str_format(int argc, const VALUE *argv, VALUE fmt)
int i, need = 6; int i, need = 6;
char fbuf[32]; char fbuf[32];
fval = RFLOAT(rb_Float(val))->value; fval = RFLOAT_VALUE(rb_Float(val));
if (isnan(fval) || isinf(fval)) { if (isnan(fval) || isinf(fval)) {
const char *expr; const char *expr;

2
string.c
View File

@ -2839,7 +2839,7 @@ rb_str_to_i(int argc, VALUE *argv, VALUE str)
static VALUE static VALUE
rb_str_to_f(VALUE str) rb_str_to_f(VALUE str)
{ {
return rb_float_new(rb_str_to_dbl(str, Qfalse)); return DOUBLE2NUM(rb_str_to_dbl(str, Qfalse));
} }

10
time.c
View File

@ -173,15 +173,15 @@ time_timeval(VALUE time, int interval)
break; break;
case T_FLOAT: case T_FLOAT:
if (interval && RFLOAT(time)->value < 0.0) if (interval && RFLOAT_VALUE(time) < 0.0)
rb_raise(rb_eArgError, "%s must be positive", tstr); rb_raise(rb_eArgError, "%s must be positive", tstr);
else { else {
double f, d; double f, d;
d = modf(RFLOAT(time)->value, &f); d = modf(RFLOAT_VALUE(time), &f);
t.tv_sec = (time_t)f; t.tv_sec = (time_t)f;
if (f != t.tv_sec) { if (f != t.tv_sec) {
rb_raise(rb_eRangeError, "%f out of Time range", RFLOAT(time)->value); rb_raise(rb_eRangeError, "%f out of Time range", RFLOAT_VALUE(time));
} }
t.tv_usec = (time_t)(d*1e6+0.5); t.tv_usec = (time_t)(d*1e6+0.5);
} }
@ -868,7 +868,7 @@ time_to_f(VALUE time)
struct time_object *tobj; struct time_object *tobj;
GetTimeval(time, tobj); GetTimeval(time, tobj);
return rb_float_new((double)tobj->tv.tv_sec+(double)tobj->tv.tv_usec/1e6); return DOUBLE2NUM((double)tobj->tv.tv_sec+(double)tobj->tv.tv_usec/1e6);
} }
/* /*
@ -1324,7 +1324,7 @@ time_minus(VALUE time1, VALUE time2)
f += ((double)tobj->tv.tv_usec - (double)tobj2->tv.tv_usec)*1e-6; f += ((double)tobj->tv.tv_usec - (double)tobj2->tv.tv_usec)*1e-6;
/* XXX: should check float overflow on 64bit time_t platforms */ /* XXX: should check float overflow on 64bit time_t platforms */
return rb_float_new(f); return DOUBLE2NUM(f);
} }
return time_add(tobj, time2, -1); return time_add(tobj, time2, -1);
} }