/*

** numeric.c - Numeric, Integer, Float class

**

** See Copyright Notice in mruby.h

*/

#include <mruby.h>

#include <mruby/array.h>

#include <mruby/numeric.h>

#include <mruby/string.h>

#include <mruby/class.h>

#include <mruby/internal.h>

#include <string.h>

#ifndef MRB_NO_FLOAT

#ifdef MRB_USE_FLOAT32

#define trunc(f) truncf(f)

#define fmod(x,y) fmodf(x,y)

#else

#endif

#endif

/**

* This function is called to raise a RangeError when an integer operation

* results in an overflow. It's marked mrb_noreturn as it always raises an

* exception and does not return.

*

* @param mrb The mruby state.

* @param reason A string describing the operation that caused the overflow

* (e.g., "addition", "multiplication").

*/

mrb_noreturn void

mrb_int_overflow(mrb_state *mrb, const char *reason)

{

mrb_raisef(mrb, E_RANGE_ERROR, "integer overflow in %s", reason);

}

/**

* This function is called to raise a ZeroDivisionError. It's marked

* mrb_noreturn as it always raises an exception and does not return.

*

* @param mrb The mruby state.

*/

mrb_noreturn void

mrb_int_zerodiv(mrb_state *mrb)

{

mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0");

}

static mrb_noreturn void

mrb_int_noconv(mrb_state *mrb, mrb_value y)

{

mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y into Integer", y);

}

/**

* Calculates x raised to the power of y, where x is an integer.

* y can be an integer or float. The result type can be Integer,

* Float, or BigInt depending on the inputs and intermediate calculations.

*

* @param mrb The mruby state.

* @param x The base (must be an integer type, possibly BigInt).

* @param y The exponent (can be Integer or Float).

* @return An mrb_value representing the result of the exponentiation.

* This can be an Integer, Float, or BigInt.

* Handles potential overflows by promoting to BigInt if MRB_USE_BIGINT is defined,

* or by raising RangeError if not.

* Handles negative exponents by returning a Float if MRB_NO_FLOAT is not defined,

* or raising RangeError if it is.

*/

mrb_value

mrb_int_pow(mrb_state *mrb, mrb_value x, mrb_value y)

{

#ifdef MRB_USE_BIGINT

if (mrb_bigint_p(x)) {

#ifndef MRB_NO_FLOAT

if (mrb_float_p(y)) {

return mrb_float_value(mrb, pow(mrb_bint_as_float(mrb, x), mrb_float(y)));

}

#endif

return mrb_bint_pow(mrb, x, y);

}

#endif

mrb_int base = mrb_integer(x);

mrb_int result = 1;

mrb_int exp;

#ifndef MRB_NO_FLOAT

if (mrb_float_p(y)) {

return mrb_float_value(mrb, pow((double)base, mrb_float(y)));

}

else if (mrb_integer_p(y)) {

exp = mrb_integer(y);

}

else

#endif

{

exp = mrb_as_int(mrb, y);

}

if (exp < 0) {

#ifndef MRB_NO_FLOAT

return mrb_float_value(mrb, pow((double)base, (double)exp));

#else

mrb_int_overflow(mrb, "negative power");

#endif

}

for (;;) {

if (exp & 1) {

if (mrb_int_mul_overflow(result, base, &result)) {

#ifdef MRB_USE_BIGINT

return mrb_bint_pow(mrb, mrb_bint_new_int(mrb, mrb_integer(x)), y);

#else

mrb_int_overflow(mrb, "power");

#endif

}

}

exp >>= 1;

if (exp == 0) break;

if (mrb_int_mul_overflow(base, base, &base)) {

#ifdef MRB_USE_BIGINT

return mrb_bint_pow(mrb, mrb_bint_new_int(mrb, mrb_integer(x)), y);

#else

mrb_int_overflow(mrb, "power");

#endif

}

}

return mrb_int_value(mrb, result);

}

/*

* call-seq:

*

* num ** other -> num

*

* Raises `num` the `other` power.

*

* 2.0**3 #=> 8.0

*/

