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)
2378 if (int_round_zero_p(num, ndigits))
2380 f = int_pow(10, -ndigits);
2384 if (neg) x = -x + y - 1;
2393 return rb_int_minus(num, rb_int_modulo(num, f));
2397rb_int_ceil(
VALUE num,
int ndigits)
2401 if (int_round_zero_p(num, ndigits))
2403 f = int_pow(10, -ndigits);
2417 return rb_int_plus(num, rb_int_minus(f, rb_int_modulo(num, f)));
2421rb_int_truncate(
VALUE num,
int ndigits)
2426 if (int_round_zero_p(num, ndigits))
2428 f = int_pow(10, -ndigits);
2441 m = rb_int_modulo(num, f);
2442 if (int_neg_p(num)) {
2443 return rb_int_plus(num, rb_int_minus(f, m));
2446 return rb_int_minus(num, m);
2508 double number, f, x;
2511 enum ruby_num_rounding_mode mode;
2516 mode = rb_num_get_rounding_option(opt);
2518 if (number == 0.0) {
2522 return rb_int_round(flo_to_i(num), ndigits, mode);
2525 x = ROUND_CALL(mode, round, (number, 1.0));
2528 if (isfinite(number)) {
2530 frexp(number, &binexp);
2531 if (float_round_overflow(ndigits, binexp))
return num;
2532 if (float_round_underflow(ndigits, binexp))
return DBL2NUM(0);
2535 return rb_flo_round_by_rational(argc, argv, num);
2537 f = pow(10, ndigits);
2538 x = ROUND_CALL(mode, round, (number, f));
2545float_round_overflow(
int ndigits,
int binexp)
2547 enum {float_dig = DBL_DIG+2};
2566 if (ndigits >= float_dig - (binexp > 0 ? binexp / 4 : binexp / 3 - 1)) {
2573float_round_underflow(
int ndigits,
int binexp)
2575 if (ndigits < - (binexp > 0 ? binexp / 3 + 1 : binexp / 4)) {
2602 if (f > 0.0) f = floor(f);
2603 if (f < 0.0) f = ceil(f);
2644flo_truncate(
int argc,
VALUE *argv,
VALUE num)
2647 return flo_ceil(argc, argv, num);
2649 return flo_floor(argc, argv, num);
2666 return flo_floor(argc, argv,
rb_Float(num));
2683 return flo_ceil(argc, argv,
rb_Float(num));
2700 return flo_round(argc, argv,
rb_Float(num));
2715num_truncate(
int argc,
VALUE *argv,
VALUE num)
2717 return flo_truncate(argc, argv,
rb_Float(num));
2721ruby_float_step_size(
double beg,
double end,
double unit,
int excl)
2723 const double epsilon = DBL_EPSILON;
2730 return unit > 0 ? beg <= end : beg >= end;
2732 n= (end - beg)/unit;
2733 err = (fabs(beg) + fabs(end) + fabs(end-beg)) / fabs(unit) * epsilon;
2734 if (err>0.5) err=0.5;
2741 d = +((n + 1) * unit) + beg;
2746 else if (beg > end) {
2754 d = +((n + 1) * unit) + beg;
2759 else if (beg > end) {
2768ruby_float_step(
VALUE from,
VALUE to,
VALUE step,
int excl,
int allow_endless)
2773 double end = (allow_endless &&
NIL_P(to)) ? (unit < 0 ? -1 : 1)*HUGE_VAL :
NUM2DBL(to);
2774 double n = ruby_float_step_size(beg, end, unit, excl);
2781 else if (unit == 0) {
2787 for (i=0; i<n; i++) {
2788 double d = i*unit+beg;
2789 if (unit >= 0 ? end < d : d < end) d = end;
2799ruby_num_interval_step_size(
VALUE from,
VALUE to,
VALUE step,
int excl)
2824 if (isinf(n))
return DBL2NUM(n);
2826 return rb_dbl2big(n);
2832 case 0:
return DBL2NUM(HUGE_VAL);
2833 case -1: cmp =
'<';
break;
2845num_step_negative_p(
VALUE num)
2855 else if (RB_BIGNUM_TYPE_P(num)) {
2857 return BIGNUM_NEGATIVE_P(num);
2862 coerce_failed(num,
INT2FIX(0));
2872 argc =
rb_scan_args(argc, argv,
"02:", to, step, &hash);
2879 if (!UNDEF_P(values[0])) {
2880 if (argc > 0) rb_raise(rb_eArgError,
"to is given twice");
2883 if (!UNDEF_P(values[1])) {
2884 if (argc > 1) rb_raise(rb_eArgError,
"step is given twice");
2893num_step_check_fix_args(
int argc,
VALUE *to,
VALUE *step,
VALUE by,
int fix_nil,
int allow_zero_step)
2901 if (argc > 1 &&
NIL_P(*step)) {
2906 rb_raise(rb_eArgError,
"step can't be 0");
2911 desc = num_step_negative_p(*step);
2912 if (fix_nil &&
NIL_P(*to)) {
2919num_step_scan_args(
int argc,
const VALUE *argv,
VALUE *to,
VALUE *step,
int fix_nil,
int allow_zero_step)
2922 argc = num_step_extract_args(argc, argv, to, step, &by);
2923 return num_step_check_fix_args(argc, to, step, by, fix_nil, allow_zero_step);
2933 num_step_scan_args(argc, argv, &to, &step, TRUE, FALSE);
2935 return ruby_num_interval_step_size(from, to, step, FALSE);
3043 num_step_extract_args(argc, argv, &to, &step, &by);
3051 rb_raise(rb_eArgError,
"step can't be 0");
3055 return rb_arith_seq_new(from,
ID2SYM(rb_frame_this_func()), argc, argv,
3056 num_step_size, from, to, step, FALSE);
3062 desc = num_step_scan_args(argc, argv, &to, &step, TRUE, FALSE);
3068 inf = isinf(f) && (signbit(f) ? desc : !desc);
3084 for (; i >= end; i += diff)
3088 for (; i <= end; i += diff)
3093 else if (!ruby_float_step(from, to, step, FALSE, FALSE)) {
3101 ID cmp = desc ?
'<' :
'>';
3111out_of_range_float(
char (*pbuf)[24],
VALUE val)
3113 char *
const buf = *pbuf;
3116 snprintf(buf,
sizeof(*pbuf),
"%-.10g",
RFLOAT_VALUE(val));
3117 if ((s = strchr(buf,
' ')) != 0) *s =
'\0';
3121#define FLOAT_OUT_OF_RANGE(val, type) do { \
3123 rb_raise(rb_eRangeError, "float %s out of range of "type, \
3124 out_of_range_float(&buf, (val))); \
3127#define LONG_MIN_MINUS_ONE ((double)LONG_MIN-1)
3128#define LONG_MAX_PLUS_ONE (2*(double)(LONG_MAX/2+1))
3129#define ULONG_MAX_PLUS_ONE (2*(double)(ULONG_MAX/2+1))
3130#define LONG_MIN_MINUS_ONE_IS_LESS_THAN(n) \
3131 (LONG_MIN_MINUS_ONE == (double)LONG_MIN ? \
3133 LONG_MIN_MINUS_ONE < (n))
3140 rb_raise(
rb_eTypeError,
"no implicit conversion from nil to integer");
3147 && LONG_MIN_MINUS_ONE_IS_LESS_THAN(
RFLOAT_VALUE(val))) {
3151 FLOAT_OUT_OF_RANGE(val,
"integer");
3154 else if (RB_BIGNUM_TYPE_P(val)) {
3155 return rb_big2long(val);
3164rb_num2ulong_internal(
VALUE val,
int *wrap_p)
3168 rb_raise(
rb_eTypeError,
"no implicit conversion of nil into Integer");
3175 return (
unsigned long)l;
3179 if (d < ULONG_MAX_PLUS_ONE && LONG_MIN_MINUS_ONE_IS_LESS_THAN(d)) {
3181 *wrap_p = d <= -1.0;
3183 return (
unsigned long)d;
3184 return (
unsigned long)(long)d;
3187 FLOAT_OUT_OF_RANGE(val,
"integer");
3190 else if (RB_BIGNUM_TYPE_P(val)) {
3192 unsigned long ul = rb_big2ulong(val);
3194 *wrap_p = BIGNUM_NEGATIVE_P(val);
3207 return rb_num2ulong_internal(val, NULL);
3213 rb_raise(
rb_eRangeError,
"integer %"PRIdVALUE
" too %s to convert to `int'",
3214 num, num < 0 ?
"small" :
"big");
3217#if SIZEOF_INT < SIZEOF_LONG
3221 if ((
long)(
int)num != num) {
3227check_uint(
unsigned long num,
int sign)
3231 if (num < (
unsigned long)INT_MIN)
3232 rb_raise(
rb_eRangeError,
"integer %ld too small to convert to `unsigned int'", (
long)num);
3237 rb_raise(
rb_eRangeError,
"integer %lu too big to convert to `unsigned int'", num);
3263 unsigned long num = rb_num2ulong_internal(val, &wrap);
3265 check_uint(num, wrap);
3279 check_uint(num, FIXNUM_NEGATIVE_P(val));
3308NORETURN(
static void rb_out_of_short(
SIGNED_VALUE num));
3312 rb_raise(
rb_eRangeError,
"integer %"PRIdVALUE
" too %s to convert to `short'",
3313 num, num < 0 ?
"small" :
"big");
3317check_short(
long num)
3319 if ((
long)(
short)num != num) {
3320 rb_out_of_short(num);
3325check_ushort(
unsigned long num,
int sign)
3329 if (num < (
unsigned long)SHRT_MIN)
3330 rb_raise(
rb_eRangeError,
"integer %ld too small to convert to `unsigned short'", (
long)num);
3334 if (USHRT_MAX < num)
3335 rb_raise(
rb_eRangeError,
"integer %lu too big to convert to `unsigned short'", num);
3361 unsigned long num = rb_num2ulong_internal(val, &wrap);
3363 check_ushort(num, wrap);
3377 check_ushort(num, FIXNUM_NEGATIVE_P(val));
3390 rb_raise(
rb_eRangeError,
"integer %ld out of range of fixnum", v);
3396#define LLONG_MIN_MINUS_ONE ((double)LLONG_MIN-1)
3397#define LLONG_MAX_PLUS_ONE (2*(double)(LLONG_MAX/2+1))
3398#define ULLONG_MAX_PLUS_ONE (2*(double)(ULLONG_MAX/2+1))
3400#define ULLONG_MAX ((unsigned LONG_LONG)LLONG_MAX*2+1)
3402#define LLONG_MIN_MINUS_ONE_IS_LESS_THAN(n) \
3403 (LLONG_MIN_MINUS_ONE == (double)LLONG_MIN ? \
3405 LLONG_MIN_MINUS_ONE < (n))
3418 if (d < LLONG_MAX_PLUS_ONE && (LLONG_MIN_MINUS_ONE_IS_LESS_THAN(d))) {
3422 FLOAT_OUT_OF_RANGE(val,
"long long");
3425 else if (RB_BIGNUM_TYPE_P(val)) {
3426 return rb_big2ll(val);
3428 else if (RB_TYPE_P(val,
T_STRING)) {
3429 rb_raise(
rb_eTypeError,
"no implicit conversion from string");
3431 else if (RB_TYPE_P(val,
T_TRUE) || RB_TYPE_P(val,
T_FALSE)) {
3432 rb_raise(
rb_eTypeError,
"no implicit conversion from boolean");
3443 rb_raise(
rb_eTypeError,
"no implicit conversion of nil into Integer");
3450 if (d < ULLONG_MAX_PLUS_ONE && LLONG_MIN_MINUS_ONE_IS_LESS_THAN(d)) {
3456 FLOAT_OUT_OF_RANGE(val,
"unsigned long long");
3459 else if (RB_BIGNUM_TYPE_P(val)) {
3460 return rb_big2ull(val);
3565rb_int_odd_p(
VALUE num)
3568 return RBOOL(num & 2);
3571 assert(RB_BIGNUM_TYPE_P(num));
3572 return rb_big_odd_p(num);
3577int_even_p(
VALUE num)
3580 return RBOOL((num & 2) == 0);
3583 assert(RB_BIGNUM_TYPE_P(num));
3584 return rb_big_even_p(num);
3589rb_int_even_p(
VALUE num)
3591 return int_even_p(num);
3621 return rb_int_equal(rb_int_and(num, mask), mask);
3651 return RBOOL(!int_zero_p(rb_int_and(num, mask)));
3681 return RBOOL(int_zero_p(rb_int_and(num, mask)));
3697rb_int_succ(
VALUE num)
3703 if (RB_BIGNUM_TYPE_P(num)) {
3704 return rb_big_plus(num,
INT2FIX(1));
3706 return num_funcall1(num,
'+',
INT2FIX(1));
3709#define int_succ rb_int_succ
3725rb_int_pred(
VALUE num)
3731 if (RB_BIGNUM_TYPE_P(num)) {
3732 return rb_big_minus(num,
INT2FIX(1));
3734 return num_funcall1(num,
'-',
INT2FIX(1));
3737#define int_pred rb_int_pred
3744 switch (n = rb_enc_codelen(code, enc)) {
3745 case ONIGERR_INVALID_CODE_POINT_VALUE:
3746 rb_raise(
rb_eRangeError,
"invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
3748 case ONIGERR_TOO_BIG_WIDE_CHAR_VALUE:
3753 str = rb_enc_str_new(0, n, enc);
3754 rb_enc_mbcput(code, RSTRING_PTR(str), enc);
3755 if (rb_enc_precise_mbclen(RSTRING_PTR(str), RSTRING_END(str), enc) != n) {
3756 rb_raise(
rb_eRangeError,
"invalid codepoint 0x%X in %s", code, rb_enc_name(enc));
3787 if (rb_num_to_uint(num, &i) == 0) {
3799 enc = rb_default_internal_encoding();
3815 rb_error_arity(argc, 0, 1);
3817 enc = rb_to_encoding(argv[0]);
3818 if (!enc) enc = rb_ascii8bit_encoding();
3828fix_uminus(
VALUE num)
3834rb_int_uminus(
VALUE num)
3837 return fix_uminus(num);
3840 assert(RB_BIGNUM_TYPE_P(num));
3841 return rb_big_uminus(num);
3848 char buf[
SIZEOF_VALUE*CHAR_BIT + 1], *
const e = buf +
sizeof buf, *b = e;
3853 if (base < 2 || 36 < base) {
3854 rb_raise(rb_eArgError,
"invalid radix %d", base);
3856#if SIZEOF_LONG < SIZEOF_VOIDP
3857# if SIZEOF_VOIDP == SIZEOF_LONG_LONG
3858 if ((val >= 0 && (x & 0xFFFFFFFF00000000ull)) ||
3859 (val < 0 && (x & 0xFFFFFFFF00000000ull) != 0xFFFFFFFF00000000ull)) {
3860 rb_bug(
"Unnormalized Fixnum value %p", (
void *)x);
3871 u = 1 + (
unsigned long)(-(val + 1));
3878 *--b = ruby_digitmap[(int)(u % base)];
3879 }
while (u /= base);
3887static VALUE rb_fix_to_s_static[10];
3893 if (i >= 0 && i < 10) {
3894 return rb_fix_to_s_static[i];
3926 return rb_int2str(x, base);
3930rb_int2str(
VALUE x,
int base)
3935 else if (RB_BIGNUM_TYPE_P(x)) {
3936 return rb_big2str(x, base);
3946 return rb_fix_plus_fix(x, y);
3948 else if (RB_BIGNUM_TYPE_P(y)) {
3949 return rb_big_plus(y, x);
3955 return rb_complex_plus(y, x);
3965 return fix_plus(x, y);
3987 return fix_plus(x, y);
3989 else if (RB_BIGNUM_TYPE_P(x)) {
3990 return rb_big_plus(x, y);
3999 return rb_fix_minus_fix(x, y);
4001 else if (RB_BIGNUM_TYPE_P(y)) {
4003 return rb_big_minus(x, y);
4032 return fix_minus(x, y);
4034 else if (RB_BIGNUM_TYPE_P(x)) {
4035 return rb_big_minus(x, y);
4041#define SQRT_LONG_MAX HALF_LONG_MSB
4043#define FIT_SQRT_LONG(n) (((n)<SQRT_LONG_MAX)&&((n)>=-SQRT_LONG_MAX))
4049 return rb_fix_mul_fix(x, y);
4051 else if (RB_BIGNUM_TYPE_P(y)) {
4056 return rb_big_mul(y, x);
4062 return rb_complex_mul(y, x);
4087 return fix_mul(x, y);
4089 else if (RB_BIGNUM_TYPE_P(x)) {
4090 return rb_big_mul(x, y);
4100#if SIZEOF_LONG * CHAR_BIT > DBL_MANT_DIG
4101 if ((iy < 0 ? -iy : iy) >= (1L << DBL_MANT_DIG)) {
4102 return rb_big_fdiv_double(rb_int2big(
FIX2LONG(x)), rb_int2big(iy));
4105 return double_div_double(
FIX2LONG(x), iy);
4107 else if (RB_BIGNUM_TYPE_P(y)) {
4108 return rb_big_fdiv_double(rb_int2big(
FIX2LONG(x)), y);
4122 VALUE gcd = rb_gcd(x, y);
4123 if (!FIXNUM_ZERO_P(gcd) && gcd !=
INT2FIX(1)) {
4124 x = rb_int_idiv(x, gcd);
4125 y = rb_int_idiv(y, gcd);
4129 return fix_fdiv_double(x, y);
4131 else if (RB_BIGNUM_TYPE_P(x)) {
4132 return rb_big_fdiv_double(x, y);
4159 return DBL2NUM(rb_int_fdiv_double(x, y));
4169 return rb_fix_div_fix(x, y);
4171 else if (RB_BIGNUM_TYPE_P(y)) {
4173 return rb_big_div(x, y);
4178 return rb_flo_div_flo(
DBL2NUM(d), y);
4183 v = fix_divide(x, y,
'/');
4184 return flo_floor(0, 0, v);
4190 return rb_rational_reciprocal(y);
4198 return fix_divide(x, y,
'/');
4224 return fix_div(x, y);
4226 else if (RB_BIGNUM_TYPE_P(x)) {
4227 return rb_big_div(x, y);
4235 return fix_divide(x, y, id_div);
4260 return fix_idiv(x, y);
4262 else if (RB_BIGNUM_TYPE_P(x)) {
4263 return rb_big_idiv(x, y);
4265 return num_div(x, y);
4273 return rb_fix_mod_fix(x, y);
4275 else if (RB_BIGNUM_TYPE_P(y)) {
4277 return rb_big_modulo(x, y);
4319 return fix_mod(x, y);
4321 else if (RB_BIGNUM_TYPE_P(x)) {
4322 return rb_big_modulo(x, y);
4324 return num_modulo(x, y);
4355 VALUE z = fix_mod(x, y);
4358 z = fix_minus(z, y);
4361 else if (!RB_BIGNUM_TYPE_P(y)) {
4362 return num_remainder(x, y);
4366 else if (!RB_BIGNUM_TYPE_P(x)) {
4369 return rb_big_remainder(x, y);
4378 rb_fix_divmod_fix(x, y, &div, &mod);
4379 return rb_assoc_new(div, mod);
4381 else if (RB_BIGNUM_TYPE_P(y)) {
4383 return rb_big_divmod(x, y);
4388 volatile VALUE a, b;
4393 return rb_assoc_new(a, b);
4430 return fix_divmod(x, y);
4432 else if (RB_BIGNUM_TYPE_P(x)) {
4433 return rb_big_divmod(x, y);
4455int_pow(
long x,
unsigned long y)
4460 if (y == 0)
return INT2FIX(1);
4469 while (y % 2 == 0) {
4470 if (!FIT_SQRT_LONG(x)) {
4477 if (MUL_OVERFLOW_FIXNUM_P(x, z)) {
4488 v = rb_big_pow(rb_int2big(x),
LONG2NUM(y));
4491 if (z != 1) v = rb_big_mul(rb_int2big(neg ? -z : z), v);
4496rb_int_positive_pow(
long x,
unsigned long y)
4498 return int_pow(x, y);
4509 VALUE y = rb_int_pow(x, minusb);
4529 if (a == 1)
return INT2FIX(1);
4530 if (a == -1)
return INT2FIX(b % 2 ? -1 : 1);
4531 if (b < 0)
return fix_pow_inverted(x, fix_uminus(y));
4532 if (b == 0)
return INT2FIX(1);
4533 if (b == 1)
return x;
4534 if (a == 0)
return INT2FIX(0);
4535 return int_pow(a, b);
4537 else if (RB_BIGNUM_TYPE_P(y)) {
4538 if (a == 1)
return INT2FIX(1);
4539 if (a == -1)
return INT2FIX(int_even_p(y) ? 1 : -1);
4540 if (BIGNUM_NEGATIVE_P(y))
return fix_pow_inverted(x, rb_big_uminus(y));
4541 if (a == 0)
return INT2FIX(0);
4543 return rb_big_pow(x, y);
4547 if (dy == 0.0)
return DBL2NUM(1.0);
4549 return DBL2NUM(dy < 0 ? HUGE_VAL : 0.0);
4551 if (a == 1)
return DBL2NUM(1.0);
4552 if (a < 0 && dy != round(dy))
4553 return rb_dbl_complex_new_polar_pi(pow(-(
double)a, dy), dy);
4554 return DBL2NUM(pow((
double)a, dy));
4580 return fix_pow(x, y);
4582 else if (RB_BIGNUM_TYPE_P(x)) {
4583 return rb_big_pow(x, y);
4591 VALUE z = rb_int_pow(x, y);
4592 if (!
NIL_P(z))
return z;
4597 return rb_complex_pow(x, y);
4599 return rb_rational_pow(x, y);
4609 if (x == y)
return Qtrue;
4611 else if (RB_BIGNUM_TYPE_P(y)) {
4612 return rb_big_eq(y, x);
4615 return rb_integer_float_eq(x, y);
4618 return num_equal(x, y);
4638 return fix_equal(x, y);
4640 else if (RB_BIGNUM_TYPE_P(x)) {
4641 return rb_big_eq(x, y);
4649 if (x == y)
return INT2FIX(0);
4654 else if (RB_BIGNUM_TYPE_P(y)) {
4655 VALUE cmp = rb_big_cmp(y, x);
4663 return rb_integer_float_cmp(x, y);
4700 return fix_cmp(x, y);
4702 else if (RB_BIGNUM_TYPE_P(x)) {
4703 return rb_big_cmp(x, y);
4716 else if (RB_BIGNUM_TYPE_P(y)) {
4717 return RBOOL(rb_big_cmp(y, x) ==
INT2FIX(-1));
4720 return RBOOL(rb_integer_float_cmp(x, y) ==
INT2FIX(1));
4747 return fix_gt(x, y);
4749 else if (RB_BIGNUM_TYPE_P(x)) {
4750 return rb_big_gt(x, y);
4761 else if (RB_BIGNUM_TYPE_P(y)) {
4762 return RBOOL(rb_big_cmp(y, x) !=
INT2FIX(+1));
4765 VALUE rel = rb_integer_float_cmp(x, y);
4794 return fix_ge(x, y);
4796 else if (RB_BIGNUM_TYPE_P(x)) {
4797 return rb_big_ge(x, y);
4808 else if (RB_BIGNUM_TYPE_P(y)) {
4809 return RBOOL(rb_big_cmp(y, x) ==
INT2FIX(+1));
4812 return RBOOL(rb_integer_float_cmp(x, y) ==
INT2FIX(-1));
4839 return fix_lt(x, y);
4841 else if (RB_BIGNUM_TYPE_P(x)) {
4842 return rb_big_lt(x, y);
4853 else if (RB_BIGNUM_TYPE_P(y)) {
4854 return RBOOL(rb_big_cmp(y, x) !=
INT2FIX(-1));
4857 VALUE rel = rb_integer_float_cmp(x, y);
4886 return fix_le(x, y);
4888 else if (RB_BIGNUM_TYPE_P(x)) {
4889 return rb_big_le(x, y);
4901rb_int_comp(
VALUE num)
4904 return fix_comp(num);
4906 else if (RB_BIGNUM_TYPE_P(num)) {
4907 return rb_big_comp(num);
4913num_funcall_bit_1(
VALUE y,
VALUE arg,
int recursive)
4918 num_funcall_op_1_recursion(x, func, y);
4928 args[0] = (
VALUE)func;
4931 do_coerce(&args[1], &args[2], TRUE);
4933 args[2], args[1], (
VALUE)args);
4936 coerce_failed(x, y);
4949 if (RB_BIGNUM_TYPE_P(y)) {
4950 return rb_big_and(y, x);
4975 return fix_and(x, y);
4977 else if (RB_BIGNUM_TYPE_P(x)) {
4978 return rb_big_and(x, y);
4991 if (RB_BIGNUM_TYPE_P(y)) {
4992 return rb_big_or(y, x);
5017 return fix_or(x, y);
5019 else if (RB_BIGNUM_TYPE_P(x)) {
5020 return rb_big_or(x, y);
5033 if (RB_BIGNUM_TYPE_P(y)) {
5034 return rb_big_xor(y, x);
5059 return fix_xor(x, y);
5061 else if (RB_BIGNUM_TYPE_P(x)) {
5062 return rb_big_xor(x, y);
5075 return rb_big_lshift(rb_int2big(val), y);
5078 return fix_rshift(val, (
unsigned long)-width);
5079 return fix_lshift(val, width);
5083fix_lshift(
long val,
unsigned long width)
5085 if (width > (SIZEOF_LONG*CHAR_BIT-1)
5086 || ((
unsigned long)val)>>(SIZEOF_LONG*CHAR_BIT-1-width) > 0) {
5087 return rb_big_lshift(rb_int2big(val),
ULONG2NUM(width));
5114 return rb_fix_lshift(x, y);
5116 else if (RB_BIGNUM_TYPE_P(x)) {
5117 return rb_big_lshift(x, y);
5130 return rb_big_rshift(rb_int2big(val), y);
5132 if (i == 0)
return x;
5134 return fix_lshift(val, (
unsigned long)-i);
5135 return fix_rshift(val, i);
5139fix_rshift(
long val,
unsigned long i)
5141 if (i >=
sizeof(
long)*CHAR_BIT-1) {
5142 if (val < 0)
return INT2FIX(-1);
5145 val = RSHIFT(val, i);
5170 return rb_fix_rshift(x, y);
5172 else if (RB_BIGNUM_TYPE_P(x)) {
5173 return rb_big_rshift(x, y);
5186 idx = rb_big_norm(idx);
5188 if (!BIGNUM_SIGN(idx) || val >= 0)
5196 if (SIZEOF_LONG*CHAR_BIT-1 <= i) {
5197 if (val < 0)
return INT2FIX(1);
5219 return rb_cmpint(r, a, b);
5231 VALUE orig_num = num, beg, end;
5237 if (!
RTEST(num_negative_p(end))) {
5238 if (!excl) end = rb_int_plus(end,
INT2FIX(1));
5239 VALUE mask = generate_mask(end);
5240 if (int_zero_p(rb_int_and(num, mask))) {
5244 rb_raise(rb_eArgError,
"The beginless range for Integer#[] results in infinity");
5251 num = rb_int_rshift(num, beg);
5253 int cmp = compare_indexes(beg, end);
5254 if (!
NIL_P(end) && cmp < 0) {
5255 VALUE len = rb_int_minus(end, beg);
5258 num = rb_int_and(num, mask);
5260 else if (cmp == 0) {
5271 return rb_fix_aref(num, arg);
5273 else if (RB_BIGNUM_TYPE_P(num)) {
5274 return rb_big_aref(num, arg);
5282 num = rb_int_rshift(num, beg);
5284 num = rb_int_and(num, mask);
5328int_aref(
int const argc,
VALUE *
const argv,
VALUE const num)
5332 return int_aref2(num, argv[0], argv[1]);
5334 return int_aref1(num, argv[0]);
5364 else if (RB_BIGNUM_TYPE_P(num)) {
5365 val = rb_big2dbl(num);
5385rb_int_abs(
VALUE num)
5388 return fix_abs(num);
5390 else if (RB_BIGNUM_TYPE_P(num)) {
5391 return rb_big_abs(num);
5403rb_int_size(
VALUE num)
5406 return fix_size(num);
5408 else if (RB_BIGNUM_TYPE_P(num)) {
5409 return rb_big_size_m(num);
5415rb_fix_bit_length(
VALUE fix)
5424rb_int_bit_length(
VALUE num)
5427 return rb_fix_bit_length(num);
5429 else if (RB_BIGNUM_TYPE_P(num)) {
5430 return rb_big_bit_length(num);
5436rb_fix_digits(
VALUE fix,
long base)
5444 rb_raise(rb_eArgError,
"invalid radix %ld", base);
5447 return rb_ary_new_from_args(1,
INT2FIX(0));
5449 digits = rb_ary_new();
5462 VALUE digits, bases;
5464 assert(!rb_num_negative_p(num));
5466 if (RB_BIGNUM_TYPE_P(base))
5467 base = rb_big_norm(base);
5470 rb_raise(rb_eArgError,
"invalid radix %ld",
FIX2LONG(base));
5471 else if (RB_BIGNUM_TYPE_P(base) && BIGNUM_NEGATIVE_P(base))
5472 rb_raise(rb_eArgError,
"negative radix");
5475 return rb_fix_digits(num,
FIX2LONG(base));
5478 return rb_ary_new_from_args(1, num);
5480 if (int_lt(rb_int_div(rb_int_bit_length(num), rb_int_bit_length(base)),
INT2FIX(50))) {
5481 digits = rb_ary_new();
5483 VALUE qr = rb_int_divmod(num, base);
5490 bases = rb_ary_new();
5491 for (
VALUE b = base; int_lt(b, num) ==
Qtrue; b = rb_int_mul(b, b)) {
5492 rb_ary_push(bases, b);
5494 digits = rb_ary_new_from_args(1, num);
5496 VALUE b = rb_ary_pop(bases);
5498 for(i = last_idx; i >= 0; i--) {
5500 VALUE divmod = rb_int_divmod(n, b);
5503 if (i != last_idx || div !=
INT2FIX(0)) rb_ary_store(digits, 2 * i + 1, div);
5504 rb_ary_store(digits, 2 * i, mod);
5528rb_int_digits(
int argc,
VALUE *argv,
VALUE num)
5533 if (rb_num_negative_p(num))
5539 rb_raise(
rb_eTypeError,
"wrong argument type %s (expected Integer)",
5541 if (RB_BIGNUM_TYPE_P(base_value))
5542 return rb_int_digits_bigbase(num, base_value);
5546 rb_raise(rb_eArgError,
"negative radix");
5548 rb_raise(rb_eArgError,
"invalid radix %ld", base);
5554 return rb_fix_digits(num, base);
5555 else if (RB_BIGNUM_TYPE_P(num))
5556 return rb_int_digits_bigbase(num,
LONG2FIX(base));
5595 for (i =
FIX2LONG(from); i <= end; i++) {
5606 ensure_cmp(c, i, to);
5645 for (i=
FIX2LONG(from); i >= end; i--) {
5656 if (
NIL_P(c)) rb_cmperr(i, to);
5717 if (!
rb_scan_args(argc, argv,
"01:", &nd, &opt))
return num;
5719 mode = rb_num_get_rounding_option(opt);
5723 return rb_int_round(num, ndigits, mode);
5760 return rb_int_floor(num, ndigits);
5797 return rb_int_ceil(num, ndigits);
5824int_truncate(
int argc,
VALUE* argv,
VALUE num)
5833 return rb_int_truncate(num, ndigits);
5836#define DEFINE_INT_SQRT(rettype, prefix, argtype) \
5838prefix##_isqrt(argtype n) \
5840 if (!argtype##_IN_DOUBLE_P(n)) { \
5841 unsigned int b = bit_length(n); \
5843 rettype x = (rettype)(n >> (b/2+1)); \
5844 x |= ((rettype)1LU << (b-1)/2); \
5845 while ((t = n/x) < (argtype)x) x = (rettype)((x + t) >> 1); \
5848 return (rettype)sqrt(argtype##_TO_DOUBLE(n)); \
5851#if SIZEOF_LONG*CHAR_BIT > DBL_MANT_DIG
5852# define RB_ULONG_IN_DOUBLE_P(n) ((n) < (1UL << DBL_MANT_DIG))
5854# define RB_ULONG_IN_DOUBLE_P(n) 1
5856#define RB_ULONG_TO_DOUBLE(n) (double)(n)
5857#define RB_ULONG unsigned long
5858DEFINE_INT_SQRT(
unsigned long, rb_ulong, RB_ULONG)
5860#if 2*SIZEOF_BDIGIT > SIZEOF_LONG
5861# if 2*SIZEOF_BDIGIT*CHAR_BIT > DBL_MANT_DIG
5862# define BDIGIT_DBL_IN_DOUBLE_P(n) ((n) < ((BDIGIT_DBL)1UL << DBL_MANT_DIG))
5864# define BDIGIT_DBL_IN_DOUBLE_P(n) 1
5866# ifdef ULL_TO_DOUBLE
5867# define BDIGIT_DBL_TO_DOUBLE(n) ULL_TO_DOUBLE(n)
5869# define BDIGIT_DBL_TO_DOUBLE(n) (double)(n)
5871DEFINE_INT_SQRT(BDIGIT, rb_bdigit_dbl, BDIGIT_DBL)
5874#define domain_error(msg) \
5875 rb_raise(rb_eMathDomainError, "Numerical argument is out of domain - " #msg)
5912 unsigned long n, sq;
5915 if (FIXNUM_NEGATIVE_P(num)) {
5916 domain_error(
"isqrt");
5919 sq = rb_ulong_isqrt(n);
5925 domain_error(
"isqrt");
5927 biglen = BIGNUM_LEN(num);
5928 if (biglen == 0)
return INT2FIX(0);
5929#if SIZEOF_BDIGIT <= SIZEOF_LONG
5932 n = BIGNUM_DIGITS(num)[0];
5933 sq = rb_ulong_isqrt(n);
5937 return rb_big_isqrt(num);
5960 return rb_check_integer_type(num);
6242 rb_fix_to_s_static[0] = rb_fstring_literal(
"0");
6243 rb_fix_to_s_static[1] = rb_fstring_literal(
"1");
6244 rb_fix_to_s_static[2] = rb_fstring_literal(
"2");
6245 rb_fix_to_s_static[3] = rb_fstring_literal(
"3");
6246 rb_fix_to_s_static[4] = rb_fstring_literal(
"4");
6247 rb_fix_to_s_static[5] = rb_fstring_literal(
"5");
6248 rb_fix_to_s_static[6] = rb_fstring_literal(
"6");
6249 rb_fix_to_s_static[7] = rb_fstring_literal(
"7");
6250 rb_fix_to_s_static[8] = rb_fstring_literal(
"8");
6251 rb_fix_to_s_static[9] = rb_fstring_literal(
"9");
6252 for(
int i = 0; i < 10; i++) {
6253 rb_gc_register_mark_object(rb_fix_to_s_static[i]);
6379#undef rb_float_value
6383 return rb_float_value_inline(v);
6388rb_float_new(
double d)
6390 return rb_float_new_inline(d);
6393#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.