diff options
Diffstat (limited to 'internal/numeric.h')
| -rw-r--r-- | internal/numeric.h | 213 |
1 files changed, 213 insertions, 0 deletions
diff --git a/internal/numeric.h b/internal/numeric.h new file mode 100644 index 0000000000..3e64b82daf --- /dev/null +++ b/internal/numeric.h @@ -0,0 +1,213 @@ +#ifndef INTERNAL_NUMERIC_H /* -*- C -*- */ +#define INTERNAL_NUMERIC_H +/** + * @file + * @brief Internal header for Numeric. + * @author \@shyouhei + * @copyright This file is a part of the programming language Ruby. + * Permission is hereby granted, to either redistribute and/or + * modify this file, provided that the conditions mentioned in the + * file COPYING are met. Consult the file for details. + */ + +struct RFloat { + struct RBasic basic; + double float_value; +}; + +#define RFLOAT(obj) (R_CAST(RFloat)(obj)) + +/* numeric.c */ + +#define FIXNUM_POSITIVE_P(num) ((SIGNED_VALUE)(num) > (SIGNED_VALUE)INT2FIX(0)) +#define FIXNUM_NEGATIVE_P(num) ((SIGNED_VALUE)(num) < 0) +#define FIXNUM_ZERO_P(num) ((num) == INT2FIX(0)) + +#define INT_NEGATIVE_P(x) (FIXNUM_P(x) ? FIXNUM_NEGATIVE_P(x) : BIGNUM_NEGATIVE_P(x)) + +#define FLOAT_ZERO_P(x) (RFLOAT_VALUE(x) == 0.0) + +#ifndef ROUND_DEFAULT +# define ROUND_DEFAULT RUBY_NUM_ROUND_HALF_UP +#endif +enum ruby_num_rounding_mode { + RUBY_NUM_ROUND_HALF_UP, + RUBY_NUM_ROUND_HALF_EVEN, + RUBY_NUM_ROUND_HALF_DOWN, + RUBY_NUM_ROUND_DEFAULT = ROUND_DEFAULT +}; +#define ROUND_TO(mode, even, up, down) \ + ((mode) == RUBY_NUM_ROUND_HALF_EVEN ? even : \ + (mode) == RUBY_NUM_ROUND_HALF_UP ? up : down) +#define ROUND_FUNC(mode, name) \ + ROUND_TO(mode, name##_half_even, name##_half_up, name##_half_down) +#define ROUND_CALL(mode, name, args) \ + ROUND_TO(mode, name##_half_even args, \ + name##_half_up args, name##_half_down args) + +int rb_num_to_uint(VALUE val, unsigned int *ret); +VALUE ruby_num_interval_step_size(VALUE from, VALUE to, VALUE step, int excl); +double ruby_float_step_size(double beg, double end, double unit, int excl); +int ruby_float_step(VALUE from, VALUE to, VALUE step, int excl, int allow_endless); +double ruby_float_mod(double x, double y); +int rb_num_negative_p(VALUE); +VALUE rb_int_succ(VALUE num); +VALUE rb_int_uminus(VALUE num); +VALUE rb_float_uminus(VALUE num); +VALUE rb_int_plus(VALUE x, VALUE y); +VALUE rb_float_plus(VALUE x, VALUE y); +VALUE rb_int_minus(VALUE x, VALUE y); +VALUE rb_int_mul(VALUE x, VALUE y); +VALUE rb_float_mul(VALUE x, VALUE y); +VALUE rb_float_div(VALUE x, VALUE y); +VALUE rb_int_idiv(VALUE x, VALUE y); +VALUE rb_int_modulo(VALUE x, VALUE y); +VALUE rb_int2str(VALUE num, int base); +VALUE rb_fix_plus(VALUE x, VALUE y); +VALUE rb_fix_aref(VALUE fix, VALUE idx); +VALUE rb_int_gt(VALUE x, VALUE y); +int rb_float_cmp(VALUE x, VALUE y); +VALUE rb_float_gt(VALUE x, VALUE y); +VALUE rb_int_ge(VALUE x, VALUE y); +enum ruby_num_rounding_mode rb_num_get_rounding_option(VALUE opts); +double rb_int_fdiv_double(VALUE x, VALUE y); +VALUE rb_int_pow(VALUE x, VALUE y); +VALUE rb_float_pow(VALUE x, VALUE y); +VALUE rb_int_cmp(VALUE x, VALUE y); +VALUE rb_int_equal(VALUE x, VALUE y); +VALUE rb_int_divmod(VALUE x, VALUE y); +VALUE rb_int_and(VALUE x, VALUE y); +VALUE rb_int_lshift(VALUE x, VALUE y); +VALUE rb_int_div(VALUE x, VALUE y); +VALUE rb_int_abs(VALUE num); +VALUE rb_int_odd_p(VALUE num); +int rb_int_positive_p(VALUE num); +int rb_int_negative_p(VALUE num); +VALUE rb_num_pow(VALUE x, VALUE y); +VALUE rb_float_ceil(VALUE num, int ndigits); + +RUBY_SYMBOL_EXPORT_BEGIN +/* numeric.c (export) */ +VALUE rb_int_positive_pow(long x, unsigned long y); +RUBY_SYMBOL_EXPORT_END + + +static inline VALUE +rb_num_compare_with_zero(VALUE num, ID mid) +{ + VALUE zero = INT2FIX(0); + VALUE r = rb_check_funcall(num, mid, 1, &zero); + if (r == Qundef) { + rb_cmperr(num, zero); + } + return r; +} + +static inline int +rb_num_positive_int_p(VALUE num) +{ + const ID mid = '>'; + + if (FIXNUM_P(num)) { + if (rb_method_basic_definition_p(rb_cInteger, mid)) + return FIXNUM_POSITIVE_P(num); + } + else if (RB_TYPE_P(num, T_BIGNUM)) { + if (rb_method_basic_definition_p(rb_cInteger, mid)) + return BIGNUM_POSITIVE_P(num); + } + return RTEST(rb_num_compare_with_zero(num, mid)); +} + + +static inline int +rb_num_negative_int_p(VALUE num) +{ + const ID mid = '<'; + + if (FIXNUM_P(num)) { + if (rb_method_basic_definition_p(rb_cInteger, mid)) + return FIXNUM_NEGATIVE_P(num); + } + else if (RB_TYPE_P(num, T_BIGNUM)) { + if (rb_method_basic_definition_p(rb_cInteger, mid)) + return BIGNUM_NEGATIVE_P(num); + } + return RTEST(rb_num_compare_with_zero(num, mid)); +} + + +VALUE rb_float_abs(VALUE flt); +VALUE rb_float_equal(VALUE x, VALUE y); +VALUE rb_float_eql(VALUE x, VALUE y); +VALUE rb_flo_div_flo(VALUE x, VALUE y); + +static inline double +rb_float_flonum_value(VALUE v) +{ +#if USE_FLONUM + if (v != (VALUE)0x8000000000000002) { /* LIKELY */ + union { + double d; + VALUE v; + } t; + + VALUE b63 = (v >> 63); + /* e: xx1... -> 011... */ + /* xx0... -> 100... */ + /* ^b63 */ + t.v = RUBY_BIT_ROTR((2 - b63) | (v & ~(VALUE)0x03), 3); + return t.d; + } +#endif + return 0.0; +} + +static inline double +rb_float_noflonum_value(VALUE v) +{ + return ((struct RFloat *)v)->float_value; +} + +static inline double +rb_float_value_inline(VALUE v) +{ + if (FLONUM_P(v)) { + return rb_float_flonum_value(v); + } + return rb_float_noflonum_value(v); +} + +static inline VALUE +rb_float_new_inline(double d) +{ +#if USE_FLONUM + union { + double d; + VALUE v; + } t; + int bits; + + t.d = d; + bits = (int)((VALUE)(t.v >> 60) & 0x7); + /* bits contains 3 bits of b62..b60. */ + /* bits - 3 = */ + /* b011 -> b000 */ + /* b100 -> b001 */ + + if (t.v != 0x3000000000000000 /* 1.72723e-77 */ && + !((bits-3) & ~0x01)) { + return (RUBY_BIT_ROTL(t.v, 3) & ~(VALUE)0x01) | 0x02; + } + else if (t.v == (VALUE)0) { + /* +0.0 */ + return 0x8000000000000002; + } + /* out of range */ +#endif + return rb_float_new_in_heap(d); +} + +#define rb_float_value(v) rb_float_value_inline(v) +#define rb_float_new(d) rb_float_new_inline(d) +#endif /* INTERNAL_NUMERIC_H */ |