static mrb_value

int_pow(mrb_state *mrb, mrb_value x)

{

return mrb_int_pow(mrb, x, mrb_get_arg1(mrb));

}

/**

* Performs integer division of x by y. This function implements specific

* rounding behavior for negative numbers to match Ruby's / operator for

* integers (floor division).

*

* @param x The dividend.

* @param y The divisor.

* @return The result of the integer division (mrb_int).

* Note: This function does not handle division by zero; the caller is

* expected to check for this.

*/

mrb_int

mrb_div_int(mrb_int x, mrb_int y)

{

mrb_int div = x / y;

if ((x ^ y) < 0 && x != div * y) {

div -= 1;

}

return div;

}

/**

* Performs integer division of x by y and returns the result as an mrb_value.

* It uses mrb_div_int for the division logic.

*

* @param mrb The mruby state.

* @param x The dividend.

* @param y The divisor.

* @return An mrb_value (integer) representing the result of the division.

* @raise ZeroDivisionError if y is 0.

* @raise RangeError for overflow conditions (specifically MRB_INT_MIN / -1).

*/

mrb_value

mrb_div_int_value(mrb_state *mrb, mrb_int x, mrb_int y)

{

if (y == 0) {

mrb_int_zerodiv(mrb);

}

else if (x == MRB_INT_MIN && y == -1) {

#ifdef MRB_USE_BIGINT

return mrb_bint_mul_ii(mrb, x, y);

#else

mrb_int_overflow(mrb, "division");

#endif

}

return mrb_int_value(mrb, mrb_div_int(x, y));

}

/* 15.2.8.3.6 */

/*

* call-seq:

* int / num -> num

*

* Performs division: the class of the resulting object depends on

* the class of `num` and on the magnitude of the

* result.

*/

static mrb_value

int_div(mrb_state *mrb, mrb_value x)

{

mrb_value y = mrb_get_arg1(mrb);

#ifdef MRB_USE_BIGINT

if (mrb_bigint_p(x)) {

if (mrb_bigint_p(y) || mrb_integer_p(y)) {

return mrb_bint_div(mrb, x, y);

}

} else

#endif

if (mrb_integer_p(y)) {

return mrb_div_int_value(mrb, mrb_integer(x), mrb_integer(y));

}

switch (mrb_type(y)) {

#ifdef MRB_USE_BIGINT

case MRB_TT_INTEGER:

case MRB_TT_BIGINT:

return mrb_bint_div(mrb, mrb_as_bint(mrb, x), y);

#endif

#ifdef MRB_USE_RATIONAL

case MRB_TT_RATIONAL:

return mrb_rational_div(mrb, mrb_as_rational(mrb, x), y);

#endif

#ifdef MRB_USE_COMPLEX

case MRB_TT_COMPLEX:

x = mrb_complex_new(mrb, mrb_as_float(mrb, x), 0);

return mrb_complex_div(mrb, x, y);

#endif

#ifndef MRB_NO_FLOAT

case MRB_TT_FLOAT:

return mrb_float_value(mrb, mrb_div_float(mrb_as_float(mrb, x), mrb_as_float(mrb, y)));

#endif

default:

mrb_int_noconv(mrb, y);

}

}

/* 15.2.9.3.19(x) */

/*

* call-seq:

* num.quo(numeric) -> real

*

* Returns most exact division.

*/

/*

* call-seq:

* int.div(other) -> int

*

* Performs division: resulting integer.

*/

static mrb_value

int_idiv(mrb_state *mrb, mrb_value x)

{

#ifdef MRB_USE_BIGINT

if (mrb_bigint_p(x)) {

return mrb_bint_div(mrb, x, mrb_get_arg1(mrb));

}

#endif

mrb_int y = mrb_as_int(mrb, mrb_get_arg1(mrb));

return mrb_div_int_value(mrb, mrb_integer(x), y);

}

#ifndef MRB_NO_FLOAT

static mrb_value

