From be1c7e50e1e8809ea56f2c9d472eccd8ffd73a97 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 04:57:58 +0200 Subject: Adding upstream version 1.44.3. Signed-off-by: Daniel Baumann --- web/server/h2o/libh2o/deps/mruby/src/numeric.c | 1355 ++++++++++++++++++++++++ 1 file changed, 1355 insertions(+) create mode 100644 web/server/h2o/libh2o/deps/mruby/src/numeric.c (limited to 'web/server/h2o/libh2o/deps/mruby/src/numeric.c') diff --git a/web/server/h2o/libh2o/deps/mruby/src/numeric.c b/web/server/h2o/libh2o/deps/mruby/src/numeric.c new file mode 100644 index 00000000..afb8415a --- /dev/null +++ b/web/server/h2o/libh2o/deps/mruby/src/numeric.c @@ -0,0 +1,1355 @@ +/* +** numeric.c - Numeric, Integer, Float, Fixnum class +** +** See Copyright Notice in mruby.h +*/ + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#ifdef MRB_USE_FLOAT +#define trunc(f) truncf(f) +#define floor(f) floorf(f) +#define ceil(f) ceilf(f) +#define fmod(x,y) fmodf(x,y) +#define MRB_FLO_TO_STR_FMT "%.7g" +#else +#define MRB_FLO_TO_STR_FMT "%.14g" +#endif + +MRB_API mrb_float +mrb_to_flo(mrb_state *mrb, mrb_value val) +{ + switch (mrb_type(val)) { + case MRB_TT_FIXNUM: + return (mrb_float)mrb_fixnum(val); + case MRB_TT_FLOAT: + break; + default: + mrb_raise(mrb, E_TYPE_ERROR, "non float value"); + } + return mrb_float(val); +} + +/* + * call-seq: + * + * num ** other -> num + * + * Raises num the other power. + * + * 2.0**3 #=> 8.0 + */ +static mrb_value +num_pow(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + mrb_float d; + + mrb_get_args(mrb, "o", &y); + if (mrb_fixnum_p(x) && mrb_fixnum_p(y)) { + /* try ipow() */ + mrb_int base = mrb_fixnum(x); + mrb_int exp = mrb_fixnum(y); + mrb_int result = 1; + + if (exp < 0) goto float_pow; + for (;;) { + if (exp & 1) { + if (mrb_int_mul_overflow(result, base, &result)) { + goto float_pow; + } + } + exp >>= 1; + if (exp == 0) break; + if (mrb_int_mul_overflow(base, base, &base)) { + goto float_pow; + } + } + return mrb_fixnum_value(result); + } + float_pow: + d = pow(mrb_to_flo(mrb, x), mrb_to_flo(mrb, y)); + return mrb_float_value(mrb, d); +} + +/* 15.2.8.3.4 */ +/* 15.2.9.3.4 */ +/* + * call-seq: + * num / other -> num + * + * Performs division: the class of the resulting object depends on + * the class of num and on the magnitude of the + * result. + */ + +mrb_value +mrb_num_div(mrb_state *mrb, mrb_value x, mrb_value y) +{ + return mrb_float_value(mrb, mrb_to_flo(mrb, x) / mrb_to_flo(mrb, y)); +} + +/* 15.2.9.3.19(x) */ +/* + * call-seq: + * num.quo(numeric) -> real + * + * Returns most exact division. + */ + +static mrb_value +num_div(mrb_state *mrb, mrb_value x) +{ + mrb_float y; + + mrb_get_args(mrb, "f", &y); + return mrb_float_value(mrb, mrb_to_flo(mrb, x) / y); +} + +/******************************************************************** + * + * Document-class: Float + * + * Float objects represent inexact real numbers using + * the native architecture's double-precision floating point + * representation. + */ + +/* 15.2.9.3.16(x) */ +/* + * call-seq: + * flt.to_s -> string + * + * Returns a string containing a representation of self. As well as a + * fixed or exponential form of the number, the call may return + * "NaN", "Infinity", and + * "-Infinity". + */ + +static mrb_value +flo_to_s(mrb_state *mrb, mrb_value flt) +{ + if (isnan(mrb_float(flt))) { + return mrb_str_new_lit(mrb, "NaN"); + } + return mrb_float_to_str(mrb, flt, MRB_FLO_TO_STR_FMT); +} + +/* 15.2.9.3.2 */ +/* + * call-seq: + * float - other -> float + * + * Returns a new float which is the difference of float + * and other. + */ + +static mrb_value +flo_minus(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + + mrb_get_args(mrb, "o", &y); + return mrb_float_value(mrb, mrb_float(x) - mrb_to_flo(mrb, y)); +} + +/* 15.2.9.3.3 */ +/* + * call-seq: + * float * other -> float + * + * Returns a new float which is the product of float + * and other. + */ + +static mrb_value +flo_mul(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + + mrb_get_args(mrb, "o", &y); + return mrb_float_value(mrb, mrb_float(x) * mrb_to_flo(mrb, y)); +} + +static void +flodivmod(mrb_state *mrb, mrb_float x, mrb_float y, mrb_float *divp, mrb_float *modp) +{ + mrb_float div; + mrb_float mod; + + if (y == 0.0) { + if (x > 0.0) div = INFINITY; + else if (x < 0.0) div = -INFINITY; + else div = NAN; /* x == 0.0 */ + mod = NAN; + } + else { + mod = fmod(x, y); + if (isinf(x) && isfinite(y)) + div = x; + else + div = (x - mod) / y; + if (y*mod < 0) { + mod += y; + div -= 1.0; + } + } + + if (modp) *modp = mod; + if (divp) *divp = div; +} + +/* 15.2.9.3.5 */ +/* + * call-seq: + * flt % other -> float + * flt.modulo(other) -> float + * + * Return the modulo after division of flt by other. + * + * 6543.21.modulo(137) #=> 104.21 + * 6543.21.modulo(137.24) #=> 92.9299999999996 + */ + +static mrb_value +flo_mod(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + mrb_float mod; + + mrb_get_args(mrb, "o", &y); + + flodivmod(mrb, mrb_float(x), mrb_to_flo(mrb, y), 0, &mod); + return mrb_float_value(mrb, mod); +} + +/* 15.2.8.3.16 */ +/* + * call-seq: + * num.eql?(numeric) -> true or false + * + * Returns true if num and numeric are the + * same type and have equal values. + * + * 1 == 1.0 #=> true + * 1.eql?(1.0) #=> false + * (1.0).eql?(1.0) #=> true + */ +static mrb_value +fix_eql(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + + mrb_get_args(mrb, "o", &y); + if (!mrb_fixnum_p(y)) return mrb_false_value(); + return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y)); +} + +static mrb_value +flo_eql(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + + mrb_get_args(mrb, "o", &y); + if (!mrb_float_p(y)) return mrb_false_value(); + return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_fixnum(y)); +} + +/* 15.2.9.3.7 */ +/* + * call-seq: + * flt == obj -> true or false + * + * Returns true only if obj has the same value + * as flt. Contrast this with Float#eql?, which + * requires obj to be a Float. + * + * 1.0 == 1 #=> true + * + */ + +static mrb_value +flo_eq(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + mrb_get_args(mrb, "o", &y); + + switch (mrb_type(y)) { + case MRB_TT_FIXNUM: + return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_fixnum(y)); + case MRB_TT_FLOAT: + return mrb_bool_value(mrb_float(x) == mrb_float(y)); + default: + return mrb_false_value(); + } +} + +static int64_t +value_int64(mrb_state *mrb, mrb_value x) +{ + switch (mrb_type(x)) { + case MRB_TT_FIXNUM: + return (int64_t)mrb_fixnum(x); + break; + case MRB_TT_FLOAT: + return (int64_t)mrb_float(x); + default: + mrb_raise(mrb, E_TYPE_ERROR, "cannot convert to Integer"); + break; + } + /* not reached */ + return 0; +} + +static mrb_value +int64_value(mrb_state *mrb, int64_t v) +{ + if (FIXABLE(v)) { + return mrb_fixnum_value((mrb_int)v); + } + return mrb_float_value(mrb, (mrb_float)v); +} + +static mrb_value +flo_rev(mrb_state *mrb, mrb_value x) +{ + int64_t v1; + mrb_get_args(mrb, ""); + v1 = (int64_t)mrb_float(x); + return int64_value(mrb, ~v1); +} + +static mrb_value +flo_and(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + int64_t v1, v2; + mrb_get_args(mrb, "o", &y); + + v1 = (int64_t)mrb_float(x); + v2 = value_int64(mrb, y); + return int64_value(mrb, v1 & v2); +} + +static mrb_value +flo_or(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + int64_t v1, v2; + mrb_get_args(mrb, "o", &y); + + v1 = (int64_t)mrb_float(x); + v2 = value_int64(mrb, y); + return int64_value(mrb, v1 | v2); +} + +static mrb_value +flo_xor(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + int64_t v1, v2; + mrb_get_args(mrb, "o", &y); + + v1 = (int64_t)mrb_float(x); + v2 = value_int64(mrb, y); + return int64_value(mrb, v1 ^ v2); +} + +static mrb_value +flo_shift(mrb_state *mrb, mrb_value x, mrb_int width) +{ + mrb_float val; + + if (width == 0) { + return x; + } + val = mrb_float(x); + if (width < 0) { + while (width++) { + val /= 2; + } +#if defined(_ISOC99_SOURCE) + val = trunc(val); +#else + if (val > 0){ + val = floor(val); + } else { + val = ceil(val); + } +#endif + if (val == 0 && mrb_float(x) < 0) { + return mrb_fixnum_value(-1); + } + } + else { + while (width--) { + val *= 2; + } + } + if (FIXABLE_FLOAT(val)) { + return mrb_fixnum_value((mrb_int)val); + } + return mrb_float_value(mrb, val); +} + +static mrb_value +flo_lshift(mrb_state *mrb, mrb_value x) +{ + mrb_int width; + + mrb_get_args(mrb, "i", &width); + return flo_shift(mrb, x, -width); +} + +static mrb_value +flo_rshift(mrb_state *mrb, mrb_value x) +{ + mrb_int width; + + mrb_get_args(mrb, "i", &width); + return flo_shift(mrb, x, width); +} + +/* 15.2.9.3.13 */ +/* + * call-seq: + * flt.to_f -> self + * + * As flt is already a float, returns +self+. + */ + +static mrb_value +flo_to_f(mrb_state *mrb, mrb_value num) +{ + return num; +} + +/* 15.2.9.3.11 */ +/* + * call-seq: + * flt.infinite? -> nil, -1, +1 + * + * Returns nil, -1, or +1 depending on whether flt + * is finite, -infinity, or +infinity. + * + * (0.0).infinite? #=> nil + * (-1.0/0.0).infinite? #=> -1 + * (+1.0/0.0).infinite? #=> 1 + */ + +static mrb_value +flo_infinite_p(mrb_state *mrb, mrb_value num) +{ + mrb_float value = mrb_float(num); + + if (isinf(value)) { + return mrb_fixnum_value(value < 0 ? -1 : 1); + } + return mrb_nil_value(); +} + +/* 15.2.9.3.9 */ +/* + * call-seq: + * flt.finite? -> true or false + * + * Returns true if flt is a valid IEEE floating + * point number (it is not infinite, and nan? is + * false). + * + */ + +static mrb_value +flo_finite_p(mrb_state *mrb, mrb_value num) +{ + return mrb_bool_value(isfinite(mrb_float(num))); +} + +void +mrb_check_num_exact(mrb_state *mrb, mrb_float num) +{ + if (isinf(num)) { + mrb_raise(mrb, E_FLOATDOMAIN_ERROR, num < 0 ? "-Infinity" : "Infinity"); + } + if (isnan(num)) { + mrb_raise(mrb, E_FLOATDOMAIN_ERROR, "NaN"); + } +} + +/* 15.2.9.3.10 */ +/* + * call-seq: + * flt.floor -> integer + * + * Returns the largest integer less than or equal to flt. + * + * 1.2.floor #=> 1 + * 2.0.floor #=> 2 + * (-1.2).floor #=> -2 + * (-2.0).floor #=> -2 + */ + +static mrb_value +flo_floor(mrb_state *mrb, mrb_value num) +{ + mrb_float f = floor(mrb_float(num)); + + mrb_check_num_exact(mrb, f); + if (!FIXABLE_FLOAT(f)) { + return mrb_float_value(mrb, f); + } + return mrb_fixnum_value((mrb_int)f); +} + +/* 15.2.9.3.8 */ +/* + * call-seq: + * flt.ceil -> integer + * + * Returns the smallest Integer greater than or equal to + * flt. + * + * 1.2.ceil #=> 2 + * 2.0.ceil #=> 2 + * (-1.2).ceil #=> -1 + * (-2.0).ceil #=> -2 + */ + +static mrb_value +flo_ceil(mrb_state *mrb, mrb_value num) +{ + mrb_float f = ceil(mrb_float(num)); + + mrb_check_num_exact(mrb, f); + if (!FIXABLE_FLOAT(f)) { + return mrb_float_value(mrb, f); + } + return mrb_fixnum_value((mrb_int)f); +} + +/* 15.2.9.3.12 */ +/* + * call-seq: + * flt.round([ndigits]) -> integer or float + * + * Rounds flt to a given precision in decimal digits (default 0 digits). + * Precision may be negative. Returns a floating point number when ndigits + * is more than zero. + * + * 1.4.round #=> 1 + * 1.5.round #=> 2 + * 1.6.round #=> 2 + * (-1.5).round #=> -2 + * + * 1.234567.round(2) #=> 1.23 + * 1.234567.round(3) #=> 1.235 + * 1.234567.round(4) #=> 1.2346 + * 1.234567.round(5) #=> 1.23457 + * + * 34567.89.round(-5) #=> 0 + * 34567.89.round(-4) #=> 30000 + * 34567.89.round(-3) #=> 35000 + * 34567.89.round(-2) #=> 34600 + * 34567.89.round(-1) #=> 34570 + * 34567.89.round(0) #=> 34568 + * 34567.89.round(1) #=> 34567.9 + * 34567.89.round(2) #=> 34567.89 + * 34567.89.round(3) #=> 34567.89 + * + */ + +static mrb_value +flo_round(mrb_state *mrb, mrb_value num) +{ + double number, f; + mrb_int ndigits = 0; + mrb_int i; + + mrb_get_args(mrb, "|i", &ndigits); + number = mrb_float(num); + + if (0 < ndigits && (isinf(number) || isnan(number))) { + return num; + } + mrb_check_num_exact(mrb, number); + + f = 1.0; + i = ndigits >= 0 ? ndigits : -ndigits; + while (--i >= 0) + f = f*10.0; + + if (isinf(f)) { + if (ndigits < 0) number = 0; + } + else { + double d; + + if (ndigits < 0) number /= f; + else number *= f; + + /* home-made inline implementation of round(3) */ + if (number > 0.0) { + d = floor(number); + number = d + (number - d >= 0.5); + } + else if (number < 0.0) { + d = ceil(number); + number = d - (d - number >= 0.5); + } + + if (ndigits < 0) number *= f; + else number /= f; + } + + if (ndigits > 0) { + if (!isfinite(number)) return num; + return mrb_float_value(mrb, number); + } + return mrb_fixnum_value((mrb_int)number); +} + +/* 15.2.9.3.14 */ +/* 15.2.9.3.15 */ +/* + * call-seq: + * flt.to_i -> integer + * flt.to_int -> integer + * flt.truncate -> integer + * + * Returns flt truncated to an Integer. + */ + +static mrb_value +flo_truncate(mrb_state *mrb, mrb_value num) +{ + mrb_float f = mrb_float(num); + + if (f > 0.0) f = floor(f); + if (f < 0.0) f = ceil(f); + + mrb_check_num_exact(mrb, f); + if (!FIXABLE_FLOAT(f)) { + return mrb_float_value(mrb, f); + } + return mrb_fixnum_value((mrb_int)f); +} + +static mrb_value +flo_nan_p(mrb_state *mrb, mrb_value num) +{ + return mrb_bool_value(isnan(mrb_float(num))); +} + +/* + * Document-class: Integer + * + * Integer is the basis for the two concrete classes that + * hold whole numbers, Bignum and Fixnum. + * + */ + + +/* + * call-seq: + * int.to_i -> integer + * int.to_int -> integer + * + * As int is already an Integer, all these + * methods simply return the receiver. + */ + +static mrb_value +int_to_i(mrb_state *mrb, mrb_value num) +{ + return num; +} + +mrb_value +mrb_fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y) +{ + mrb_int a; + + a = mrb_fixnum(x); + if (mrb_fixnum_p(y)) { + mrb_int b, c; + + if (a == 0) return x; + b = mrb_fixnum(y); + if (mrb_int_mul_overflow(a, b, &c)) { + return mrb_float_value(mrb, (mrb_float)a * (mrb_float)b); + } + return mrb_fixnum_value(c); + } + return mrb_float_value(mrb, (mrb_float)a * mrb_to_flo(mrb, y)); +} + +/* 15.2.8.3.3 */ +/* + * call-seq: + * fix * numeric -> numeric_result + * + * Performs multiplication: the class of the resulting object depends on + * the class of numeric and on the magnitude of the + * result. + */ + +static mrb_value +fix_mul(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + + mrb_get_args(mrb, "o", &y); + return mrb_fixnum_mul(mrb, x, y); +} + +static void +fixdivmod(mrb_state *mrb, mrb_int x, mrb_int y, mrb_int *divp, mrb_int *modp) +{ + mrb_int div, mod; + + /* TODO: add mrb_assert(y != 0) to make sure */ + + if (y < 0) { + if (x < 0) + div = -x / -y; + else + div = - (x / -y); + } + else { + if (x < 0) + div = - (-x / y); + else + div = x / y; + } + mod = x - div*y; + if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) { + mod += y; + div -= 1; + } + if (divp) *divp = div; + if (modp) *modp = mod; +} + +/* 15.2.8.3.5 */ +/* + * call-seq: + * fix % other -> real + * fix.modulo(other) -> real + * + * Returns fix modulo other. + * See numeric.divmod for more information. + */ + +static mrb_value +fix_mod(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + mrb_int a; + + mrb_get_args(mrb, "o", &y); + a = mrb_fixnum(x); + if (mrb_fixnum_p(y)) { + mrb_int b, mod; + + if ((b=mrb_fixnum(y)) == 0) { + return mrb_float_value(mrb, NAN); + } + fixdivmod(mrb, a, b, 0, &mod); + return mrb_fixnum_value(mod); + } + else { + mrb_float mod; + + flodivmod(mrb, (mrb_float)a, mrb_to_flo(mrb, y), 0, &mod); + return mrb_float_value(mrb, mod); + } +} + +/* + * call-seq: + * fix.divmod(numeric) -> array + * + * See Numeric#divmod. + */ +static mrb_value +fix_divmod(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + + mrb_get_args(mrb, "o", &y); + + if (mrb_fixnum_p(y)) { + mrb_int div, mod; + + if (mrb_fixnum(y) == 0) { + return mrb_assoc_new(mrb, ((mrb_fixnum(x) == 0) ? + mrb_float_value(mrb, NAN): + mrb_float_value(mrb, INFINITY)), + mrb_float_value(mrb, NAN)); + } + fixdivmod(mrb, mrb_fixnum(x), mrb_fixnum(y), &div, &mod); + return mrb_assoc_new(mrb, mrb_fixnum_value(div), mrb_fixnum_value(mod)); + } + else { + mrb_float div, mod; + mrb_value a, b; + + flodivmod(mrb, (mrb_float)mrb_fixnum(x), mrb_to_flo(mrb, y), &div, &mod); + a = mrb_float_value(mrb, div); + b = mrb_float_value(mrb, mod); + return mrb_assoc_new(mrb, a, b); + } +} + +static mrb_value +flo_divmod(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + mrb_float div, mod; + mrb_value a, b; + + mrb_get_args(mrb, "o", &y); + + flodivmod(mrb, mrb_float(x), mrb_to_flo(mrb, y), &div, &mod); + a = mrb_float_value(mrb, div); + b = mrb_float_value(mrb, mod); + return mrb_assoc_new(mrb, a, b); +} + +/* 15.2.8.3.7 */ +/* + * call-seq: + * fix == other -> true or false + * + * Return true if fix equals other + * numerically. + * + * 1 == 2 #=> false + * 1 == 1.0 #=> true + */ + +static mrb_value +fix_equal(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + + mrb_get_args(mrb, "o", &y); + switch (mrb_type(y)) { + case MRB_TT_FIXNUM: + return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y)); + case MRB_TT_FLOAT: + return mrb_bool_value((mrb_float)mrb_fixnum(x) == mrb_float(y)); + default: + return mrb_false_value(); + } +} + +/* 15.2.8.3.8 */ +/* + * call-seq: + * ~fix -> integer + * + * One's complement: returns a number where each bit is flipped. + * ex.0---00001 (1)-> 1---11110 (-2) + * ex.0---00010 (2)-> 1---11101 (-3) + * ex.0---00100 (4)-> 1---11011 (-5) + */ + +static mrb_value +fix_rev(mrb_state *mrb, mrb_value num) +{ + mrb_int val = mrb_fixnum(num); + + return mrb_fixnum_value(~val); +} + +static mrb_value flo_and(mrb_state *mrb, mrb_value x); +static mrb_value flo_or(mrb_state *mrb, mrb_value x); +static mrb_value flo_xor(mrb_state *mrb, mrb_value x); +#define bit_op(x,y,op1,op2) do {\ + if (mrb_fixnum_p(y)) return mrb_fixnum_value(mrb_fixnum(x) op2 mrb_fixnum(y));\ + return flo_ ## op1(mrb, mrb_float_value(mrb, mrb_fixnum(x)));\ +} while(0) + +/* 15.2.8.3.9 */ +/* + * call-seq: + * fix & integer -> integer_result + * + * Bitwise AND. + */ + +static mrb_value +fix_and(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + + mrb_get_args(mrb, "o", &y); + bit_op(x, y, and, &); +} + +/* 15.2.8.3.10 */ +/* + * call-seq: + * fix | integer -> integer_result + * + * Bitwise OR. + */ + +static mrb_value +fix_or(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + + mrb_get_args(mrb, "o", &y); + bit_op(x, y, or, |); +} + +/* 15.2.8.3.11 */ +/* + * call-seq: + * fix ^ integer -> integer_result + * + * Bitwise EXCLUSIVE OR. + */ + +static mrb_value +fix_xor(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + + mrb_get_args(mrb, "o", &y); + bit_op(x, y, or, ^); +} + +#define NUMERIC_SHIFT_WIDTH_MAX (MRB_INT_BIT-1) + +static mrb_value +lshift(mrb_state *mrb, mrb_int val, mrb_int width) +{ + if (width < 0) { /* mrb_int overflow */ + return mrb_float_value(mrb, INFINITY); + } + if (val > 0) { + if ((width > NUMERIC_SHIFT_WIDTH_MAX) || + (val > (MRB_INT_MAX >> width))) { + goto bit_overflow; + } + return mrb_fixnum_value(val << width); + } + else { + if ((width > NUMERIC_SHIFT_WIDTH_MAX) || + (val < (MRB_INT_MIN >> width))) { + goto bit_overflow; + } + return mrb_fixnum_value(val * (1u << width)); + } + +bit_overflow: + { + mrb_float f = (mrb_float)val; + while (width--) { + f *= 2; + } + return mrb_float_value(mrb, f); + } +} + +static mrb_value +rshift(mrb_int val, mrb_int width) +{ + if (width < 0) { /* mrb_int overflow */ + return mrb_fixnum_value(0); + } + if (width >= NUMERIC_SHIFT_WIDTH_MAX) { + if (val < 0) { + return mrb_fixnum_value(-1); + } + return mrb_fixnum_value(0); + } + return mrb_fixnum_value(val >> width); +} + +/* 15.2.8.3.12 */ +/* + * call-seq: + * fix << count -> integer or float + * + * Shifts _fix_ left _count_ positions (right if _count_ is negative). + */ + +static mrb_value +fix_lshift(mrb_state *mrb, mrb_value x) +{ + mrb_int width, val; + + mrb_get_args(mrb, "i", &width); + if (width == 0) { + return x; + } + val = mrb_fixnum(x); + if (val == 0) return x; + if (width < 0) { + return rshift(val, -width); + } + return lshift(mrb, val, width); +} + +/* 15.2.8.3.13 */ +/* + * call-seq: + * fix >> count -> integer or float + * + * Shifts _fix_ right _count_ positions (left if _count_ is negative). + */ + +static mrb_value +fix_rshift(mrb_state *mrb, mrb_value x) +{ + mrb_int width, val; + + mrb_get_args(mrb, "i", &width); + if (width == 0) { + return x; + } + val = mrb_fixnum(x); + if (val == 0) return x; + if (width < 0) { + return lshift(mrb, val, -width); + } + return rshift(val, width); +} + +/* 15.2.8.3.23 */ +/* + * call-seq: + * fix.to_f -> float + * + * Converts fix to a Float. + * + */ + +static mrb_value +fix_to_f(mrb_state *mrb, mrb_value num) +{ + return mrb_float_value(mrb, (mrb_float)mrb_fixnum(num)); +} + +/* + * Document-class: FloatDomainError + * + * Raised when attempting to convert special float values + * (in particular infinite or NaN) + * to numerical classes which don't support them. + * + * Float::INFINITY.to_r + * + * raises the exception: + * + * FloatDomainError: Infinity + */ +/* ------------------------------------------------------------------------*/ +MRB_API mrb_value +mrb_flo_to_fixnum(mrb_state *mrb, mrb_value x) +{ + mrb_int z = 0; + + if (!mrb_float_p(x)) { + mrb_raise(mrb, E_TYPE_ERROR, "non float value"); + z = 0; /* not reached. just suppress warnings. */ + } + else { + mrb_float d = mrb_float(x); + + if (isinf(d)) { + mrb_raise(mrb, E_FLOATDOMAIN_ERROR, d < 0 ? "-Infinity" : "Infinity"); + } + if (isnan(d)) { + mrb_raise(mrb, E_FLOATDOMAIN_ERROR, "NaN"); + } + if (FIXABLE_FLOAT(d)) { + z = (mrb_int)d; + } + else { + mrb_raisef(mrb, E_ARGUMENT_ERROR, "number (%S) too big for integer", x); + } + } + return mrb_fixnum_value(z); +} + +mrb_value +mrb_fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y) +{ + mrb_int a; + + a = mrb_fixnum(x); + if (mrb_fixnum_p(y)) { + mrb_int b, c; + + if (a == 0) return y; + b = mrb_fixnum(y); + if (mrb_int_add_overflow(a, b, &c)) { + return mrb_float_value(mrb, (mrb_float)a + (mrb_float)b); + } + return mrb_fixnum_value(c); + } + return mrb_float_value(mrb, (mrb_float)a + mrb_to_flo(mrb, y)); +} + +/* 15.2.8.3.1 */ +/* + * call-seq: + * fix + numeric -> numeric_result + * + * Performs addition: the class of the resulting object depends on + * the class of numeric and on the magnitude of the + * result. + */ +static mrb_value +fix_plus(mrb_state *mrb, mrb_value self) +{ + mrb_value other; + + mrb_get_args(mrb, "o", &other); + return mrb_fixnum_plus(mrb, self, other); +} + +mrb_value +mrb_fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y) +{ + mrb_int a; + + a = mrb_fixnum(x); + if (mrb_fixnum_p(y)) { + mrb_int b, c; + + b = mrb_fixnum(y); + if (mrb_int_sub_overflow(a, b, &c)) { + return mrb_float_value(mrb, (mrb_float)a - (mrb_float)b); + } + return mrb_fixnum_value(c); + } + return mrb_float_value(mrb, (mrb_float)a - mrb_to_flo(mrb, y)); +} + +/* 15.2.8.3.2 */ +/* 15.2.8.3.16 */ +/* + * call-seq: + * fix - numeric -> numeric_result + * + * Performs subtraction: the class of the resulting object depends on + * the class of numeric and on the magnitude of the + * result. + */ +static mrb_value +fix_minus(mrb_state *mrb, mrb_value self) +{ + mrb_value other; + + mrb_get_args(mrb, "o", &other); + return mrb_fixnum_minus(mrb, self, other); +} + + +MRB_API mrb_value +mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, int base) +{ + char buf[MRB_INT_BIT+1]; + char *b = buf + sizeof buf; + mrb_int val = mrb_fixnum(x); + + if (base < 2 || 36 < base) { + mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %S", mrb_fixnum_value(base)); + } + + if (val == 0) { + *--b = '0'; + } + else if (val < 0) { + do { + *--b = mrb_digitmap[-(val % base)]; + } while (val /= base); + *--b = '-'; + } + else { + do { + *--b = mrb_digitmap[(int)(val % base)]; + } while (val /= base); + } + + return mrb_str_new(mrb, b, buf + sizeof(buf) - b); +} + +/* 15.2.8.3.25 */ +/* + * call-seq: + * fix.to_s(base=10) -> string + * + * Returns a string containing the representation of fix radix + * base (between 2 and 36). + * + * 12345.to_s #=> "12345" + * 12345.to_s(2) #=> "11000000111001" + * 12345.to_s(8) #=> "30071" + * 12345.to_s(10) #=> "12345" + * 12345.to_s(16) #=> "3039" + * 12345.to_s(36) #=> "9ix" + * + */ +static mrb_value +fix_to_s(mrb_state *mrb, mrb_value self) +{ + mrb_int base = 10; + + mrb_get_args(mrb, "|i", &base); + return mrb_fixnum_to_str(mrb, self, base); +} + +/* 15.2.9.3.6 */ +/* + * call-seq: + * self.f <=> other.f => -1, 0, +1 + * < => -1 + * = => 0 + * > => +1 + * Comparison---Returns -1, 0, or +1 depending on whether fix is + * less than, equal to, or greater than numeric. This is the + * basis for the tests in Comparable. + */ +static mrb_value +num_cmp(mrb_state *mrb, mrb_value self) +{ + mrb_value other; + mrb_float x, y; + + mrb_get_args(mrb, "o", &other); + + x = mrb_to_flo(mrb, self); + switch (mrb_type(other)) { + case MRB_TT_FIXNUM: + y = (mrb_float)mrb_fixnum(other); + break; + case MRB_TT_FLOAT: + y = mrb_float(other); + break; + default: + return mrb_nil_value(); + } + if (x > y) + return mrb_fixnum_value(1); + else { + if (x < y) + return mrb_fixnum_value(-1); + return mrb_fixnum_value(0); + } +} + +/* 15.2.9.3.1 */ +/* + * call-seq: + * float + other -> float + * + * Returns a new float which is the sum of float + * and other. + */ +static mrb_value +flo_plus(mrb_state *mrb, mrb_value x) +{ + mrb_value y; + + mrb_get_args(mrb, "o", &y); + return mrb_float_value(mrb, mrb_float(x) + mrb_to_flo(mrb, y)); +} + +/* ------------------------------------------------------------------------*/ +void +mrb_init_numeric(mrb_state *mrb) +{ + struct RClass *numeric, *integer, *fixnum, *fl; + + /* Numeric Class */ + numeric = mrb_define_class(mrb, "Numeric", mrb->object_class); /* 15.2.7 */ + + mrb_define_method(mrb, numeric, "**", num_pow, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, numeric, "/", num_div, MRB_ARGS_REQ(1)); /* 15.2.8.3.4 */ + mrb_define_method(mrb, numeric, "quo", num_div, MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */ + mrb_define_method(mrb, numeric, "<=>", num_cmp, MRB_ARGS_REQ(1)); /* 15.2.9.3.6 */ + + /* Integer Class */ + integer = mrb_define_class(mrb, "Integer", numeric); /* 15.2.8 */ + MRB_SET_INSTANCE_TT(integer, MRB_TT_FIXNUM); + mrb_undef_class_method(mrb, integer, "new"); + mrb_define_method(mrb, integer, "to_i", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.24 */ + mrb_define_method(mrb, integer, "to_int", int_to_i, MRB_ARGS_NONE()); + mrb_define_method(mrb, integer, "ceil", int_to_i, MRB_ARGS_REQ(1)); /* 15.2.8.3.8 (x) */ + mrb_define_method(mrb, integer, "floor", int_to_i, MRB_ARGS_REQ(1)); /* 15.2.8.3.10 (x) */ + mrb_define_method(mrb, integer, "round", int_to_i, MRB_ARGS_REQ(1)); /* 15.2.8.3.12 (x) */ + mrb_define_method(mrb, integer, "truncate", int_to_i, MRB_ARGS_REQ(1)); /* 15.2.8.3.15 (x) */ + + /* Fixnum Class */ + mrb->fixnum_class = fixnum = mrb_define_class(mrb, "Fixnum", integer); + mrb_define_method(mrb, fixnum, "+", fix_plus, MRB_ARGS_REQ(1)); /* 15.2.8.3.1 */ + mrb_define_method(mrb, fixnum, "-", fix_minus, MRB_ARGS_REQ(1)); /* 15.2.8.3.2 */ + mrb_define_method(mrb, fixnum, "*", fix_mul, MRB_ARGS_REQ(1)); /* 15.2.8.3.3 */ + mrb_define_method(mrb, fixnum, "%", fix_mod, MRB_ARGS_REQ(1)); /* 15.2.8.3.5 */ + mrb_define_method(mrb, fixnum, "==", fix_equal, MRB_ARGS_REQ(1)); /* 15.2.8.3.7 */ + mrb_define_method(mrb, fixnum, "~", fix_rev, MRB_ARGS_NONE()); /* 15.2.8.3.8 */ + mrb_define_method(mrb, fixnum, "&", fix_and, MRB_ARGS_REQ(1)); /* 15.2.8.3.9 */ + mrb_define_method(mrb, fixnum, "|", fix_or, MRB_ARGS_REQ(1)); /* 15.2.8.3.10 */ + mrb_define_method(mrb, fixnum, "^", fix_xor, MRB_ARGS_REQ(1)); /* 15.2.8.3.11 */ + mrb_define_method(mrb, fixnum, "<<", fix_lshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */ + mrb_define_method(mrb, fixnum, ">>", fix_rshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */ + mrb_define_method(mrb, fixnum, "eql?", fix_eql, MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */ + mrb_define_method(mrb, fixnum, "to_f", fix_to_f, MRB_ARGS_NONE()); /* 15.2.8.3.23 */ + mrb_define_method(mrb, fixnum, "to_s", fix_to_s, MRB_ARGS_NONE()); /* 15.2.8.3.25 */ + mrb_define_method(mrb, fixnum, "inspect", fix_to_s, MRB_ARGS_NONE()); + mrb_define_method(mrb, fixnum, "divmod", fix_divmod, MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */ + + /* Float Class */ + mrb->float_class = fl = mrb_define_class(mrb, "Float", numeric); /* 15.2.9 */ + MRB_SET_INSTANCE_TT(fl, MRB_TT_FLOAT); + mrb_undef_class_method(mrb, fl, "new"); + mrb_define_method(mrb, fl, "+", flo_plus, MRB_ARGS_REQ(1)); /* 15.2.9.3.1 */ + mrb_define_method(mrb, fl, "-", flo_minus, MRB_ARGS_REQ(1)); /* 15.2.9.3.2 */ + mrb_define_method(mrb, fl, "*", flo_mul, MRB_ARGS_REQ(1)); /* 15.2.9.3.3 */ + mrb_define_method(mrb, fl, "%", flo_mod, MRB_ARGS_REQ(1)); /* 15.2.9.3.5 */ + mrb_define_method(mrb, fl, "==", flo_eq, MRB_ARGS_REQ(1)); /* 15.2.9.3.7 */ + mrb_define_method(mrb, fl, "~", flo_rev, MRB_ARGS_NONE()); + mrb_define_method(mrb, fl, "&", flo_and, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, fl, "|", flo_or, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, fl, "^", flo_xor, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, fl, ">>", flo_lshift, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, fl, "<<", flo_rshift, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, fl, "ceil", flo_ceil, MRB_ARGS_NONE()); /* 15.2.9.3.8 */ + mrb_define_method(mrb, fl, "finite?", flo_finite_p, MRB_ARGS_NONE()); /* 15.2.9.3.9 */ + mrb_define_method(mrb, fl, "floor", flo_floor, MRB_ARGS_NONE()); /* 15.2.9.3.10 */ + mrb_define_method(mrb, fl, "infinite?", flo_infinite_p, MRB_ARGS_NONE()); /* 15.2.9.3.11 */ + mrb_define_method(mrb, fl, "round", flo_round, MRB_ARGS_OPT(1)); /* 15.2.9.3.12 */ + mrb_define_method(mrb, fl, "to_f", flo_to_f, MRB_ARGS_NONE()); /* 15.2.9.3.13 */ + mrb_define_method(mrb, fl, "to_i", flo_truncate, MRB_ARGS_NONE()); /* 15.2.9.3.14 */ + mrb_define_method(mrb, fl, "to_int", flo_truncate, MRB_ARGS_NONE()); + mrb_define_method(mrb, fl, "truncate", flo_truncate, MRB_ARGS_NONE()); /* 15.2.9.3.15 */ + mrb_define_method(mrb, fl, "divmod", flo_divmod, MRB_ARGS_REQ(1)); + mrb_define_method(mrb, fl, "eql?", flo_eql, MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */ + + mrb_define_method(mrb, fl, "to_s", flo_to_s, MRB_ARGS_NONE()); /* 15.2.9.3.16(x) */ + mrb_define_method(mrb, fl, "inspect", flo_to_s, MRB_ARGS_NONE()); + mrb_define_method(mrb, fl, "nan?", flo_nan_p, MRB_ARGS_NONE()); + +#ifdef INFINITY + mrb_define_const(mrb, fl, "INFINITY", mrb_float_value(mrb, INFINITY)); +#endif +#ifdef NAN + mrb_define_const(mrb, fl, "NAN", mrb_float_value(mrb, NAN)); +#endif +} -- cgit v1.2.3