12#include "ruby/internal/config.h"
29#include "internal/array.h"
30#include "internal/compilers.h"
31#include "internal/complex.h"
32#include "internal/enumerator.h"
33#include "internal/gc.h"
34#include "internal/hash.h"
35#include "internal/numeric.h"
36#include "internal/object.h"
37#include "internal/rational.h"
38#include "internal/string.h"
39#include "internal/util.h"
40#include "internal/variable.h"
50#define DBL_MIN 2.2250738585072014e-308
53#define DBL_MAX 1.7976931348623157e+308
56#define DBL_MIN_EXP (-1021)
59#define DBL_MAX_EXP 1024
62#define DBL_MIN_10_EXP (-307)
65#define DBL_MAX_10_EXP 308
71#define DBL_MANT_DIG 53
74#define DBL_EPSILON 2.2204460492503131e-16
77#ifndef USE_RB_INFINITY
78#elif !defined(WORDS_BIGENDIAN)
85#elif !defined(WORDS_BIGENDIAN)
99 x = f + (x - f >= 0.5);
103 x = f - (f - x >= 0.5);
110round_half_up(
double x,
double s)
112 double f, xs = x * s;
115 if (s == 1.0)
return f;
117 if ((
double)((f + 0.5) / s) <= x) f += 1;
121 if ((
double)((f - 0.5) / s) >= x) f -= 1;
128round_half_down(
double x,
double s)
130 double f, xs = x * s;
134 if ((
double)((f - 0.5) / s) >= x) f -= 1;
138 if ((
double)((f + 0.5) / s) <= x) f += 1;
145round_half_even(
double x,
double s)
147 double u, v, us, vs, f, d, uf;
159 else if (d == 0.5 || ((
double)((uf + 0.5) / s) <= x))
171 else if (d == 0.5 || ((
double)((uf - 0.5) / s) >= x))
180static VALUE fix_lshift(
long,
unsigned long);
181static VALUE fix_rshift(
long,
unsigned long);
182static VALUE int_pow(
long x,
unsigned long y);
183static VALUE rb_int_floor(
VALUE num,
int ndigits);
184static VALUE rb_int_ceil(
VALUE num,
int ndigits);
186static int float_round_overflow(
int ndigits,
int binexp);
187static int float_round_underflow(
int ndigits,
int binexp);
191#define id_divmod idDivmod
192#define id_to_i idTo_i
203static ID id_to, id_by;
211enum ruby_num_rounding_mode
212rb_num_get_rounding_option(
VALUE opts)
214 static ID round_kwds[1];
220 if (!round_kwds[0]) {
223 if (!
rb_get_kwargs(opts, round_kwds, 0, 1, &rounding))
goto noopt;
227 else if (
NIL_P(rounding)) {
230 else if (!RB_TYPE_P(str = rounding,
T_STRING)) {
232 if (
NIL_P(str))
goto invalid;
235 s = RSTRING_PTR(str);
236 switch (RSTRING_LEN(str)) {
238 if (rb_memcicmp(s,
"up", 2) == 0)
239 return RUBY_NUM_ROUND_HALF_UP;
242 if (rb_memcicmp(s,
"even", 4) == 0)
243 return RUBY_NUM_ROUND_HALF_EVEN;
244 if (strncasecmp(s,
"down", 4) == 0)
245 return RUBY_NUM_ROUND_HALF_DOWN;
249 rb_raise(rb_eArgError,
"invalid rounding mode: % "PRIsVALUE, rounding);
252 return RUBY_NUM_ROUND_DEFAULT;
257rb_num_to_uint(
VALUE val,
unsigned int *ret)
260#define NUMERR_NEGATIVE 2
261#define NUMERR_TOOLARGE 3
264#if SIZEOF_INT < SIZEOF_LONG
265 if (v > (
long)UINT_MAX)
return NUMERR_TOOLARGE;
267 if (v < 0)
return NUMERR_NEGATIVE;
268 *ret = (
unsigned int)v;
272 if (RB_BIGNUM_TYPE_P(val)) {
273 if (BIGNUM_NEGATIVE_P(val))
return NUMERR_NEGATIVE;
274#if SIZEOF_INT < SIZEOF_LONG
276 return NUMERR_TOOLARGE;
279 if (rb_absint_size(val, NULL) >
sizeof(
int))
return NUMERR_TOOLARGE;
280 *ret = (
unsigned int)rb_big2ulong((
VALUE)val);
287#define method_basic_p(klass) rb_method_basic_definition_p(klass, mid)
293 return FIXNUM_POSITIVE_P(num);
295 else if (RB_BIGNUM_TYPE_P(num)) {
296 return BIGNUM_POSITIVE_P(num);
305 return FIXNUM_NEGATIVE_P(num);
307 else if (RB_BIGNUM_TYPE_P(num)) {
308 return BIGNUM_NEGATIVE_P(num);
314rb_int_positive_p(
VALUE num)
316 return int_pos_p(num);
320rb_int_negative_p(
VALUE num)
322 return int_neg_p(num);
326rb_num_negative_p(
VALUE num)
328 return rb_num_negative_int_p(num);
332num_funcall_op_0(
VALUE x,
VALUE arg,
int recursive)
336 const char *name = rb_id2name(func);
341 else if (name[0] && name[1] ==
'@' && !name[2]) {
350 return rb_funcallv(x, func, 0, 0);
359NORETURN(
static void num_funcall_op_1_recursion(
VALUE x,
ID func,
VALUE y));
364 const char *name = rb_id2name(func);
366 rb_name_error(func,
"%"PRIsVALUE
".%"PRIsVALUE
"(%"PRIsVALUE
")",
376num_funcall_op_1(
VALUE y,
VALUE arg,
int recursive)
381 num_funcall_op_1_recursion(x, func, y);
390 args[0] = (
VALUE)func;
434 return rb_assoc_new(y, x);
437 return rb_assoc_new(y, x);
440NORETURN(
static void coerce_failed(
VALUE x,
VALUE y));
450 rb_raise(
rb_eTypeError,
"%"PRIsVALUE
" can't be coerced into %"PRIsVALUE,
460 coerce_failed(*x, *y);
464 if (!err &&
NIL_P(ary)) {
479 do_coerce(&x, &y, TRUE);
486 if (do_coerce(&x, &y, FALSE))
494 if (
NIL_P(c)) rb_cmperr(x, y);
501 VALUE x0 = x, y0 = y;
503 if (!do_coerce(&x, &y, FALSE)) {
507 return ensure_cmp(
rb_funcall(x, func, 1, y), x0, y0);
527 "can't define singleton method \"%"PRIsVALUE
"\" for %"PRIsVALUE,
549 return rb_immutable_obj_clone(argc, argv, x);
552# define num_clone rb_immutable_obj_clone
571# define num_dup num_uplus
603num_imaginary(
VALUE num)
605 return rb_complex_new(
INT2FIX(0), num);
621 do_coerce(&zero, &num, TRUE);
623 return num_funcall1(zero,
'-', num);
662 return rb_funcall(num_funcall1(x,
'/', y), rb_intern(
"floor"), 0);
702 VALUE q = num_funcall1(x, id_div, y);
742 do_coerce(&x, &y, TRUE);
744 VALUE z = num_funcall1(x,
'%', y);
747 ((rb_num_negative_int_p(x) &&
748 rb_num_positive_int_p(y)) ||
749 (rb_num_positive_int_p(x) &&
750 rb_num_negative_int_p(y)))) {
792 return rb_assoc_new(num_div(x, y), num_modulo(x, y));
810 if (rb_num_negative_int_p(num)) {
811 return num_funcall0(num, idUMinus);
837 return FIXNUM_ZERO_P(num);
839 assert(RB_BIGNUM_TYPE_P(num));
840 return rb_bigzero_p(num);
844rb_int_zero_p(
VALUE num)
846 return RBOOL(int_zero_p(num));
868num_nonzero_p(
VALUE num)
870 if (
RTEST(num_funcall0(num, rb_intern(
"zero?")))) {
898 return num_funcall0(num, id_to_i);
910num_positive_p(
VALUE num)
918 else if (RB_BIGNUM_TYPE_P(num)) {
920 return RBOOL(BIGNUM_POSITIVE_P(num) && !rb_bigzero_p(num));
922 return rb_num_compare_with_zero(num, mid);
934num_negative_p(
VALUE num)
936 return RBOOL(rb_num_negative_int_p(num));
1023#if SIZEOF_DOUBLE <= SIZEOF_VALUE
1024 flt->float_value = d;
1028 rb_float_value_type v;
1030 flt->float_value = u.v;
1061 enum {decimal_mant = DBL_MANT_DIG-DBL_DIG};
1062 enum {float_dig = DBL_DIG+1};
1063 char buf[float_dig + roomof(decimal_mant, CHAR_BIT) + 10];
1067 int sign, decpt, digs;
1070 static const char minf[] =
"-Infinity";
1071 const int pos = (value > 0);
1074 else if (isnan(value))
1077 p = ruby_dtoa(value, 0, 0, &decpt, &sign, &e);
1079 if ((digs = (
int)(e - p)) >= (
int)
sizeof(buf)) digs = (
int)
sizeof(buf) - 1;
1080 memcpy(buf, p, digs);
1084 memmove(buf + decpt + 1, buf + decpt, digs - decpt);
1086 rb_str_cat(s, buf, digs + 1);
1088 else if (decpt <= DBL_DIG) {
1091 rb_str_cat(s, buf, digs);
1092 rb_str_resize(s, (
len = RSTRING_LEN(s)) + decpt - digs + 2);
1093 ptr = RSTRING_PTR(s) +
len;
1095 memset(ptr,
'0', decpt - digs);
1096 ptr += decpt - digs;
1098 memcpy(ptr,
".0", 2);
1104 else if (decpt > -4) {
1107 rb_str_cat(s,
"0.", 2);
1108 rb_str_resize(s, (
len = RSTRING_LEN(s)) - decpt + digs);
1109 ptr = RSTRING_PTR(s);
1110 memset(ptr +=
len,
'0', -decpt);
1111 memcpy(ptr -= decpt, buf, digs);
1120 memmove(buf + 2, buf + 1, digs - 1);
1127 rb_str_cat(s, buf, digs + 1);
1128 rb_str_catf(s,
"e%+03d", decpt - 1);
1152 return rb_assoc_new(
rb_Float(y), x);
1156rb_float_uminus(
VALUE flt)
1181 else if (RB_BIGNUM_TYPE_P(y)) {
1212 else if (RB_BIGNUM_TYPE_P(y)) {
1242 else if (RB_BIGNUM_TYPE_P(y)) {
1254double_div_double(
double x,
double y)
1256 if (LIKELY(y != 0.0)) {
1259 else if (x == 0.0) {
1263 double z = signbit(y) ? -1.0 : 1.0;
1264 return x * z * HUGE_VAL;
1273 double ret = double_div_double(num, den);
1301 else if (RB_BIGNUM_TYPE_P(y)) {
1302 den = rb_big2dbl(y);
1311 ret = double_div_double(num, den);
1332 return num_funcall1(x,
'/', y);
1336flodivmod(
double x,
double y,
double *divp,
double *modp)
1342 if (modp) *modp = y;
1343 if (divp) *divp = y;
1347 if ((x == 0.0) || (isinf(y) && !isinf(x)))
1359 if (isinf(x) && !isinf(y))
1362 div = (x - mod) / y;
1363 if (modp && divp) div = round(div);
1369 if (modp) *modp = mod;
1370 if (divp) *divp = div;
1379ruby_float_mod(
double x,
double y)
1382 flodivmod(x, y, 0, &mod);
1423 else if (RB_BIGNUM_TYPE_P(y)) {
1441 return rb_dbl2big(d);
1473 double fy, div, mod;
1474 volatile VALUE a, b;
1479 else if (RB_BIGNUM_TYPE_P(y)) {
1491 return rb_assoc_new(a, b);
1521 else if (RB_BIGNUM_TYPE_P(y)) {
1528 if (dx < 0 && dy != round(dy))
1529 return rb_dbl_complex_new_polar_pi(pow(-dx, dy), dy);
1563 if (RB_BIGNUM_TYPE_P(x)) {
1564 return rb_big_eql(x, y);
1583 if (x == y)
return INT2FIX(0);
1591 if (x == y)
return Qtrue;
1592 result = num_funcall1(y, id_eq, x);
1593 return RBOOL(
RTEST(result));
1616 volatile double a, b;
1619 return rb_integer_float_eq(y, x);
1623#if MSC_VERSION_BEFORE(1300)
1624 if (isnan(b))
return Qfalse;
1628 return num_equal(x, y);
1631#if MSC_VERSION_BEFORE(1300)
1632 if (isnan(a))
return Qfalse;
1634 return RBOOL(a == b);
1637#define flo_eq rb_float_equal
1638static VALUE rb_dbl_hash(
double d);
1656rb_dbl_hash(
double d)
1658 return ST2FIX(rb_dbl_long_hash(d));
1664 if (isnan(a) || isnan(b))
return Qnil;
1665 if (a == b)
return INT2FIX(0);
1667 if (a < b)
return INT2FIX(-1);
1706 if (isnan(a))
return Qnil;
1708 VALUE rel = rb_integer_float_cmp(y, x);
1717 if (isinf(a) && !UNDEF_P(i =
rb_check_funcall(y, rb_intern(
"infinite?"), 0, 0))) {
1719 int j = rb_cmpint(i, x, y);
1720 j = (a > 0.0) ? (j > 0 ? 0 : +1) : (j < 0 ? 0 : -1);
1723 if (a > 0.0)
return INT2FIX(1);
1734 return NUM2INT(ensure_cmp(flo_cmp(x, y), x, y));
1759 VALUE rel = rb_integer_float_cmp(y, x);
1766#if MSC_VERSION_BEFORE(1300)
1767 if (isnan(b))
return Qfalse;
1773#if MSC_VERSION_BEFORE(1300)
1774 if (isnan(a))
return Qfalse;
1776 return RBOOL(a > b);
1801 if (RB_TYPE_P(y,
T_FIXNUM) || RB_BIGNUM_TYPE_P(y)) {
1802 VALUE rel = rb_integer_float_cmp(y, x);
1809#if MSC_VERSION_BEFORE(1300)
1810 if (isnan(b))
return Qfalse;
1816#if MSC_VERSION_BEFORE(1300)
1817 if (isnan(a))
return Qfalse;
1819 return RBOOL(a >= b);
1844 VALUE rel = rb_integer_float_cmp(y, x);
1851#if MSC_VERSION_BEFORE(1300)
1852 if (isnan(b))
return Qfalse;
1858#if MSC_VERSION_BEFORE(1300)
1859 if (isnan(a))
return Qfalse;
1861 return RBOOL(a < b);
1887 VALUE rel = rb_integer_float_cmp(y, x);
1894#if MSC_VERSION_BEFORE(1300)
1895 if (isnan(b))
return Qfalse;
1901#if MSC_VERSION_BEFORE(1300)
1902 if (isnan(a))
return Qfalse;
1904 return RBOOL(a <= b);
1931#if MSC_VERSION_BEFORE(1300)
1932 if (isnan(a) || isnan(b))
return Qfalse;
1934 return RBOOL(a == b);
1939#define flo_eql rb_float_eql
1942rb_float_abs(
VALUE flt)
1961flo_is_nan_p(
VALUE num)
1965 return RBOOL(isnan(value));
1992rb_flo_is_infinite_p(
VALUE num)
1997 return INT2FIX( value < 0 ? -1 : 1 );
2022rb_flo_is_finite_p(
VALUE num)
2026 return RBOOL(isfinite(value));
2030flo_nextafter(
VALUE flo,
double value)
2034 y = nextafter(x, value);
2083flo_next_float(
VALUE vx)
2085 return flo_nextafter(vx, HUGE_VAL);
2124flo_prev_float(
VALUE vx)
2126 return flo_nextafter(vx, -HUGE_VAL);
2130rb_float_floor(
VALUE num,
int ndigits)
2134 if (number == 0.0) {
2140 frexp(number, &binexp);
2141 if (float_round_overflow(ndigits, binexp))
return num;
2142 if (number > 0.0 && float_round_underflow(ndigits, binexp))
2144 f = pow(10, ndigits);
2145 mul = floor(number * f);
2146 res = (mul + 1) / f;
2152 num = dbl2ival(floor(number));
2153 if (ndigits < 0) num = rb_int_floor(num, ndigits);
2159flo_ndigits(
int argc,
VALUE *argv)
2206 int ndigits = flo_ndigits(argc, argv);
2207 return rb_float_floor(num, ndigits);
2249 int ndigits = flo_ndigits(argc, argv);
2250 return rb_float_ceil(num, ndigits);
2254rb_float_ceil(
VALUE num,
int ndigits)
2259 if (number == 0.0) {
2264 frexp(number, &binexp);
2265 if (float_round_overflow(ndigits, binexp))
return num;
2266 if (number < 0.0 && float_round_underflow(ndigits, binexp))
2268 f = pow(10, ndigits);
2269 f = ceil(number * f) / f;
2273 num = dbl2ival(ceil(number));
2274 if (ndigits < 0) num = rb_int_ceil(num, ndigits);
2280int_round_zero_p(
VALUE num,
int ndigits)
2286 bytes =
sizeof(long);
2288 else if (RB_BIGNUM_TYPE_P(num)) {
2289 bytes = rb_big_size(num);
2294 return (-0.415241 * ndigits - 0.125 > bytes);
2301 if ((z * y - x) * 2 == y) {
2310 return (x + y / 2) / y * y;
2316 return (x + y / 2 - 1) / y * y;
2322 return (
int)rb_int_odd_p(rb_int_idiv(n, f));
2328 return int_pos_p(num);
2334 return int_neg_p(num);
2341rb_int_round(
VALUE num,
int ndigits,
enum ruby_num_rounding_mode mode)
2345 if (int_round_zero_p(num, ndigits)) {
2349 f = int_pow(10, -ndigits);
2354 x = ROUND_CALL(mode, int_round, (x, y));
2362 h = rb_int_idiv(f,
INT2FIX(2));
2363 r = rb_int_modulo(num, f);
2364 n = rb_int_minus(num, r);
2365 r = rb_int_cmp(r, h);
2366 if (FIXNUM_POSITIVE_P(r) ||
2367 (FIXNUM_ZERO_P(r) && ROUND_CALL(mode, int_half_p, (num, n, f)))) {
2368 n = rb_int_plus(n, f);
2374rb_int_floor(
VALUE num,
int ndigits)
2376 VALUE f = int_pow(10, -ndigits);
2380 if (neg) x = -x + y - 1;
2386 bool neg = int_neg_p(num);
2387 if (neg) num = rb_int_minus(rb_int_plus(rb_int_uminus(num), f),
INT2FIX(1));
2388 num = rb_int_mul(rb_int_div(num, f), f);
2389 if (neg) num = rb_int_uminus(num);
2395rb_int_ceil(
VALUE num,
int ndigits)
2397 VALUE f = int_pow(10, -ndigits);
2408 bool neg = int_neg_p(num);
2410 num = rb_int_uminus(num);
2412 num = rb_int_plus(num, rb_int_minus(f,
INT2FIX(1)));
2413 num = rb_int_mul(rb_int_div(num, f), f);
2414 if (neg) num = rb_int_uminus(num);
2420rb_int_truncate(
VALUE num,
int ndigits)
2425 if (int_round_zero_p(num, ndigits))
2427 f = int_pow(10, -ndigits);
2440 m = rb_int_modulo(num, f);
2441 if (int_neg_p(num)) {
2442 return rb_int_plus(num, rb_int_minus(f, m));
2445 return rb_int_minus(num, m);
2507 double number, f, x;
2510 enum ruby_num_rounding_mode mode;
2515 mode = rb_num_get_rounding_option(opt);
2517 if (number == 0.0) {
2521 return rb_int_round(flo_to_i(num), ndigits, mode);
2524 x = ROUND_CALL(mode, round, (number, 1.0));
2527 if (isfinite(number)) {
2529 frexp(number, &binexp);
2530 if (float_round_overflow(ndigits, binexp))
return num;
2531 if (float_round_underflow(ndigits, binexp))
return DBL2NUM(0);
2534 return rb_flo_round_by_rational(argc, argv, num);
2536 f = pow(10, ndigits);
2537 x = ROUND_CALL(mode, round, (number, f));
2544float_round_overflow(
int ndigits,
int binexp)
2546 enum {float_dig = DBL_DIG+2};
2565 if (ndigits >= float_dig - (binexp > 0 ? binexp / 4 : binexp / 3 - 1)) {
2572float_round_underflow(
int ndigits,
int binexp)
2574 if (ndigits < - (binexp > 0 ? binexp / 3 + 1 : binexp / 4)) {
2601 if (f > 0.0) f = floor(f);
2602 if (f < 0.0) f = ceil(f);
2643flo_truncate(
int argc,
VALUE *argv,
VALUE num)
2646 return flo_ceil(argc, argv, num);
2648 return flo_floor(argc, argv, num);
2665 return flo_floor(argc, argv,
rb_Float(num));
2682 return flo_ceil(argc, argv,
rb_Float(num));
2699 return flo_round(argc, argv,
rb_Float(num));
2714num_truncate(
int argc,
VALUE *argv,
VALUE num)
2716 return flo_truncate(argc, argv,
rb_Float(num));
2720ruby_float_step_size(
double beg,
double end,
double unit,
int excl)
2722 const double epsilon = DBL_EPSILON;
2729 return unit > 0 ? beg <= end : beg >= end;
2731 n= (end - beg)/unit;
2732 err = (fabs(beg) + fabs(end) + fabs(end-beg)) / fabs(unit) * epsilon;
2733 if (err>0.5) err=0.5;
2740 d = +((n + 1) * unit) + beg;
2745 else if (beg > end) {
2753 d = +((n + 1) * unit) + beg;
2758 else if (beg > end) {
2767ruby_float_step(
VALUE from,
VALUE to,
VALUE step,
int excl,
int allow_endless)
2772 double end = (allow_endless &&
NIL_P(to)) ? (unit < 0 ? -1 : 1)*HUGE_VAL :
NUM2DBL(to);
2773 double n = ruby_float_step_size(beg, end, unit, excl);
2780 else if (unit == 0) {
2786 for (i=0; i<n; i++) {
2787 double d = i*unit+beg;
2788 if (unit >= 0 ? end < d : d < end) d = end;
2798ruby_num_interval_step_size(
VALUE from,
VALUE to,
VALUE step,
int excl)
2823 if (isinf(n))
return DBL2NUM(n);
2825 return rb_dbl2big(n);
2831 case 0:
return DBL2NUM(HUGE_VAL);
2832 case -1: cmp =
'<';
break;
2844num_step_negative_p(
VALUE num)
2854 else if (RB_BIGNUM_TYPE_P(num)) {
2856 return BIGNUM_NEGATIVE_P(num);
2861 coerce_failed(num,
INT2FIX(0));
2871 argc =
rb_scan_args(argc, argv,
"02:", to, step, &hash);
2878 if (!UNDEF_P(values[0])) {
2879 if (argc > 0) rb_raise(rb_eArgError,
"to is given twice");
2882 if (!UNDEF_P(values[1])) {
2883 if (argc > 1) rb_raise(rb_eArgError,
"step is given twice");
2892num_step_check_fix_args(
int argc,
VALUE *to,
VALUE *step,
VALUE by,
int fix_nil,
int allow_zero_step)
2900 if (argc > 1 &&
NIL_P(*step)) {
2905 rb_raise(rb_eArgError,
"step can't be 0");
2910 desc = num_step_negative_p(*step);
2911 if (fix_nil &&
NIL_P(*to)) {
2918num_step_scan_args(
int argc,
const VALUE *argv,
VALUE *to,
VALUE *step,
int fix_nil,
int allow_zero_step)
2921 argc = num_step_extract_args(argc, argv, to, step, &by);
2922 return num_step_check_fix_args(argc, to, step, by, fix_nil, allow_zero_step);
2932 num_step_scan_args(argc, argv, &to, &step, TRUE, FALSE);
2934 return ruby_num_interval_step_size(from, to, step, FALSE);
3042 num_step_extract_args(argc, argv, &to, &step, &by);
3050 rb_raise(rb_eArgError,
"step can't be 0");
3054 return rb_arith_seq_new(from,
ID2SYM(rb_frame_this_func()), argc, argv,
3055 num_step_size, from, to, step, FALSE);
3061 desc = num_step_scan_args(argc, argv, &to, &step, TRUE, FALSE);
3067 inf = isinf(f) && (signbit(f) ? desc : !desc);
3083 for (; i >= end; i += diff)
3087 for (; i <= end; i += diff)
3092 else if (!ruby_float_step(from, to, step, FALSE, FALSE)) {
3100 ID cmp = desc ?
'<' :
'>';
3110out_of_range_float(
char (*pbuf)[24],
VALUE val)
3112 char *
const buf = *pbuf;
3115 snprintf(buf,
sizeof(*pbuf),
"%-.10g",
RFLOAT_VALUE(val));
3116 if ((s = strchr(buf,
' ')) != 0) *s =
'\0';
3120#define FLOAT_OUT_OF_RANGE(val, type) do { \
3122 rb_raise(rb_eRangeError, "float %s out of range of "type, \
3123 out_of_range_float(&buf, (val))); \
3126#define LONG_MIN_MINUS_ONE ((double)LONG_MIN-1)
3127#define LONG_MAX_PLUS_ONE (2*(double)(LONG_MAX/2+1))
3128#define ULONG_MAX_PLUS_ONE (2*(double)(ULONG_MAX/2+1))
3129#define LONG_MIN_MINUS_ONE_IS_LESS_THAN(n) \
3130 (LONG_MIN_MINUS_ONE == (double)LONG_MIN ? \
3132 LONG_MIN_MINUS_ONE < (n))
3139 rb_raise(
rb_eTypeError,
"no implicit conversion from nil to integer");
3146 && LONG_MIN_MINUS_ONE_IS_LESS_THAN(
RFLOAT_VALUE(val))) {
3150 FLOAT_OUT_OF_RANGE(val,
"integer");
3153 else if (RB_BIGNUM_TYPE_P(val)) {
3154 return rb_big2long(val);
3163rb_num2ulong_internal(
VALUE val,
int *wrap_p)
3167 rb_raise(
rb_eTypeError,
"no implicit conversion of nil into Integer");
3174 return (
unsigned long)l;
3178 if (d < ULONG_MAX_PLUS_ONE && LONG_MIN_MINUS_ONE_IS_LESS_THAN(d)) {
3180 *wrap_p = d <= -1.0;
3182 return (
unsigned long)d;
3183 return (
unsigned long)(long)d;
3186 FLOAT_OUT_OF_RANGE(val,
"integer");
3189 else if (RB_BIGNUM_TYPE_P(val)) {
3191 unsigned long ul = rb_big2ulong(val);
3193 *wrap_p = BIGNUM_NEGATIVE_P(val);
3206 return rb_num2ulong_internal(val, NULL);
3212 rb_raise(
rb_eRangeError,
"integer %"PRIdVALUE
" too %s to convert to `int'",
3213 num, num < 0 ?
"small" :
"big");
3216#if SIZEOF_INT < SIZEOF_LONG
3220 if ((
long)(
int)num != num) {
3226check_uint(
unsigned long num,
int sign)
3230 if (num < (
unsigned long)INT_MIN)
3231 rb_raise(
rb_eRangeError,
"integer %ld too small to convert to `unsigned int'", (
long)num);
3236 rb_raise(
rb_eRangeError,
"integer %lu too big to convert to `unsigned int'", num);
3262 unsigned long num = rb_num2ulong_internal(val, &wrap);
3264 check_uint(num, wrap);
3278 check_uint(num, FIXNUM_NEGATIVE_P(val));
3307NORETURN(
static void rb_out_of_short(
SIGNED_VALUE num));
3311 rb_raise(
rb_eRangeError,
"integer %"PRIdVALUE
" too %s to convert to `short'",
3312 num, num < 0 ?
"small" :
"big");
3316check_short(
long num)
3318 if ((
long)(
short)num != num) {
3319 rb_out_of_short(num);
3324check_ushort(
unsigned long num,
int sign)
3328 if (num < (
unsigned long)SHRT_MIN)
3329 rb_raise(
rb_eRangeError,
"integer %ld too small to convert to `unsigned short'", (
long)num);
3333 if (USHRT_MAX < num)
3334 rb_raise(
rb_eRangeError,
"integer %lu too big to convert to `unsigned short'", num);
3360 unsigned long num = rb_num2ulong_internal(val, &wrap);
3362 check_ushort(num, wrap);
3376 check_ushort(num, FIXNUM_NEGATIVE_P(val));
3389 rb_raise(
rb_eRangeError,
"integer %ld out of range of fixnum", v);
3395#define LLONG_MIN_MINUS_ONE ((double)LLONG_MIN-1)
3396#define LLONG_MAX_PLUS_ONE (2*(double)(LLONG_MAX/2+1))
3397#define ULLONG_MAX_PLUS_ONE (2*(double)(ULLONG_MAX/2+1))
3399#define ULLONG_MAX ((unsigned LONG_LONG)LLONG_MAX*2+1)
3401#define LLONG_MIN_MINUS_ONE_IS_LESS_THAN(n) \
3402 (LLONG_MIN_MINUS_ONE == (double)LLONG_MIN ? \
3404 LLONG_MIN_MINUS_ONE < (n))
3417 if (d < LLONG_MAX_PLUS_ONE && (LLONG_MIN_MINUS_ONE_IS_LESS_THAN(d))) {
3421 FLOAT_OUT_OF_RANGE(val,
"long long");
3424 else if (RB_BIGNUM_TYPE_P(val)) {
3425 return rb_big2ll(val);
3427 else if (RB_TYPE_P(val,
T_STRING)) {
3428 rb_raise(
rb_eTypeError,
"no implicit conversion from string");
3430 else if (RB_TYPE_P(val,
T_TRUE) || RB_TYPE_P(val,
T_FALSE)) {
3431 rb_raise(
rb_eTypeError,
"no implicit conversion from boolean");
3442 rb_raise(
rb_eTypeError,
"no implicit conversion of nil into Integer");
3449 if (d < ULLONG_MAX_PLUS_ONE && LLONG_MIN_MINUS_ONE_IS_LESS_THAN(d)) {
3455 FLOAT_OUT_OF_RANGE(val,
"unsigned long long");
3458 else if (RB_BIGNUM_TYPE_P(val)) {
3459 return rb_big2ull(val);
3564rb_int_odd_p(
VALUE num)
3567 return RBOOL(num & 2);
3570 assert(RB_BIGNUM_TYPE_P(num));
3571 return rb_big_odd_p(num);
3576int_even_p(
VALUE num)
3579 return RBOOL((num & 2) == 0);
3582 assert(RB_BIGNUM_TYPE_P(num));
3583 return rb_big_even_p(num);
3588rb_int_even_p(
VALUE num)
3590 return int_even_p(num);
3620 return rb_int_equal(rb_int_and(num, mask), mask);
3650 return RBOOL(!int_zero_p(rb_int_and(num, mask)));
3680 return RBOOL(int_zero_p(rb_int_and(num, mask)));
3696rb_int_succ(
VALUE num)
3702 if (RB_BIGNUM_TYPE_P(num)) {
3703 return rb_big_plus(num,
INT2FIX(1));
3705 return num_funcall1(num,
'+',
INT2FIX(1));
3708#define int_succ rb_int_succ
3724rb_int_pred(
VALUE num)
3730 if (RB_BIGNUM_TYPE_P(num)) {
3731 return rb_big_minus(num,
INT2FIX(1));
3733 return num_funcall1(num,
'-',
INT2FIX(1));
3736#define int_pred rb_int_pred
3743 switch (n = rb_enc_codelen(code, enc)) {
3744 case ONIGERR_INVALID_CODE_POINT_VALUE:
3745 rb_raise(
rb_eRangeError,
"invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
3747 case ONIGERR_TOO_BIG_WIDE_CHAR_VALUE:
3752 str = rb_enc_str_new(0, n, enc);
3753 rb_enc_mbcput(code, RSTRING_PTR(str), enc);
3754 if (rb_enc_precise_mbclen(RSTRING_PTR(str), RSTRING_END(str), enc) != n) {
3755 rb_raise(
rb_eRangeError,
"invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
3786 if (rb_num_to_uint(num, &i) == 0) {
3798 enc = rb_default_internal_encoding();
3814 rb_error_arity(argc, 0, 1);
3816 enc = rb_to_encoding(argv[0]);
3817 if (!enc) enc = rb_ascii8bit_encoding();
3827fix_uminus(
VALUE num)
3833rb_int_uminus(
VALUE num)
3836 return fix_uminus(num);
3839 assert(RB_BIGNUM_TYPE_P(num));
3840 return rb_big_uminus(num);
3847 char buf[
SIZEOF_VALUE*CHAR_BIT + 1], *
const e = buf +
sizeof buf, *b = e;
3852 if (base < 2 || 36 < base) {
3853 rb_raise(rb_eArgError,
"invalid radix %d", base);
3855#if SIZEOF_LONG < SIZEOF_VOIDP
3856# if SIZEOF_VOIDP == SIZEOF_LONG_LONG
3857 if ((val >= 0 && (x & 0xFFFFFFFF00000000ull)) ||
3858 (val < 0 && (x & 0xFFFFFFFF00000000ull) != 0xFFFFFFFF00000000ull)) {
3859 rb_bug(
"Unnormalized Fixnum value %p", (
void *)x);
3870 u = 1 + (
unsigned long)(-(val + 1));
3877 *--b = ruby_digitmap[(int)(u % base)];
3878 }
while (u /= base);
3886static VALUE rb_fix_to_s_static[10];
3892 if (i >= 0 && i < 10) {
3893 return rb_fix_to_s_static[i];
3925 return rb_int2str(x, base);
3929rb_int2str(
VALUE x,
int base)
3934 else if (RB_BIGNUM_TYPE_P(x)) {
3935 return rb_big2str(x, base);
3945 return rb_fix_plus_fix(x, y);
3947 else if (RB_BIGNUM_TYPE_P(y)) {
3948 return rb_big_plus(y, x);
3954 return rb_complex_plus(y, x);
3964 return fix_plus(x, y);
3986 return fix_plus(x, y);
3988 else if (RB_BIGNUM_TYPE_P(x)) {
3989 return rb_big_plus(x, y);
3998 return rb_fix_minus_fix(x, y);
4000 else if (RB_BIGNUM_TYPE_P(y)) {
4002 return rb_big_minus(x, y);
4031 return fix_minus(x, y);
4033 else if (RB_BIGNUM_TYPE_P(x)) {
4034 return rb_big_minus(x, y);
4040#define SQRT_LONG_MAX HALF_LONG_MSB
4042#define FIT_SQRT_LONG(n) (((n)<SQRT_LONG_MAX)&&((n)>=-SQRT_LONG_MAX))
4048 return rb_fix_mul_fix(x, y);
4050 else if (RB_BIGNUM_TYPE_P(y)) {
4055 return rb_big_mul(y, x);
4061 return rb_complex_mul(y, x);
4086 return fix_mul(x, y);
4088 else if (RB_BIGNUM_TYPE_P(x)) {
4089 return rb_big_mul(x, y);
4099#if SIZEOF_LONG * CHAR_BIT > DBL_MANT_DIG
4100 if ((iy < 0 ? -iy : iy) >= (1L << DBL_MANT_DIG)) {
4101 return rb_big_fdiv_double(rb_int2big(
FIX2LONG(x)), rb_int2big(iy));
4104 return double_div_double(
FIX2LONG(x), iy);
4106 else if (RB_BIGNUM_TYPE_P(y)) {
4107 return rb_big_fdiv_double(rb_int2big(
FIX2LONG(x)), y);
4121 VALUE gcd = rb_gcd(x, y);
4122 if (!FIXNUM_ZERO_P(gcd) && gcd !=
INT2FIX(1)) {
4123 x = rb_int_idiv(x, gcd);
4124 y = rb_int_idiv(y, gcd);
4128 return fix_fdiv_double(x, y);
4130 else if (RB_BIGNUM_TYPE_P(x)) {
4131 return rb_big_fdiv_double(x, y);
4158 return DBL2NUM(rb_int_fdiv_double(x, y));
4168 return rb_fix_div_fix(x, y);
4170 else if (RB_BIGNUM_TYPE_P(y)) {
4172 return rb_big_div(x, y);
4177 return rb_flo_div_flo(
DBL2NUM(d), y);
4182 v = fix_divide(x, y,
'/');
4183 return flo_floor(0, 0, v);
4189 return rb_rational_reciprocal(y);
4197 return fix_divide(x, y,
'/');
4223 return fix_div(x, y);
4225 else if (RB_BIGNUM_TYPE_P(x)) {
4226 return rb_big_div(x, y);
4234 return fix_divide(x, y, id_div);
4259 return fix_idiv(x, y);
4261 else if (RB_BIGNUM_TYPE_P(x)) {
4262 return rb_big_idiv(x, y);
4264 return num_div(x, y);
4272 return rb_fix_mod_fix(x, y);
4274 else if (RB_BIGNUM_TYPE_P(y)) {
4276 return rb_big_modulo(x, y);
4318 return fix_mod(x, y);
4320 else if (RB_BIGNUM_TYPE_P(x)) {
4321 return rb_big_modulo(x, y);
4323 return num_modulo(x, y);
4354 VALUE z = fix_mod(x, y);
4357 z = fix_minus(z, y);
4360 else if (!RB_BIGNUM_TYPE_P(y)) {
4361 return num_remainder(x, y);
4365 else if (!RB_BIGNUM_TYPE_P(x)) {
4368 return rb_big_remainder(x, y);
4377 rb_fix_divmod_fix(x, y, &div, &mod);
4378 return rb_assoc_new(div, mod);
4380 else if (RB_BIGNUM_TYPE_P(y)) {
4382 return rb_big_divmod(x, y);
4387 volatile VALUE a, b;
4392 return rb_assoc_new(a, b);
4429 return fix_divmod(x, y);
4431 else if (RB_BIGNUM_TYPE_P(x)) {
4432 return rb_big_divmod(x, y);
4454int_pow(
long x,
unsigned long y)
4459 if (y == 0)
return INT2FIX(1);
4468 while (y % 2 == 0) {
4469 if (!FIT_SQRT_LONG(x)) {
4476 if (MUL_OVERFLOW_FIXNUM_P(x, z)) {
4487 v = rb_big_pow(rb_int2big(x),
LONG2NUM(y));
4490 if (z != 1) v = rb_big_mul(rb_int2big(neg ? -z : z), v);
4495rb_int_positive_pow(
long x,
unsigned long y)
4497 return int_pow(x, y);
4508 VALUE y = rb_int_pow(x, minusb);
4528 if (a == 1)
return INT2FIX(1);
4529 if (a == -1)
return INT2FIX(b % 2 ? -1 : 1);
4530 if (b < 0)
return fix_pow_inverted(x, fix_uminus(y));
4531 if (b == 0)
return INT2FIX(1);
4532 if (b == 1)
return x;
4533 if (a == 0)
return INT2FIX(0);
4534 return int_pow(a, b);
4536 else if (RB_BIGNUM_TYPE_P(y)) {
4537 if (a == 1)
return INT2FIX(1);
4538 if (a == -1)
return INT2FIX(int_even_p(y) ? 1 : -1);
4539 if (BIGNUM_NEGATIVE_P(y))
return fix_pow_inverted(x, rb_big_uminus(y));
4540 if (a == 0)
return INT2FIX(0);
4542 return rb_big_pow(x, y);
4546 if (dy == 0.0)
return DBL2NUM(1.0);
4548 return DBL2NUM(dy < 0 ? HUGE_VAL : 0.0);
4550 if (a == 1)
return DBL2NUM(1.0);
4551 if (a < 0 && dy != round(dy))
4552 return rb_dbl_complex_new_polar_pi(pow(-(
double)a, dy), dy);
4553 return DBL2NUM(pow((
double)a, dy));
4579 return fix_pow(x, y);
4581 else if (RB_BIGNUM_TYPE_P(x)) {
4582 return rb_big_pow(x, y);
4590 VALUE z = rb_int_pow(x, y);
4591 if (!
NIL_P(z))
return z;
4596 return rb_complex_pow(x, y);
4598 return rb_rational_pow(x, y);
4608 if (x == y)
return Qtrue;
4610 else if (RB_BIGNUM_TYPE_P(y)) {
4611 return rb_big_eq(y, x);
4614 return rb_integer_float_eq(x, y);
4617 return num_equal(x, y);
4637 return fix_equal(x, y);
4639 else if (RB_BIGNUM_TYPE_P(x)) {
4640 return rb_big_eq(x, y);
4648 if (x == y)
return INT2FIX(0);
4653 else if (RB_BIGNUM_TYPE_P(y)) {
4654 VALUE cmp = rb_big_cmp(y, x);
4662 return rb_integer_float_cmp(x, y);
4699 return fix_cmp(x, y);
4701 else if (RB_BIGNUM_TYPE_P(x)) {
4702 return rb_big_cmp(x, y);
4715 else if (RB_BIGNUM_TYPE_P(y)) {
4716 return RBOOL(rb_big_cmp(y, x) ==
INT2FIX(-1));
4719 return RBOOL(rb_integer_float_cmp(x, y) ==
INT2FIX(1));
4746 return fix_gt(x, y);
4748 else if (RB_BIGNUM_TYPE_P(x)) {
4749 return rb_big_gt(x, y);
4760 else if (RB_BIGNUM_TYPE_P(y)) {
4761 return RBOOL(rb_big_cmp(y, x) !=
INT2FIX(+1));
4764 VALUE rel = rb_integer_float_cmp(x, y);
4793 return fix_ge(x, y);
4795 else if (RB_BIGNUM_TYPE_P(x)) {
4796 return rb_big_ge(x, y);
4807 else if (RB_BIGNUM_TYPE_P(y)) {
4808 return RBOOL(rb_big_cmp(y, x) ==
INT2FIX(+1));
4811 return RBOOL(rb_integer_float_cmp(x, y) ==
INT2FIX(-1));
4838 return fix_lt(x, y);
4840 else if (RB_BIGNUM_TYPE_P(x)) {
4841 return rb_big_lt(x, y);
4852 else if (RB_BIGNUM_TYPE_P(y)) {
4853 return RBOOL(rb_big_cmp(y, x) !=
INT2FIX(-1));
4856 VALUE rel = rb_integer_float_cmp(x, y);
4885 return fix_le(x, y);
4887 else if (RB_BIGNUM_TYPE_P(x)) {
4888 return rb_big_le(x, y);
4900rb_int_comp(
VALUE num)
4903 return fix_comp(num);
4905 else if (RB_BIGNUM_TYPE_P(num)) {
4906 return rb_big_comp(num);
4912num_funcall_bit_1(
VALUE y,
VALUE arg,
int recursive)
4917 num_funcall_op_1_recursion(x, func, y);
4927 args[0] = (
VALUE)func;
4930 do_coerce(&args[1], &args[2], TRUE);
4932 args[2], args[1], (
VALUE)args);
4935 coerce_failed(x, y);
4948 if (RB_BIGNUM_TYPE_P(y)) {
4949 return rb_big_and(y, x);
4974 return fix_and(x, y);
4976 else if (RB_BIGNUM_TYPE_P(x)) {
4977 return rb_big_and(x, y);
4990 if (RB_BIGNUM_TYPE_P(y)) {
4991 return rb_big_or(y, x);
5016 return fix_or(x, y);
5018 else if (RB_BIGNUM_TYPE_P(x)) {
5019 return rb_big_or(x, y);
5032 if (RB_BIGNUM_TYPE_P(y)) {
5033 return rb_big_xor(y, x);
5058 return fix_xor(x, y);
5060 else if (RB_BIGNUM_TYPE_P(x)) {
5061 return rb_big_xor(x, y);
5074 return rb_big_lshift(rb_int2big(val), y);
5077 return fix_rshift(val, (
unsigned long)-width);
5078 return fix_lshift(val, width);
5082fix_lshift(
long val,
unsigned long width)
5084 if (width > (SIZEOF_LONG*CHAR_BIT-1)
5085 || ((
unsigned long)val)>>(SIZEOF_LONG*CHAR_BIT-1-width) > 0) {
5086 return rb_big_lshift(rb_int2big(val),
ULONG2NUM(width));
5113 return rb_fix_lshift(x, y);
5115 else if (RB_BIGNUM_TYPE_P(x)) {
5116 return rb_big_lshift(x, y);
5129 return rb_big_rshift(rb_int2big(val), y);
5131 if (i == 0)
return x;
5133 return fix_lshift(val, (
unsigned long)-i);
5134 return fix_rshift(val, i);
5138fix_rshift(
long val,
unsigned long i)
5140 if (i >=
sizeof(
long)*CHAR_BIT-1) {
5141 if (val < 0)
return INT2FIX(-1);
5144 val = RSHIFT(val, i);
5169 return rb_fix_rshift(x, y);
5171 else if (RB_BIGNUM_TYPE_P(x)) {
5172 return rb_big_rshift(x, y);
5185 idx = rb_big_norm(idx);
5187 if (!BIGNUM_SIGN(idx) || val >= 0)
5195 if (SIZEOF_LONG*CHAR_BIT-1 <= i) {
5196 if (val < 0)
return INT2FIX(1);
5218 return rb_cmpint(r, a, b);
5230 VALUE orig_num = num, beg, end;
5236 if (!
RTEST(num_negative_p(end))) {
5237 if (!excl) end = rb_int_plus(end,
INT2FIX(1));
5238 VALUE mask = generate_mask(end);
5239 if (int_zero_p(rb_int_and(num, mask))) {
5243 rb_raise(rb_eArgError,
"The beginless range for Integer#[] results in infinity");
5250 num = rb_int_rshift(num, beg);
5252 int cmp = compare_indexes(beg, end);
5253 if (!
NIL_P(end) && cmp < 0) {
5254 VALUE len = rb_int_minus(end, beg);
5257 num = rb_int_and(num, mask);
5259 else if (cmp == 0) {
5270 return rb_fix_aref(num, arg);
5272 else if (RB_BIGNUM_TYPE_P(num)) {
5273 return rb_big_aref(num, arg);
5281 num = rb_int_rshift(num, beg);
5283 num = rb_int_and(num, mask);
5327int_aref(
int const argc,
VALUE *
const argv,
VALUE const num)
5331 return int_aref2(num, argv[0], argv[1]);
5333 return int_aref1(num, argv[0]);
5363 else if (RB_BIGNUM_TYPE_P(num)) {
5364 val = rb_big2dbl(num);
5384rb_int_abs(
VALUE num)
5387 return fix_abs(num);
5389 else if (RB_BIGNUM_TYPE_P(num)) {
5390 return rb_big_abs(num);
5402rb_int_size(
VALUE num)
5405 return fix_size(num);
5407 else if (RB_BIGNUM_TYPE_P(num)) {
5408 return rb_big_size_m(num);
5414rb_fix_bit_length(
VALUE fix)
5423rb_int_bit_length(
VALUE num)
5426 return rb_fix_bit_length(num);
5428 else if (RB_BIGNUM_TYPE_P(num)) {
5429 return rb_big_bit_length(num);
5435rb_fix_digits(
VALUE fix,
long base)
5443 rb_raise(rb_eArgError,
"invalid radix %ld", base);
5446 return rb_ary_new_from_args(1,
INT2FIX(0));
5448 digits = rb_ary_new();
5461 VALUE digits, bases;
5463 assert(!rb_num_negative_p(num));
5465 if (RB_BIGNUM_TYPE_P(base))
5466 base = rb_big_norm(base);
5469 rb_raise(rb_eArgError,
"invalid radix %ld",
FIX2LONG(base));
5470 else if (RB_BIGNUM_TYPE_P(base) && BIGNUM_NEGATIVE_P(base))
5471 rb_raise(rb_eArgError,
"negative radix");
5474 return rb_fix_digits(num,
FIX2LONG(base));
5477 return rb_ary_new_from_args(1, num);
5479 if (int_lt(rb_int_div(rb_int_bit_length(num), rb_int_bit_length(base)),
INT2FIX(50))) {
5480 digits = rb_ary_new();
5482 VALUE qr = rb_int_divmod(num, base);
5489 bases = rb_ary_new();
5490 for (
VALUE b = base; int_lt(b, num) ==
Qtrue; b = rb_int_mul(b, b)) {
5491 rb_ary_push(bases, b);
5493 digits = rb_ary_new_from_args(1, num);
5495 VALUE b = rb_ary_pop(bases);
5497 for(i = last_idx; i >= 0; i--) {
5499 VALUE divmod = rb_int_divmod(n, b);
5502 if (i != last_idx || div !=
INT2FIX(0)) rb_ary_store(digits, 2 * i + 1, div);
5503 rb_ary_store(digits, 2 * i, mod);
5527rb_int_digits(
int argc,
VALUE *argv,
VALUE num)
5532 if (rb_num_negative_p(num))
5538 rb_raise(
rb_eTypeError,
"wrong argument type %s (expected Integer)",
5540 if (RB_BIGNUM_TYPE_P(base_value))
5541 return rb_int_digits_bigbase(num, base_value);
5545 rb_raise(rb_eArgError,
"negative radix");
5547 rb_raise(rb_eArgError,
"invalid radix %ld", base);
5553 return rb_fix_digits(num, base);
5554 else if (RB_BIGNUM_TYPE_P(num))
5555 return rb_int_digits_bigbase(num,
LONG2FIX(base));
5594 for (i =
FIX2LONG(from); i <= end; i++) {
5605 ensure_cmp(c, i, to);
5644 for (i=
FIX2LONG(from); i >= end; i--) {
5655 if (
NIL_P(c)) rb_cmperr(i, to);
5716 if (!
rb_scan_args(argc, argv,
"01:", &nd, &opt))
return num;
5718 mode = rb_num_get_rounding_option(opt);
5722 return rb_int_round(num, ndigits, mode);
5759 return rb_int_floor(num, ndigits);
5796 return rb_int_ceil(num, ndigits);
5823int_truncate(
int argc,
VALUE* argv,
VALUE num)
5832 return rb_int_truncate(num, ndigits);
5835#define DEFINE_INT_SQRT(rettype, prefix, argtype) \
5837prefix##_isqrt(argtype n) \
5839 if (!argtype##_IN_DOUBLE_P(n)) { \
5840 unsigned int b = bit_length(n); \
5842 rettype x = (rettype)(n >> (b/2+1)); \
5843 x |= ((rettype)1LU << (b-1)/2); \
5844 while ((t = n/x) < (argtype)x) x = (rettype)((x + t) >> 1); \
5847 return (rettype)sqrt(argtype##_TO_DOUBLE(n)); \
5850#if SIZEOF_LONG*CHAR_BIT > DBL_MANT_DIG
5851# define RB_ULONG_IN_DOUBLE_P(n) ((n) < (1UL << DBL_MANT_DIG))
5853# define RB_ULONG_IN_DOUBLE_P(n) 1
5855#define RB_ULONG_TO_DOUBLE(n) (double)(n)
5856#define RB_ULONG unsigned long
5857DEFINE_INT_SQRT(
unsigned long, rb_ulong, RB_ULONG)
5859#if 2*SIZEOF_BDIGIT > SIZEOF_LONG
5860# if 2*SIZEOF_BDIGIT*CHAR_BIT > DBL_MANT_DIG
5861# define BDIGIT_DBL_IN_DOUBLE_P(n) ((n) < ((BDIGIT_DBL)1UL << DBL_MANT_DIG))
5863# define BDIGIT_DBL_IN_DOUBLE_P(n) 1
5865# ifdef ULL_TO_DOUBLE
5866# define BDIGIT_DBL_TO_DOUBLE(n) ULL_TO_DOUBLE(n)
5868# define BDIGIT_DBL_TO_DOUBLE(n) (double)(n)
5870DEFINE_INT_SQRT(BDIGIT, rb_bdigit_dbl, BDIGIT_DBL)
5873#define domain_error(msg) \
5874 rb_raise(rb_eMathDomainError, "Numerical argument is out of domain - " #msg)
5911 unsigned long n, sq;
5914 if (FIXNUM_NEGATIVE_P(num)) {
5915 domain_error(
"isqrt");
5918 sq = rb_ulong_isqrt(n);
5924 domain_error(
"isqrt");
5926 biglen = BIGNUM_LEN(num);
5927 if (biglen == 0)
return INT2FIX(0);
5928#if SIZEOF_BDIGIT <= SIZEOF_LONG
5931 n = BIGNUM_DIGITS(num)[0];
5932 sq = rb_ulong_isqrt(n);
5936 return rb_big_isqrt(num);
5959 return rb_check_integer_type(num);
6241 rb_fix_to_s_static[0] = rb_fstring_literal(
"0");
6242 rb_fix_to_s_static[1] = rb_fstring_literal(
"1");
6243 rb_fix_to_s_static[2] = rb_fstring_literal(
"2");
6244 rb_fix_to_s_static[3] = rb_fstring_literal(
"3");
6245 rb_fix_to_s_static[4] = rb_fstring_literal(
"4");
6246 rb_fix_to_s_static[5] = rb_fstring_literal(
"5");
6247 rb_fix_to_s_static[6] = rb_fstring_literal(
"6");
6248 rb_fix_to_s_static[7] = rb_fstring_literal(
"7");
6249 rb_fix_to_s_static[8] = rb_fstring_literal(
"8");
6250 rb_fix_to_s_static[9] = rb_fstring_literal(
"9");
6251 for(
int i = 0; i < 10; i++) {
6252 rb_gc_register_mark_object(rb_fix_to_s_static[i]);
6378#undef rb_float_value
6382 return rb_float_value_inline(v);
6387rb_float_new(
double d)
6389 return rb_float_new_inline(d);
6392#include "numeric.rbinc"
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
VALUE rb_float_new_in_heap(double d)
Identical to rb_float_new(), except it does not generate Flonums.
void rb_include_module(VALUE klass, VALUE module)
Includes a module to a class.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
VALUE rb_singleton_class(VALUE obj)
Finds or creates the singleton class of the passed object.
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
void rb_undef_method(VALUE klass, const char *name)
Defines an undef of a method.
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
int rb_block_given_p(void)
Determines if the current method is given a block.
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
Keyword argument deconstructor.
#define T_COMPLEX
Old name of RUBY_T_COMPLEX.
#define TYPE(_)
Old name of rb_type.
#define NEWOBJ_OF
Old name of RB_NEWOBJ_OF.
#define RB_INTEGER_TYPE_P
Old name of rb_integer_type_p.
#define NUM2LL
Old name of RB_NUM2LL.
#define RFLOAT_VALUE
Old name of rb_float_value.
#define T_STRING
Old name of RUBY_T_STRING.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define T_FLOAT
Old name of RUBY_T_FLOAT.
#define ID2SYM
Old name of RB_ID2SYM.
#define SPECIAL_CONST_P
Old name of RB_SPECIAL_CONST_P.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
#define ULONG2NUM
Old name of RB_ULONG2NUM.
#define T_FIXNUM
Old name of RUBY_T_FIXNUM.
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define FIXNUM_FLAG
Old name of RUBY_FIXNUM_FLAG.
#define CLASS_OF
Old name of rb_class_of.
#define FIXABLE
Old name of RB_FIXABLE.
#define LONG2FIX
Old name of RB_INT2FIX.
#define FIX2INT
Old name of RB_FIX2INT.
#define FIX2ULONG
Old name of RB_FIX2ULONG.
#define T_TRUE
Old name of RUBY_T_TRUE.
#define T_RATIONAL
Old name of RUBY_T_RATIONAL.
#define NUM2DBL
Old name of rb_num2dbl.
#define LONG2NUM
Old name of RB_LONG2NUM.
#define rb_usascii_str_new2
Old name of rb_usascii_str_new_cstr.
#define T_FALSE
Old name of RUBY_T_FALSE.
#define Qtrue
Old name of RUBY_Qtrue.
#define ST2FIX
Old name of RB_ST2FIX.
#define NUM2INT
Old name of RB_NUM2INT.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define FIX2LONG
Old name of RB_FIX2LONG.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
#define NIL_P
Old name of RB_NIL_P.
#define NUM2ULL
Old name of RB_NUM2ULL.
#define FL_WB_PROTECTED
Old name of RUBY_FL_WB_PROTECTED.
#define POSFIXABLE
Old name of RB_POSFIXABLE.
#define DBL2NUM
Old name of rb_float_new.
#define BUILTIN_TYPE
Old name of RB_BUILTIN_TYPE.
#define NUM2LONG
Old name of RB_NUM2LONG.
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define ISALNUM
Old name of rb_isalnum.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
VALUE rb_eNotImpError
NotImplementedError exception.
void rb_name_error(ID id, const char *fmt,...)
Raises an instance of rb_eNameError.
VALUE rb_eZeroDivError
ZeroDivisionError exception.
VALUE rb_eStandardError
StandardError exception.
VALUE rb_eRangeError
RangeError exception.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_eFloatDomainError
FloatDomainError exception.
VALUE rb_eMathDomainError
Math::DomainError exception.
VALUE rb_Float(VALUE val)
This is the logic behind Kernel#Float.
VALUE rb_any_to_s(VALUE obj)
Generates a textual representation of the given object.
VALUE rb_cInteger
Module class.
VALUE rb_cNumeric
Numeric class.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_inspect(VALUE obj)
Generates a human-readable textual representation of the given object.
VALUE rb_equal(VALUE lhs, VALUE rhs)
This function is an optimised version of calling #==.
VALUE rb_obj_is_kind_of(VALUE obj, VALUE klass)
Queries if the given object is an instance (of possibly descendants) of the given class.
VALUE rb_mComparable
Comparable module.
VALUE rb_cFloat
Float class.
VALUE rb_to_int(VALUE val)
Identical to rb_check_to_int(), except it raises in case of conversion mismatch.
VALUE rb_enc_uint_chr(unsigned int code, rb_encoding *enc)
Encodes the passed code point into a series of bytes.
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
#define RGENGC_WB_PROTECTED_FLOAT
This is a compile-time flag to enable/disable write barrier for struct RFloat.
#define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn)
This roughly resembles return enum_for(__callee__) unless block_given?.
#define SIZED_ENUMERATOR_KW(obj, argc, argv, size_fn, kw_splat)
This is an implementation detail of RETURN_SIZED_ENUMERATOR_KW().
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
void rb_num_zerodiv(void)
Just always raises an exception.
VALUE rb_num2fix(VALUE val)
Converts a numeric value into a Fixnum.
VALUE rb_fix2str(VALUE val, int base)
Generates a place-value representation of the given Fixnum, with given radix.
VALUE rb_dbl_cmp(double lhs, double rhs)
Compares two doubles.
VALUE rb_num_coerce_bit(VALUE lhs, VALUE rhs, ID op)
This one is optimised for bitwise operations, but the API is identical to rb_num_coerce_bin().
VALUE rb_num_coerce_relop(VALUE lhs, VALUE rhs, ID op)
Identical to rb_num_coerce_cmp(), except for return values.
VALUE rb_num_coerce_cmp(VALUE lhs, VALUE rhs, ID op)
Identical to rb_num_coerce_bin(), except for return values.
VALUE rb_num_coerce_bin(VALUE lhs, VALUE rhs, ID op)
Coerced binary operation.
int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp)
Deconstructs a range into its components.
VALUE rb_rational_raw(VALUE num, VALUE den)
Identical to rb_rational_new(), except it skips argument validations.
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
#define rb_usascii_str_new(str, len)
Identical to rb_str_new, except it generates a string of "US ASCII" encoding.
#define rb_usascii_str_new_cstr(str)
Identical to rb_str_new_cstr, except it generates a string of "US ASCII" encoding.
void rb_must_asciicompat(VALUE obj)
Asserts that the given string's encoding is (Ruby's definition of) ASCII compatible.
VALUE rb_check_string_type(VALUE obj)
Try converting an object to its stringised representation using its to_str method,...
VALUE rb_exec_recursive(VALUE(*f)(VALUE g, VALUE h, int r), VALUE g, VALUE h)
"Recursion" API entry point.
VALUE rb_exec_recursive_paired(VALUE(*f)(VALUE g, VALUE h, int r), VALUE g, VALUE p, VALUE h)
Identical to rb_exec_recursive(), except it checks for the recursion on the ordered pair of { g,...
void rb_undef_alloc_func(VALUE klass)
Deletes the allocator function of a class.
VALUE rb_check_funcall(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv(), except it returns RUBY_Qundef instead of raising rb_eNoMethodError.
void rb_remove_method_id(VALUE klass, ID mid)
Identical to rb_remove_method(), except it accepts the method name as ID.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
VALUE rb_sym2str(VALUE id)
Identical to rb_id2str(), except it takes an instance of rb_cSymbol rather than an ID.
void rb_define_const(VALUE klass, const char *name, VALUE val)
Defines a Ruby level constant under a namespace.
int len
Length of the buffer.
unsigned long rb_num2uint(VALUE num)
Converts an instance of rb_cNumeric into C's unsigned long.
long rb_fix2int(VALUE num)
Identical to rb_num2int().
long rb_num2int(VALUE num)
Converts an instance of rb_cNumeric into C's long.
unsigned long rb_fix2uint(VALUE num)
Identical to rb_num2uint().
LONG_LONG rb_num2ll(VALUE num)
Converts an instance of rb_cNumeric into C's long long.
unsigned LONG_LONG rb_num2ull(VALUE num)
Converts an instance of rb_cNumeric into C's unsigned long long.
VALUE rb_yield(VALUE val)
Yields the block.
#define RB_FIX2ULONG
Just another name of rb_fix2ulong.
void rb_out_of_int(SIGNED_VALUE num)
This is an utility function to raise an rb_eRangeError.
long rb_num2long(VALUE num)
Converts an instance of rb_cNumeric into C's long.
unsigned long rb_num2ulong(VALUE num)
Converts an instance of rb_cNumeric into C's unsigned long.
#define RARRAY_LEN
Just another name of rb_array_len.
static int RARRAY_LENINT(VALUE ary)
Identical to rb_array_len(), except it differs for the return type.
#define RARRAY_AREF(a, i)
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
static bool RBIGNUM_NEGATIVE_P(VALUE b)
Checks if the bignum is negative.
const char * rb_obj_classname(VALUE obj)
Queries the name of the class of the passed object.
short rb_num2short(VALUE num)
Converts an instance of rb_cNumeric into C's short.
unsigned short rb_num2ushort(VALUE num)
Converts an instance of rb_cNumeric into C's unsigned short.
short rb_fix2short(VALUE num)
Identical to rb_num2short().
unsigned short rb_fix2ushort(VALUE num)
Identical to rb_num2ushort().
#define RTEST
This is an old name of RB_TEST.
intptr_t SIGNED_VALUE
A signed integer type that has the same width with VALUE.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
#define SIZEOF_VALUE
Identical to sizeof(VALUE), except it is a macro that can also be used inside of preprocessor directi...
uintptr_t VALUE
Type that represents a Ruby object.
static bool RB_FLOAT_TYPE_P(VALUE obj)
Queries if the object is an instance of rb_cFloat.