int_fdiv(mrb_state *mrb, mrb_value x)

{

mrb_float y = mrb_as_float(mrb, mrb_get_arg1(mrb));

if (y == 0) {

mrb_int_zerodiv(mrb);

}

#ifdef MRB_USE_BIGINT

if (mrb_bigint_p(x)) {

return mrb_float_value(mrb, mrb_bint_as_float(mrb, x) / y);

}

#endif

return mrb_float_value(mrb, mrb_integer(x) / y);

}

#endif

static mrb_value

int_quo(mrb_state *mrb, mrb_value x)

{

#ifndef MRB_USE_RATIONAL

#ifdef MRB_NO_FLOAT

return int_idiv(mrb, x);

#else

return int_fdiv(mrb, x);

#endif

#else

mrb_int a = mrb_integer(x);

mrb_value y = mrb_get_arg1(mrb);

if (mrb_integer_p(y) && mrb_class_defined_id(mrb, MRB_SYM(Rational))) {

return mrb_rational_new(mrb, a, mrb_integer(y));

}

switch (mrb_type(y)) {

case MRB_TT_RATIONAL:

x = mrb_rational_new(mrb, a, 1);

return mrb_rational_div(mrb, x, y);

default:

#ifndef MRB_NO_FLOAT

return mrb_float_value(mrb, mrb_div_float((mrb_float)a, mrb_as_float(mrb, y)));

#else

mrb_int_noconv(mrb, y);

break;

#endif

}

#endif

}

static mrb_value

coerce_step_counter(mrb_state *mrb, mrb_value self)

{

mrb->c->ci->mid = 0;

#ifndef MRB_NO_FLOAT

mrb_value step = mrb_get_arg1(mrb);

if (mrb_float_p(step)) {

return mrb_ensure_float_type(mrb, self);

}

#endif

return self;

}

#ifndef MRB_NO_FLOAT

/********************************************************************

*

* Document-class: Float

*

* `Float` objects represent inexact real numbers using

* the native architecture's double-precision floating-point

* representation.

*/

static mrb_value

flo_pow(mrb_state *mrb, mrb_value x)

{

mrb_value y = mrb_get_arg1(mrb);

mrb_float d = pow(mrb_as_float(mrb, x), mrb_as_float(mrb, y));

return mrb_float_value(mrb, d);

}

static mrb_value

flo_idiv(mrb_state *mrb, mrb_value xv)

{

mrb_float x = mrb_float(xv);

mrb_check_num_exact(mrb, x);

mrb_int y = mrb_as_int(mrb, mrb_get_arg1(mrb));

return mrb_div_int_value(mrb, (mrb_int)x, y);

}

mrb_float

mrb_div_float(mrb_float x, mrb_float y)

{

if (y != 0.0) {

return x / y;

}

else if (x == 0.0) {

return NAN;

}

else {

return x * (signbit(y) ? -1.0 : 1.0) * INFINITY;

}

}

/* 15.2.9.3.6 */

/*

* call-seq:

* float / num -> float

*

* Returns a new Float which is the result of dividing float by num.

*/

static mrb_value

flo_div(mrb_state *mrb, mrb_value x)

{

mrb_value y = mrb_get_arg1(mrb);

mrb_float a = mrb_float(x);

switch(mrb_type(y)) {

#ifdef MRB_USE_COMPLEX

case MRB_TT_COMPLEX:

return mrb_complex_div(mrb, mrb_complex_new(mrb, a, 0), y);

#endif

case MRB_TT_FLOAT:

a = mrb_div_float(a, mrb_float(y));

return mrb_float_value(mrb, a);

default:

a = mrb_div_float(a, mrb_as_float(mrb, y));

return mrb_float_value(mrb, a);

}

return mrb_float_value(mrb, a);

}

static mrb_value

num_fdiv(mrb_state *mrb, mrb_value x)

{

return flo_div(mrb, mrb_ensure_float_type(mrb, x));

}

