src/numeric.c

   1 /*
   2 ** numeric.c - Numeric, Integer, Float class
   3 **
   4 ** See Copyright Notice in mruby.h
   5 */
   6
   7 #include <mruby.h>
   8 #include <mruby/array.h>
   9 #include <mruby/numeric.h>
  10 #include <mruby/string.h>
  11 #include <mruby/class.h>
  12 #include <mruby/internal.h>
  13 #include <mruby/presym.h>
  14 #include <string.h>
  15
  16 #ifndef MRB_NO_FLOAT
  17 #ifdef MRB_USE_FLOAT32
  18 #define trunc(f) truncf(f)
  19 #define fmod(x,y) fmodf(x,y)
  20 #else
  21 #endif
  22 #endif
  23
  24 mrb_noreturn void
  25 mrb_int_overflow(mrb_state *mrb, const char *reason)
  26 {
  27   mrb_raisef(mrb, E_RANGE_ERROR, "integer overflow in %s", reason);
  28 }
  29
  30 mrb_noreturn void
  31 mrb_int_zerodiv(mrb_state *mrb)
  32 {
  33   mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0");
  34 }
  35
  36 static mrb_noreturn void
  37 mrb_int_noconv(mrb_state *mrb, mrb_value y)
  38 {
  39   mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y into Integer", y);
  40 }
  41
  42 mrb_value
  43 mrb_int_pow(mrb_state *mrb, mrb_value x, mrb_value y)
  44 {
  45 #ifdef MRB_USE_BIGINT
  46   if (mrb_bigint_p(x)) {
  47 #ifndef MRB_NO_FLOAT
  48     if (mrb_float_p(y)) {
  49       return mrb_float_value(mrb, pow(mrb_bint_as_float(mrb, x), mrb_float(y)));
  50     }
  51 #endif
  52     return mrb_bint_pow(mrb, x, y);
  53   }
  54 #endif
  55   mrb_int base = mrb_integer(x);
  56   mrb_int result = 1;
  57   mrb_int exp;
  58
  59 #ifndef MRB_NO_FLOAT
  60   if (mrb_float_p(y)) {
  61     return mrb_float_value(mrb, pow((double)base, mrb_float(y)));
  62   }
  63   else if (mrb_integer_p(y)) {
  64     exp = mrb_integer(y);
  65   }
  66   else
  67 #endif
  68   {
  69     exp = mrb_as_int(mrb, y);
  70   }
  71   if (exp < 0) {
  72 #ifndef MRB_NO_FLOAT
  73     return mrb_float_value(mrb, pow((double)base, (double)exp));
  74 #else
  75     mrb_int_overflow(mrb, "negative power");
  76 #endif
  77   }
  78   for (;;) {
  79     if (exp & 1) {
  80       if (mrb_int_mul_overflow(result, base, &result)) {
  81 #ifdef MRB_USE_BIGINT
  82         return mrb_bint_pow(mrb, mrb_bint_new_int(mrb, mrb_integer(x)), y);
  83 #else
  84         mrb_int_overflow(mrb, "power");
  85 #endif
  86       }
  87     }
  88     exp >>= 1;
  89     if (exp == 0) break;
  90     if (mrb_int_mul_overflow(base, base, &base)) {
  91 #ifdef MRB_USE_BIGINT
  92       return mrb_bint_pow(mrb, mrb_bint_new_int(mrb, mrb_integer(x)), y);
  93 #else
  94       mrb_int_overflow(mrb, "power");
  95 #endif
  96     }
  97   }
  98   return mrb_int_value(mrb, result);
  99 }
 100
 101 /*
 102  * call-seq:
 103  *
 104  *  num ** other  ->  num
 105  *
 106  * Raises <code>num</code> the <code>other</code> power.
 107  *
 108  *    2.0**3      #=> 8.0
 109  */
 110 static mrb_value
 111 int_pow(mrb_state *mrb, mrb_value x)
 112 {
 113   return mrb_int_pow(mrb, x, mrb_get_arg1(mrb));
 114 }
 115
 116 mrb_int
 117 mrb_div_int(mrb_int x, mrb_int y)
 118 {
 119   mrb_int div = x / y;
 120
 121   if ((x ^ y) < 0 && x != div * y) {
 122     div -= 1;
 123   }
 124   return div;
 125 }
 126
 127 mrb_value
 128 mrb_div_int_value(mrb_state *mrb, mrb_int x, mrb_int y)
 129 {
 130   if (y == 0) {
 131     mrb_int_zerodiv(mrb);
 132   }
 133   else if (x == MRB_INT_MIN && y == -1) {
 134 #ifdef MRB_USE_BIGINT
 135     return mrb_bint_mul_ii(mrb, x, y);
 136 #else
 137     mrb_int_overflow(mrb, "division");
 138 #endif
 139   }
 140   return mrb_int_value(mrb, mrb_div_int(x, y));
 141 }
 142
 143 /* 15.2.8.3.6 */
 144 /*
 145  * call-seq:
 146  *   int / num  ->  num
 147  *
 148  * Performs division: the class of the resulting object depends on
 149  * the class of <code>num</code> and on the magnitude of the
 150  * result.
 151  */
 152 static mrb_value
 153 int_div(mrb_state *mrb, mrb_value x)
 154 {
 155   mrb_value y = mrb_get_arg1(mrb);
 156 #ifdef MRB_USE_BIGINT
 157   if (mrb_bigint_p(x)) {
 158     return mrb_bint_div(mrb, x, y);
 159   }
 160 #endif
 161  mrb_int a = mrb_integer(x);
 162
 163   if (mrb_integer_p(y)) {
 164     return mrb_div_int_value(mrb, a, mrb_integer(y));
 165   }
 166   switch (mrb_type(y)) {
 167 #ifdef MRB_USE_BIGINT
 168   case MRB_TT_BIGINT:
 169     return mrb_bint_div(mrb, mrb_bint_new_int(mrb, a), y);
 170 #endif
 171 #ifdef MRB_USE_RATIONAL
 172   case MRB_TT_RATIONAL:
 173     return mrb_rational_div(mrb, mrb_rational_new(mrb, a, 1), y);
 174 #endif
 175 #ifdef MRB_USE_COMPLEX
 176   case MRB_TT_COMPLEX:
 177     x = mrb_complex_new(mrb, (mrb_float)a, 0);
 178     return mrb_complex_div(mrb, x, y);
 179 #endif
 180 #ifndef MRB_NO_FLOAT
 181   case MRB_TT_FLOAT:
 182     return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y)));
 183 #endif
 184   default:
 185     mrb_int_noconv(mrb, y);
 186   }
 187 }
 188
 189 /* 15.2.9.3.19(x) */
 190 /*
 191  *  call-seq:
 192  *     num.quo(numeric)  ->  real
 193  *
 194  *  Returns most exact division.
 195  */
 196
 197 /*
 198  * call-seq:
 199  *   int.div(other)  ->  int
 200  *
 201  * Performs division: resulting integer.
 202  */
 203 static mrb_value
 204 int_idiv(mrb_state *mrb, mrb_value x)
 205 {
 206 #ifdef MRB_USE_BIGINT
 207   if (mrb_bigint_p(x)) {
 208     return mrb_bint_div(mrb, x, mrb_get_arg1(mrb));
 209   }
 210 #endif
 211   mrb_int y = mrb_as_int(mrb,  mrb_get_arg1(mrb));
 212   return mrb_div_int_value(mrb, mrb_integer(x), y);
 213 }
 214
 215 static mrb_value
 216 int_quo(mrb_state *mrb, mrb_value x)
 217 {
 218 #ifndef MRB_USE_RATIONAL
 219 #ifdef MRB_NO_FLOAT
 220   return int_idiv(mrb, x);
 221 #else
 222   mrb_float y = mrb_as_float(mrb,  mrb_get_arg1(mrb));
 223
 224   if (y == 0) {
 225     mrb_int_zerodiv(mrb);
 226   }
 227 #ifdef MRB_USE_BIGINT
 228   if (mrb_bigint_p(x)) {
 229     return mrb_float_value(mrb, mrb_bint_as_float(mrb, x) / y);
 230   }
 231 #endif
 232   return mrb_float_value(mrb, mrb_integer(x) / y);
 233 #endif
 234 #else
 235   mrb_int a = mrb_integer(x);
 236   mrb_value y = mrb_get_arg1(mrb);
 237   if (mrb_integer_p(y) && mrb_class_defined_id(mrb, MRB_SYM(Rational))) {
 238     return mrb_rational_new(mrb, a, mrb_integer(y));
 239   }
 240   switch (mrb_type(y)) {
 241   case MRB_TT_RATIONAL:
 242     x = mrb_rational_new(mrb, a, 1);
 243     return mrb_rational_div(mrb, x, y);
 244   default:
 245 #ifndef MRB_NO_FLOAT
 246     return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y)));
 247 #else
 248     mrb_int_noconv(mrb, y);
 249     break;
 250 #endif
 251   }
 252 #endif
 253 }
 254
 255 static mrb_value
 256 coerce_step_counter(mrb_state *mrb, mrb_value self)
 257 {
 258   mrb_value num, step;
 259
 260   mrb_get_args(mrb, "oo", &num, &step);
 261
 262 #ifndef MRB_NO_FLOAT
 263   mrb->c->ci->mid = 0;
 264   if (mrb_float_p(num) || mrb_float_p(step)) {
 265     return mrb_ensure_float_type(mrb, self);
 266   }
 267 #endif
 268
 269   return self;
 270 }
 271
 272 #ifndef MRB_NO_FLOAT
 273 /********************************************************************
 274  *
 275  * Document-class: Float
 276  *
 277  *  <code>Float</code> objects represent inexact real numbers using
 278  *  the native architecture's double-precision floating-point
 279  *  representation.
 280  */
 281
 282 static mrb_value
 283 flo_pow(mrb_state *mrb, mrb_value x)
 284 {
 285   mrb_value y = mrb_get_arg1(mrb);
 286   mrb_float d = pow(mrb_as_float(mrb, x), mrb_as_float(mrb, y));
 287   return mrb_float_value(mrb, d);
 288 }
 289
 290 static mrb_value
 291 flo_idiv(mrb_state *mrb, mrb_value xv)
 292 {
 293   mrb_float x = mrb_float(xv);
 294   mrb_check_num_exact(mrb, x);
 295   mrb_int y = mrb_as_int(mrb, mrb_get_arg1(mrb));
 296   return mrb_div_int_value(mrb, (mrb_int)x, y);
 297 }
 298
 299 mrb_float
 300 mrb_div_float(mrb_float x, mrb_float y)
 301 {
 302   if (y != 0.0) {
 303     return x / y;
 304   }
 305   else if (x == 0.0) {
 306     return NAN;
 307   }
 308   else {
 309     return x * (signbit(y) ? -1.0 : 1.0) * INFINITY;
 310   }
 311 }
 312
 313 /* 15.2.9.3.6 */
 314 /*
 315  * call-seq:
 316  *   float / num  ->  float
 317  *
 318  * Returns a new Float which is the result of dividing float by num.
 319  */
 320 static mrb_value
 321 flo_div(mrb_state *mrb, mrb_value x)
 322 {
 323   mrb_value y = mrb_get_arg1(mrb);
 324   mrb_float a = mrb_float(x);
 325
 326   switch(mrb_type(y)) {
 327 #ifdef MRB_USE_COMPLEX
 328   case MRB_TT_COMPLEX:
 329     return mrb_complex_div(mrb, mrb_complex_new(mrb, a, 0), y);
 330 #endif
 331   case MRB_TT_FLOAT:
 332     a = mrb_div_float(a, mrb_float(y));
 333     return mrb_float_value(mrb, a);
 334   default:
 335     a = mrb_div_float(a, mrb_as_float(mrb, y));
 336     return mrb_float_value(mrb, a);
 337   }
 338   return mrb_float_value(mrb, a);
 339 }
 340
 341 /* the argument `fmt` is no longer used; you can pass `NULL` */
 342 mrb_value
 343 mrb_float_to_str(mrb_state *mrb, mrb_value flo, const char *fmt)
 344 {
 345   char buf[25];
 346 #ifdef MRB_USE_FLOAT32
 347   const int prec =  7;
 348 #else
 349   const int prec =  15;
 350 #endif
 351
 352   mrb_format_float(mrb_float(flo), buf, sizeof(buf), 'g', prec, '\0');
 353   for (char *p = buf; *p; p++) {
 354     if (*p == '.') goto exit;
 355     if (*p == 'e') {
 356       memmove(p+2, p, strlen(p)+1);
 357       p[0] = '.';
 358       p[1] = '0';
 359       goto exit;
 360     }
 361   }
 362   strcat(buf, ".0");
 363  exit:
 364   return mrb_str_new_cstr(mrb, buf);
 365 }
 366
 367 /* 15.2.9.3.16(x) */
 368 /*
 369  *  call-seq:
 370  *     flt.to_s  ->  string
 371  *     flt.inspect  ->  string
 372  *
 373  *  Returns a string containing a representation of self. As well as a
 374  *  fixed or exponential form of the number, the call may return
 375  *  "<code>NaN</code>", "<code>Infinity</code>", and
 376  *  "<code>-Infinity</code>".
 377  *
 378  *     3.0.to_s   #=> 3.0
 379  *     3.25.to_s  #=> 3.25
 380  */
 381
 382 static mrb_value
 383 flo_to_s(mrb_state *mrb, mrb_value flt)
 384 {
 385   mrb_float f = mrb_float(flt);
 386   mrb_value str;
 387
 388   if (isinf(f)) {
 389     str = f < 0 ? mrb_str_new_lit(mrb, "-Infinity")
 390                 : mrb_str_new_lit(mrb, "Infinity");
 391   }
 392   else if (isnan(f)) {
 393     str = mrb_str_new_lit(mrb, "NaN");
 394   }
 395   else {
 396     str = mrb_float_to_str(mrb, flt, NULL);
 397   }
 398
 399   RSTR_SET_ASCII_FLAG(mrb_str_ptr(str));
 400   return str;
 401 }
 402
 403 /* 15.2.9.3.3 */
 404 /*
 405  * call-seq:
 406  *   float + other  ->  float
 407  *
 408  * Returns a new float which is the sum of <code>float</code>
 409  * and <code>other</code>.
 410  */
 411 static mrb_value
 412 flo_add(mrb_state *mrb, mrb_value x)
 413 {
 414   mrb_value y = mrb_get_arg1(mrb);
 415   mrb_float a = mrb_float(x);
 416
 417   switch (mrb_type(y)) {
 418   case MRB_TT_FLOAT:
 419     return mrb_float_value(mrb, a + mrb_float(y));
 420 #if defined(MRB_USE_COMPLEX)
 421   case MRB_TT_COMPLEX:
 422     return mrb_complex_add(mrb, y, x);
 423 #endif
 424   default:
 425     return mrb_float_value(mrb, a + mrb_as_float(mrb, y));
 426   }
 427 }
 428
 429 /* 15.2.9.3.4 */
 430 /*
 431  * call-seq:
 432  *   float - other  ->  float
 433  *
 434  * Returns a new float which is the difference of <code>float</code>
 435  * and <code>other</code>.
 436  */
 437
 438 static mrb_value
 439 flo_sub(mrb_state *mrb, mrb_value x)
 440 {
 441   mrb_value y = mrb_get_arg1(mrb);
 442   mrb_float a = mrb_float(x);
 443
 444   switch (mrb_type(y)) {
 445   case MRB_TT_FLOAT:
 446     return mrb_float_value(mrb, a - mrb_float(y));
 447 #if defined(MRB_USE_COMPLEX)
 448   case MRB_TT_COMPLEX:
 449     return mrb_complex_sub(mrb, mrb_complex_new(mrb, a, 0), y);
 450 #endif
 451   default:
 452     return mrb_float_value(mrb, a - mrb_as_float(mrb, y));
 453   }
 454 }
 455
 456 /* 15.2.9.3.5 */
 457 /*
 458  * call-seq:
 459  *   float * other  ->  float
 460  *
 461  * Returns a new float which is the product of <code>float</code>
 462  * and <code>other</code>.
 463  */
 464
 465 static mrb_value
 466 flo_mul(mrb_state *mrb, mrb_value x)
 467 {
 468   mrb_value y = mrb_get_arg1(mrb);
 469   mrb_float a = mrb_float(x);
 470
 471   switch (mrb_type(y)) {
 472   case MRB_TT_FLOAT:
 473     return mrb_float_value(mrb, a * mrb_float(y));
 474 #if defined(MRB_USE_COMPLEX)
 475   case MRB_TT_COMPLEX:
 476     return mrb_complex_mul(mrb, y, x);
 477 #endif
 478   default:
 479     return mrb_float_value(mrb, a * mrb_as_float(mrb, y));
 480   }
 481 }
 482
 483 static void
 484 flodivmod(mrb_state *mrb, double x, double y, mrb_float *divp, mrb_float *modp)
 485 {
 486   double div, mod;
 487
 488   if (isnan(y)) {
 489     /* y is NaN so all results are NaN */
 490     div = mod = y;
 491     goto exit;
 492   }
 493   if (y == 0.0) {
 494     mrb_int_zerodiv(mrb);
 495   }
 496   if (isinf(y) && !isinf(x)) {
 497     mod = x;
 498   }
 499   else {
 500     mod = fmod(x, y);
 501   }
 502   if (isinf(x) && !isinf(y)) {
 503     div = x;
 504   }
 505   else {
 506     div = (x - mod) / y;
 507     if (modp && divp) div = round(div);
 508   }
 509   if (div == 0) div = 0.0;
 510   if (mod == 0) mod = 0.0;
 511   if (y*mod < 0) {
 512     mod += y;
 513     div -= 1.0;
 514   }
 515  exit:
 516   if (modp) *modp = mod;
 517   if (divp) *divp = div;
 518 }
 519
 520 /* 15.2.9.3.5 */
 521 /*
 522  *  call-seq:
 523  *     flt % other        ->  float
 524  *     flt.modulo(other)  ->  float
 525  *
 526  *  Return the modulo after division of <code>flt</code> by <code>other</code>.
 527  *
 528  *     6543.21.modulo(137)      #=> 104.21
 529  *     6543.21.modulo(137.24)   #=> 92.9299999999996
 530  */
 531
 532 static mrb_value
 533 flo_mod(mrb_state *mrb, mrb_value x)
 534 {
 535   mrb_value y = mrb_get_arg1(mrb);
 536   mrb_float mod;
 537
 538   flodivmod(mrb, mrb_float(x), mrb_as_float(mrb, y), NULL, &mod);
 539   return mrb_float_value(mrb, mod);
 540 }
 541 #endif
 542
 543 /* 15.2.8.3.16 */
 544 /*
 545  *  call-seq:
 546  *     num.eql?(numeric)  ->  true or false
 547  *
 548  *  Returns <code>true</code> if <i>num</i> and <i>numeric</i> are the
 549  *  same type and have equal values.
 550  *
 551  *     1 == 1.0          #=> true
 552  *     1.eql?(1.0)       #=> false
 553  *     (1.0).eql?(1.0)   #=> true
 554  */
 555 static mrb_value
 556 num_eql(mrb_state *mrb, mrb_value x)
 557 {
 558   mrb_value y = mrb_get_arg1(mrb);
 559
 560 #ifdef MRB_USE_BIGINT
 561   if (mrb_bigint_p(x)) {
 562     return mrb_bool_value(mrb_bint_cmp(mrb, x, y) == 0);
 563   }
 564 #endif
 565 #ifndef MRB_NO_FLOAT
 566   if (mrb_float_p(x)) {
 567     if (!mrb_float_p(y)) return mrb_false_value();
 568     return mrb_bool_value(mrb_float(x) == mrb_float(y));
 569   }
 570 #endif
 571   if (mrb_integer_p(x)) {
 572     if (!mrb_integer_p(y)) return mrb_false_value();
 573     return mrb_bool_value(mrb_integer(x) == mrb_integer(y));
 574   }
 575   return mrb_bool_value(mrb_equal(mrb, x, y));
 576 }
 577
 578 #ifndef MRB_NO_FLOAT
 579 /* 15.2.9.3.7 */
 580 /*
 581  *  call-seq:
 582  *     flt == obj  ->  true or false
 583  *
 584  *  Returns <code>true</code> only if <i>obj</i> has the same value
 585  *  as <i>flt</i>. Contrast this with <code>Float#eql?</code>, which
 586  *  requires <i>obj</i> to be a <code>Float</code>.
 587  *
 588  *     1.0 == 1   #=> true
 589  *
 590  */
 591
 592 static mrb_value
 593 flo_eq(mrb_state *mrb, mrb_value x)
 594 {
 595   mrb_value y = mrb_get_arg1(mrb);
 596
 597   switch (mrb_type(y)) {
 598   case MRB_TT_INTEGER:
 599     return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_integer(y));
 600   case MRB_TT_FLOAT:
 601     return mrb_bool_value(mrb_float(x) == mrb_float(y));
 602 #ifdef MRB_USE_RATIONAL
 603   case MRB_TT_RATIONAL:
 604     return mrb_bool_value(mrb_float(x) == mrb_as_float(mrb, y));
 605 #endif
 606 #ifdef MRB_USE_COMPLEX
 607   case MRB_TT_COMPLEX:
 608     return mrb_bool_value(mrb_equal(mrb, y, x));
 609 #endif
 610   default:
 611     return mrb_false_value();
 612   }
 613 }
 614
 615 /* 15.2.9.3.13 */
 616 /*
 617  * Document-method: Float#to_f
 618  *
 619  * call-seq:
 620  *   flt.to_f  ->  self
 621  *
 622  * As <code>flt</code> is already a float, returns +self+.
 623  */
 624
 625 /* 15.2.9.3.11 */
 626 /*
 627  *  call-seq:
 628  *     flt.infinite?  ->  nil, -1, +1
 629  *
 630  *  Returns <code>nil</code>, -1, or +1 depending on whether <i>flt</i>
 631  *  is finite, -infinity, or +infinity.
 632  *
 633  *     (0.0).infinite?        #=> nil
 634  *     (-1.0/0.0).infinite?   #=> -1
 635  *     (+1.0/0.0).infinite?   #=> 1
 636  */
 637
 638 static mrb_value
 639 flo_infinite_p(mrb_state *mrb, mrb_value num)
 640 {
 641   mrb_float value = mrb_float(num);
 642
 643   if (isinf(value)) {
 644     return mrb_fixnum_value(value < 0 ? -1 : 1);
 645   }
 646   return mrb_nil_value();
 647 }
 648
 649 /* 15.2.9.3.9 */
 650 /*
 651  *  call-seq:
 652  *     flt.finite?  ->  true or false
 653  *
 654  *  Returns <code>true</code> if <i>flt</i> is a valid IEEE floating
 655  *  point number (it is not infinite, and <code>nan?</code> is
 656  *  <code>false</code>).
 657  *
 658  */
 659
 660 static mrb_value
 661 flo_finite_p(mrb_state *mrb, mrb_value num)
 662 {
 663   return mrb_bool_value(isfinite(mrb_float(num)));
 664 }
 665
 666 /*
 667  *  Document-class: FloatDomainError
 668  *
 669  *  Raised when attempting to convert special float values
 670  *  (in particular infinite or NaN)
 671  *  to numerical classes which don't support them.
 672  *
 673  *     Float::INFINITY.to_i
 674  *
 675  *  <em>raises the exception:</em>
 676  *
 677  *     FloatDomainError: Infinity
 678  */
 679 /* ------------------------------------------------------------------------*/
 680 void
 681 mrb_check_num_exact(mrb_state *mrb, mrb_float num)
 682 {
 683   if (isinf(num)) {
 684     mrb_raise(mrb, E_FLOATDOMAIN_ERROR, num < 0 ? "-Infinity" : "Infinity");
 685   }
 686   if (isnan(num)) {
 687     mrb_raise(mrb, E_FLOATDOMAIN_ERROR, "NaN");
 688   }
 689 }
 690
 691 static mrb_value
 692 flo_rounding_int(mrb_state *mrb, mrb_float f)
 693 {
 694   if (!FIXABLE_FLOAT(f)) {
 695 #ifdef MRB_USE_BIGINT
 696     return mrb_bint_new_float(mrb, f);
 697 #else
 698     mrb_int_overflow(mrb, "rounding");
 699 #endif
 700   }
 701   return mrb_int_value(mrb, (mrb_int)f);
 702 }
 703
 704 static mrb_value
 705 flo_rounding(mrb_state *mrb, mrb_value num, double (*func)(double))
 706 {
 707   mrb_float f = mrb_float(num);
 708   mrb_int ndigits = 0;
 709 #ifdef MRB_USE_FLOAT32
 710   const int fprec =  7;
 711 #else
 712   const int fprec =  15;
 713 #endif
 714
 715   mrb_get_args(mrb, "|i", &ndigits);
 716   if (f == 0.0) {
 717     return ndigits > 0 ? mrb_float_value(mrb, f) : mrb_fixnum_value(0);
 718   }
 719   if (ndigits > 0) {
 720     if (ndigits > fprec) return num;
 721     mrb_float d = pow(10, (double)ndigits);
 722     f = func(f * d) / d;
 723     mrb_check_num_exact(mrb, f);
 724     return mrb_float_value(mrb, f);
 725   }
 726   if (ndigits < 0) {
 727     mrb_float d = pow(10, -(double)ndigits);
 728     f = func(f / d) * d;
 729   }
 730   else {                        /* ndigits == 0 */
 731     f = func(f);
 732   }
 733   mrb_check_num_exact(mrb, f);
 734   return flo_rounding_int(mrb, f);
 735 }
 736
 737 /* 15.2.9.3.10 */
 738 /*
 739  *  call-seq:
 740  *     float.floor([ndigits])  ->  integer or float
 741  *
 742  *  Returns the largest number less than or equal to +float+ with
 743  *  a precision of +ndigits+ decimal digits (default: 0).
 744  *
 745  *  When the precision is negative, the returned value is an integer
 746  *  with at least <code>ndigits.abs</code> trailing zeros.
 747  *
 748  *  Returns a floating-point number when +ndigits+ is positive,
 749  *  otherwise returns an integer.
 750  *
 751  *     1.2.floor      #=> 1
 752  *     2.0.floor      #=> 2
 753  *     (-1.2).floor   #=> -2
 754  *     (-2.0).floor   #=> -2
 755  *
 756  *     1.234567.floor(2)   #=> 1.23
 757  *     1.234567.floor(3)   #=> 1.234
 758  *     1.234567.floor(4)   #=> 1.2345
 759  *     1.234567.floor(5)   #=> 1.23456
 760  *
 761  *     34567.89.floor(-5)  #=> 0
 762  *     34567.89.floor(-4)  #=> 30000
 763  *     34567.89.floor(-3)  #=> 34000
 764  *     34567.89.floor(-2)  #=> 34500
 765  *     34567.89.floor(-1)  #=> 34560
 766  *     34567.89.floor(0)   #=> 34567
 767  *     34567.89.floor(1)   #=> 34567.8
 768  *     34567.89.floor(2)   #=> 34567.89
 769  *     34567.89.floor(3)   #=> 34567.89
 770  *
 771  *  Note that the limited precision of floating-point arithmetic
 772  *  might lead to surprising results:
 773  *
 774  *     (0.3 / 0.1).floor  #=> 2 (!)
 775  */
 776 static mrb_value
 777 flo_floor(mrb_state *mrb, mrb_value num)
 778 {
 779   return flo_rounding(mrb, num, floor);
 780 }
 781
 782 /* 15.2.9.3.8 */
 783 /*
 784  *  call-seq:
 785  *     float.ceil([ndigits])  ->  integer or float
 786  *
 787  *  Returns the smallest number greater than or equal to +float+ with
 788  *  a precision of +ndigits+ decimal digits (default: 0).
 789  *
 790  *  When the precision is negative, the returned value is an integer
 791  *  with at least <code>ndigits.abs</code> trailing zeros.
 792  *
 793  *  Returns a floating-point number when +ndigits+ is positive,
 794  *  otherwise returns an integer.
 795  *
 796  *     1.2.ceil      #=> 2
 797  *     2.0.ceil      #=> 2
 798  *     (-1.2).ceil   #=> -1
 799  *     (-2.0).ceil   #=> -2
 800  *
 801  *     1.234567.ceil(2)   #=> 1.24
 802  *     1.234567.ceil(3)   #=> 1.235
 803  *     1.234567.ceil(4)   #=> 1.2346
 804  *     1.234567.ceil(5)   #=> 1.23457
 805  *
 806  *     34567.89.ceil(-5)  #=> 100000
 807  *     34567.89.ceil(-4)  #=> 40000
 808  *     34567.89.ceil(-3)  #=> 35000
 809  *     34567.89.ceil(-2)  #=> 34600
 810  *     34567.89.ceil(-1)  #=> 34570
 811  *     34567.89.ceil(0)   #=> 34568
 812  *     34567.89.ceil(1)   #=> 34567.9
 813  *     34567.89.ceil(2)   #=> 34567.89
 814  *     34567.89.ceil(3)   #=> 34567.89
 815  *
 816  *  Note that the limited precision of floating-point arithmetic
 817  *  might lead to surprising results:
 818  *
 819  *     (2.1 / 0.7).ceil  #=> 4 (!)
 820  */
 821
 822 static mrb_value
 823 flo_ceil(mrb_state *mrb, mrb_value num)
 824 {
 825   return flo_rounding(mrb, num, ceil);
 826 }
 827
 828 /* 15.2.9.3.12 */
 829 /*
 830  *  call-seq:
 831  *     flt.round([ndigits])  ->  integer or float
 832  *
 833  *  Rounds <i>flt</i> to a given precision in decimal digits (default 0 digits).
 834  *  Precision may be negative.  Returns a floating-point number when ndigits
 835  *  is more than zero.
 836  *
 837  *     1.4.round      #=> 1
 838  *     1.5.round      #=> 2
 839  *     1.6.round      #=> 2
 840  *     (-1.5).round   #=> -2
 841  *
 842  *     1.234567.round(2)  #=> 1.23
 843  *     1.234567.round(3)  #=> 1.235
 844  *     1.234567.round(4)  #=> 1.2346
 845  *     1.234567.round(5)  #=> 1.23457
 846  *
 847  *     34567.89.round(-5) #=> 0
 848  *     34567.89.round(-4) #=> 30000
 849  *     34567.89.round(-3) #=> 35000
 850  *     34567.89.round(-2) #=> 34600
 851  *     34567.89.round(-1) #=> 34570
 852  *     34567.89.round(0)  #=> 34568
 853  *     34567.89.round(1)  #=> 34567.9
 854  *     34567.89.round(2)  #=> 34567.89
 855  *     34567.89.round(3)  #=> 34567.89
 856  *
 857  */
 858
 859 static mrb_value
 860 flo_round(mrb_state *mrb, mrb_value num)
 861 {
 862   double number, f;
 863   mrb_int ndigits = 0;
 864   mrb_int i;
 865
 866   mrb_get_args(mrb, "|i", &ndigits);
 867   number = mrb_float(num);
 868
 869   if (0 < ndigits && (isinf(number) || isnan(number))) {
 870     return num;
 871   }
 872   mrb_check_num_exact(mrb, number);
 873
 874   f = 1.0;
 875   if (ndigits < -DBL_DIG-2) return mrb_fixnum_value(0);
 876   i = ndigits >= 0 ? ndigits : -ndigits;
 877   if (ndigits > DBL_DIG+2) return num;
 878   while  (--i >= 0)
 879     f = f*10.0;
 880
 881   if (isinf(f)) {
 882     if (ndigits < 0) number = 0;
 883   }
 884   else {
 885     double d;
 886
 887     if (ndigits < 0) number /= f;
 888     else number *= f;
 889
 890     /* home-made inline implementation of round(3) */
 891     if (number > 0.0) {
 892       d = floor(number);
 893       number = d + (number - d >= 0.5);
 894     }
 895     else if (number < 0.0) {
 896       d = ceil(number);
 897       number = d - (d - number >= 0.5);
 898     }
 899
 900     if (ndigits < 0) number *= f;
 901     else number /= f;
 902   }
 903
 904   if (ndigits > 0) {
 905     if (!isfinite(number)) return num;
 906     return mrb_float_value(mrb, number);
 907   }
 908   if (!FIXABLE_FLOAT(number))
 909     return mrb_float_value(mrb, number);
 910   return mrb_int_value(mrb, (mrb_int)number);
 911 }
 912
 913 /* 15.2.9.3.14 */
 914 static mrb_value
 915 flo_to_i(mrb_state *mrb, mrb_value num)
 916 {
 917   mrb_float f = mrb_float(num);
 918
 919   mrb_check_num_exact(mrb, f);
 920   if (!FIXABLE_FLOAT(f)) {
 921 #ifdef MRB_USE_BIGINT
 922     return mrb_bint_new_float(mrb, f);
 923 #else
 924     mrb_int_overflow(mrb, "to_f");
 925 #endif
 926   }
 927   if (f > 0.0) f = floor(f);
 928   if (f < 0.0) f = ceil(f);
 929
 930   return mrb_int_value(mrb, (mrb_int)f);
 931 }
 932
 933 /* 15.2.9.3.15 */
 934 /*
 935  *  call-seq:
 936  *     flt.to_i      ->  integer
 937  *     flt.truncate  ->  integer
 938  *
 939  *  Returns <i>flt</i> truncated to an <code>Integer</code>.
 940  */
 941
 942 static mrb_value
 943 flo_truncate(mrb_state *mrb, mrb_value num)
 944 {
 945   if (signbit(mrb_float(num))) return flo_ceil(mrb, num);
 946   return flo_floor(mrb, num);
 947 }
 948
 949 static mrb_value
 950 flo_nan_p(mrb_state *mrb, mrb_value num)
 951 {
 952   return mrb_bool_value(isnan(mrb_float(num)));
 953 }
 954
 955 static mrb_value
 956 flo_abs(mrb_state *mrb, mrb_value num)
 957 {
 958   mrb_float f = mrb_float(num);
 959
 960   if (signbit(f)) return mrb_float_value(mrb, -f);
 961   return num;
 962 }
 963 #endif
 964
 965 /*
 966  * Document-class: Integer
 967  *
 968  *  <code>Integer</code> is hold whole numbers.
 969  *
 970  */
 971
 972 /* 15.2.9.3.24 */
 973 /*
 974  *  Document-method: Integer#to_i
 975  *  Document-method: Integer#to_int
 976  *
 977  *  call-seq:
 978  *     int.to_i      ->  integer
 979  *     int.to_int    ->  integer
 980  *
 981  *  As <i>int</i> is already an <code>Integer</code>, all these
 982  *  methods simply return the receiver.
 983  */
 984
 985 mrb_value
 986 mrb_int_mul(mrb_state *mrb, mrb_value x, mrb_value y)
 987 {
 988   mrb_int a;
 989
 990   a = mrb_integer(x);
 991   if (mrb_integer_p(y)) {
 992     mrb_int b, c;
 993
 994     if (a == 0) return x;
 995     if (a == 1) return y;
 996     b = mrb_integer(y);
 997     if (b == 0) return y;
 998     if (b == 1) return x;
 999     if (mrb_int_mul_overflow(a, b, &c)) {
1000 #ifdef MRB_USE_BIGINT
1001       x = mrb_bint_new_int(mrb, a);
1002       return mrb_bint_mul(mrb, x, y);
1003 #else
1004       mrb_int_overflow(mrb, "multiplication");
1005 #endif
1006     }
1007     return mrb_int_value(mrb, c);
1008   }
1009   switch (mrb_type(y)) {
1010 #ifdef MRB_USE_BIGINT
1011   case MRB_TT_BIGINT:
1012     if (a == 0) return x;
1013     if (a == 1) return y;
1014     return mrb_bint_mul(mrb, y, x);
1015 #endif
1016 #ifdef MRB_USE_RATIONAL
1017   case MRB_TT_RATIONAL:
1018     if (a == 0) return x;
1019     if (a == 1) return y;
1020     return mrb_rational_mul(mrb, y, x);
1021 #endif
1022 #ifdef MRB_USE_COMPLEX
1023   case MRB_TT_COMPLEX:
1024     if (a == 0) return x;
1025     if (a == 1) return y;
1026     return mrb_complex_mul(mrb, y, x);
1027 #endif
1028 #ifndef MRB_NO_FLOAT
1029   case MRB_TT_FLOAT:
1030     return mrb_float_value(mrb, (mrb_float)a * mrb_as_float(mrb, y));
1031 #endif
1032   default:
1033     mrb_int_noconv(mrb, y);
1034   }
1035 }
1036
1037 /* 15.2.8.3.5 */
1038 /*
1039  * call-seq:
1040  *   int * numeric  ->  numeric_result
1041  *
1042  * Performs multiplication: the class of the resulting object depends on
1043  * the class of <code>numeric</code> and on the magnitude of the
1044  * result.
1045  */
1046
1047 static mrb_value
1048 int_mul(mrb_state *mrb, mrb_value x)
1049 {
1050   mrb_value y = mrb_get_arg1(mrb);
1051
1052 #ifdef MRB_USE_BIGINT
1053   if (mrb_bigint_p(x)) {
1054     return mrb_bint_mul(mrb, x, y);
1055   }
1056 #endif
1057   return mrb_int_mul(mrb, x, y);
1058 }
1059
1060 static void
1061 intdivmod(mrb_state *mrb, mrb_int x, mrb_int y, mrb_int *divp, mrb_int *modp)
1062 {
1063   if (y == 0) {
1064     mrb_int_zerodiv(mrb);
1065   }
1066   else if (x == MRB_INT_MIN && y == -1) {
1067     mrb_int_overflow(mrb, "division");
1068   }
1069   else {
1070     mrb_int div = x / y;
1071     mrb_int mod = x - div * y;
1072
1073     if ((x ^ y) < 0 && x != div * y) {
1074       mod += y;
1075       div -= 1;
1076     }
1077     if (divp) *divp = div;
1078     if (modp) *modp = mod;
1079   }
1080 }
1081
1082 /* 15.2.8.3.7 */
1083 /*
1084  *  call-seq:
1085  *    int % num        ->  num
1086  *
1087  *  Returns <code>int</code> modulo <code>other</code>.
1088  *  See <code>numeric.divmod</code> for more information.
1089  */
1090
1091 static mrb_value
1092 int_mod(mrb_state *mrb, mrb_value x)
1093 {
1094   mrb_value y = mrb_get_arg1(mrb);
1095   mrb_int a, b;
1096
1097 #ifdef MRB_USE_BIGINT
1098   if (mrb_bigint_p(x)) {
1099     return mrb_bint_mod(mrb, x, y);
1100   }
1101 #endif
1102   a = mrb_integer(x);
1103   if (a == 0) return x;
1104   if (mrb_integer_p(y)) {
1105     b = mrb_integer(y);
1106     if (b == 0) mrb_int_zerodiv(mrb);
1107     if (a == MRB_INT_MIN && b == -1) return mrb_fixnum_value(0);
1108     mrb_int mod = a % b;
1109     if ((a < 0) != (b < 0) && mod != 0) {
1110       mod += b;
1111     }
1112     return mrb_int_value(mrb, mod);
1113   }
1114 #ifdef MRB_NO_FLOAT
1115   mrb_raise(mrb, E_TYPE_ERROR, "non integer modulo");
1116 #else
1117   mrb_float mod;
1118
1119   flodivmod(mrb, (mrb_float)a, mrb_as_float(mrb, y), NULL, &mod);
1120   return mrb_float_value(mrb, mod);
1121 #endif
1122 }
1123
1124 #ifndef MRB_NO_FLOAT
1125 static mrb_value flo_divmod(mrb_state *mrb, mrb_value x);
1126 #endif
1127
1128 /*
1129  *  call-seq:
1130  *     int.divmod(numeric)  ->  array
1131  *
1132  *  See <code>Numeric#divmod</code>.
1133  */
1134 static mrb_value
1135 int_divmod(mrb_state *mrb, mrb_value x)
1136 {
1137   mrb_value y = mrb_get_arg1(mrb);
1138
1139 #ifdef MRB_USE_BIGINT
1140   if (mrb_bigint_p(x)) {
1141 #ifndef MRB_NO_FLOAT
1142     if (mrb_float_p(y)) {
1143       mrb_float f = mrb_bint_as_float(mrb, x);
1144       return flo_divmod(mrb, mrb_float_value(mrb, f));
1145     }
1146 #endif
1147     return mrb_bint_divmod(mrb, x, y);
1148   }
1149 #endif
1150   if (mrb_integer_p(y)) {
1151     mrb_int div, mod;
1152
1153     intdivmod(mrb, mrb_integer(x), mrb_integer(y), &div, &mod);
1154     return mrb_assoc_new(mrb, mrb_int_value(mrb, div), mrb_int_value(mrb, mod));
1155   }
1156 #ifdef MRB_NO_FLOAT
1157   mrb_raise(mrb, E_TYPE_ERROR, "non integer divmod");
1158 #else
1159   return flo_divmod(mrb, x);
1160 #endif
1161 }
1162
1163 #ifndef MRB_NO_FLOAT
1164 static mrb_value
1165 flo_divmod(mrb_state *mrb, mrb_value x)
1166 {
1167   mrb_value y = mrb_get_arg1(mrb);
1168   mrb_float div, mod;
1169   mrb_value a, b;
1170
1171   flodivmod(mrb, mrb_float(x), mrb_as_float(mrb, y), &div, &mod);
1172   if (!FIXABLE_FLOAT(div))
1173     a = mrb_float_value(mrb, div);
1174   else
1175     a = mrb_int_value(mrb, (mrb_int)div);
1176   b = mrb_float_value(mrb, mod);
1177   return mrb_assoc_new(mrb, a, b);
1178 }
1179 #endif
1180
1181 /* 15.2.8.3.2 */
1182 /*
1183  * call-seq:
1184  *   int == other  ->  true or false
1185  *
1186  * Return <code>true</code> if <code>int</code> equals <code>other</code>
1187  * numerically.
1188  *
1189  *   1 == 2      #=> false
1190  *   1 == 1.0    #=> true
1191  */
1192
1193 static mrb_value
1194 int_equal(mrb_state *mrb, mrb_value x)
1195 {
1196   mrb_value y = mrb_get_arg1(mrb);
1197
1198   switch (mrb_type(y)) {
1199   case MRB_TT_INTEGER:
1200     return mrb_bool_value(mrb_integer(x) == mrb_integer(y));
1201 #ifndef MRB_NO_FLOAT
1202   case MRB_TT_FLOAT:
1203     return mrb_bool_value((mrb_float)mrb_integer(x) == mrb_float(y));
1204 #endif
1205 #ifdef MRB_USE_BIGINT
1206   case MRB_TT_BIGINT:
1207     return mrb_bool_value(mrb_bint_cmp(mrb, y, x) == 0);
1208 #endif
1209 #ifdef MRB_USE_RATIONAL
1210   case MRB_TT_RATIONAL:
1211     return mrb_bool_value(mrb_equal(mrb, y, x));
1212 #endif
1213 #ifdef MRB_USE_COMPLEX
1214   case MRB_TT_COMPLEX:
1215     return mrb_bool_value(mrb_equal(mrb, y, x));
1216 #endif
1217   default:
1218     return mrb_false_value();
1219   }
1220 }
1221
1222 /* 15.2.8.3.8 */
1223 /*
1224  * call-seq:
1225  *   ~int  ->  integer
1226  *
1227  * One's complement: returns a number where each bit is flipped.
1228  *   ex.0---00001 (1)-> 1---11110 (-2)
1229  *   ex.0---00010 (2)-> 1---11101 (-3)
1230  *   ex.0---00100 (4)-> 1---11011 (-5)
1231  */
1232
1233 static mrb_value
1234 int_rev(mrb_state *mrb, mrb_value num)
1235 {
1236 #ifdef MRB_USE_BIGINT
1237   if (mrb_bigint_p(num)) {
1238     return mrb_bint_rev(mrb, num);
1239   }
1240 #endif
1241   mrb_int val = mrb_integer(num);
1242   return mrb_int_value(mrb, ~val);
1243 }
1244
1245 #define bit_op(x,y,op1,op2) do {\
1246   return mrb_int_value(mrb, (mrb_integer(x) op2 mrb_integer(y)));\
1247 } while(0)
1248
1249 /* 15.2.8.3.9 */
1250 /*
1251  * call-seq:
1252  *   int & integer  ->  integer_result
1253  *
1254  * Bitwise AND.
1255  */
1256
1257 static mrb_value
1258 int_and(mrb_state *mrb, mrb_value x)
1259 {
1260   mrb_value y = mrb_get_arg1(mrb);
1261
1262 #ifdef MRB_USE_BIGINT
1263   if (mrb_bigint_p(x)) {
1264     return mrb_bint_and(mrb, x, y);
1265   }
1266   if (mrb_bigint_p(y)) {
1267     return mrb_bint_and(mrb, mrb_as_bint(mrb, x), y);
1268   }
1269 #endif
1270   bit_op(x, y, and, &);
1271 }
1272
1273 /* 15.2.8.3.10 */
1274 /*
1275  * call-seq:
1276  *   int | integer  ->  integer_result
1277  *
1278  * Bitwise OR.
1279  */
1280
1281 static mrb_value
1282 int_or(mrb_state *mrb, mrb_value x)
1283 {
1284   mrb_value y = mrb_get_arg1(mrb);
1285
1286 #ifdef MRB_USE_BIGINT
1287   if (mrb_bigint_p(x)) {
1288     return mrb_bint_or(mrb, x, y);
1289   }
1290   if (mrb_bigint_p(y)) {
1291     return mrb_bint_or(mrb, mrb_as_bint(mrb, x), y);
1292   }
1293 #endif
1294   bit_op(x, y, or, |);
1295 }
1296
1297 /* 15.2.8.3.11 */
1298 /*
1299  * call-seq:
1300  *   int ^ integer  ->  integer_result
1301  *
1302  * Bitwise EXCLUSIVE OR.
1303  */
1304
1305 static mrb_value
1306 int_xor(mrb_state *mrb, mrb_value x)
1307 {
1308   mrb_value y = mrb_get_arg1(mrb);
1309
1310 #ifdef MRB_USE_BIGINT
1311   if (mrb_bigint_p(x)) {
1312     return mrb_bint_xor(mrb, x, y);
1313   }
1314   if (mrb_bigint_p(y)) {
1315     return mrb_bint_xor(mrb, mrb_as_bint(mrb, x), y);
1316   }
1317 #endif
1318   bit_op(x, y, xor, ^);
1319 }
1320
1321 #define NUMERIC_SHIFT_WIDTH_MAX (MRB_INT_BIT-1)
1322
1323 mrb_bool
1324 mrb_num_shift(mrb_state *mrb, mrb_int val, mrb_int width, mrb_int *num)
1325 {
1326   if (width < 0) {              /* rshift */
1327     if (width == MRB_INT_MIN || -width >= NUMERIC_SHIFT_WIDTH_MAX) {
1328       if (val < 0) {
1329         *num = -1;
1330       }
1331       else {
1332         *num = 0;
1333       }
1334     }
1335     else {
1336       *num = val >> -width;
1337     }
1338   }
1339   else if (val > 0) {
1340     if ((width > NUMERIC_SHIFT_WIDTH_MAX) ||
1341         (val   > (MRB_INT_MAX >> width))) {
1342       return FALSE;
1343     }
1344     *num = val << width;
1345   }
1346   else {
1347     if ((width > NUMERIC_SHIFT_WIDTH_MAX) ||
1348         (val   < (MRB_INT_MIN >> width))) {
1349       return FALSE;
1350     }
1351     if (width == NUMERIC_SHIFT_WIDTH_MAX)
1352       *num = MRB_INT_MIN;
1353     else
1354       *num = val * ((mrb_int)1 << width);
1355   }
1356   return TRUE;
1357 }
1358
1359 /* 15.2.8.3.12 */
1360 /*
1361  * call-seq:
1362  *   int << count  ->  integer or float
1363  *
1364  * Shifts _int_ left _count_ positions (right if _count_ is negative).
1365  */
1366
1367 static mrb_value
1368 int_lshift(mrb_state *mrb, mrb_value x)
1369 {
1370   mrb_int width, val;
1371
1372   width = mrb_as_int(mrb, mrb_get_arg1(mrb));
1373   if (width == 0) {
1374     return x;
1375   }
1376   if (width == MRB_INT_MIN) mrb_int_overflow(mrb, "bit shift");
1377 #ifdef MRB_USE_BIGINT
1378   if (mrb_bigint_p(x)) {
1379     return mrb_bint_lshift(mrb, x, width);
1380   }
1381 #endif
1382   val = mrb_integer(x);
1383   if (val == 0) return x;
1384   if (!mrb_num_shift(mrb, val, width, &val)) {
1385 #ifdef MRB_USE_BIGINT
1386     return mrb_bint_lshift(mrb, mrb_bint_new_int(mrb, val), width);
1387 #else
1388     mrb_int_overflow(mrb, "bit shift");
1389 #endif
1390   }
1391   return mrb_int_value(mrb, val);
1392 }
1393
1394 /* 15.2.8.3.13 */
1395 /*
1396  * call-seq:
1397  *   int >> count  ->  integer or float
1398  *
1399  * Shifts _int_ right _count_ positions (left if _count_ is negative).
1400  */
1401
1402 static mrb_value
1403 int_rshift(mrb_state *mrb, mrb_value x)
1404 {
1405   mrb_int width, val;
1406
1407   width = mrb_as_int(mrb, mrb_get_arg1(mrb));
1408   if (width == 0) {
1409     return x;
1410   }
1411   if (width == MRB_INT_MIN) mrb_int_overflow(mrb, "bit shift");
1412 #ifdef MRB_USE_BIGINT
1413   if (mrb_bigint_p(x)) {
1414     return mrb_bint_rshift(mrb, x, width);
1415   }
1416 #endif
1417   val = mrb_integer(x);
1418   if (val == 0) return x;
1419   if (!mrb_num_shift(mrb, val, -width, &val)) {
1420 #ifdef MRB_USE_BIGINT
1421     return mrb_bint_rshift(mrb, mrb_bint_new_int(mrb, val), width);
1422 #else
1423     mrb_int_overflow(mrb, "bit shift");
1424 #endif
1425   }
1426   return mrb_int_value(mrb, val);
1427 }
1428
1429 static mrb_value
1430 prepare_int_rounding(mrb_state *mrb, mrb_value x)
1431 {
1432   mrb_int nd = 0;
1433   size_t bytes;
1434
1435   mrb_get_args(mrb, "|i", &nd);
1436   if (nd >= 0) {
1437     return mrb_nil_value();
1438   }
1439 #ifdef MRB_USE_BIGINT
1440   if (mrb_bigint_p(x)) {
1441     bytes = mrb_bint_memsize(x);
1442   }
1443   else
1444 #endif
1445     bytes = sizeof(mrb_int);
1446   if (-0.415241 * nd - 0.125 > bytes) {
1447     return mrb_undef_value();
1448   }
1449   return mrb_int_pow(mrb, mrb_fixnum_value(10), mrb_fixnum_value(-nd));
1450 }
1451
1452 /* 15.2.8.3.14 Integer#ceil */
1453 /*
1454  *  call-seq:
1455  *     int.ceil          ->  int
1456  *     int.ceil(ndigits) ->  int
1457  *
1458  *  Returns self.
1459  *
1460  *  When the precision (ndigits) is negative, the returned value is an integer
1461  *  with at least <code>ndigits.abs</code> trailing zeros.
1462  */
1463 static mrb_value
1464 int_ceil(mrb_state *mrb, mrb_value x)
1465 {
1466   mrb_value f = prepare_int_rounding(mrb, x);
1467   if (mrb_undef_p(f)) return mrb_fixnum_value(0);
1468   if (mrb_nil_p(f)) return x;
1469 #ifdef MRB_USE_BIGINT
1470   if (mrb_bigint_p(x)) {
1471     x = mrb_bint_add_d(mrb, x, f);
1472     return mrb_bint_sub(mrb, x, mrb_bint_mod(mrb, x, f));
1473   }
1474 #endif
1475   mrb_int a = mrb_integer(x);
1476   mrb_int b = mrb_integer(f);
1477   mrb_int c = a % b;
1478   int neg = a < 0;
1479   a -= c;
1480   if (!neg) {
1481     if (mrb_int_add_overflow(a, b, &c)) {
1482 #ifdef MRB_USE_BIGINT
1483       x = mrb_bint_new_int(mrb, a);
1484       return mrb_bint_add(mrb, x, f);
1485 #else
1486       mrb_int_overflow(mrb, "ceil");
1487 #endif
1488     }
1489     a = c;
1490   }
1491   return mrb_int_value(mrb, a);
1492 }
1493
1494 /* 15.2.8.3.17 Integer#floor */
1495 /*
1496  *  call-seq:
1497  *     int.floor          ->  int
1498  *     int.floor(ndigits) ->  int
1499  *
1500  *  Returns self.
1501  *
1502  *  When the precision (ndigits) is negative, the returned value is an integer
1503  *  with at least <code>ndigits.abs</code> trailing zeros.
1504  */
1505 static mrb_value
1506 int_floor(mrb_state *mrb, mrb_value x)
1507 {
1508   mrb_value f = prepare_int_rounding(mrb, x);
1509   if (mrb_undef_p(f)) return mrb_fixnum_value(0);
1510   if (mrb_nil_p(f)) return x;
1511 #ifdef MRB_USE_BIGINT
1512   if (mrb_bigint_p(x)) {
1513     return mrb_bint_sub(mrb, x, mrb_bint_mod(mrb, x, f));
1514   }
1515 #endif
1516   mrb_int a = mrb_integer(x);
1517   mrb_int b = mrb_integer(f);
1518   mrb_int c = a % b;
1519   int neg = a < 0;
1520   a -= c;
1521   if (neg) {
1522     if (mrb_int_sub_overflow(a, b, &c)) {
1523 #ifdef MRB_USE_BIGINT
1524       x = mrb_bint_new_int(mrb, a);
1525       return mrb_bint_sub(mrb, x, f);
1526 #else
1527       mrb_int_overflow(mrb, "floor");
1528 #endif
1529     }
1530     a = c;
1531   }
1532   return mrb_int_value(mrb, a);
1533 }
1534
1535 /* 15.2.8.3.20 Integer#round */
1536 /*
1537  *  call-seq:
1538  *     int.round          ->  int
1539  *     int.round(ndigits) ->  int
1540  *
1541  *  Returns self.
1542  *
1543  *  When the precision (ndigits) is negative, the returned value is an integer
1544  *  with at least <code>ndigits.abs</code> trailing zeros.
1545  */
1546 static mrb_value
1547 int_round(mrb_state *mrb, mrb_value x)
1548 {
1549   mrb_value f = prepare_int_rounding(mrb, x);
1550   if (mrb_undef_p(f)) return mrb_fixnum_value(0);
1551   if (mrb_nil_p(f)) return x;
1552 #ifdef MRB_USE_BIGINT
1553   if (mrb_bigint_p(x)) {
1554     mrb_value r = mrb_bint_mod(mrb, x, f);
1555     mrb_value n = mrb_bint_sub(mrb, x, r);
1556     mrb_value h = mrb_bigint_p(f) ? mrb_bint_rshift(mrb, f, 1) : mrb_int_value(mrb, mrb_integer(f)>>1);
1557     mrb_int cmp = mrb_bigint_p(r) ? mrb_bint_cmp(mrb, r, h) : (mrb_bigint_p(h) ? -mrb_bint_cmp(mrb, h, r) : (mrb_integer(r)-mrb_integer(h)));
1558     if ((cmp > 0) || (cmp == 0 && mrb_bint_cmp(mrb, x, mrb_fixnum_value(0)) > 0)) {
1559       n = mrb_as_bint(mrb, n);
1560       n = mrb_bint_add(mrb, n, f);
1561     }
1562     return n;
1563   }
1564 #endif
1565   mrb_int a = mrb_integer(x);
1566   mrb_int b = mrb_integer(f);
1567   mrb_int c = a % b;
1568   a -= c;
1569   if (c < 0) {
1570     c = -c;
1571     if (b/2 < c) {
1572       if (mrb_int_sub_overflow(a, b, &c)) {
1573 #ifdef MRB_USE_BIGINT
1574         x = mrb_bint_new_int(mrb, a);
1575         return mrb_bint_sub(mrb, x, f);
1576 #else
1577         mrb_int_overflow(mrb, "round");
1578 #endif
1579       }
1580     }
1581     a = c;
1582   }
1583   else {
1584     if (b/2 < c) {
1585       if (mrb_int_add_overflow(a, b, &c)) {
1586 #ifdef MRB_USE_BIGINT
1587         x = mrb_bint_new_int(mrb, a);
1588         return mrb_bint_add(mrb, x, f);
1589 #else
1590         mrb_int_overflow(mrb, "round");
1591 #endif
1592       }
1593     }
1594     a = c;
1595   }
1596   return mrb_int_value(mrb, a);
1597 }
1598
1599 /* 15.2.8.3.26 Integer#truncate */
1600 /*
1601  *  call-seq:
1602  *     int.truncate          ->  int
1603  *     int.truncate(ndigits) ->  int
1604  *
1605  *  Returns self.
1606  *
1607  *  When the precision (ndigits) is negative, the returned value is an integer
1608  *  with at least <code>ndigits.abs</code> trailing zeros.
1609  */
1610 static mrb_value
1611 int_truncate(mrb_state *mrb, mrb_value x)
1612 {
1613   mrb_value f = prepare_int_rounding(mrb, x);
1614   if (mrb_undef_p(f)) return mrb_fixnum_value(0);
1615   if (mrb_nil_p(f)) return x;
1616 #ifdef MRB_USE_BIGINT
1617   if (mrb_bigint_p(x)) {
1618     mrb_value m = mrb_bint_mod(mrb, x, f);
1619     x = mrb_bint_sub_d(mrb, x, m);
1620     if (mrb_bint_cmp(mrb, x, mrb_fixnum_value(0)) < 0) {
1621       return mrb_bint_add(mrb, x, f);
1622     }
1623     return x;
1624   }
1625 #endif
1626   mrb_int a = mrb_integer(x);
1627   mrb_int b = mrb_integer(f);
1628   return mrb_int_value(mrb, a - (a % b));
1629 }
1630
1631 /* 15.2.8.3.23 */
1632 /*
1633  *  call-seq:
1634  *     int.to_f  ->  float
1635  *
1636  *  Converts <i>int</i> to a <code>Float</code>.
1637  *
1638  */
1639
1640 #ifndef MRB_NO_FLOAT
1641 static mrb_value
1642 int_to_f(mrb_state *mrb, mrb_value num)
1643 {
1644 #ifdef MRB_USE_BIGINT
1645   if (mrb_bigint_p(num)) {
1646     return mrb_float_value(mrb, mrb_bint_as_float(mrb, num));
1647   }
1648 #endif
1649   return mrb_float_value(mrb, (mrb_float)mrb_integer(num));
1650 }
1651
1652 MRB_API mrb_value
1653 mrb_float_to_integer(mrb_state *mrb, mrb_value x)
1654 {
1655   if (!mrb_float_p(x)) {
1656     mrb_raise(mrb, E_TYPE_ERROR, "non float value");
1657   }
1658   mrb_float f = mrb_float(x);
1659   if (isinf(f) || isnan(f)) {
1660     mrb_raisef(mrb, E_RANGE_ERROR, "float %f out of range", f);
1661   }
1662   return flo_to_i(mrb, x);
1663 }
1664 #endif
1665
1666 mrb_value
1667 mrb_int_add(mrb_state *mrb, mrb_value x, mrb_value y)
1668 {
1669   mrb_int a;
1670
1671   a = mrb_integer(x);
1672   if (mrb_integer_p(y)) {
1673     mrb_int b, c;
1674
1675     if (a == 0) return y;
1676     b = mrb_integer(y);
1677     if (b == 0) return x;
1678     if (mrb_int_add_overflow(a, b, &c)) {
1679 #ifdef MRB_USE_BIGINT
1680       x = mrb_bint_new_int(mrb, a);
1681       return mrb_bint_add(mrb, x, y);
1682 #else
1683       mrb_int_overflow(mrb, "addition");
1684 #endif
1685     }
1686     return mrb_int_value(mrb, c);
1687   }
1688   switch (mrb_type(y)) {
1689 #ifdef MRB_USE_BIGINT
1690   case MRB_TT_BIGINT:
1691     return mrb_bint_add(mrb, y, x);
1692 #endif
1693 #ifdef MRB_USE_RATIONAL
1694   case MRB_TT_RATIONAL:
1695     return mrb_rational_add(mrb, y, x);
1696 #endif
1697 #ifdef MRB_USE_COMPLEX
1698   case MRB_TT_COMPLEX:
1699     return mrb_complex_add(mrb, y, x);
1700 #endif
1701   default:
1702 #ifdef MRB_NO_FLOAT
1703     mrb_raise(mrb, E_TYPE_ERROR, "non integer addition");
1704 #else
1705     return mrb_float_value(mrb, (mrb_float)a + mrb_as_float(mrb, y));
1706 #endif
1707   }
1708 }
1709
1710 /* 15.2.8.3.3 */
1711 /*
1712  * call-seq:
1713  *   int + numeric  ->  numeric_result
1714  *
1715  * Performs addition: the class of the resulting object depends on
1716  * the class of <code>numeric</code> and on the magnitude of the
1717  * result.
1718  */
1719 static mrb_value
1720 int_add(mrb_state *mrb, mrb_value self)
1721 {
1722   mrb_value other = mrb_get_arg1(mrb);
1723
1724 #ifdef MRB_USE_BIGINT
1725   if (mrb_bigint_p(self)) {
1726     return mrb_bint_add(mrb, self, other);
1727   }
1728 #endif
1729   return mrb_int_add(mrb, self, other);
1730 }
1731
1732 mrb_value
1733 mrb_int_sub(mrb_state *mrb, mrb_value x, mrb_value y)
1734 {
1735   mrb_int a;
1736
1737   a = mrb_integer(x);
1738   if (mrb_integer_p(y)) {
1739     mrb_int b, c;
1740
1741     b = mrb_integer(y);
1742     if (mrb_int_sub_overflow(a, b, &c)) {
1743 #ifdef MRB_USE_BIGINT
1744       x = mrb_bint_new_int(mrb, a);
1745       return mrb_bint_sub(mrb, x, y);
1746 #else
1747       mrb_int_overflow(mrb, "subtraction");
1748 #endif
1749     }
1750     return mrb_int_value(mrb, c);
1751   }
1752   switch (mrb_type(y)) {
1753 #ifdef MRB_USE_BIGINT
1754   case MRB_TT_BIGINT:
1755     return mrb_bint_sub(mrb, mrb_bint_new_int(mrb, a), y);
1756 #endif
1757 #ifdef MRB_USE_RATIONAL
1758   case MRB_TT_RATIONAL:
1759     return mrb_rational_sub(mrb, mrb_rational_new(mrb, a, 1), y);
1760 #endif
1761 #ifdef MRB_USE_COMPLEX
1762   case MRB_TT_COMPLEX:
1763     return mrb_complex_sub(mrb, mrb_complex_new(mrb, (mrb_float)a, 0), y);
1764 #endif
1765   default:
1766 #ifdef MRB_NO_FLOAT
1767     mrb_raise(mrb, E_TYPE_ERROR, "non integer subtraction");
1768 #else
1769     return mrb_float_value(mrb, (mrb_float)a - mrb_as_float(mrb, y));
1770 #endif
1771   }
1772 }
1773
1774 /* 15.2.8.3.4 */
1775 /*
1776  * call-seq:
1777  *   int - numeric  ->  numeric
1778  *
1779  * Performs subtraction: the class of the resulting object depends on
1780  * the class of <code>numeric</code> and on the magnitude of the
1781  * result.
1782  */
1783 static mrb_value
1784 int_sub(mrb_state *mrb, mrb_value self)
1785 {
1786   mrb_value other = mrb_get_arg1(mrb);
1787
1788 #ifdef MRB_USE_BIGINT
1789   if (mrb_bigint_p(self)) {
1790     return mrb_bint_sub(mrb, self, other);
1791   }
1792 #endif
1793   return mrb_int_sub(mrb, self, other);
1794 }
1795
1796 MRB_API char*
1797 mrb_int_to_cstr(char *buf, size_t len, mrb_int n, mrb_int base)
1798 {
1799   char *bufend = buf + len;
1800   char *b = bufend-1;
1801
1802   if (base < 2 || 36 < base) return NULL;
1803   if (len < 2) return NULL;
1804
1805   if (n == 0) {
1806     buf[0] = '0';
1807     buf[1] = '\0';
1808     return buf;
1809   }
1810
1811   *b = '\0';
1812   if (n < 0) {
1813     do {
1814       if (b-- == buf) return NULL;
1815       *b = mrb_digitmap[-(n % base)];
1816     } while (n /= base);
1817     if (b-- == buf) return NULL;
1818     *b = '-';
1819   }
1820   else {
1821     do {
1822       if (b-- == buf) return NULL;
1823       *b = mrb_digitmap[(int)(n % base)];
1824     } while (n /= base);
1825   }
1826   return b;
1827 }
1828
1829 MRB_API mrb_value
1830 mrb_integer_to_str(mrb_state *mrb, mrb_value x, mrb_int base)
1831 {
1832   char buf[MRB_INT_BIT+1];
1833
1834   if (base < 2 || 36 < base) {
1835     mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %i", base);
1836   }
1837 #ifdef MRB_USE_BIGINT
1838   if (mrb_bigint_p(x)) {
1839     return mrb_bint_to_s(mrb, x, base);
1840   }
1841 #endif
1842   mrb_int val = mrb_integer(x);
1843   const char *p = mrb_int_to_cstr(buf, sizeof(buf), val, base);
1844   mrb_assert(p != NULL);
1845   mrb_value str = mrb_str_new_cstr(mrb, p);
1846   RSTR_SET_ASCII_FLAG(mrb_str_ptr(str));
1847   return str;
1848 }
1849
1850 /* 15.2.8.3.25 */
1851 /*
1852  *  call-seq:
1853  *     int.to_s(base=10)  ->  string
1854  *
1855  *  Returns a string containing the representation of <i>int</i> radix
1856  *  <i>base</i> (between 2 and 36).
1857  *
1858  *     12345.to_s       #=> "12345"
1859  *     12345.to_s(2)    #=> "11000000111001"
1860  *     12345.to_s(8)    #=> "30071"
1861  *     12345.to_s(10)   #=> "12345"
1862  *     12345.to_s(16)   #=> "3039"
1863  *     12345.to_s(36)   #=> "9ix"
1864  *
1865  */
1866 static mrb_value
1867 int_to_s(mrb_state *mrb, mrb_value self)
1868 {
1869   mrb_int base;
1870
1871   if (mrb_get_argc(mrb) > 0) {
1872     base = mrb_integer(mrb_get_arg1(mrb));
1873   }
1874   else {
1875     base = 10;
1876   }
1877   return mrb_integer_to_str(mrb, self, base);
1878 }
1879
1880 /* compare two numbers: (1:0:-1; -2 for error) */
1881 static mrb_int
1882 cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2)
1883 {
1884 #ifdef MRB_USE_BIGINT
1885   if (mrb_bigint_p(v1)) {
1886     return mrb_bint_cmp(mrb, v1, v2);
1887   }
1888   if (mrb_bigint_p(v2)) {
1889     return mrb_bint_cmp(mrb, mrb_bint_new_int(mrb, mrb_integer(v1)), v2);
1890   }
1891 #endif
1892
1893 #ifdef MRB_NO_FLOAT
1894   mrb_int x, y;
1895 #else
1896   mrb_float x, y;
1897 #endif
1898
1899 #ifdef MRB_NO_FLOAT
1900   x = mrb_integer(v1);
1901 #else
1902   x = mrb_as_float(mrb, v1);
1903 #endif
1904   switch (mrb_type(v2)) {
1905   case MRB_TT_INTEGER:
1906 #ifdef MRB_NO_FLOAT
1907     y = mrb_integer(v2);
1908 #else
1909     y = (mrb_float)mrb_integer(v2);
1910 #endif
1911     break;
1912 #ifndef MRB_NO_FLOAT
1913   case MRB_TT_FLOAT:
1914     y = mrb_float(v2);
1915     break;
1916 #ifdef MRB_USE_RATIONAL
1917   case MRB_TT_RATIONAL:
1918     y = mrb_as_float(mrb, v2);
1919     break;
1920 #endif
1921 #endif
1922   default:
1923     return -2;
1924   }
1925   if (x > y)
1926     return 1;
1927   else {
1928     if (x < y)
1929       return -1;
1930     return 0;
1931   }
1932 }
1933
1934 static mrb_value
1935 int_hash(mrb_state *mrb, mrb_value self)
1936 {
1937 #ifdef MRB_USE_BIGINT
1938   if (mrb_bigint_p(self)) {
1939     return mrb_bint_hash(mrb, self);
1940   }
1941 #endif
1942   mrb_int n = mrb_integer(self);
1943   return mrb_int_value(mrb, mrb_byte_hash((uint8_t*)&n, sizeof(n)));
1944 }
1945
1946 /* 15.2.8.3.1 */
1947 /* 15.2.9.3.1 */
1948 /*
1949  * call-seq:
1950  *     self.f <=> other.f    => -1, 0, +1, or nil
1951  *             <  => -1
1952  *             =  =>  0
1953  *             >  => +1
1954  *  Comparison---Returns -1, 0, or +1 depending on whether <i>int</i> is
1955  *  less than, equal to, or greater than <i>numeric</i>. This is the
1956  *  basis for the tests in <code>Comparable</code>. When the operands are
1957  *  not comparable, it returns nil instead of raising an exception.
1958  */
1959 static mrb_value
1960 num_cmp(mrb_state *mrb, mrb_value self)
1961 {
1962   mrb_value other = mrb_get_arg1(mrb);
1963   mrb_int n;
1964
1965   n = cmpnum(mrb, self, other);
1966   if (n == -2) return mrb_nil_value();
1967   return mrb_fixnum_value(n);
1968 }
1969
1970 static mrb_noreturn void
1971 cmperr(mrb_state *mrb, mrb_value v1, mrb_value v2)
1972 {
1973   mrb_raisef(mrb, E_ARGUMENT_ERROR, "comparison of %t with %t failed", v1, v2);
1974 }
1975
1976 static mrb_value
1977 num_lt(mrb_state *mrb, mrb_value self)
1978 {
1979   mrb_value other = mrb_get_arg1(mrb);
1980   mrb_int n;
1981
1982   n = cmpnum(mrb, self, other);
1983   if (n == -2) cmperr(mrb, self, other);
1984   if (n < 0) return mrb_true_value();
1985   return mrb_false_value();
1986 }
1987
1988 static mrb_value
1989 num_le(mrb_state *mrb, mrb_value self)
1990 {
1991   mrb_value other = mrb_get_arg1(mrb);
1992   mrb_int n;
1993
1994   n = cmpnum(mrb, self, other);
1995   if (n == -2) cmperr(mrb, self, other);
1996   if (n <= 0) return mrb_true_value();
1997   return mrb_false_value();
1998 }
1999
2000 static mrb_value
2001 num_gt(mrb_state *mrb, mrb_value self)
2002 {
2003   mrb_value other = mrb_get_arg1(mrb);
2004   mrb_int n;
2005
2006   n = cmpnum(mrb, self, other);
2007   if (n == -2) cmperr(mrb, self, other);
2008   if (n > 0) return mrb_true_value();
2009   return mrb_false_value();
2010 }
2011
2012 static mrb_value
2013 num_ge(mrb_state *mrb, mrb_value self)
2014 {
2015   mrb_value other = mrb_get_arg1(mrb);
2016   mrb_int n;
2017
2018   n = cmpnum(mrb, self, other);
2019   if (n == -2) cmperr(mrb, self, other);
2020   if (n >= 0) return mrb_true_value();
2021   return mrb_false_value();
2022 }
2023
2024 MRB_API mrb_int
2025 mrb_cmp(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
2026 {
2027   mrb_value v;
2028
2029   switch (mrb_type(obj1)) {
2030   case MRB_TT_INTEGER:
2031   case MRB_TT_FLOAT:
2032   case MRB_TT_BIGINT:
2033     return cmpnum(mrb, obj1, obj2);
2034   case MRB_TT_STRING:
2035     if (!mrb_string_p(obj2))
2036       return -2;
2037     return mrb_str_cmp(mrb, obj1, obj2);
2038   default:
2039     if (!mrb_respond_to(mrb, obj1, MRB_OPSYM(cmp))) return -2;
2040     v = mrb_funcall_argv(mrb, obj1, MRB_OPSYM(cmp), 1, &obj2);
2041     if (mrb_nil_p(v) || !mrb_integer_p(v))
2042       return -2;
2043     return mrb_integer(v);
2044   }
2045 }
2046
2047 static mrb_value
2048 num_finite_p(mrb_state *mrb, mrb_value self)
2049 {
2050   return mrb_true_value();
2051 }
2052
2053 static mrb_value
2054 num_infinite_p(mrb_state *mrb, mrb_value self)
2055 {
2056   return mrb_false_value();
2057 }
2058
2059 #ifndef MRB_NO_FLOAT
2060 static mrb_value
2061 flo_hash(mrb_state *mrb, mrb_value flo)
2062 {
2063   mrb_float f = mrb_float(flo);
2064   /* normalize -0.0 to 0.0 */
2065   if (f == 0) f = 0.0;
2066   return mrb_int_value(mrb, (mrb_int)mrb_byte_hash((uint8_t*)&f, sizeof(f)));
2067 }
2068 #endif
2069
2070 /* ------------------------------------------------------------------------*/
2071 void
2072 mrb_init_numeric(mrb_state *mrb)
2073 {
2074   struct RClass *numeric, *integer;
2075 #ifndef MRB_NO_FLOAT
2076   struct RClass *fl;
2077 #endif
2078
2079   /* Numeric Class */
2080   numeric = mrb_define_class_id(mrb, MRB_SYM(Numeric), mrb->object_class);                  /* 15.2.7 */
2081   mrb_define_method_id(mrb, numeric, MRB_SYM_Q(finite),  num_finite_p,    MRB_ARGS_NONE());
2082   mrb_define_method_id(mrb, numeric, MRB_SYM_Q(infinite),num_infinite_p,  MRB_ARGS_NONE());
2083   mrb_define_method_id(mrb, numeric, MRB_SYM_Q(eql),     num_eql,         MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
2084
2085   /* Integer Class */
2086   mrb->integer_class = integer = mrb_define_class_id(mrb, MRB_SYM(Integer),  numeric);     /* 15.2.8 */
2087   MRB_SET_INSTANCE_TT(integer, MRB_TT_INTEGER);
2088   MRB_UNDEF_ALLOCATOR(integer);
2089   mrb_undef_class_method_id(mrb, integer, MRB_SYM(new));
2090   mrb_define_method_id(mrb, integer, MRB_OPSYM(pow),    int_pow,         MRB_ARGS_REQ(1));
2091   mrb_define_method_id(mrb, integer, MRB_OPSYM(cmp),    num_cmp,         MRB_ARGS_REQ(1)); /* 15.2.8.3.1  */
2092   mrb_define_method_id(mrb, integer, MRB_OPSYM(lt),     num_lt,          MRB_ARGS_REQ(1));
2093   mrb_define_method_id(mrb, integer, MRB_OPSYM(le),     num_le,          MRB_ARGS_REQ(1));
2094   mrb_define_method_id(mrb, integer, MRB_OPSYM(gt),     num_gt,          MRB_ARGS_REQ(1));
2095   mrb_define_method_id(mrb, integer, MRB_OPSYM(ge),     num_ge,          MRB_ARGS_REQ(1));
2096
2097   mrb_define_method_id(mrb, integer, MRB_SYM(to_i),     mrb_obj_itself,  MRB_ARGS_NONE()); /* 15.2.8.3.24 */
2098   mrb_define_method_id(mrb, integer, MRB_SYM(to_int),   mrb_obj_itself,  MRB_ARGS_NONE());
2099
2100   mrb_define_method_id(mrb, integer, MRB_OPSYM(add),    int_add,         MRB_ARGS_REQ(1)); /* 15.2.8.3.1 */
2101   mrb_define_method_id(mrb, integer, MRB_OPSYM(sub),    int_sub,         MRB_ARGS_REQ(1)); /* 15.2.8.3.2 */
2102   mrb_define_method_id(mrb, integer, MRB_OPSYM(mul),    int_mul,         MRB_ARGS_REQ(1)); /* 15.2.8.3.3 */
2103   mrb_define_method_id(mrb, integer, MRB_OPSYM(mod),    int_mod,         MRB_ARGS_REQ(1)); /* 15.2.8.3.5 */
2104   mrb_define_method_id(mrb, integer, MRB_OPSYM(div),    int_div,         MRB_ARGS_REQ(1)); /* 15.2.8.3.6 */
2105   mrb_define_method_id(mrb, integer, MRB_SYM(quo),      int_quo,         MRB_ARGS_REQ(1)); /* 15.2.7.4.5(x) */
2106   mrb_define_method_id(mrb, integer, MRB_SYM(div),      int_idiv,        MRB_ARGS_REQ(1));
2107   mrb_define_method_id(mrb, integer, MRB_OPSYM(eq),     int_equal,       MRB_ARGS_REQ(1)); /* 15.2.8.3.7 */
2108   mrb_define_method_id(mrb, integer, MRB_OPSYM(neg),    int_rev,         MRB_ARGS_NONE()); /* 15.2.8.3.8 */
2109   mrb_define_method_id(mrb, integer, MRB_OPSYM(and),    int_and,         MRB_ARGS_REQ(1)); /* 15.2.8.3.9 */
2110   mrb_define_method_id(mrb, integer, MRB_OPSYM(or),     int_or,          MRB_ARGS_REQ(1)); /* 15.2.8.3.10 */
2111   mrb_define_method_id(mrb, integer, MRB_OPSYM(xor),    int_xor,         MRB_ARGS_REQ(1)); /* 15.2.8.3.11 */
2112   mrb_define_method_id(mrb, integer, MRB_OPSYM(lshift), int_lshift,      MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */
2113   mrb_define_method_id(mrb, integer, MRB_OPSYM(rshift), int_rshift,      MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */
2114   mrb_define_method_id(mrb, integer, MRB_SYM(ceil),     int_ceil,        MRB_ARGS_OPT(1)); /* 15.2.8.3.14 */
2115   mrb_define_method_id(mrb, integer, MRB_SYM(floor),    int_floor,       MRB_ARGS_OPT(1)); /* 15.2.8.3.17 */
2116   mrb_define_method_id(mrb, integer, MRB_SYM(round),    int_round,       MRB_ARGS_OPT(1)); /* 15.2.8.3.20 */
2117   mrb_define_method_id(mrb, integer, MRB_SYM(truncate), int_truncate,    MRB_ARGS_OPT(1)); /* 15.2.8.3.26 */
2118   mrb_define_method_id(mrb, integer, MRB_SYM(hash),     int_hash,        MRB_ARGS_NONE()); /* 15.2.8.3.18 */
2119 #ifndef MRB_NO_FLOAT
2120   mrb_define_method_id(mrb, integer, MRB_SYM(to_f),     int_to_f,        MRB_ARGS_NONE()); /* 15.2.8.3.23 */
2121 #endif
2122   mrb_define_method_id(mrb, integer, MRB_SYM(to_s),     int_to_s,        MRB_ARGS_OPT(1)); /* 15.2.8.3.25 */
2123   mrb_define_method_id(mrb, integer, MRB_SYM(inspect),  int_to_s,        MRB_ARGS_OPT(1));
2124   mrb_define_method_id(mrb, integer, MRB_SYM(divmod),   int_divmod,      MRB_ARGS_REQ(1)); /* 15.2.8.3.30(x) */
2125   mrb_define_method_id(mrb, integer, MRB_SYM(__coerce_step_counter), coerce_step_counter, MRB_ARGS_REQ(2));
2126
2127   /* Fixnum Class for compatibility */
2128   mrb_define_const_id(mrb, mrb->object_class, MRB_SYM(Fixnum), mrb_obj_value(integer));
2129
2130 #ifndef MRB_NO_FLOAT
2131   /* Float Class */
2132   mrb->float_class = fl = mrb_define_class_id(mrb, MRB_SYM(Float), numeric);               /* 15.2.9 */
2133   MRB_SET_INSTANCE_TT(fl, MRB_TT_FLOAT);
2134   MRB_UNDEF_ALLOCATOR(fl);
2135   mrb_undef_class_method(mrb,  fl, "new");
2136   mrb_define_method_id(mrb, fl,      MRB_OPSYM(pow),     flo_pow,        MRB_ARGS_REQ(1));
2137   mrb_define_method_id(mrb, fl,      MRB_OPSYM(div),     flo_div,        MRB_ARGS_REQ(1)); /* 15.2.9.3.6 */
2138   mrb_define_method_id(mrb, fl,      MRB_SYM(quo),       flo_div,        MRB_ARGS_REQ(1)); /* 15.2.7.4.5(x) */
2139   mrb_define_method_id(mrb, fl,      MRB_SYM(div),       flo_idiv,       MRB_ARGS_REQ(1));
2140   mrb_define_method_id(mrb, fl,      MRB_OPSYM(add),     flo_add,        MRB_ARGS_REQ(1)); /* 15.2.9.3.3 */
2141   mrb_define_method_id(mrb, fl,      MRB_OPSYM(sub),     flo_sub,        MRB_ARGS_REQ(1)); /* 15.2.9.3.4 */
2142   mrb_define_method_id(mrb, fl,      MRB_OPSYM(mul),     flo_mul,        MRB_ARGS_REQ(1)); /* 15.2.9.3.5 */
2143   mrb_define_method_id(mrb, fl,      MRB_OPSYM(mod),     flo_mod,        MRB_ARGS_REQ(1)); /* 15.2.9.3.7 */
2144   mrb_define_method_id(mrb, fl,      MRB_OPSYM(cmp),     num_cmp,        MRB_ARGS_REQ(1)); /* 15.2.9.3.1 */
2145   mrb_define_method_id(mrb, fl,      MRB_OPSYM(lt),      num_lt,         MRB_ARGS_REQ(1));
2146   mrb_define_method_id(mrb, fl,      MRB_OPSYM(le),      num_le,         MRB_ARGS_REQ(1));
2147   mrb_define_method_id(mrb, fl,      MRB_OPSYM(gt),      num_gt,         MRB_ARGS_REQ(1));
2148   mrb_define_method_id(mrb, fl,      MRB_OPSYM(ge),      num_ge,         MRB_ARGS_REQ(1));
2149   mrb_define_method_id(mrb, fl,      MRB_OPSYM(eq),      flo_eq,         MRB_ARGS_REQ(1)); /* 15.2.9.3.2 */
2150   mrb_define_method_id(mrb, fl,      MRB_SYM(ceil),      flo_ceil,       MRB_ARGS_OPT(1)); /* 15.2.9.3.8  */
2151   mrb_define_method_id(mrb, fl,      MRB_SYM_Q(finite),  flo_finite_p,   MRB_ARGS_NONE()); /* 15.2.9.3.9  */
2152   mrb_define_method_id(mrb, fl,      MRB_SYM(floor),     flo_floor,      MRB_ARGS_OPT(1)); /* 15.2.9.3.10 */
2153   mrb_define_method_id(mrb, fl,      MRB_SYM_Q(infinite),flo_infinite_p, MRB_ARGS_NONE()); /* 15.2.9.3.11 */
2154   mrb_define_method_id(mrb, fl,      MRB_SYM(round),     flo_round,      MRB_ARGS_OPT(1)); /* 15.2.9.3.12 */
2155   mrb_define_method_id(mrb, fl,      MRB_SYM(to_f),      mrb_obj_itself, MRB_ARGS_NONE()); /* 15.2.9.3.13 */
2156   mrb_define_method_id(mrb, fl,      MRB_SYM(to_i),      flo_to_i,       MRB_ARGS_NONE()); /* 15.2.9.3.14 */
2157   mrb_define_method_id(mrb, fl,      MRB_SYM(truncate),  flo_truncate,   MRB_ARGS_OPT(1)); /* 15.2.9.3.15 */
2158   mrb_define_method_id(mrb, fl,      MRB_SYM(divmod),    flo_divmod,     MRB_ARGS_REQ(1));
2159
2160   mrb_define_method_id(mrb, fl,      MRB_SYM(to_s),      flo_to_s,       MRB_ARGS_NONE()); /* 15.2.9.3.16(x) */
2161   mrb_define_method_id(mrb, fl,      MRB_SYM(inspect),   flo_to_s,       MRB_ARGS_NONE());
2162   mrb_define_method_id(mrb, fl,      MRB_SYM_Q(nan),     flo_nan_p,      MRB_ARGS_NONE());
2163   mrb_define_method_id(mrb, fl,      MRB_SYM(abs),       flo_abs,        MRB_ARGS_NONE()); /* 15.2.7.4.3 */
2164   mrb_define_method_id(mrb, fl,      MRB_SYM(hash),      flo_hash,       MRB_ARGS_NONE());
2165
2166 #ifdef INFINITY
2167   mrb_define_const_id(mrb, fl, MRB_SYM(INFINITY), mrb_float_value(mrb, INFINITY));
2168 #endif
2169 #ifdef NAN
2170   mrb_define_const_id(mrb, fl, MRB_SYM(NAN), mrb_float_value(mrb, NAN));
2171 #endif
2172 #endif
2173 }