/**

* Converts an mrb_value float to a new mrb_value string.

* It handles formatting to ensure the string representation includes a

* decimal point and fractional part (e.g., ".0" is appended if not present).

*

* @param mrb The mruby state.

* @param flo The float mrb_value to convert.

* @param fmt This argument is noted as no longer used and can be NULL.

* The function uses a default format.

* @return A new mrb_value string representing the float.

*/

/* the argument `fmt` is no longer used; you can pass `NULL` */

mrb_value

mrb_float_to_str(mrb_state *mrb, mrb_value flo, const char *fmt)

{

char buf[25];

#ifdef MRB_USE_FLOAT32

const int prec = 7;

#else

const int prec = 15;

#endif

mrb_format_float(mrb_float(flo), buf, sizeof(buf), 'g', prec, '\0');

for (char *p = buf; *p; p++) {

if (*p == '.') goto exit;

if (*p == 'e') {

memmove(p+2, p, strlen(p)+1);

p[0] = '.';

p[1] = '0';

goto exit;

}

}

strcat(buf, ".0");

exit:

return mrb_str_new_cstr(mrb, buf);

}

/* 15.2.9.3.16(x) */

/*

* call-seq:

* flt.to_s -> string

* flt.inspect -> 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`".

*

* 3.0.to_s #=> 3.0

* 3.25.to_s #=> 3.25

*/

static mrb_value

flo_to_s(mrb_state *mrb, mrb_value flt)

{

mrb_float f = mrb_float(flt);

mrb_value str;

if (isinf(f)) {

str = f < 0 ? mrb_str_new_lit(mrb, "-Infinity")

: mrb_str_new_lit(mrb, "Infinity");

}

else if (isnan(f)) {

str = mrb_str_new_lit(mrb, "NaN");

}

else {

str = mrb_float_to_str(mrb, flt, NULL);

}

RSTR_SET_ASCII_FLAG(mrb_str_ptr(str));

return str;

}

/* 15.2.9.3.3 */

/*

* call-seq:

* float + other -> float

*

* Returns a new float which is the sum of `float`

* and `other`.

*/

static mrb_value

flo_add(mrb_state *mrb, mrb_value x)

{

mrb_value y = mrb_get_arg1(mrb);

mrb_float a = mrb_float(x);

switch (mrb_type(y)) {

case MRB_TT_FLOAT:

return mrb_float_value(mrb, a + mrb_float(y));

#if defined(MRB_USE_COMPLEX)

case MRB_TT_COMPLEX:

return mrb_complex_add(mrb, y, x);

#endif

default:

return mrb_float_value(mrb, a + mrb_as_float(mrb, y));

}

}

/* 15.2.9.3.4 */

/*

* call-seq:

* float - other -> float

*

* Returns a new float which is the difference of `float`

* and `other`.

*/

static mrb_value

flo_sub(mrb_state *mrb, mrb_value x)

{

mrb_value y = mrb_get_arg1(mrb);

mrb_float a = mrb_float(x);

switch (mrb_type(y)) {

case MRB_TT_FLOAT:

return mrb_float_value(mrb, a - mrb_float(y));

#if defined(MRB_USE_COMPLEX)

case MRB_TT_COMPLEX:

return mrb_complex_sub(mrb, mrb_complex_new(mrb, a, 0), y);

#endif

default:

return mrb_float_value(mrb, a - mrb_as_float(mrb, y));

}

}

/* 15.2.9.3.5 */

/*

* 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_arg1(mrb);

mrb_float a = mrb_float(x);

switch (mrb_type(y)) {

case MRB_TT_FLOAT:

return mrb_float_value(mrb, a * mrb_float(y));

#if defined(MRB_USE_COMPLEX)

case MRB_TT_COMPLEX:

return mrb_complex_mul(mrb, y, x);

#endif

default:

return mrb_float_value(mrb, a * mrb_as_float(mrb, y));

}

}

static void

flodivmod(mrb_state *mrb, double x, double y, mrb_float *divp, mrb_float *modp)

{

double div, mod;

if (isnan(y)) {

/* y is NaN so all results are NaN */

div = mod = y;

goto exit;

}

if (y == 0.0) {

mrb_int_zerodiv(mrb);

}

if (isinf(y) && !isinf(x)) {

mod = x;

}

else {

mod = fmod(x, y);

}

if (isinf(x) && !isinf(y)) {

div = x;

}

else {

div = (x - mod) / y;

if (modp && divp) div = round(div);

}

if (div == 0) div = 0.0;

if (mod == 0) mod = 0.0;

if (y*mod < 0) {

mod += y;

div -= 1.0;

}

exit:

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_get_arg1(mrb);

mrb_float mod;

flodivmod(mrb, mrb_float(x), mrb_as_float(mrb, y), NULL, &mod);

return mrb_float_value(mrb, mod);

}

#endif

/* 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

num_eql(mrb_state *mrb, mrb_value x)

{

mrb_value y = mrb_get_arg1(mrb);

#ifdef MRB_USE_BIGINT

if (mrb_bigint_p(x)) {

return mrb_bool_value(mrb_bint_cmp(mrb, x, y) == 0);

}

#endif

#ifndef MRB_NO_FLOAT

if (mrb_float_p(x)) {

if (!mrb_float_p(y)) return mrb_false_value();

return mrb_bool_value(mrb_float(x) == mrb_float(y));

}

#endif

if (mrb_integer_p(x)) {

if (!mrb_integer_p(y)) return mrb_false_value();

return mrb_bool_value(mrb_integer(x) == mrb_integer(y));

}

return mrb_bool_value(mrb_equal(mrb, x, y));

}

#ifndef MRB_NO_FLOAT

/* 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_arg1(mrb);

switch (mrb_type(y)) {

case MRB_TT_INTEGER:

return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_integer(y));

case MRB_TT_FLOAT:

return mrb_bool_value(mrb_float(x) == mrb_float(y));

#ifdef MRB_USE_RATIONAL

case MRB_TT_RATIONAL:

return mrb_bool_value(mrb_float(x) == mrb_as_float(mrb, y));

#endif

#ifdef MRB_USE_COMPLEX

case MRB_TT_COMPLEX:

return mrb_bool_value(mrb_equal(mrb, y, x));

#endif

default:

return mrb_false_value();

}

}

/* 15.2.9.3.13 */

/*

* Document-method: Float#to_f

*

* call-seq:

* flt.to_f -> self

*

* As `flt` is already a float, returns `self`.

*/

/* 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)));

}

/*

* 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_i

*

* <em>raises the exception:</em>

*

* FloatDomainError: Infinity

*/

/* ------------------------------------------------------------------------*/

/**

* Checks if a mrb_float value is Infinity or NaN. If it is, this function

* raises a FloatDomainError. This is used to prevent conversions of these

* special float values to exact number types like Integer.

*

* @param mrb The mruby state.

* @param num The float value to check.

* It does not return a value (void function) but will raise an exception

* if the number is not exact.

*/

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");

}

}

static mrb_value

flo_rounding_int(mrb_state *mrb, mrb_float f)

{

if (!FIXABLE_FLOAT(f)) {

#ifdef MRB_USE_BIGINT

return mrb_bint_new_float(mrb, f);

#else

mrb_int_overflow(mrb, "rounding");

#endif

}

return mrb_int_value(mrb, (mrb_int)f);

}

static mrb_value

flo_rounding(mrb_state *mrb, mrb_value num, double (*func)(double))

{

mrb_float f = mrb_float(num);

mrb_int ndigits = 0;

#ifdef MRB_USE_FLOAT32

const int fprec = 7;

#else

const int fprec = 15;

#endif

mrb_get_args(mrb, "|i", &ndigits);

if (f == 0.0) {

return ndigits > 0 ? mrb_float_value(mrb, f) : mrb_fixnum_value(0);

}

if (ndigits > 0) {

if (ndigits > fprec) return num;

mrb_float d = pow(10, (double)ndigits);

f = func(f * d) / d;

mrb_check_num_exact(mrb, f);

return mrb_float_value(mrb, f);

}

if (ndigits < 0) {

mrb_float d = pow(10, -(double)ndigits);

f = func(f / d) * d;

}

else { /* ndigits == 0 */

f = func(f);

}

mrb_check_num_exact(mrb, f);

return flo_rounding_int(mrb, f);

}

/* 15.2.9.3.10 */

/*

* call-seq:

* float.floor([ndigits]) -> integer or float

*

* Returns the largest number less than or equal to `float` with

* a precision of `ndigits` decimal digits (default: 0).

*

* When the precision is negative, the returned value is an integer

* with at least `ndigits.abs` trailing zeros.

*

* Returns a floating-point number when `ndigits` is positive,

* otherwise returns an integer.

*

* 1.2.floor #=> 1

* 2.0.floor #=> 2

* (-1.2).floor #=> -2

* (-2.0).floor #=> -2

*

* 1.234567.floor(2) #=> 1.23

* 1.234567.floor(3) #=> 1.234

* 1.234567.floor(4) #=> 1.2345

* 1.234567.floor(5) #=> 1.23456

*

* 34567.89.floor(-5) #=> 0

* 34567.89.floor(-4) #=> 30000

* 34567.89.floor(-3) #=> 34000

* 34567.89.floor(-2) #=> 34500

* 34567.89.floor(-1) #=> 34560

* 34567.89.floor(0) #=> 34567

* 34567.89.floor(1) #=> 34567.8

* 34567.89.floor(2) #=> 34567.89

* 34567.89.floor(3) #=> 34567.89

*

* Note that the limited precision of floating-point arithmetic

* might lead to surprising results:

*

* (0.3 / 0.1).floor #=> 2 (!)

*/

static mrb_value

flo_floor(mrb_state *mrb, mrb_value num)

{

return flo_rounding(mrb, num, floor);

}

/* 15.2.9.3.8 */

/*

* call-seq:

* float.ceil([ndigits]) -> integer or float

*

* Returns the smallest number greater than or equal to `float` with

* a precision of `ndigits` decimal digits (default: 0).

*

* When the precision is negative, the returned value is an integer

* with at least `ndigits.abs` trailing zeros.

*

* Returns a floating-point number when `ndigits` is positive,

* otherwise returns an integer.

*

* 1.2.ceil #=> 2

* 2.0.ceil #=> 2

* (-1.2).ceil #=> -1

* (-2.0).ceil #=> -2

*

* 1.234567.ceil(2) #=> 1.24

* 1.234567.ceil(3) #=> 1.235

* 1.234567.ceil(4) #=> 1.2346

* 1.234567.ceil(5) #=> 1.23457

*

* 34567.89.ceil(-5) #=> 100000

* 34567.89.ceil(-4) #=> 40000

* 34567.89.ceil(-3) #=> 35000

* 34567.89.ceil(-2) #=> 34600

* 34567.89.ceil(-1) #=> 34570

* 34567.89.ceil(0) #=> 34568

* 34567.89.ceil(1) #=> 34567.9

* 34567.89.ceil(2) #=> 34567.89

* 34567.89.ceil(3) #=> 34567.89

*

* Note that the limited precision of floating-point arithmetic

* might lead to surprising results:

*

* (2.1 / 0.7).ceil #=> 4 (!)

*/

static mrb_value

flo_ceil(mrb_state *mrb, mrb_value num)

{

return flo_rounding(mrb, num, ceil);

}

/* 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_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;

if (ndigits < -DBL_DIG-2) return mrb_fixnum_value(0);

mrb_int i = ndigits >= 0 ? ndigits : -ndigits;

if (ndigits > DBL_DIG+2) return num;

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);

}

if (!FIXABLE_FLOAT(number))

return mrb_float_value(mrb, number);

return mrb_int_value(mrb, (mrb_int)number);

}

/* 15.2.9.3.14 */

static mrb_value

flo_to_i(mrb_state *mrb, mrb_value num)