From 597179bb95812dcf90b75520d3dd17d94ac16d51 Mon Sep 17 00:00:00 2001 From: tadf Date: Mon, 31 Mar 2008 16:42:24 +0000 Subject: [PATCH] adopted the ruby's style. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@15868 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- ChangeLog | 6 + complex.c | 1734 +++++++++++++++++++++++------------------------ rational.c | 1910 ++++++++++++++++++++++++++-------------------------- 3 files changed, 1837 insertions(+), 1813 deletions(-) diff --git a/ChangeLog b/ChangeLog index 8088c380f2..b61c663b77 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,9 @@ +Tue Apr 1 01:40:58 2008 Tadayoshi Funaba + + * complex.c: adopted the ruby's style. + + * rational.c: ditto. + Tue Apr 1 00:17:35 2008 Tadayoshi Funaba * rational.c: revert. diff --git a/complex.c b/complex.c index 1644746360..ae076a326e 100644 --- a/complex.c +++ b/complex.c @@ -34,103 +34,103 @@ static ID id_Unify, id_abs, id_abs2, id_arg, id_atan2_bang, id_cmp, inline static VALUE \ f_##n(VALUE x, VALUE y)\ {\ - return rb_funcall(x, op, 1, y);\ + return rb_funcall(x, op, 1, y);\ } #define fun1(n) \ inline static VALUE \ f_##n(VALUE x)\ {\ - return rb_funcall(x, id_##n, 0);\ + return rb_funcall(x, id_##n, 0);\ } #define fun2(n) \ inline static VALUE \ f_##n(VALUE x, VALUE y)\ {\ - return rb_funcall(x, id_##n, 1, y);\ + return rb_funcall(x, id_##n, 1, y);\ } #define math1(n) \ inline static VALUE \ m_##n(VALUE x)\ {\ - return rb_funcall(rb_mMath, id_##n, 1, x);\ + return rb_funcall(rb_mMath, id_##n, 1, x);\ } #define math2(n) \ inline static VALUE \ m_##n(VALUE x, VALUE y)\ {\ - return rb_funcall(rb_mMath, id_##n, 2, x, y);\ + return rb_funcall(rb_mMath, id_##n, 2, x, y);\ } inline static VALUE f_add(VALUE x, VALUE y) { - VALUE r; - if (FIXNUM_P(y)) { - if (FIX2LONG(y) == 0) - r = x; - else - r = rb_funcall(x, '+', 1, y); - } else if (FIXNUM_P(x)) { - if (FIX2LONG(x) == 0) - r = y; - else - r = rb_funcall(x, '+', 1, y); - } else - r = rb_funcall(x, '+', 1, y); - return r; + VALUE r; + if (FIXNUM_P(y)) { + if (FIX2LONG(y) == 0) + r = x; + else + r = rb_funcall(x, '+', 1, y); + } else if (FIXNUM_P(x)) { + if (FIX2LONG(x) == 0) + r = y; + else + r = rb_funcall(x, '+', 1, y); + } else + r = rb_funcall(x, '+', 1, y); + return r; } inline static VALUE f_cmp(VALUE x, VALUE y) { - VALUE r; - if (FIXNUM_P(x) && FIXNUM_P(y)) { - long c = FIX2LONG(x) - FIX2LONG(y); - if (c > 0) - c = 1; - else if (c < 0) - c = -1; - r = INT2FIX(c); - } else - r = rb_funcall(x, id_cmp, 1, y); - return r; + VALUE r; + if (FIXNUM_P(x) && FIXNUM_P(y)) { + long c = FIX2LONG(x) - FIX2LONG(y); + if (c > 0) + c = 1; + else if (c < 0) + c = -1; + r = INT2FIX(c); + } else + r = rb_funcall(x, id_cmp, 1, y); + return r; } inline static VALUE f_div(VALUE x, VALUE y) { - VALUE r; - if (FIXNUM_P(y) && FIX2LONG(y) == 1) - r = x; - else - r = rb_funcall(x, '/', 1, y); - return r; + VALUE r; + if (FIXNUM_P(y) && FIX2LONG(y) == 1) + r = x; + else + r = rb_funcall(x, '/', 1, y); + return r; } inline static VALUE f_gt_p(VALUE x, VALUE y) { - VALUE r; - if (FIXNUM_P(x) && FIXNUM_P(y)) - r = f_boolcast(FIX2LONG(x) > FIX2LONG(y)); - else - r = rb_funcall(x, '>', 1, y); - return r; + VALUE r; + if (FIXNUM_P(x) && FIXNUM_P(y)) + r = f_boolcast(FIX2LONG(x) > FIX2LONG(y)); + else + r = rb_funcall(x, '>', 1, y); + return r; } inline static VALUE f_lt_p(VALUE x, VALUE y) { - VALUE r; - if (FIXNUM_P(x) && FIXNUM_P(y)) - r = f_boolcast(FIX2LONG(x) < FIX2LONG(y)); - else - r = rb_funcall(x, '<', 1, y); - return r; + VALUE r; + if (FIXNUM_P(x) && FIXNUM_P(y)) + r = f_boolcast(FIX2LONG(x) < FIX2LONG(y)); + else + r = rb_funcall(x, '<', 1, y); + return r; } binop(mod, '%') @@ -138,46 +138,46 @@ binop(mod, '%') inline static VALUE f_mul(VALUE x, VALUE y) { - VALUE r; - if (FIXNUM_P(y)) { - long _iy = FIX2LONG(y); - if (_iy == 0) { - if (TYPE(x) == T_FLOAT) - r = rb_float_new(0.0); - else - r = ZERO; - } else if (_iy == 1) - r = x; - else - r = rb_funcall(x, '*', 1, y); - } else if (FIXNUM_P(x)) { - long _ix = FIX2LONG(x); - if (_ix == 0) { - if (TYPE(y) == T_FLOAT) - r = rb_float_new(0.0); - else - r = ZERO; - } else if (_ix == 1) - r = y; - else - r = rb_funcall(x, '*', 1, y); - } else - r = rb_funcall(x, '*', 1, y); - return r; + VALUE r; + if (FIXNUM_P(y)) { + long _iy = FIX2LONG(y); + if (_iy == 0) { + if (TYPE(x) == T_FLOAT) + r = rb_float_new(0.0); + else + r = ZERO; + } else if (_iy == 1) + r = x; + else + r = rb_funcall(x, '*', 1, y); + } else if (FIXNUM_P(x)) { + long _ix = FIX2LONG(x); + if (_ix == 0) { + if (TYPE(y) == T_FLOAT) + r = rb_float_new(0.0); + else + r = ZERO; + } else if (_ix == 1) + r = y; + else + r = rb_funcall(x, '*', 1, y); + } else + r = rb_funcall(x, '*', 1, y); + return r; } inline static VALUE f_sub(VALUE x, VALUE y) { - VALUE r; - if (FIXNUM_P(y)) { - if (FIX2LONG(y) == 0) - r = x; - else - r = rb_funcall(x, '-', 1, y); - } else - r = rb_funcall(x, '-', 1, y); - return r; + VALUE r; + if (FIXNUM_P(y)) { + if (FIX2LONG(y) == 0) + r = x; + else + r = rb_funcall(x, '-', 1, y); + } else + r = rb_funcall(x, '-', 1, y); + return r; } binop(xor, '^') @@ -206,12 +206,12 @@ fun2(divmod) inline static VALUE f_equal_p(VALUE x, VALUE y) { - VALUE r; - if (FIXNUM_P(x) && FIXNUM_P(y)) - r = f_boolcast(FIX2LONG(x) == FIX2LONG(y)); - else - r = rb_funcall(x, id_equal_p, 1, y); - return r; + VALUE r; + if (FIXNUM_P(x) && FIXNUM_P(y)) + r = f_boolcast(FIX2LONG(x) == FIX2LONG(y)); + else + r = rb_funcall(x, id_equal_p, 1, y); + return r; } fun2(expt) @@ -221,151 +221,151 @@ fun2(quo) inline static VALUE f_negative_p(VALUE x) { - VALUE r; - if (FIXNUM_P(x)) - r = f_boolcast(FIX2LONG(x) < 0); - else - r = rb_funcall(x, '<', 1, ZERO); - return r; + VALUE r; + if (FIXNUM_P(x)) + r = f_boolcast(FIX2LONG(x) < 0); + else + r = rb_funcall(x, '<', 1, ZERO); + return r; } inline static VALUE f_zero_p(VALUE x) { - VALUE r; - if (FIXNUM_P(x)) - r = f_boolcast(FIX2LONG(x) == 0); - else - r = rb_funcall(x, id_equal_p, 1, ZERO); - return r; + VALUE r; + if (FIXNUM_P(x)) + r = f_boolcast(FIX2LONG(x) == 0); + else + r = rb_funcall(x, id_equal_p, 1, ZERO); + return r; } inline static VALUE f_one_p(VALUE x) { - VALUE r; - if (FIXNUM_P(x)) - r = f_boolcast(FIX2LONG(x) == 1); - else - r = rb_funcall(x, id_equal_p, 1, ONE); - return r; + VALUE r; + if (FIXNUM_P(x)) + r = f_boolcast(FIX2LONG(x) == 1); + else + r = rb_funcall(x, id_equal_p, 1, ONE); + return r; } inline static VALUE f_kind_of_p(VALUE x, VALUE c) { - return rb_obj_is_kind_of(x, c); + return rb_obj_is_kind_of(x, c); } inline static VALUE k_numeric_p(VALUE x) { - return f_kind_of_p(x, rb_cNumeric); + return f_kind_of_p(x, rb_cNumeric); } inline static VALUE k_integer_p(VALUE x) { - return f_kind_of_p(x, rb_cInteger); + return f_kind_of_p(x, rb_cInteger); } inline static VALUE k_float_p(VALUE x) { - return f_kind_of_p(x, rb_cFloat); + return f_kind_of_p(x, rb_cFloat); } inline static VALUE k_rational_p(VALUE x) { - return f_kind_of_p(x, rb_cRational); + return f_kind_of_p(x, rb_cRational); } inline static VALUE k_complex_p(VALUE x) { - return f_kind_of_p(x, rb_cComplex); + return f_kind_of_p(x, rb_cComplex); } inline static VALUE f_generic_p(VALUE x) { - switch (TYPE(x)) { - case T_FIXNUM: - case T_BIGNUM: - case T_FLOAT: - case T_RATIONAL: - return Qtrue; - default: - return Qfalse; - } + switch (TYPE(x)) { + case T_FIXNUM: + case T_BIGNUM: + case T_FLOAT: + case T_RATIONAL: + return Qtrue; + default: + return Qfalse; + } } static VALUE nucomp_s_generic_p(VALUE klass, VALUE x) { - return f_generic_p(x); + return f_generic_p(x); } #define get_dat1(x) \ - struct RComplex *dat;\ - dat = ((struct RComplex *)(x)) + struct RComplex *dat;\ + dat = ((struct RComplex *)(x)) #define get_dat2(x,y) \ - struct RComplex *adat, *bdat;\ - adat = ((struct RComplex *)(x));\ - bdat = ((struct RComplex *)(y)) + struct RComplex *adat, *bdat;\ + adat = ((struct RComplex *)(x));\ + bdat = ((struct RComplex *)(y)) inline static VALUE nucomp_s_new_internal(VALUE klass, VALUE real, VALUE image) { - NEWOBJ(obj, struct RComplex); - OBJSETUP(obj, klass, T_COMPLEX); + NEWOBJ(obj, struct RComplex); + OBJSETUP(obj, klass, T_COMPLEX); - obj->real = real; - obj->image = image; + obj->real = real; + obj->image = image; - return (VALUE)obj; + return (VALUE)obj; } static VALUE nucomp_s_alloc(VALUE klass) { - return nucomp_s_new_internal(klass, ZERO, ZERO); + return nucomp_s_new_internal(klass, ZERO, ZERO); } static VALUE nucomp_s_new_bang(int argc, VALUE *argv, VALUE klass) { - VALUE real, image; + VALUE real, image; - switch (rb_scan_args(argc, argv, "11", &real, &image)) { - case 1: - if (!k_numeric_p(real)) - real = f_to_i(real); - image = ZERO; - break; - default: - if (!k_numeric_p(real)) - real = f_to_i(real); - if (!k_numeric_p(image)) - image = f_to_i(image); - break; - } + switch (rb_scan_args(argc, argv, "11", &real, &image)) { + case 1: + if (!k_numeric_p(real)) + real = f_to_i(real); + image = ZERO; + break; + default: + if (!k_numeric_p(real)) + real = f_to_i(real); + if (!k_numeric_p(image)) + image = f_to_i(image); + break; + } - return nucomp_s_new_internal(klass, real, image); + return nucomp_s_new_internal(klass, real, image); } inline static VALUE f_complex_new_bang1(VALUE klass, VALUE x) { - return nucomp_s_new_internal(klass, x, ZERO); + return nucomp_s_new_internal(klass, x, ZERO); } inline static VALUE f_complex_new_bang2(VALUE klass, VALUE x, VALUE y) { - return nucomp_s_new_internal(klass, x, y); + return nucomp_s_new_internal(klass, x, y); } #define f_unify_p(klass) rb_const_defined(klass, id_Unify) @@ -375,122 +375,124 @@ nucomp_s_canonicalize_internal(VALUE klass, VALUE real, VALUE image) { #define CL_CANON #ifdef CL_CANON - if (f_zero_p(image) && f_unify_p(klass) && - !k_float_p(real) && !k_float_p(image)) - return real; + if (f_zero_p(image) && f_unify_p(klass) && + !k_float_p(real) && !k_float_p(image)) + return real; #else - if (f_zero_p(image) && f_unify_p(klass)) - return real; + if (f_zero_p(image) && f_unify_p(klass)) + return real; #endif - else if (f_scalar_p(real) && f_scalar_p(image)) - return nucomp_s_new_internal(klass, real, image); - else if (f_scalar_p(real)) { - get_dat1(image); + else if (f_scalar_p(real) && f_scalar_p(image)) + return nucomp_s_new_internal(klass, real, image); + else if (f_scalar_p(real)) { + get_dat1(image); - return nucomp_s_new_internal(klass, - f_sub(real, dat->image), - f_add(ZERO, dat->real)); - } else if (f_scalar_p(image)) { - get_dat1(real); + return nucomp_s_new_internal(klass, + f_sub(real, dat->image), + f_add(ZERO, dat->real)); + } else if (f_scalar_p(image)) { + get_dat1(real); - return nucomp_s_new_internal(klass, - dat->real, - f_add(dat->image, image)); - } else { - get_dat2(real, image); + return nucomp_s_new_internal(klass, + dat->real, + f_add(dat->image, image)); + } else { + get_dat2(real, image); - return nucomp_s_new_internal(klass, - f_sub(adat->real, bdat->image), - f_add(adat->image, bdat->real)); - } + return nucomp_s_new_internal(klass, + f_sub(adat->real, bdat->image), + f_add(adat->image, bdat->real)); + } } +#if 0 static VALUE nucomp_s_canonicalize(int argc, VALUE *argv, VALUE klass) { - VALUE real, image; + VALUE real, image; - switch (rb_scan_args(argc, argv, "11", &real, &image)) { - case 1: - image = ZERO; - break; - } + switch (rb_scan_args(argc, argv, "11", &real, &image)) { + case 1: + image = ZERO; + break; + } - switch (TYPE(real)) { - case T_FIXNUM: - case T_BIGNUM: - case T_FLOAT: - break; - default: - if (!k_rational_p(real)) - rb_raise(rb_eArgError, "not a real"); - } + switch (TYPE(real)) { + case T_FIXNUM: + case T_BIGNUM: + case T_FLOAT: + break; + default: + if (!k_rational_p(real)) + rb_raise(rb_eArgError, "not a real"); + } - switch (TYPE(image)) { - case T_FIXNUM: - case T_BIGNUM: - case T_FLOAT: - break; - default: - if (!k_rational_p(image)) - rb_raise(rb_eArgError, "not a real"); - } + switch (TYPE(image)) { + case T_FIXNUM: + case T_BIGNUM: + case T_FLOAT: + break; + default: + if (!k_rational_p(image)) + rb_raise(rb_eArgError, "not a real"); + } - return nucomp_s_canonicalize_internal(klass, real, image); + return nucomp_s_canonicalize_internal(klass, real, image); } +#endif static VALUE nucomp_s_new(int argc, VALUE *argv, VALUE klass) { - VALUE real, image; + VALUE real, image; - switch (rb_scan_args(argc, argv, "11", &real, &image)) { - case 1: - image = ZERO; - break; - } + switch (rb_scan_args(argc, argv, "11", &real, &image)) { + case 1: + image = ZERO; + break; + } - switch (TYPE(real)) { - case T_FIXNUM: - case T_BIGNUM: - case T_FLOAT: - break; - default: - if (!k_rational_p(real)) - rb_raise(rb_eArgError, "not a real"); - } + switch (TYPE(real)) { + case T_FIXNUM: + case T_BIGNUM: + case T_FLOAT: + break; + default: + if (!k_rational_p(real)) + rb_raise(rb_eArgError, "not a real"); + } - switch (TYPE(image)) { - case T_FIXNUM: - case T_BIGNUM: - case T_FLOAT: - break; - default: - if (!k_rational_p(image)) - rb_raise(rb_eArgError, "not a real"); - } + switch (TYPE(image)) { + case T_FIXNUM: + case T_BIGNUM: + case T_FLOAT: + break; + default: + if (!k_rational_p(image)) + rb_raise(rb_eArgError, "not a real"); + } - return nucomp_s_canonicalize_internal(klass, real, image); + return nucomp_s_canonicalize_internal(klass, real, image); } inline static VALUE f_complex_new1(VALUE klass, VALUE x) { - assert(!k_complex_p(x)); - return nucomp_s_canonicalize_internal(klass, x, ZERO); + assert(!k_complex_p(x)); + return nucomp_s_canonicalize_internal(klass, x, ZERO); } inline static VALUE f_complex_new2(VALUE klass, VALUE x, VALUE y) { - assert(!k_complex_p(x)); - return nucomp_s_canonicalize_internal(klass, x, y); + assert(!k_complex_p(x)); + return nucomp_s_canonicalize_internal(klass, x, y); } static VALUE nucomp_f_complex(int argc, VALUE *argv, VALUE klass) { - return rb_funcall2(rb_cComplex, id_convert, argc, argv); + return rb_funcall2(rb_cComplex, id_convert, argc, argv); } #if 1 @@ -507,27 +509,27 @@ nucomp_f_complex(int argc, VALUE *argv, VALUE klass) static void domain_check(double x, char *msg) { - while(1) { - if (errno) { - rb_sys_fail(msg); - } - if (isnan(x)) { + while(1) { + if (errno) { + rb_sys_fail(msg); + } + if (isnan(x)) { #if defined(EDOM) - errno = EDOM; + errno = EDOM; #elif defined(ERANGE) - errno = ERANGE; + errno = ERANGE; #endif - continue; + continue; + } + break; } - break; - } } static VALUE m_cos_bang(VALUE x) { - Need_Float(x); - return DOUBLE2NUM(cos(RFLOAT_VALUE(x))); + Need_Float(x); + return DOUBLE2NUM(cos(RFLOAT_VALUE(x))); } static VALUE m_cos_bang(VALUE); @@ -538,513 +540,519 @@ static VALUE m_sinh_bang(VALUE); static VALUE m_cos(VALUE x) { - get_dat1(x); + get_dat1(x); - if (f_generic_p(x)) - return m_cos_bang(x); - else - return f_complex_new2(rb_cComplex, - f_mul(m_cos_bang(dat->real), - m_cosh_bang(dat->image)), - f_mul(f_negate(m_sin_bang(dat->real)), - m_sinh_bang(dat->image))); + if (f_generic_p(x)) + return m_cos_bang(x); + else + return f_complex_new2(rb_cComplex, + f_mul(m_cos_bang(dat->real), + m_cosh_bang(dat->image)), + f_mul(f_negate(m_sin_bang(dat->real)), + m_sinh_bang(dat->image))); } #ifndef HAVE_COSH double cosh(double x) { - return (exp(x) + exp(-x)) / 2; + return (exp(x) + exp(-x)) / 2; } #endif static VALUE m_cosh_bang(VALUE x) { - Need_Float(x); - return DOUBLE2NUM(cosh(RFLOAT_VALUE(x))); + Need_Float(x); + return DOUBLE2NUM(cosh(RFLOAT_VALUE(x))); } static VALUE m_exp_bang(VALUE x) { - Need_Float(x); - return DOUBLE2NUM(exp(RFLOAT_VALUE(x))); + Need_Float(x); + return DOUBLE2NUM(exp(RFLOAT_VALUE(x))); } static VALUE m_log_bang(VALUE x) { - double d; + double d; - Need_Float(x); - errno = 0; - d = log(RFLOAT_VALUE(x)); - domain_check(d, "log"); - return DOUBLE2NUM(d); + Need_Float(x); + errno = 0; + d = log(RFLOAT_VALUE(x)); + domain_check(d, "log"); + return DOUBLE2NUM(d); } static VALUE m_sin_bang(VALUE x) { - Need_Float(x); - return DOUBLE2NUM(sin(RFLOAT_VALUE(x))); + Need_Float(x); + return DOUBLE2NUM(sin(RFLOAT_VALUE(x))); } static VALUE m_sin(VALUE x) { - get_dat1(x); + get_dat1(x); - if (f_generic_p(x)) - return m_sin_bang(x); - else - return f_complex_new2(rb_cComplex, - f_mul(m_sin_bang(dat->real), - m_cosh_bang(dat->image)), - f_mul(m_cos_bang(dat->real), - m_sinh_bang(dat->image))); + if (f_generic_p(x)) + return m_sin_bang(x); + else + return f_complex_new2(rb_cComplex, + f_mul(m_sin_bang(dat->real), + m_cosh_bang(dat->image)), + f_mul(m_cos_bang(dat->real), + m_sinh_bang(dat->image))); } #ifndef HAVE_SINH double sinh(double x) { - return (exp(x) - exp(-x)) / 2; + return (exp(x) - exp(-x)) / 2; } #endif static VALUE m_sinh_bang(VALUE x) { - Need_Float(x); - return DOUBLE2NUM(sinh(RFLOAT_VALUE(x))); + Need_Float(x); + return DOUBLE2NUM(sinh(RFLOAT_VALUE(x))); } static VALUE m_sqrt_bang(VALUE x) { - double d; + double d; - Need_Float(x); - errno = 0; - d = sqrt(RFLOAT_VALUE(x)); - domain_check(d, "sqrt"); - return DOUBLE2NUM(d); + Need_Float(x); + errno = 0; + d = sqrt(RFLOAT_VALUE(x)); + domain_check(d, "sqrt"); + return DOUBLE2NUM(d); } static VALUE m_sqrt(VALUE x) { - if (f_generic_p(x)) { - if (!f_negative_p(x)) - return m_sqrt_bang(x); - else - return f_complex_new2(rb_cComplex, ZERO, m_sqrt_bang(f_negate(x))); - } else { - get_dat1(x); + if (f_generic_p(x)) { + if (!f_negative_p(x)) + return m_sqrt_bang(x); + else + return f_complex_new2(rb_cComplex, ZERO, m_sqrt_bang(f_negate(x))); + } else { + get_dat1(x); - if (f_negative_p(dat->image)) - return f_conjugate(m_sqrt(f_conjugate(x))); - else { - VALUE a = f_abs(x); - return f_complex_new2(rb_cComplex, - m_sqrt_bang(f_div(f_add(a, dat->real), TWO)), - m_sqrt_bang(f_div(f_sub(a, dat->real), TWO))); + if (f_negative_p(dat->image)) + return f_conjugate(m_sqrt(f_conjugate(x))); + else { + VALUE a = f_abs(x); + return f_complex_new2(rb_cComplex, + m_sqrt_bang(f_div(f_add(a, dat->real), TWO)), + m_sqrt_bang(f_div(f_sub(a, dat->real), TWO))); + } } - } } static VALUE m_atan2_bang(VALUE y, VALUE x) { - Need_Float2(y, x); - return DOUBLE2NUM(atan2(RFLOAT_VALUE(y), RFLOAT_VALUE(x))); + Need_Float2(y, x); + return DOUBLE2NUM(atan2(RFLOAT_VALUE(y), RFLOAT_VALUE(x))); } +#if 0 static VALUE m_hypot(VALUE x, VALUE y) { - Need_Float2(x, y); - return DOUBLE2NUM(hypot(RFLOAT_VALUE(x), RFLOAT_VALUE(y))); + Need_Float2(x, y); + return DOUBLE2NUM(hypot(RFLOAT_VALUE(x), RFLOAT_VALUE(y))); } #endif +#endif static VALUE nucomp_s_polar(VALUE klass, VALUE abs, VALUE arg) { - return f_complex_new2(klass, - f_mul(abs, m_cos(arg)), - f_mul(abs, m_sin(arg))); + return f_complex_new2(klass, + f_mul(abs, m_cos(arg)), + f_mul(abs, m_sin(arg))); } static VALUE nucomp_real(VALUE self) { - get_dat1(self); - return dat->real; + get_dat1(self); + return dat->real; } static VALUE nucomp_image(VALUE self) { - get_dat1(self); - return dat->image; + get_dat1(self); + return dat->image; } static VALUE nucomp_add(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - case T_FLOAT: - case T_RATIONAL: - { - get_dat1(self); + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + case T_FLOAT: + case T_RATIONAL: + { + get_dat1(self); - return f_complex_new2(CLASS_OF(self), - f_add(dat->real, other), dat->image); + return f_complex_new2(CLASS_OF(self), + f_add(dat->real, other), dat->image); + } + case T_COMPLEX: + { + VALUE real, image; + + get_dat2(self, other); + + real = f_add(adat->real, bdat->real); + image = f_add(adat->image, bdat->image); + + return f_complex_new2(CLASS_OF(self), real, image); + } + default: + { + VALUE a = f_coerce(other, self); + return f_add(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); + } } - case T_COMPLEX: - { - VALUE real, image; - - get_dat2(self, other); - - real = f_add(adat->real, bdat->real); - image = f_add(adat->image, bdat->image); - - return f_complex_new2(CLASS_OF(self), real, image); - } - default: - { - VALUE a = f_coerce(other, self); - return f_add(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); - } - } } static VALUE nucomp_sub(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - case T_FLOAT: - case T_RATIONAL: - { - get_dat1(self); + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + case T_FLOAT: + case T_RATIONAL: + { + get_dat1(self); - return f_complex_new2(CLASS_OF(self), - f_sub(dat->real, other), dat->image); + return f_complex_new2(CLASS_OF(self), + f_sub(dat->real, other), dat->image); + } + case T_COMPLEX: + { + VALUE real, image; + + get_dat2(self, other); + + real = f_sub(adat->real, bdat->real); + image = f_sub(adat->image, bdat->image); + + return f_complex_new2(CLASS_OF(self), real, image); + } + default: + { + VALUE a = f_coerce(other, self); + return f_sub(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); + } } - case T_COMPLEX: - { - VALUE real, image; - - get_dat2(self, other); - - real = f_sub(adat->real, bdat->real); - image = f_sub(adat->image, bdat->image); - - return f_complex_new2(CLASS_OF(self), real, image); - } - default: - { - VALUE a = f_coerce(other, self); - return f_sub(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); - } - } } static VALUE nucomp_mul(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - case T_FLOAT: - case T_RATIONAL: - { - get_dat1(self); + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + case T_FLOAT: + case T_RATIONAL: + { + get_dat1(self); - return f_complex_new2(CLASS_OF(self), - f_mul(dat->real, other), - f_mul(dat->image, other)); + return f_complex_new2(CLASS_OF(self), + f_mul(dat->real, other), + f_mul(dat->image, other)); + } + case T_COMPLEX: + { + VALUE real, image; + + get_dat2(self, other); + + real = f_sub(f_mul(adat->real, bdat->real), + f_mul(adat->image, bdat->image)); + image = f_add(f_mul(adat->real, bdat->image), + f_mul(adat->image, bdat->real)); + + return f_complex_new2(CLASS_OF(self), real, image); + } + default: + { + VALUE a = f_coerce(other, self); + return f_mul(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); + } } - case T_COMPLEX: - { - VALUE real, image; - - get_dat2(self, other); - - real = f_sub(f_mul(adat->real, bdat->real), - f_mul(adat->image, bdat->image)); - image = f_add(f_mul(adat->real, bdat->image), - f_mul(adat->image, bdat->real)); - - return f_complex_new2(CLASS_OF(self), real, image); - } - default: - { - VALUE a = f_coerce(other, self); - return f_mul(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); - } - } } static VALUE nucomp_div(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - case T_FLOAT: - case T_RATIONAL: - { - get_dat1(self); + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + case T_FLOAT: + case T_RATIONAL: + { + get_dat1(self); - return f_complex_new2(CLASS_OF(self), - f_div(dat->real, other), - f_div(dat->image, other)); + return f_complex_new2(CLASS_OF(self), + f_div(dat->real, other), + f_div(dat->image, other)); + } + case T_COMPLEX: + return f_div(f_mul(self, f_conjugate(other)), f_abs2(other)); + default: + { + VALUE a = f_coerce(other, self); + return f_div(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); + } } - case T_COMPLEX: - return f_div(f_mul(self, f_conjugate(other)), f_abs2(other)); - default: - { - VALUE a = f_coerce(other, self); - return f_div(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); - } - } } static VALUE nucomp_rdiv(VALUE self, VALUE other) { - get_dat1(self); + get_dat1(self); - return f_div(f_complex_new2(CLASS_OF(self), - f_to_r(dat->real), - f_to_r(dat->image)), other); + return f_div(f_complex_new2(CLASS_OF(self), + f_to_r(dat->real), + f_to_r(dat->image)), other); } +#if 0 static VALUE nucomp_fdiv(VALUE self, VALUE other) { - get_dat1(self); + get_dat1(self); - return f_div(f_complex_new2(CLASS_OF(self), - f_to_f(dat->real), - f_to_f(dat->image)), other); + return f_div(f_complex_new2(CLASS_OF(self), + f_to_f(dat->real), + f_to_f(dat->image)), other); } +#endif static VALUE nucomp_expt(VALUE self, VALUE other) { - if (f_zero_p(other)) - return f_complex_new_bang1(CLASS_OF(self), ONE); + if (f_zero_p(other)) + return f_complex_new_bang1(CLASS_OF(self), ONE); - if (k_rational_p(other) && f_one_p(f_denominator(other))) - other = f_numerator(other); /* good? */ + if (k_rational_p(other) && f_one_p(f_denominator(other))) + other = f_numerator(other); /* good? */ - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - if (f_gt_p(other, ZERO)) { - VALUE x, z, n; + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + if (f_gt_p(other, ZERO)) { + VALUE x, z, n; - x = self; - z = x; - n = f_sub(other, ONE); + x = self; + z = x; + n = f_sub(other, ONE); - while (!f_zero_p(n)) { - VALUE a; + while (!f_zero_p(n)) { + VALUE a; - while (a = f_divmod(n, TWO), - f_zero_p(RARRAY_PTR(a)[1])) { - get_dat1(x); + while (a = f_divmod(n, TWO), + f_zero_p(RARRAY_PTR(a)[1])) { + get_dat1(x); - x = f_complex_new2(CLASS_OF(self), - f_sub(f_mul(dat->real, dat->real), - f_mul(dat->image, dat->image)), - f_mul(f_mul(TWO, dat->real), dat->image)); - n = RARRAY_PTR(a)[0]; + x = f_complex_new2(CLASS_OF(self), + f_sub(f_mul(dat->real, dat->real), + f_mul(dat->image, dat->image)), + f_mul(f_mul(TWO, dat->real), dat->image)); + n = RARRAY_PTR(a)[0]; + } + z = f_mul(z, x); + n = f_sub(n, ONE); + } + return z; + } else { + return f_expt(f_div(f_to_r(ONE), self), f_negate(other)); } - z = f_mul(z, x); - n = f_sub(n, ONE); + case T_FLOAT: + case T_RATIONAL: + { + VALUE a, r, theta; + + a = f_polar(self); + r = RARRAY_PTR(a)[0]; + theta = RARRAY_PTR(a)[1]; + return nucomp_s_polar(CLASS_OF(self), f_expt(r, other), + f_mul(theta, other)); } - return z; - } else { - return f_expt(f_div(f_to_r(ONE), self), f_negate(other)); - } - case T_FLOAT: - case T_RATIONAL: - { - VALUE a, r, theta; + case T_COMPLEX: + { + VALUE a, r, theta, ore, oim, nr, ntheta; - a = f_polar(self); - r = RARRAY_PTR(a)[0]; - theta = RARRAY_PTR(a)[1]; - return nucomp_s_polar(CLASS_OF(self), f_expt(r, other), - f_mul(theta, other)); - } - case T_COMPLEX: - { - VALUE a, r, theta, ore, oim, nr, ntheta; + get_dat1(other); - get_dat1(other); + a = f_polar(self); + r = RARRAY_PTR(a)[0]; + theta = RARRAY_PTR(a)[1]; - a = f_polar(self); - r = RARRAY_PTR(a)[0]; - theta = RARRAY_PTR(a)[1]; - - ore = dat->real; - oim = dat->image; - nr = m_exp_bang(f_sub(f_mul(ore, m_log_bang(r)), - f_mul(oim, theta))); - ntheta = f_add(f_mul(theta, ore), f_mul(oim, m_log_bang(r))); - return nucomp_s_polar(CLASS_OF(self), nr, ntheta); + ore = dat->real; + oim = dat->image; + nr = m_exp_bang(f_sub(f_mul(ore, m_log_bang(r)), + f_mul(oim, theta))); + ntheta = f_add(f_mul(theta, ore), f_mul(oim, m_log_bang(r))); + return nucomp_s_polar(CLASS_OF(self), nr, ntheta); + } + default: + { + VALUE a = f_coerce(other, self); + return f_expt(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); + } } - default: - { - VALUE a = f_coerce(other, self); - return f_expt(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); - } - } } static VALUE nucomp_equal_p(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - case T_FLOAT: - case T_RATIONAL: - { - get_dat1(self); + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + case T_FLOAT: + case T_RATIONAL: + { + get_dat1(self); - return f_boolcast(f_equal_p(dat->real, other) && f_zero_p(dat->image)); - } - case T_COMPLEX: - { - get_dat2(self, other); + return f_boolcast(f_equal_p(dat->real, other) && f_zero_p(dat->image)); + } + case T_COMPLEX: + { + get_dat2(self, other); - return f_boolcast(f_equal_p(adat->real, bdat->real) && - f_equal_p(adat->image, bdat->image)); + return f_boolcast(f_equal_p(adat->real, bdat->real) && + f_equal_p(adat->image, bdat->image)); + } + default: + return f_equal_p(other, self); } - default: - return f_equal_p(other, self); - } } static VALUE nucomp_coerce(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - case T_FLOAT: - case T_RATIONAL: - return rb_assoc_new(f_complex_new_bang1(CLASS_OF(self), other), self); - } + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + case T_FLOAT: + case T_RATIONAL: + return rb_assoc_new(f_complex_new_bang1(CLASS_OF(self), other), self); + } - rb_raise(rb_eTypeError, "%s can't be coerced into %s", - rb_obj_classname(other), rb_obj_classname(self)); - return Qnil; + rb_raise(rb_eTypeError, "%s can't be coerced into %s", + rb_obj_classname(other), rb_obj_classname(self)); + return Qnil; } static VALUE nucomp_abs(VALUE self) { - get_dat1(self); - return m_sqrt(f_add(f_mul(dat->real, dat->real), - f_mul(dat->image, dat->image))); + get_dat1(self); + return m_sqrt(f_add(f_mul(dat->real, dat->real), + f_mul(dat->image, dat->image))); } static VALUE nucomp_abs2(VALUE self) { - get_dat1(self); - return f_add(f_mul(dat->real, dat->real), - f_mul(dat->image, dat->image)); + get_dat1(self); + return f_add(f_mul(dat->real, dat->real), + f_mul(dat->image, dat->image)); } static VALUE nucomp_arg(VALUE self) { - get_dat1(self); - return m_atan2_bang(dat->image, dat->real); + get_dat1(self); + return m_atan2_bang(dat->image, dat->real); } static VALUE nucomp_polar(VALUE self) { - return rb_assoc_new(f_abs(self), f_arg(self)); + return rb_assoc_new(f_abs(self), f_arg(self)); } static VALUE nucomp_conjugate(VALUE self) { - get_dat1(self); - return f_complex_new2(CLASS_OF(self), dat->real, f_negate(dat->image)); + get_dat1(self); + return f_complex_new2(CLASS_OF(self), dat->real, f_negate(dat->image)); } +#if 0 static VALUE nucomp_real_p(VALUE self) { - return Qfalse; + return Qfalse; } static VALUE nucomp_complex_p(VALUE self) { - return Qtrue; + return Qtrue; } static VALUE nucomp_exact_p(VALUE self) { - get_dat1(self); - return f_boolcast(f_exact_p(dat->real) && f_exact_p(dat->image)); + get_dat1(self); + return f_boolcast(f_exact_p(dat->real) && f_exact_p(dat->image)); } static VALUE nucomp_inexact_p(VALUE self) { - return f_boolcast(!nucomp_exact_p(self)); + return f_boolcast(!nucomp_exact_p(self)); } +#endif extern VALUE rb_lcm(VALUE x, VALUE y); static VALUE nucomp_denominator(VALUE self) { - get_dat1(self); - return rb_lcm(f_denominator(dat->real), f_denominator(dat->image)); + get_dat1(self); + return rb_lcm(f_denominator(dat->real), f_denominator(dat->image)); } static VALUE nucomp_numerator(VALUE self) { - VALUE cd; + VALUE cd; - get_dat1(self); + get_dat1(self); - cd = f_denominator(self); - return f_complex_new2(CLASS_OF(self), - f_mul(f_numerator(dat->real), - f_div(cd, f_denominator(dat->real))), - f_mul(f_numerator(dat->image), - f_div(cd, f_denominator(dat->image)))); + cd = f_denominator(self); + return f_complex_new2(CLASS_OF(self), + f_mul(f_numerator(dat->real), + f_div(cd, f_denominator(dat->real))), + f_mul(f_numerator(dat->image), + f_div(cd, f_denominator(dat->image)))); } static VALUE nucomp_hash(VALUE self) { - get_dat1(self); - return f_xor(dat->real, dat->image); + get_dat1(self); + return f_xor(dat->real, dat->image); } #ifndef HAVE_SIGNBIT @@ -1056,95 +1064,95 @@ nucomp_hash(VALUE self) inline static VALUE f_signbit(VALUE x) { - switch (TYPE(x)) { - case T_FLOAT: + switch (TYPE(x)) { + case T_FLOAT: #ifdef HAVE_SIGNBIT - return f_boolcast(signbit(RFLOAT_VALUE(x))); + return f_boolcast(signbit(RFLOAT_VALUE(x))); #else - { - char s[2]; + { + char s[2]; - (void)snprintf(s, sizeof s, "%.0f", RFLOAT_VALUE(x)); + (void)snprintf(s, sizeof s, "%.0f", RFLOAT_VALUE(x)); - return f_boolcast(s[0] == '-'); - } + return f_boolcast(s[0] == '-'); + } #endif - } - return f_negative_p(x); + } + return f_negative_p(x); } inline static VALUE f_tzero_p(VALUE x) { - return f_boolcast(f_zero_p(x) && !f_signbit(x)); + return f_boolcast(f_zero_p(x) && !f_signbit(x)); } inline static VALUE f_tpositive_p(VALUE x) { - return f_boolcast(!f_signbit(x)); + return f_boolcast(!f_signbit(x)); } static VALUE nucomp_to_s(VALUE self) { - VALUE s, rezero, impos; + VALUE s, rezero, impos; - get_dat1(self); + get_dat1(self); - rezero = f_tzero_p(dat->real); - impos = f_tpositive_p(dat->image); + rezero = f_tzero_p(dat->real); + impos = f_tpositive_p(dat->image); - if (rezero) - s = rb_str_new2(""); - else { - s = f_to_s(dat->real); - rb_str_concat(s, rb_str_new2(!impos ? "-" : "+")); - } + if (rezero) + s = rb_str_new2(""); + else { + s = f_to_s(dat->real); + rb_str_cat2(s, !impos ? "-" : "+"); + } - if (k_rational_p(dat->image) && - !f_one_p(f_denominator(dat->image))) { - rb_str_concat(s, rb_str_new2("(")); - rb_str_concat(s, f_to_s(rezero ? dat->image : f_abs(dat->image))); - rb_str_concat(s, rb_str_new2(")i")); - } else { - rb_str_concat(s, f_to_s(rezero ? dat->image : f_abs(dat->image))); - rb_str_concat(s, rb_str_new2("i")); - } + if (k_rational_p(dat->image) && + !f_one_p(f_denominator(dat->image))) { + rb_str_cat2(s, "("); + rb_str_concat(s, f_to_s(rezero ? dat->image : f_abs(dat->image))); + rb_str_cat2(s, ")i"); + } else { + rb_str_concat(s, f_to_s(rezero ? dat->image : f_abs(dat->image))); + rb_str_cat2(s, "i"); + } - return s; + return s; } static VALUE nucomp_inspect(VALUE self) { - VALUE s; + VALUE s; - get_dat1(self); + get_dat1(self); - s = rb_str_new2("Complex("); - rb_str_concat(s, f_inspect(dat->real)); - rb_str_concat(s, rb_str_new2(", ")); - rb_str_concat(s, f_inspect(dat->image)); - rb_str_concat(s, rb_str_new2(")")); + s = rb_str_new2("Complex("); + rb_str_concat(s, f_inspect(dat->real)); + rb_str_cat2(s, ", "); + rb_str_concat(s, f_inspect(dat->image)); + rb_str_cat2(s, ")"); - return s; + return s; } static VALUE nucomp_marshal_dump(VALUE self) { - get_dat1(self); - return rb_assoc_new(dat->real, dat->image); + get_dat1(self); + return rb_assoc_new(dat->real, dat->image); } static VALUE nucomp_marshal_load(VALUE self, VALUE a) { - get_dat1(self); - dat->real = RARRAY_PTR(a)[0]; - dat->image = RARRAY_PTR(a)[1]; - return self; + get_dat1(self); + dat->real = RARRAY_PTR(a)[0]; + dat->image = RARRAY_PTR(a)[1]; + return self; } /* --- */ @@ -1152,13 +1160,13 @@ nucomp_marshal_load(VALUE self, VALUE a) VALUE rb_complex_raw(VALUE x, VALUE y) { - return nucomp_s_new_internal(rb_cComplex, x, y); + return nucomp_s_new_internal(rb_cComplex, x, y); } VALUE rb_complex_new(VALUE x, VALUE y) { - return nucomp_s_canonicalize_internal(rb_cComplex, x, y); + return nucomp_s_canonicalize_internal(rb_cComplex, x, y); } static VALUE nucomp_s_convert(int argc, VALUE *argv, VALUE klass); @@ -1166,71 +1174,71 @@ static VALUE nucomp_s_convert(int argc, VALUE *argv, VALUE klass); VALUE rb_Complex(VALUE x, VALUE y) { - VALUE a[2]; - a[0] = x; - a[1] = y; - return nucomp_s_convert(2, a, rb_cComplex); + VALUE a[2]; + a[0] = x; + a[1] = y; + return nucomp_s_convert(2, a, rb_cComplex); } static VALUE nucomp_scalar_p(VALUE self) { - return Qfalse; + return Qfalse; } static VALUE nucomp_to_i(VALUE self) { - get_dat1(self); + get_dat1(self); - if (k_float_p(dat->image) || !f_zero_p(dat->image)) { - VALUE s = f_to_s(self); - rb_raise(rb_eRangeError, "can't convert %s into Integer", - StringValuePtr(s)); - } - return f_to_i(dat->real); + if (k_float_p(dat->image) || !f_zero_p(dat->image)) { + VALUE s = f_to_s(self); + rb_raise(rb_eRangeError, "can't convert %s into Integer", + StringValuePtr(s)); + } + return f_to_i(dat->real); } static VALUE nucomp_to_f(VALUE self) { - get_dat1(self); + get_dat1(self); - if (k_float_p(dat->image) || !f_zero_p(dat->image)) { - VALUE s = f_to_s(self); - rb_raise(rb_eRangeError, "can't convert %s into Integer", - StringValuePtr(s)); - } - return f_to_f(dat->real); + if (k_float_p(dat->image) || !f_zero_p(dat->image)) { + VALUE s = f_to_s(self); + rb_raise(rb_eRangeError, "can't convert %s into Integer", + StringValuePtr(s)); + } + return f_to_f(dat->real); } static VALUE nucomp_to_r(VALUE self) { - get_dat1(self); + get_dat1(self); - if (k_float_p(dat->image) || !f_zero_p(dat->image)) { - VALUE s = f_to_s(self); - rb_raise(rb_eRangeError, "can't convert %s into Integer", - StringValuePtr(s)); - } - return f_to_r(dat->real); + if (k_float_p(dat->image) || !f_zero_p(dat->image)) { + VALUE s = f_to_s(self); + rb_raise(rb_eRangeError, "can't convert %s into Integer", + StringValuePtr(s)); + } + return f_to_r(dat->real); } static VALUE nilclass_to_c(VALUE self) { - return rb_complex_new1(INT2FIX(0)); + return rb_complex_new1(INT2FIX(0)); } static VALUE numeric_to_c(VALUE self) { - return rb_complex_new1(self); + return rb_complex_new1(self); } static VALUE comp_pat1, comp_pat2, a_slash, a_dot_and_an_e, - image_garbages_pat, null_string, underscores_pat, an_underscore; + image_garbages_pat, null_string, underscores_pat, an_underscore; #define DIGITS "(?:\\d(?:_\\d|\\d)*)" #define NUMERATOR "(?:" DIGITS "?\\.)?" DIGITS "(?:[eE][-+]?" DIGITS ")?" @@ -1243,36 +1251,36 @@ static VALUE comp_pat1, comp_pat2, a_slash, a_dot_and_an_e, static void make_patterns(void) { - static char *comp_pat1_source = PATTERN1; - static char *comp_pat2_source = PATTERN2; - static char *image_garbages_pat_source = "[+\\(\\)iIjJ]"; - static char *underscores_pat_source = "_+"; + static char comp_pat1_source[] = PATTERN1; + static char comp_pat2_source[] = PATTERN2; + static char image_garbages_pat_source[] = "[+\\(\\)iIjJ]"; + static char underscores_pat_source[] = "_+"; - comp_pat1 = rb_reg_new(comp_pat1_source, strlen(comp_pat1_source), 0); - rb_global_variable(&comp_pat1); + comp_pat1 = rb_reg_new(comp_pat1_source, sizeof comp_pat1_source - 1, 0); + rb_global_variable(&comp_pat1); - comp_pat2 = rb_reg_new(comp_pat2_source, strlen(comp_pat2_source), 0); - rb_global_variable(&comp_pat2); + comp_pat2 = rb_reg_new(comp_pat2_source, sizeof comp_pat2_source - 1, 0); + rb_global_variable(&comp_pat2); - a_slash = rb_str_new2("/"); - rb_global_variable(&a_slash); + a_slash = rb_str_new2("/"); + rb_global_variable(&a_slash); - a_dot_and_an_e = rb_str_new2(".eE"); - rb_global_variable(&a_dot_and_an_e); + a_dot_and_an_e = rb_str_new2(".eE"); + rb_global_variable(&a_dot_and_an_e); - image_garbages_pat = rb_reg_new(image_garbages_pat_source, - strlen(image_garbages_pat_source), 0); - rb_global_variable(&image_garbages_pat); + image_garbages_pat = rb_reg_new(image_garbages_pat_source, + sizeof image_garbages_pat_source - 1, 0); + rb_global_variable(&image_garbages_pat); - null_string = rb_str_new2(""); - rb_global_variable(&null_string); + null_string = rb_str_new2(""); + rb_global_variable(&null_string); - underscores_pat = rb_reg_new(underscores_pat_source, - strlen(underscores_pat_source), 0); - rb_global_variable(&underscores_pat); + underscores_pat = rb_reg_new(underscores_pat_source, + sizeof underscores_pat_source - 1, 0); + rb_global_variable(&underscores_pat); - an_underscore = rb_str_new2("_"); - rb_global_variable(&an_underscore); + an_underscore = rb_str_new2("_"); + rb_global_variable(&an_underscore); } #define id_strip rb_intern("strip") @@ -1302,63 +1310,63 @@ make_patterns(void) static VALUE string_to_c_internal(VALUE self) { - VALUE s; + VALUE s; - s = f_strip(self); + s = f_strip(self); - if (RSTRING_LEN(s) == 0) - return rb_assoc_new(Qnil, self); - - { - VALUE m, sr, si, re, r, i; - - m = f_match(comp_pat1, s); - if (!NIL_P(m)) { - sr = Qnil; - si = f_aref(m, INT2FIX(1)); - re = f_post_match(m); - } - if (NIL_P(m)) { - m = f_match(comp_pat2, s); - if (NIL_P(m)) + if (RSTRING_LEN(s) == 0) return rb_assoc_new(Qnil, self); - sr = f_aref(m, INT2FIX(1)); - si = f_aref(m, INT2FIX(2)); - re = f_post_match(m); + + { + VALUE m, sr, si, re, r, i; + + m = f_match(comp_pat1, s); + if (!NIL_P(m)) { + sr = Qnil; + si = f_aref(m, INT2FIX(1)); + re = f_post_match(m); + } + if (NIL_P(m)) { + m = f_match(comp_pat2, s); + if (NIL_P(m)) + return rb_assoc_new(Qnil, self); + sr = f_aref(m, INT2FIX(1)); + si = f_aref(m, INT2FIX(2)); + re = f_post_match(m); + } + r = INT2FIX(0); + i = INT2FIX(0); + if (!NIL_P(sr)) { + if (f_include_p(sr, a_slash)) + r = f_to_r(sr); + else if (f_gt_p(f_count(sr, a_dot_and_an_e), INT2FIX(0))) + r = f_to_f(sr); + else + r = f_to_i(sr); + } + if (!NIL_P(si)) { + f_gsub_bang(si, image_garbages_pat, null_string); + if (f_include_p(si, a_slash)) + i = f_to_r(si); + else if (f_gt_p(f_count(si, a_dot_and_an_e), INT2FIX(0))) + i = f_to_f(si); + else + i = f_to_i(si); + } + return rb_assoc_new(rb_complex_new2(r, i), re); } - r = INT2FIX(0); - i = INT2FIX(0); - if (!NIL_P(sr)) { - if (f_include_p(sr, a_slash)) - r = f_to_r(sr); - else if (f_gt_p(f_count(sr, a_dot_and_an_e), INT2FIX(0))) - r = f_to_f(sr); - else - r = f_to_i(sr); - } - if (!NIL_P(si)) { - f_gsub_bang(si, image_garbages_pat, null_string); - if (f_include_p(si, a_slash)) - i = f_to_r(si); - else if (f_gt_p(f_count(si, a_dot_and_an_e), INT2FIX(0))) - i = f_to_f(si); - else - i = f_to_i(si); - } - return rb_assoc_new(rb_complex_new2(r, i), re); - } } static VALUE string_to_c_strict(VALUE self) { - VALUE a = string_to_c_internal(self); - if (NIL_P(RARRAY_PTR(a)[0]) || RSTRING_LEN(RARRAY_PTR(a)[1]) > 0) { - VALUE s = f_inspect(self); - rb_raise(rb_eArgError, "invalid value for Complex: %s", - StringValuePtr(s)); - } - return RARRAY_PTR(a)[0]; + VALUE a = string_to_c_internal(self); + if (NIL_P(RARRAY_PTR(a)[0]) || RSTRING_LEN(RARRAY_PTR(a)[1]) > 0) { + VALUE s = f_inspect(self); + rb_raise(rb_eArgError, "invalid value for Complex: %s", + StringValuePtr(s)); + } + return RARRAY_PTR(a)[0]; } #define id_gsub rb_intern("gsub") @@ -1367,74 +1375,74 @@ string_to_c_strict(VALUE self) static VALUE string_to_c(VALUE self) { - VALUE s = f_gsub(self, underscores_pat, an_underscore); - VALUE a = string_to_c_internal(s); - if (!NIL_P(RARRAY_PTR(a)[0])) - return RARRAY_PTR(a)[0]; - return rb_complex_new1(INT2FIX(0)); + VALUE s = f_gsub(self, underscores_pat, an_underscore); + VALUE a = string_to_c_internal(s); + if (!NIL_P(RARRAY_PTR(a)[0])) + return RARRAY_PTR(a)[0]; + return rb_complex_new1(INT2FIX(0)); } static VALUE nucomp_s_convert(int argc, VALUE *argv, VALUE klass) { - VALUE a1, a2; + VALUE a1, a2; - a1 = Qnil; - a2 = Qnil; - rb_scan_args(argc, argv, "02", &a1, &a2); + a1 = Qnil; + a2 = Qnil; + rb_scan_args(argc, argv, "02", &a1, &a2); - switch (TYPE(a1)) { - case T_FIXNUM: - case T_BIGNUM: - case T_FLOAT: - break; - case T_STRING: - a1 = string_to_c_strict(a1); - break; - } - - switch (TYPE(a2)) { - case T_FIXNUM: - case T_BIGNUM: - case T_FLOAT: - break; - case T_STRING: - a2 = string_to_c_strict(a2); - break; - } - - switch (TYPE(a1)) { - case T_COMPLEX: - { - get_dat1(a1); - - if (!k_float_p(dat->image) && f_zero_p(dat->image)) - a1 = dat->real; + switch (TYPE(a1)) { + case T_FIXNUM: + case T_BIGNUM: + case T_FLOAT: + break; + case T_STRING: + a1 = string_to_c_strict(a1); + break; } - } - switch (TYPE(a2)) { - case T_COMPLEX: - { - get_dat1(a2); - - if (!k_float_p(dat->image) && f_zero_p(dat->image)) - a2 = dat->real; + switch (TYPE(a2)) { + case T_FIXNUM: + case T_BIGNUM: + case T_FLOAT: + break; + case T_STRING: + a2 = string_to_c_strict(a2); + break; } - } - switch (TYPE(a1)) { - case T_COMPLEX: - if (NIL_P(a2) || f_zero_p(a2)) - return a1; - } + switch (TYPE(a1)) { + case T_COMPLEX: + { + get_dat1(a1); - { - VALUE argv2[2]; - argv2[0] = a1; - argv2[1] = a2; - return nucomp_s_new(argc, argv2, klass); - } + if (!k_float_p(dat->image) && f_zero_p(dat->image)) + a1 = dat->real; + } + } + + switch (TYPE(a2)) { + case T_COMPLEX: + { + get_dat1(a2); + + if (!k_float_p(dat->image) && f_zero_p(dat->image)) + a2 = dat->real; + } + } + + switch (TYPE(a1)) { + case T_COMPLEX: + if (NIL_P(a2) || f_zero_p(a2)) + return a1; + } + + { + VALUE argv2[2]; + argv2[0] = a1; + argv2[1] = a2; + return nucomp_s_new(argc, argv2, klass); + } } /* --- */ @@ -1444,25 +1452,25 @@ nucomp_s_convert(int argc, VALUE *argv, VALUE klass) static VALUE numeric_re(VALUE self) { - return rb_Complex1(self); + return rb_Complex1(self); } static VALUE numeric_im(VALUE self) { - return rb_Complex2(ZERO, self); + return rb_Complex2(ZERO, self); } static VALUE numeric_real(VALUE self) { - return self; + return self; } static VALUE numeric_image(VALUE self) { - return INT2FIX(0); + return INT2FIX(0); } #define id_PI rb_intern("PI") @@ -1470,185 +1478,185 @@ numeric_image(VALUE self) static VALUE numeric_arg(VALUE self) { - if (!f_negative_p(self)) - return INT2FIX(0); - return rb_const_get(rb_mMath, id_PI); + if (!f_negative_p(self)) + return INT2FIX(0); + return rb_const_get(rb_mMath, id_PI); } static VALUE numeric_polar(VALUE self) { - return rb_assoc_new(f_abs(self), f_arg(self)); + return rb_assoc_new(f_abs(self), f_arg(self)); } static VALUE numeric_conjugate(VALUE self) { - return self; + return self; } void Init_Complex(void) { - assert(fprintf(stderr, "assert() is now active\n")); + assert(fprintf(stderr, "assert() is now active\n")); - id_Unify = rb_intern("Unify"); - id_abs = rb_intern("abs"); - id_abs2 = rb_intern("abs2"); - id_arg = rb_intern("arg"); - id_atan2_bang = rb_intern("atan2!"); - id_cmp = rb_intern("<=>"); - id_coerce = rb_intern("coerce"); - id_conjugate = rb_intern("conjugate"); - id_convert = rb_intern("convert"); - id_cos = rb_intern("cos"); - id_denominator = rb_intern("denominator"); - id_divmod = rb_intern("divmod"); - id_equal_p = rb_intern("=="); - id_exact_p = rb_intern("exact?"); - id_exp_bang = rb_intern("exp!"); - id_expt = rb_intern("**"); - id_floor = rb_intern("floor"); - id_format = rb_intern("format"); - id_hypot = rb_intern("hypot"); - id_idiv = rb_intern("div"); - id_inspect = rb_intern("inspect"); - id_log_bang = rb_intern("log!"); - id_negate = rb_intern("-@"); - id_new = rb_intern("new"); - id_new_bang = rb_intern("new!"); - id_numerator = rb_intern("numerator"); - id_polar = rb_intern("polar"); - id_quo = rb_intern("quo"); - id_scalar_p = rb_intern("scalar?"); - id_sin = rb_intern("sin"); - id_sqrt = rb_intern("sqrt"); - id_to_f = rb_intern("to_f"); - id_to_i = rb_intern("to_i"); - id_to_r = rb_intern("to_r"); - id_to_s = rb_intern("to_s"); - id_truncate = rb_intern("truncate"); + id_Unify = rb_intern("Unify"); + id_abs = rb_intern("abs"); + id_abs2 = rb_intern("abs2"); + id_arg = rb_intern("arg"); + id_atan2_bang = rb_intern("atan2!"); + id_cmp = rb_intern("<=>"); + id_coerce = rb_intern("coerce"); + id_conjugate = rb_intern("conjugate"); + id_convert = rb_intern("convert"); + id_cos = rb_intern("cos"); + id_denominator = rb_intern("denominator"); + id_divmod = rb_intern("divmod"); + id_equal_p = rb_intern("=="); + id_exact_p = rb_intern("exact?"); + id_exp_bang = rb_intern("exp!"); + id_expt = rb_intern("**"); + id_floor = rb_intern("floor"); + id_format = rb_intern("format"); + id_hypot = rb_intern("hypot"); + id_idiv = rb_intern("div"); + id_inspect = rb_intern("inspect"); + id_log_bang = rb_intern("log!"); + id_negate = rb_intern("-@"); + id_new = rb_intern("new"); + id_new_bang = rb_intern("new!"); + id_numerator = rb_intern("numerator"); + id_polar = rb_intern("polar"); + id_quo = rb_intern("quo"); + id_scalar_p = rb_intern("scalar?"); + id_sin = rb_intern("sin"); + id_sqrt = rb_intern("sqrt"); + id_to_f = rb_intern("to_f"); + id_to_i = rb_intern("to_i"); + id_to_r = rb_intern("to_r"); + id_to_s = rb_intern("to_s"); + id_truncate = rb_intern("truncate"); - rb_cComplex = rb_define_class(COMPLEX_NAME, rb_cNumeric); + rb_cComplex = rb_define_class(COMPLEX_NAME, rb_cNumeric); - rb_define_alloc_func(rb_cComplex, nucomp_s_alloc); - rb_funcall(rb_cComplex, rb_intern("private_class_method"), 1, - ID2SYM(rb_intern("allocate"))); + rb_define_alloc_func(rb_cComplex, nucomp_s_alloc); + rb_funcall(rb_cComplex, rb_intern("private_class_method"), 1, + ID2SYM(rb_intern("allocate"))); - rb_define_singleton_method(rb_cComplex, "generic?", nucomp_s_generic_p, 1); + rb_define_singleton_method(rb_cComplex, "generic?", nucomp_s_generic_p, 1); - rb_define_singleton_method(rb_cComplex, "new!", nucomp_s_new_bang, -1); - rb_funcall(rb_cComplex, rb_intern("private_class_method"), 1, - ID2SYM(rb_intern("new!"))); + rb_define_singleton_method(rb_cComplex, "new!", nucomp_s_new_bang, -1); + rb_funcall(rb_cComplex, rb_intern("private_class_method"), 1, + ID2SYM(rb_intern("new!"))); - rb_define_singleton_method(rb_cComplex, "new", nucomp_s_new, -1); - rb_funcall(rb_cComplex, rb_intern("private_class_method"), 1, - ID2SYM(rb_intern("new"))); + rb_define_singleton_method(rb_cComplex, "new", nucomp_s_new, -1); + rb_funcall(rb_cComplex, rb_intern("private_class_method"), 1, + ID2SYM(rb_intern("new"))); #if 0 - rb_define_singleton_method(rb_cComplex, "rect", nucomp_s_new, -1); - rb_define_singleton_method(rb_cComplex, "rectangular", nucomp_s_new, -1); + rb_define_singleton_method(rb_cComplex, "rect", nucomp_s_new, -1); + rb_define_singleton_method(rb_cComplex, "rectangular", nucomp_s_new, -1); #endif - rb_define_singleton_method(rb_cComplex, "polar", nucomp_s_polar, 2); + rb_define_singleton_method(rb_cComplex, "polar", nucomp_s_polar, 2); - rb_define_global_function(COMPLEX_NAME, nucomp_f_complex, -1); + rb_define_global_function(COMPLEX_NAME, nucomp_f_complex, -1); - rb_undef_method(rb_cComplex, "<"); - rb_undef_method(rb_cComplex, "<="); - rb_undef_method(rb_cComplex, "<=>"); - rb_undef_method(rb_cComplex, ">"); - rb_undef_method(rb_cComplex, ">="); - rb_undef_method(rb_cComplex, "between?"); - rb_undef_method(rb_cComplex, "divmod"); - rb_undef_method(rb_cComplex, "floor"); - rb_undef_method(rb_cComplex, "ceil"); - rb_undef_method(rb_cComplex, "modulo"); - rb_undef_method(rb_cComplex, "round"); - rb_undef_method(rb_cComplex, "step"); - rb_undef_method(rb_cComplex, "truncate"); + rb_undef_method(rb_cComplex, "<"); + rb_undef_method(rb_cComplex, "<="); + rb_undef_method(rb_cComplex, "<=>"); + rb_undef_method(rb_cComplex, ">"); + rb_undef_method(rb_cComplex, ">="); + rb_undef_method(rb_cComplex, "between?"); + rb_undef_method(rb_cComplex, "divmod"); + rb_undef_method(rb_cComplex, "floor"); + rb_undef_method(rb_cComplex, "ceil"); + rb_undef_method(rb_cComplex, "modulo"); + rb_undef_method(rb_cComplex, "round"); + rb_undef_method(rb_cComplex, "step"); + rb_undef_method(rb_cComplex, "truncate"); #if NUBY - rb_undef_method(rb_cComplex, "//"); + rb_undef_method(rb_cComplex, "//"); #endif - rb_define_method(rb_cComplex, "real", nucomp_real, 0); - rb_define_method(rb_cComplex, "image", nucomp_image, 0); - rb_define_method(rb_cComplex, "imag", nucomp_image, 0); + rb_define_method(rb_cComplex, "real", nucomp_real, 0); + rb_define_method(rb_cComplex, "image", nucomp_image, 0); + rb_define_method(rb_cComplex, "imag", nucomp_image, 0); - rb_define_method(rb_cComplex, "+", nucomp_add, 1); - rb_define_method(rb_cComplex, "-", nucomp_sub, 1); - rb_define_method(rb_cComplex, "*", nucomp_mul, 1); - rb_define_method(rb_cComplex, "/", nucomp_div, 1); - rb_define_method(rb_cComplex, "quo", nucomp_rdiv, 1); - rb_define_method(rb_cComplex, "rdiv", nucomp_rdiv, 1); - rb_define_method(rb_cComplex, "fdiv", nucomp_rdiv, 1); - rb_define_method(rb_cComplex, "**", nucomp_expt, 1); + rb_define_method(rb_cComplex, "+", nucomp_add, 1); + rb_define_method(rb_cComplex, "-", nucomp_sub, 1); + rb_define_method(rb_cComplex, "*", nucomp_mul, 1); + rb_define_method(rb_cComplex, "/", nucomp_div, 1); + rb_define_method(rb_cComplex, "quo", nucomp_rdiv, 1); + rb_define_method(rb_cComplex, "rdiv", nucomp_rdiv, 1); + rb_define_method(rb_cComplex, "fdiv", nucomp_rdiv, 1); + rb_define_method(rb_cComplex, "**", nucomp_expt, 1); - rb_define_method(rb_cComplex, "==", nucomp_equal_p, 1); - rb_define_method(rb_cComplex, "coerce", nucomp_coerce, 1); + rb_define_method(rb_cComplex, "==", nucomp_equal_p, 1); + rb_define_method(rb_cComplex, "coerce", nucomp_coerce, 1); - rb_define_method(rb_cComplex, "abs", nucomp_abs, 0); + rb_define_method(rb_cComplex, "abs", nucomp_abs, 0); #if 0 - rb_define_method(rb_cComplex, "magnitude", nucomp_abs, 0); + rb_define_method(rb_cComplex, "magnitude", nucomp_abs, 0); #endif - rb_define_method(rb_cComplex, "abs2", nucomp_abs2, 0); - rb_define_method(rb_cComplex, "arg", nucomp_arg, 0); - rb_define_method(rb_cComplex, "angle", nucomp_arg, 0); - rb_define_method(rb_cComplex, "polar", nucomp_polar, 0); - rb_define_method(rb_cComplex, "conjugate", nucomp_conjugate, 0); - rb_define_method(rb_cComplex, "conj", nucomp_conjugate, 0); + rb_define_method(rb_cComplex, "abs2", nucomp_abs2, 0); + rb_define_method(rb_cComplex, "arg", nucomp_arg, 0); + rb_define_method(rb_cComplex, "angle", nucomp_arg, 0); + rb_define_method(rb_cComplex, "polar", nucomp_polar, 0); + rb_define_method(rb_cComplex, "conjugate", nucomp_conjugate, 0); + rb_define_method(rb_cComplex, "conj", nucomp_conjugate, 0); #if 0 - rb_define_method(rb_cComplex, "~", nucomp_conjugate, 0); /* gcc */ + rb_define_method(rb_cComplex, "~", nucomp_conjugate, 0); /* gcc */ #endif #if 0 - rb_define_method(rb_cComplex, "real?", nucomp_real_p, 0); - rb_define_method(rb_cComplex, "complex?", nucomp_complex_p, 0); - rb_define_method(rb_cComplex, "exact?", nucomp_exact_p, 0); - rb_define_method(rb_cComplex, "inexact?", nucomp_inexact_p, 0); + rb_define_method(rb_cComplex, "real?", nucomp_real_p, 0); + rb_define_method(rb_cComplex, "complex?", nucomp_complex_p, 0); + rb_define_method(rb_cComplex, "exact?", nucomp_exact_p, 0); + rb_define_method(rb_cComplex, "inexact?", nucomp_inexact_p, 0); #endif - rb_define_method(rb_cComplex, "numerator", nucomp_numerator, 0); - rb_define_method(rb_cComplex, "denominator", nucomp_denominator, 0); + rb_define_method(rb_cComplex, "numerator", nucomp_numerator, 0); + rb_define_method(rb_cComplex, "denominator", nucomp_denominator, 0); - rb_define_method(rb_cComplex, "hash", nucomp_hash, 0); + rb_define_method(rb_cComplex, "hash", nucomp_hash, 0); - rb_define_method(rb_cComplex, "to_s", nucomp_to_s, 0); - rb_define_method(rb_cComplex, "inspect", nucomp_inspect, 0); + rb_define_method(rb_cComplex, "to_s", nucomp_to_s, 0); + rb_define_method(rb_cComplex, "inspect", nucomp_inspect, 0); - rb_define_method(rb_cComplex, "marshal_dump", nucomp_marshal_dump, 0); - rb_define_method(rb_cComplex, "marshal_load", nucomp_marshal_load, 1); + rb_define_method(rb_cComplex, "marshal_dump", nucomp_marshal_dump, 0); + rb_define_method(rb_cComplex, "marshal_load", nucomp_marshal_load, 1); - /* --- */ + /* --- */ - rb_define_method(rb_cComplex, "scalar?", nucomp_scalar_p, 0); - rb_define_method(rb_cComplex, "to_i", nucomp_to_i, 0); - rb_define_method(rb_cComplex, "to_f", nucomp_to_f, 0); - rb_define_method(rb_cComplex, "to_r", nucomp_to_r, 0); - rb_define_method(rb_cNilClass, "to_c", nilclass_to_c, 0); - rb_define_method(rb_cNumeric, "to_c", numeric_to_c, 0); + rb_define_method(rb_cComplex, "scalar?", nucomp_scalar_p, 0); + rb_define_method(rb_cComplex, "to_i", nucomp_to_i, 0); + rb_define_method(rb_cComplex, "to_f", nucomp_to_f, 0); + rb_define_method(rb_cComplex, "to_r", nucomp_to_r, 0); + rb_define_method(rb_cNilClass, "to_c", nilclass_to_c, 0); + rb_define_method(rb_cNumeric, "to_c", numeric_to_c, 0); - make_patterns(); + make_patterns(); - rb_define_method(rb_cString, "to_c", string_to_c, 0); + rb_define_method(rb_cString, "to_c", string_to_c, 0); - rb_define_singleton_method(rb_cComplex, "convert", nucomp_s_convert, -1); - rb_funcall(rb_cComplex, rb_intern("private_class_method"), 1, - ID2SYM(rb_intern("convert"))); + rb_define_singleton_method(rb_cComplex, "convert", nucomp_s_convert, -1); + rb_funcall(rb_cComplex, rb_intern("private_class_method"), 1, + ID2SYM(rb_intern("convert"))); - /* --- */ + /* --- */ - rb_define_method(rb_cNumeric, "re", numeric_re, 0); - rb_define_method(rb_cNumeric, "im", numeric_im, 0); - rb_define_method(rb_cNumeric, "real", numeric_real, 0); - rb_define_method(rb_cNumeric, "image", numeric_image, 0); - rb_define_method(rb_cNumeric, "imag", numeric_image, 0); - rb_define_method(rb_cNumeric, "arg", numeric_arg, 0); - rb_define_method(rb_cNumeric, "angle", numeric_arg, 0); - rb_define_method(rb_cNumeric, "polar", numeric_polar, 0); - rb_define_method(rb_cNumeric, "conjugate", numeric_conjugate, 0); - rb_define_method(rb_cNumeric, "conj", numeric_conjugate, 0); + rb_define_method(rb_cNumeric, "re", numeric_re, 0); + rb_define_method(rb_cNumeric, "im", numeric_im, 0); + rb_define_method(rb_cNumeric, "real", numeric_real, 0); + rb_define_method(rb_cNumeric, "image", numeric_image, 0); + rb_define_method(rb_cNumeric, "imag", numeric_image, 0); + rb_define_method(rb_cNumeric, "arg", numeric_arg, 0); + rb_define_method(rb_cNumeric, "angle", numeric_arg, 0); + rb_define_method(rb_cNumeric, "polar", numeric_polar, 0); + rb_define_method(rb_cNumeric, "conjugate", numeric_conjugate, 0); + rb_define_method(rb_cNumeric, "conj", numeric_conjugate, 0); - rb_define_const(rb_cComplex, "I", - f_complex_new_bang2(rb_cComplex, ZERO, ONE)); + rb_define_const(rb_cComplex, "I", + f_complex_new_bang2(rb_cComplex, ZERO, ONE)); } diff --git a/rational.c b/rational.c index 7165e93232..eccc73165f 100644 --- a/rational.c +++ b/rational.c @@ -38,82 +38,82 @@ f_##n(VALUE x, VALUE y)\ inline static VALUE \ f_##n(VALUE x)\ {\ - return rb_funcall(x, id_##n, 0);\ + return rb_funcall(x, id_##n, 0);\ } #define fun2(n) \ inline static VALUE \ f_##n(VALUE x, VALUE y)\ {\ - return rb_funcall(x, id_##n, 1, y);\ + return rb_funcall(x, id_##n, 1, y);\ } inline static VALUE f_add(VALUE x, VALUE y) { - VALUE r; - if (FIXNUM_P(y)) { - if (FIX2LONG(y) == 0) - r = x; - else - r = rb_funcall(x, '+', 1, y); - } else if (FIXNUM_P(x)) { - if (FIX2LONG(x) == 0) - r = y; - else - r = rb_funcall(x, '+', 1, y); - } else - r = rb_funcall(x, '+', 1, y); - return r; + VALUE r; + if (FIXNUM_P(y)) { + if (FIX2LONG(y) == 0) + r = x; + else + r = rb_funcall(x, '+', 1, y); + } else if (FIXNUM_P(x)) { + if (FIX2LONG(x) == 0) + r = y; + else + r = rb_funcall(x, '+', 1, y); + } else + r = rb_funcall(x, '+', 1, y); + return r; } inline static VALUE f_cmp(VALUE x, VALUE y) { - VALUE r; - if (FIXNUM_P(x) && FIXNUM_P(y)) { - long c = FIX2LONG(x) - FIX2LONG(y); - if (c > 0) - c = 1; - else if (c < 0) - c = -1; - r = INT2FIX(c); - } else - r = rb_funcall(x, id_cmp, 1, y); - return r; + VALUE r; + if (FIXNUM_P(x) && FIXNUM_P(y)) { + long c = FIX2LONG(x) - FIX2LONG(y); + if (c > 0) + c = 1; + else if (c < 0) + c = -1; + r = INT2FIX(c); + } else + r = rb_funcall(x, id_cmp, 1, y); + return r; } inline static VALUE f_div(VALUE x, VALUE y) { - VALUE r; - if (FIXNUM_P(y) && FIX2LONG(y) == 1) - r = x; - else - r = rb_funcall(x, '/', 1, y); - return r; + VALUE r; + if (FIXNUM_P(y) && FIX2LONG(y) == 1) + r = x; + else + r = rb_funcall(x, '/', 1, y); + return r; } inline static VALUE f_gt_p(VALUE x, VALUE y) { VALUE r; - if (FIXNUM_P(x) && FIXNUM_P(y)) - r = f_boolcast(FIX2LONG(x) > FIX2LONG(y)); - else - r = rb_funcall(x, '>', 1, y); - return r; + if (FIXNUM_P(x) && FIXNUM_P(y)) + r = f_boolcast(FIX2LONG(x) > FIX2LONG(y)); + else + r = rb_funcall(x, '>', 1, y); + return r; } inline static VALUE f_lt_p(VALUE x, VALUE y) { - VALUE r; - if (FIXNUM_P(x) && FIXNUM_P(y)) - r = f_boolcast(FIX2LONG(x) < FIX2LONG(y)); - else - r = rb_funcall(x, '<', 1, y); - return r; + VALUE r; + if (FIXNUM_P(x) && FIXNUM_P(y)) + r = f_boolcast(FIX2LONG(x) < FIX2LONG(y)); + else + r = rb_funcall(x, '<', 1, y); + return r; } binop(mod, '%') @@ -121,46 +121,46 @@ binop(mod, '%') inline static VALUE f_mul(VALUE x, VALUE y) { - VALUE r; - if (FIXNUM_P(y)) { - long _iy = FIX2LONG(y); - if (_iy == 0) { - if (TYPE(x) == T_FLOAT) - r = rb_float_new(0.0); - else - r = ZERO; - } else if (_iy == 1) - r = x; - else - r = rb_funcall(x, '*', 1, y); - } else if (FIXNUM_P(x)) { - long _ix = FIX2LONG(x); - if (_ix == 0) { - if (TYPE(y) == T_FLOAT) - r = rb_float_new(0.0); - else - r = ZERO; - } else if (_ix == 1) - r = y; - else - r = rb_funcall(x, '*', 1, y); - } else - r = rb_funcall(x, '*', 1, y); - return r; + VALUE r; + if (FIXNUM_P(y)) { + long _iy = FIX2LONG(y); + if (_iy == 0) { + if (TYPE(x) == T_FLOAT) + r = rb_float_new(0.0); + else + r = ZERO; + } else if (_iy == 1) + r = x; + else + r = rb_funcall(x, '*', 1, y); + } else if (FIXNUM_P(x)) { + long _ix = FIX2LONG(x); + if (_ix == 0) { + if (TYPE(y) == T_FLOAT) + r = rb_float_new(0.0); + else + r = ZERO; + } else if (_ix == 1) + r = y; + else + r = rb_funcall(x, '*', 1, y); + } else + r = rb_funcall(x, '*', 1, y); + return r; } inline static VALUE f_sub(VALUE x, VALUE y) { - VALUE r; - if (FIXNUM_P(y)) { - if (FIX2LONG(y) == 0) - r = x; - else - r = rb_funcall(x, '-', 1, y); - } else - r = rb_funcall(x, '-', 1, y); - return r; + VALUE r; + if (FIXNUM_P(y)) { + if (FIX2LONG(y) == 0) + r = x; + else + r = rb_funcall(x, '-', 1, y); + } else + r = rb_funcall(x, '-', 1, y); + return r; } binop(xor, '^') @@ -179,12 +179,12 @@ fun2(coerce) inline static VALUE f_equal_p(VALUE x, VALUE y) { - VALUE r; - if (FIXNUM_P(x) && FIXNUM_P(y)) - r = f_boolcast(FIX2LONG(x) == FIX2LONG(y)); - else - r = rb_funcall(x, id_equal_p, 1, y); - return r; + VALUE r; + if (FIXNUM_P(x) && FIXNUM_P(y)) + r = f_boolcast(FIX2LONG(x) == FIX2LONG(y)); + else + r = rb_funcall(x, id_equal_p, 1, y); + return r; } fun2(expt) @@ -193,64 +193,64 @@ fun2(idiv) inline static VALUE f_negative_p(VALUE x) { - VALUE r; - if (FIXNUM_P(x)) - r = f_boolcast(FIX2LONG(x) < 0); - else - r = rb_funcall(x, '<', 1, ZERO); - return r; + VALUE r; + if (FIXNUM_P(x)) + r = f_boolcast(FIX2LONG(x) < 0); + else + r = rb_funcall(x, '<', 1, ZERO); + return r; } inline static VALUE f_zero_p(VALUE x) { - VALUE r; - if (FIXNUM_P(x)) - r = f_boolcast(FIX2LONG(x) == 0); - else - r = rb_funcall(x, id_equal_p, 1, ZERO); - return r; + VALUE r; + if (FIXNUM_P(x)) + r = f_boolcast(FIX2LONG(x) == 0); + else + r = rb_funcall(x, id_equal_p, 1, ZERO); + return r; } inline static VALUE f_one_p(VALUE x) { - VALUE r; - if (FIXNUM_P(x)) - r = f_boolcast(FIX2LONG(x) == 1); - else - r = rb_funcall(x, id_equal_p, 1, ONE); - return r; + VALUE r; + if (FIXNUM_P(x)) + r = f_boolcast(FIX2LONG(x) == 1); + else + r = rb_funcall(x, id_equal_p, 1, ONE); + return r; } inline static VALUE f_kind_of_p(VALUE x, VALUE c) { - return rb_obj_is_kind_of(x, c); + return rb_obj_is_kind_of(x, c); } inline static VALUE k_numeric_p(VALUE x) { - return f_kind_of_p(x, rb_cNumeric); + return f_kind_of_p(x, rb_cNumeric); } inline static VALUE k_integer_p(VALUE x) { - return f_kind_of_p(x, rb_cInteger); + return f_kind_of_p(x, rb_cInteger); } inline static VALUE k_float_p(VALUE x) { - return f_kind_of_p(x, rb_cFloat); + return f_kind_of_p(x, rb_cFloat); } inline static VALUE k_rational_p(VALUE x) { - return f_kind_of_p(x, rb_cRational); + return f_kind_of_p(x, rb_cRational); } #ifndef NDEBUG @@ -260,76 +260,76 @@ k_rational_p(VALUE x) inline static long i_gcd(long x, long y) { - long b; + long b; - if (x < 0) - x = -x; - if (y < 0) - y = -y; + if (x < 0) + x = -x; + if (y < 0) + y = -y; - if (x == 0) - return y; - if (y == 0) - return x; + if (x == 0) + return y; + if (y == 0) + return x; - b = 0; - while ((x & 1) == 0 && (y & 1) == 0) { - b += 1; - x >>= 1; - y >>= 1; - } - - while ((x & 1) == 0) - x >>= 1; - - while ((y & 1) == 0) - y >>= 1; - - while (x != y) { - if (y > x) { - long t; - t = x; - x = y; - y = t; + b = 0; + while ((x & 1) == 0 && (y & 1) == 0) { + b += 1; + x >>= 1; + y >>= 1; } - x -= y; - while ((x & 1) == 0) - x >>= 1; - } - return x << b; + while ((x & 1) == 0) + x >>= 1; + + while ((y & 1) == 0) + y >>= 1; + + while (x != y) { + if (y > x) { + long t; + t = x; + x = y; + y = t; + } + x -= y; + while ((x & 1) == 0) + x >>= 1; + } + + return x << b; } inline static VALUE f_gcd(VALUE x, VALUE y) { - VALUE z; + VALUE z; - if (FIXNUM_P(x) && FIXNUM_P(y)) - return LONG2NUM(i_gcd(FIX2LONG(x), FIX2LONG(y))); - - if (f_negative_p(x)) - x = f_negate(x); - if (f_negative_p(y)) - y = f_negate(y); - - if (f_zero_p(x)) - return y; - if (f_zero_p(y)) - return x; - - for (;;) { - if (FIXNUM_P(x)) { - if (FIX2LONG(x) == 0) - return y; - if (FIXNUM_P(y)) + if (FIXNUM_P(x) && FIXNUM_P(y)) return LONG2NUM(i_gcd(FIX2LONG(x), FIX2LONG(y))); + + if (f_negative_p(x)) + x = f_negate(x); + if (f_negative_p(y)) + y = f_negate(y); + + if (f_zero_p(x)) + return y; + if (f_zero_p(y)) + return x; + + for (;;) { + if (FIXNUM_P(x)) { + if (FIX2LONG(x) == 0) + return y; + if (FIXNUM_P(y)) + return LONG2NUM(i_gcd(FIX2LONG(x), FIX2LONG(y))); + } + z = x; + x = f_mod(y, x); + y = z; } - z = x; - x = f_mod(y, x); - y = z; - } - /* NOTREACHED */ + /* NOTREACHED */ } #ifndef NDEBUG @@ -338,90 +338,90 @@ f_gcd(VALUE x, VALUE y) inline static VALUE f_gcd(VALUE x, VALUE y) { - VALUE r = f_gcd_orig(x, y); - if (!f_zero_p(r)) { - assert(f_zero_p(f_mod(x, r))); - assert(f_zero_p(f_mod(y, r))); - } - return r; + VALUE r = f_gcd_orig(x, y); + if (!f_zero_p(r)) { + assert(f_zero_p(f_mod(x, r))); + assert(f_zero_p(f_mod(y, r))); + } + return r; } #endif inline static VALUE f_lcm(VALUE x, VALUE y) { - if (f_zero_p(x) || f_zero_p(y)) - return ZERO; - else - return f_abs(f_mul(f_div(x, f_gcd(x, y)), y)); + if (f_zero_p(x) || f_zero_p(y)) + return ZERO; + else + return f_abs(f_mul(f_div(x, f_gcd(x, y)), y)); } #define get_dat1(x) \ - struct RRational *dat;\ - dat = ((struct RRational *)(x)) + struct RRational *dat;\ + dat = ((struct RRational *)(x)) #define get_dat2(x,y) \ - struct RRational *adat, *bdat;\ - adat = ((struct RRational *)(x));\ - bdat = ((struct RRational *)(y)) + struct RRational *adat, *bdat;\ + adat = ((struct RRational *)(x));\ + bdat = ((struct RRational *)(y)) inline static VALUE nurat_s_new_internal(VALUE klass, VALUE num, VALUE den) { - NEWOBJ(obj, struct RRational); - OBJSETUP(obj, klass, T_RATIONAL); + NEWOBJ(obj, struct RRational); + OBJSETUP(obj, klass, T_RATIONAL); - obj->num = num; - obj->den = den; + obj->num = num; + obj->den = den; - return (VALUE)obj; + return (VALUE)obj; } static VALUE nurat_s_alloc(VALUE klass) { - return nurat_s_new_internal(klass, ZERO, ONE); + return nurat_s_new_internal(klass, ZERO, ONE); } static VALUE nurat_s_new_bang(int argc, VALUE *argv, VALUE klass) { - VALUE num, den; + VALUE num, den; - switch (rb_scan_args(argc, argv, "11", &num, &den)) { - case 1: - if (!k_integer_p(num)) - num = f_to_i(num); - den = ONE; - break; - default: - if (!k_integer_p(num)) - num = f_to_i(num); - if (!k_integer_p(den)) - den = f_to_i(den); + switch (rb_scan_args(argc, argv, "11", &num, &den)) { + case 1: + if (!k_integer_p(num)) + num = f_to_i(num); + den = ONE; + break; + default: + if (!k_integer_p(num)) + num = f_to_i(num); + if (!k_integer_p(den)) + den = f_to_i(den); - if (f_negative_p(den)) { - num = f_negate(num); - den = f_negate(den); + if (f_negative_p(den)) { + num = f_negate(num); + den = f_negate(den); + } + break; } - break; - } - return nurat_s_new_internal(klass, num, den); + return nurat_s_new_internal(klass, num, den); } inline static VALUE f_rational_new_bang1(VALUE klass, VALUE x) { - return nurat_s_new_internal(klass, x, ONE); + return nurat_s_new_internal(klass, x, ONE); } inline static VALUE f_rational_new_bang2(VALUE klass, VALUE x, VALUE y) { - assert(!f_negative_p(y)); - assert(!f_zero_p(y)); - return nurat_s_new_internal(klass, x, y); + assert(!f_negative_p(y)); + assert(!f_zero_p(y)); + return nurat_s_new_internal(klass, x, y); } #define f_unify_p(klass) rb_const_defined(klass, id_Unify) @@ -429,159 +429,161 @@ f_rational_new_bang2(VALUE klass, VALUE x, VALUE y) inline static VALUE nurat_s_canonicalize_internal(VALUE klass, VALUE num, VALUE den) { - VALUE gcd; + VALUE gcd; - switch (FIX2INT(f_cmp(den, ZERO))) { - case -1: - if (f_negative_p(den)) { - num = f_negate(num); - den = f_negate(den); + switch (FIX2INT(f_cmp(den, ZERO))) { + case -1: + if (f_negative_p(den)) { + num = f_negate(num); + den = f_negate(den); + } + break; + case 0: + rb_raise(rb_eZeroDivError, "devided by zero"); + break; } - break; - case 0: - rb_raise(rb_eZeroDivError, "devided by zero"); - break; - } - gcd = f_gcd(num, den); - num = f_idiv(num, gcd); - den = f_idiv(den, gcd); + gcd = f_gcd(num, den); + num = f_idiv(num, gcd); + den = f_idiv(den, gcd); - if (f_one_p(den) && f_unify_p(klass)) - return num; - else - return nurat_s_new_internal(klass, num, den); + if (f_one_p(den) && f_unify_p(klass)) + return num; + else + return nurat_s_new_internal(klass, num, den); } inline static VALUE nurat_s_canonicalize_internal_no_reduce(VALUE klass, VALUE num, VALUE den) { - switch (FIX2INT(f_cmp(den, ZERO))) { - case -1: - if (f_negative_p(den)) { - num = f_negate(num); - den = f_negate(den); + switch (FIX2INT(f_cmp(den, ZERO))) { + case -1: + if (f_negative_p(den)) { + num = f_negate(num); + den = f_negate(den); + } + break; + case 0: + rb_raise(rb_eZeroDivError, "devided by zero"); + break; } - break; - case 0: - rb_raise(rb_eZeroDivError, "devided by zero"); - break; - } - if (f_equal_p(den, ONE) && f_unify_p(klass)) - return num; - else - return nurat_s_new_internal(klass, num, den); + if (f_equal_p(den, ONE) && f_unify_p(klass)) + return num; + else + return nurat_s_new_internal(klass, num, den); } +#if 0 static VALUE nurat_s_canonicalize(int argc, VALUE *argv, VALUE klass) { - VALUE num, den; + VALUE num, den; - switch (rb_scan_args(argc, argv, "11", &num, &den)) { - case 1: - den = ONE; - break; - } + switch (rb_scan_args(argc, argv, "11", &num, &den)) { + case 1: + den = ONE; + break; + } - switch (TYPE(num)) { - case T_FIXNUM: - case T_BIGNUM: - break; - default: - rb_raise(rb_eArgError, "not an integer"); - } + switch (TYPE(num)) { + case T_FIXNUM: + case T_BIGNUM: + break; + default: + rb_raise(rb_eArgError, "not an integer"); + } - switch (TYPE(den)) { - case T_FIXNUM: - case T_BIGNUM: - break; - default: - rb_raise(rb_eArgError, "not an integer"); - } + switch (TYPE(den)) { + case T_FIXNUM: + case T_BIGNUM: + break; + default: + rb_raise(rb_eArgError, "not an integer"); + } - return nurat_s_canonicalize_internal(klass, num, den); + return nurat_s_canonicalize_internal(klass, num, den); } +#endif static VALUE nurat_s_new(int argc, VALUE *argv, VALUE klass) { - VALUE num, den; + VALUE num, den; - switch (rb_scan_args(argc, argv, "11", &num, &den)) { - case 1: - den = ONE; - break; - } + switch (rb_scan_args(argc, argv, "11", &num, &den)) { + case 1: + den = ONE; + break; + } - switch (TYPE(num)) { - case T_FIXNUM: - case T_BIGNUM: - break; - default: - rb_raise(rb_eArgError, "not an integer"); - } + switch (TYPE(num)) { + case T_FIXNUM: + case T_BIGNUM: + break; + default: + rb_raise(rb_eArgError, "not an integer"); + } - switch (TYPE(den)) { - case T_FIXNUM: - case T_BIGNUM: - break; - default: - rb_raise(rb_eArgError, "not an integer"); - } + switch (TYPE(den)) { + case T_FIXNUM: + case T_BIGNUM: + break; + default: + rb_raise(rb_eArgError, "not an integer"); + } - return nurat_s_canonicalize_internal(klass, num, den); + return nurat_s_canonicalize_internal(klass, num, den); } inline static VALUE f_rational_new1(VALUE klass, VALUE x) { - assert(!k_rational_p(x)); - return nurat_s_canonicalize_internal(klass, x, ONE); + assert(!k_rational_p(x)); + return nurat_s_canonicalize_internal(klass, x, ONE); } inline static VALUE f_rational_new2(VALUE klass, VALUE x, VALUE y) { - assert(!k_rational_p(x)); - assert(!k_rational_p(y)); - return nurat_s_canonicalize_internal(klass, x, y); + assert(!k_rational_p(x)); + assert(!k_rational_p(y)); + return nurat_s_canonicalize_internal(klass, x, y); } inline static VALUE f_rational_new_no_reduce1(VALUE klass, VALUE x) { - assert(!k_rational_p(x)); - return nurat_s_canonicalize_internal_no_reduce(klass, x, ONE); + assert(!k_rational_p(x)); + return nurat_s_canonicalize_internal_no_reduce(klass, x, ONE); } inline static VALUE f_rational_new_no_reduce2(VALUE klass, VALUE x, VALUE y) { - assert(!k_rational_p(x)); - assert(!k_rational_p(y)); - return nurat_s_canonicalize_internal_no_reduce(klass, x, y); + assert(!k_rational_p(x)); + assert(!k_rational_p(y)); + return nurat_s_canonicalize_internal_no_reduce(klass, x, y); } static VALUE nurat_f_rational(int argc, VALUE *argv, VALUE klass) { - return rb_funcall2(rb_cRational, id_convert, argc, argv); + return rb_funcall2(rb_cRational, id_convert, argc, argv); } static VALUE nurat_numerator(VALUE self) { - get_dat1(self); - return dat->num; + get_dat1(self); + return dat->num; } static VALUE nurat_denominator(VALUE self) { - get_dat1(self); - return dat->den; + get_dat1(self); + return dat->den; } #ifndef NDEBUG @@ -591,21 +593,21 @@ nurat_denominator(VALUE self) inline static VALUE f_imul(long a, long b) { - VALUE r; - long c; + VALUE r; + long c; - if (a == 0 || b == 0) - return ZERO; - else if (a == 1) - return LONG2NUM(b); - else if (b == 1) - return LONG2NUM(a); + if (a == 0 || b == 0) + return ZERO; + else if (a == 1) + return LONG2NUM(b); + else if (b == 1) + return LONG2NUM(a); - c = a * b; - r = LONG2NUM(c); - if (NUM2LONG(r) != c || (c / a) != b) - r = rb_big_mul(rb_int2big(a), rb_int2big(b)); - return r; + c = a * b; + r = LONG2NUM(c); + if (NUM2LONG(r) != c || (c / a) != b) + r = rb_big_mul(rb_int2big(a), rb_int2big(b)); + return r; } #ifndef NDEBUG @@ -614,465 +616,472 @@ f_imul(long a, long b) inline static VALUE f_imul(long x, long y) { - VALUE r = f_imul_orig(x, y); - assert(f_equal_p(r, f_mul(LONG2NUM(x), LONG2NUM(y)))); - return r; + VALUE r = f_imul_orig(x, y); + assert(f_equal_p(r, f_mul(LONG2NUM(x), LONG2NUM(y)))); + return r; } #endif inline static VALUE f_addsub(VALUE self, VALUE anum, VALUE aden, VALUE bnum, VALUE bden, int k) { - VALUE num, den; + VALUE num, den; - if (FIXNUM_P(anum) && FIXNUM_P(aden) && - FIXNUM_P(bnum) && FIXNUM_P(bden)) { - long an = FIX2LONG(anum); - long ad = FIX2LONG(aden); - long bn = FIX2LONG(bnum); - long bd = FIX2LONG(bden); - long ig = i_gcd(ad, bd); + if (FIXNUM_P(anum) && FIXNUM_P(aden) && + FIXNUM_P(bnum) && FIXNUM_P(bden)) { + long an = FIX2LONG(anum); + long ad = FIX2LONG(aden); + long bn = FIX2LONG(bnum); + long bd = FIX2LONG(bden); + long ig = i_gcd(ad, bd); - VALUE g = LONG2NUM(ig); - VALUE a = f_imul(an, bd / ig); - VALUE b = f_imul(bn, ad / ig); - VALUE c; + VALUE g = LONG2NUM(ig); + VALUE a = f_imul(an, bd / ig); + VALUE b = f_imul(bn, ad / ig); + VALUE c; - if (k == '+') - c = f_add(a, b); - else - c = f_sub(a, b); + if (k == '+') + c = f_add(a, b); + else + c = f_sub(a, b); - b = f_idiv(aden, g); - g = f_gcd(c, g); - num = f_idiv(c, g); - a = f_idiv(bden, g); - den = f_mul(a, b); - } else { - VALUE g = f_gcd(aden, bden); - VALUE a = f_mul(anum, f_idiv(bden, g)); - VALUE b = f_mul(bnum, f_idiv(aden, g)); - VALUE c; + b = f_idiv(aden, g); + g = f_gcd(c, g); + num = f_idiv(c, g); + a = f_idiv(bden, g); + den = f_mul(a, b); + } else { + VALUE g = f_gcd(aden, bden); + VALUE a = f_mul(anum, f_idiv(bden, g)); + VALUE b = f_mul(bnum, f_idiv(aden, g)); + VALUE c; - if (k == '+') - c = f_add(a, b); - else - c = f_sub(a, b); + if (k == '+') + c = f_add(a, b); + else + c = f_sub(a, b); - b = f_idiv(aden, g); - g = f_gcd(c, g); - num = f_idiv(c, g); - a = f_idiv(bden, g); - den = f_mul(a, b); - } - return f_rational_new_no_reduce2(CLASS_OF(self), num, den); + b = f_idiv(aden, g); + g = f_gcd(c, g); + num = f_idiv(c, g); + a = f_idiv(bden, g); + den = f_mul(a, b); + } + return f_rational_new_no_reduce2(CLASS_OF(self), num, den); } static VALUE nurat_add(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - { - get_dat1(self); + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + { + get_dat1(self); - return f_addsub(self, - dat->num, dat->den, - other, ONE, '+'); - } - case T_FLOAT: - return f_add(f_to_f(self), other); - case T_RATIONAL: - { - get_dat2(self, other); + return f_addsub(self, + dat->num, dat->den, + other, ONE, '+'); + } + case T_FLOAT: + return f_add(f_to_f(self), other); + case T_RATIONAL: + { + get_dat2(self, other); - return f_addsub(self, - adat->num, adat->den, - bdat->num, bdat->den, '+'); + return f_addsub(self, + adat->num, adat->den, + bdat->num, bdat->den, '+'); + } + default: + { + VALUE a = f_coerce(other, self); + return f_add(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); + } } - default: - { - VALUE a = f_coerce(other, self); - return f_add(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); - } - } } static VALUE nurat_sub(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - { - get_dat1(self); + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + { + get_dat1(self); - return f_addsub(self, - dat->num, dat->den, - other, ONE, '-'); - } - case T_FLOAT: - return f_sub(f_to_f(self), other); - case T_RATIONAL: - { - get_dat2(self, other); + return f_addsub(self, + dat->num, dat->den, + other, ONE, '-'); + } + case T_FLOAT: + return f_sub(f_to_f(self), other); + case T_RATIONAL: + { + get_dat2(self, other); - return f_addsub(self, - adat->num, adat->den, - bdat->num, bdat->den, '-'); + return f_addsub(self, + adat->num, adat->den, + bdat->num, bdat->den, '-'); + } + default: + { + VALUE a = f_coerce(other, self); + return f_sub(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); + } } - default: - { - VALUE a = f_coerce(other, self); - return f_sub(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); - } - } } inline static VALUE f_muldiv(VALUE self, VALUE anum, VALUE aden, VALUE bnum, VALUE bden, int k) { - VALUE num, den; + VALUE num, den; - if (k == '/') { - VALUE t; + if (k == '/') { + VALUE t; - if (f_negative_p(bnum)) { - anum = f_negate(anum); - bnum = f_negate(bnum); + if (f_negative_p(bnum)) { + anum = f_negate(anum); + bnum = f_negate(bnum); + } + t = bnum; + bnum = bden; + bden = t; } - t = bnum; - bnum = bden; - bden = t; - } - if (FIXNUM_P(anum) && FIXNUM_P(aden) && - FIXNUM_P(bnum) && FIXNUM_P(bden)) { - long an = FIX2LONG(anum); - long ad = FIX2LONG(aden); - long bn = FIX2LONG(bnum); - long bd = FIX2LONG(bden); - long g1 = i_gcd(an, bd); - long g2 = i_gcd(ad, bn); + if (FIXNUM_P(anum) && FIXNUM_P(aden) && + FIXNUM_P(bnum) && FIXNUM_P(bden)) { + long an = FIX2LONG(anum); + long ad = FIX2LONG(aden); + long bn = FIX2LONG(bnum); + long bd = FIX2LONG(bden); + long g1 = i_gcd(an, bd); + long g2 = i_gcd(ad, bn); - num = f_imul(an / g1, bn / g2); - den = f_imul(ad / g2, bd / g1); - } else { - VALUE g1 = f_gcd(anum, bden); - VALUE g2 = f_gcd(aden, bnum); + num = f_imul(an / g1, bn / g2); + den = f_imul(ad / g2, bd / g1); + } else { + VALUE g1 = f_gcd(anum, bden); + VALUE g2 = f_gcd(aden, bnum); - num = f_mul(f_idiv(anum, g1), f_idiv(bnum, g2)); - den = f_mul(f_idiv(aden, g2), f_idiv(bden, g1)); - } - return f_rational_new_no_reduce2(CLASS_OF(self), num, den); + num = f_mul(f_idiv(anum, g1), f_idiv(bnum, g2)); + den = f_mul(f_idiv(aden, g2), f_idiv(bden, g1)); + } + return f_rational_new_no_reduce2(CLASS_OF(self), num, den); } static VALUE nurat_mul(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - { - get_dat1(self); + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + { + get_dat1(self); - return f_muldiv(self, - dat->num, dat->den, - other, ONE, '*'); - } - case T_FLOAT: - return f_mul(f_to_f(self), other); - case T_RATIONAL: - { - get_dat2(self, other); + return f_muldiv(self, + dat->num, dat->den, + other, ONE, '*'); + } + case T_FLOAT: + return f_mul(f_to_f(self), other); + case T_RATIONAL: + { + get_dat2(self, other); - return f_muldiv(self, - adat->num, adat->den, - bdat->num, bdat->den, '*'); + return f_muldiv(self, + adat->num, adat->den, + bdat->num, bdat->den, '*'); + } + default: + { + VALUE a = f_coerce(other, self); + return f_mul(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); + } } - default: - { - VALUE a = f_coerce(other, self); - return f_mul(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); - } - } } static VALUE nurat_div(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - if (f_zero_p(other)) - rb_raise(rb_eZeroDivError, "devided by zero"); - { - get_dat1(self); + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + if (f_zero_p(other)) + rb_raise(rb_eZeroDivError, "devided by zero"); + { + get_dat1(self); - return f_muldiv(self, - dat->num, dat->den, - other, ONE, '/'); - } - case T_FLOAT: - return f_div(f_to_f(self), other); - case T_RATIONAL: - if (f_zero_p(other)) - rb_raise(rb_eZeroDivError, "devided by zero"); - { - get_dat2(self, other); + return f_muldiv(self, + dat->num, dat->den, + other, ONE, '/'); + } + case T_FLOAT: + return f_div(f_to_f(self), other); + case T_RATIONAL: + if (f_zero_p(other)) + rb_raise(rb_eZeroDivError, "devided by zero"); + { + get_dat2(self, other); - return f_muldiv(self, - adat->num, adat->den, - bdat->num, bdat->den, '/'); + return f_muldiv(self, + adat->num, adat->den, + bdat->num, bdat->den, '/'); + } + default: + { + VALUE a = f_coerce(other, self); + return f_div(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); + } } - default: - { - VALUE a = f_coerce(other, self); - return f_div(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); - } - } } static VALUE nurat_fdiv(VALUE self, VALUE other) { - return f_div(f_to_f(self), other); + return f_div(f_to_f(self), other); } static VALUE nurat_expt(VALUE self, VALUE other) { - if (f_zero_p(other)) - return f_rational_new_bang1(CLASS_OF(self), ONE); + if (f_zero_p(other)) + return f_rational_new_bang1(CLASS_OF(self), ONE); - if (k_rational_p(other)) { - get_dat1(other); + if (k_rational_p(other)) { + get_dat1(other); - if (f_one_p(dat->den)) - other = dat->num; /* good? */ - } + if (f_one_p(dat->den)) + other = dat->num; /* good? */ + } - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - { - VALUE num, den; + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + { + VALUE num, den; - get_dat1(self); + get_dat1(self); - switch (FIX2INT(f_cmp(other, ZERO))) { - case 1: - num = f_expt(dat->num, other); - den = f_expt(dat->den, other); - break; - case -1: - num = f_expt(dat->den, f_negate(other)); - den = f_expt(dat->num, f_negate(other)); - break; + switch (FIX2INT(f_cmp(other, ZERO))) { + case 1: + num = f_expt(dat->num, other); + den = f_expt(dat->den, other); + break; + case -1: + num = f_expt(dat->den, f_negate(other)); + den = f_expt(dat->num, f_negate(other)); + break; + default: + num = ONE; + den = ONE; + break; + } + if (f_negative_p(den)) { /* or use normal new */ + num = f_negate(num); + den = f_negate(den); + } + return f_rational_new_bang2(CLASS_OF(self), num, den); + } + case T_FLOAT: + case T_RATIONAL: + return f_expt(f_to_f(self), other); default: - num = ONE; - den = ONE; - break; + { + VALUE a = f_coerce(other, self); + return f_expt(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); } - if (f_negative_p(den)) { /* or use normal new */ - num = f_negate(num); - den = f_negate(den); - } - return f_rational_new_bang2(CLASS_OF(self), num, den); } - case T_FLOAT: - case T_RATIONAL: - return f_expt(f_to_f(self), other); - default: - { - VALUE a = f_coerce(other, self); - return f_expt(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); - } - } } static VALUE nurat_cmp(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - { - get_dat1(self); + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + { + get_dat1(self); - if (FIXNUM_P(dat->den) && FIX2LONG(dat->den) == 1) - return f_cmp(dat->num, other); - else - return f_cmp(self, f_rational_new_bang1(CLASS_OF(self), other)); - } - case T_FLOAT: - return f_cmp(f_to_f(self), other); - case T_RATIONAL: - { - VALUE num1, num2; - - get_dat2(self, other); - - if (FIXNUM_P(adat->num) && FIXNUM_P(adat->den) && - FIXNUM_P(bdat->num) && FIXNUM_P(bdat->den)) { - num1 = f_imul(FIX2LONG(adat->num), FIX2LONG(bdat->den)); - num2 = f_imul(FIX2LONG(bdat->num), FIX2LONG(adat->den)); - } else { - num1 = f_mul(adat->num, bdat->den); - num2 = f_mul(bdat->num, adat->den); + if (FIXNUM_P(dat->den) && FIX2LONG(dat->den) == 1) + return f_cmp(dat->num, other); + else + return f_cmp(self, f_rational_new_bang1(CLASS_OF(self), other)); + } + case T_FLOAT: + return f_cmp(f_to_f(self), other); + case T_RATIONAL: + { + VALUE num1, num2; + + get_dat2(self, other); + + if (FIXNUM_P(adat->num) && FIXNUM_P(adat->den) && + FIXNUM_P(bdat->num) && FIXNUM_P(bdat->den)) { + num1 = f_imul(FIX2LONG(adat->num), FIX2LONG(bdat->den)); + num2 = f_imul(FIX2LONG(bdat->num), FIX2LONG(adat->den)); + } else { + num1 = f_mul(adat->num, bdat->den); + num2 = f_mul(bdat->num, adat->den); + } + return f_cmp(f_sub(num1, num2), ZERO); + } + default: + { + VALUE a = f_coerce(other, self); + return f_cmp(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); } - return f_cmp(f_sub(num1, num2), ZERO); } - default: - { - VALUE a = f_coerce(other, self); - return f_cmp(RARRAY_PTR(a)[0], RARRAY_PTR(a)[1]); - } - } } static VALUE nurat_equal_p(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - { - get_dat1(self); + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + { + get_dat1(self); - if (!FIXNUM_P(dat->den)) - return Qfalse; - if (FIX2LONG(dat->den) != 1) - return Qfalse; - if (f_equal_p(dat->num, other)) - return Qtrue; - else - return Qfalse; - } - case T_FLOAT: - return f_equal_p(f_to_f(self), other); - case T_RATIONAL: - { - get_dat2(self, other); + if (!FIXNUM_P(dat->den)) + return Qfalse; + if (FIX2LONG(dat->den) != 1) + return Qfalse; + if (f_equal_p(dat->num, other)) + return Qtrue; + else + return Qfalse; + } + case T_FLOAT: + return f_equal_p(f_to_f(self), other); + case T_RATIONAL: + { + get_dat2(self, other); - return f_boolcast(f_equal_p(adat->num, bdat->num) && - f_equal_p(adat->den, bdat->den)); + return f_boolcast(f_equal_p(adat->num, bdat->num) && + f_equal_p(adat->den, bdat->den)); + } + default: + return f_equal_p(other, self); } - default: - return f_equal_p(other, self); - } } static VALUE nurat_coerce(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - return rb_assoc_new(f_rational_new_bang1(CLASS_OF(self), other), self); - case T_FLOAT: - return rb_assoc_new(other, f_to_f(self)); - } + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + return rb_assoc_new(f_rational_new_bang1(CLASS_OF(self), other), self); + case T_FLOAT: + return rb_assoc_new(other, f_to_f(self)); + } - rb_raise(rb_eTypeError, "%s can't be coerced into %s", - rb_obj_classname(other), rb_obj_classname(self)); - return Qnil; + rb_raise(rb_eTypeError, "%s can't be coerced into %s", + rb_obj_classname(other), rb_obj_classname(self)); + return Qnil; } static VALUE nurat_idiv(VALUE self, VALUE other) { - return f_floor(f_div(self, other)); + return f_floor(f_div(self, other)); } static VALUE nurat_mod(VALUE self, VALUE other) { - VALUE val = f_floor(f_div(self, other)); - return f_sub(self, f_mul(other, val)); + VALUE val = f_floor(f_div(self, other)); + return f_sub(self, f_mul(other, val)); } static VALUE nurat_divmod(VALUE self, VALUE other) { - VALUE val = f_floor(f_div(self, other)); - return rb_assoc_new(val, f_sub(self, f_mul(other, val))); + VALUE val = f_floor(f_div(self, other)); + return rb_assoc_new(val, f_sub(self, f_mul(other, val))); } +#if 0 static VALUE nurat_quot(VALUE self, VALUE other) { - return f_truncate(f_div(self, other)); + return f_truncate(f_div(self, other)); } +#endif + static VALUE nurat_rem(VALUE self, VALUE other) { - VALUE val = f_truncate(f_div(self, other)); - return f_sub(self, f_mul(other, val)); + VALUE val = f_truncate(f_div(self, other)); + return f_sub(self, f_mul(other, val)); } +#if 0 static VALUE nurat_quotrem(VALUE self, VALUE other) { - VALUE val = f_truncate(f_div(self, other)); - return rb_assoc_new(val, f_sub(self, f_mul(other, val))); + VALUE val = f_truncate(f_div(self, other)); + return rb_assoc_new(val, f_sub(self, f_mul(other, val))); } +#endif static VALUE nurat_abs(VALUE self) { - if (!f_negative_p(self)) - return self; - else - return f_negate(self); + if (!f_negative_p(self)) + return self; + else + return f_negate(self); } +#if 0 static VALUE nurat_true(VALUE self) { - return Qtrue; + return Qtrue; } +#endif static VALUE nurat_floor(VALUE self) { - get_dat1(self); - return f_idiv(dat->num, dat->den); + get_dat1(self); + return f_idiv(dat->num, dat->den); } static VALUE nurat_ceil(VALUE self) { - get_dat1(self); - return f_negate(f_idiv(f_negate(dat->num), dat->den)); + get_dat1(self); + return f_negate(f_idiv(f_negate(dat->num), dat->den)); } static VALUE nurat_truncate(VALUE self) { - get_dat1(self); - if (f_negative_p(dat->num)) - return f_negate(f_idiv(f_negate(dat->num), dat->den)); - return f_idiv(dat->num, dat->den); + get_dat1(self); + if (f_negative_p(dat->num)) + return f_negate(f_idiv(f_negate(dat->num), dat->den)); + return f_idiv(dat->num, dat->den); } static VALUE nurat_round(VALUE self) { - get_dat1(self); + get_dat1(self); - if (f_negative_p(dat->num)) { - VALUE num, den; + if (f_negative_p(dat->num)) { + VALUE num, den; - num = f_negate(dat->num); - num = f_add(f_mul(num, TWO), dat->den); - den = f_mul(dat->den, TWO); - return f_negate(f_idiv(num, den)); - } else { - VALUE num = f_add(f_mul(dat->num, TWO), dat->den); - VALUE den = f_mul(dat->den, TWO); - return f_idiv(num, den); - } + num = f_negate(dat->num); + num = f_add(f_mul(num, TWO), dat->den); + den = f_mul(dat->den, TWO); + return f_negate(f_idiv(num, den)); + } else { + VALUE num = f_add(f_mul(dat->num, TWO), dat->den); + VALUE den = f_mul(dat->den, TWO); + return f_idiv(num, den); + } } #define f_size(x) rb_funcall(x, rb_intern("size"), 0) @@ -1081,24 +1090,24 @@ nurat_round(VALUE self) inline static long i_ilog2(VALUE x) { - long q, r, fx; + long q, r, fx; - assert(!f_lt_p(x, ONE)); + assert(!f_lt_p(x, ONE)); - q = (NUM2LONG(f_size(x)) - sizeof(long)) * 8 + 1; + q = (NUM2LONG(f_size(x)) - sizeof(long)) * 8 + 1; - if (q > 0) - x = f_rshift(x, LONG2NUM(q)); + if (q > 0) + x = f_rshift(x, LONG2NUM(q)); - fx = NUM2LONG(x); + fx = NUM2LONG(x); - r = -1; - while (fx) { - fx >>= 1; - r += 1; - } + r = -1; + while (fx) { + fx >>= 1; + r += 1; + } - return q + r; + return q + r; } #include @@ -1106,108 +1115,108 @@ i_ilog2(VALUE x) static VALUE nurat_to_f(VALUE self) { - VALUE num, den; - int minus = 0; - long nl, dl, ml, ne, de; - int e; - double f; + VALUE num, den; + int minus = 0; + long nl, dl, ml, ne, de; + int e; + double f; - { - get_dat1(self); + { + get_dat1(self); - if (f_zero_p(dat->num)) - return rb_float_new(0.0); + if (f_zero_p(dat->num)) + return rb_float_new(0.0); - num = dat->num; - den = dat->den; - } + num = dat->num; + den = dat->den; + } - if (f_negative_p(num)) { - num = f_negate(num); - minus = 1; - } + if (f_negative_p(num)) { + num = f_negate(num); + minus = 1; + } - nl = i_ilog2(num); - dl = i_ilog2(den); - ml = (long)(log(DBL_MAX) / log(2) - 1); /* should be a static */ + nl = i_ilog2(num); + dl = i_ilog2(den); + ml = (long)(log(DBL_MAX) / log(2.0) - 1); /* should be a static */ - ne = 0; - if (nl > ml) { - ne = nl - ml; - num = f_rshift(num, LONG2NUM(ne)); - } + ne = 0; + if (nl > ml) { + ne = nl - ml; + num = f_rshift(num, LONG2NUM(ne)); + } - de = 0; - if (dl > ml) { - de = dl - ml; - den = f_rshift(den, LONG2NUM(de)); - } + de = 0; + if (dl > ml) { + de = dl - ml; + den = f_rshift(den, LONG2NUM(de)); + } - e = (int)(ne - de); + e = (int)(ne - de); - if ((e > DBL_MAX_EXP) || (e < DBL_MIN_EXP)) { - rb_warn("%s out of Float range", rb_obj_classname(self)); - return rb_float_new(e > 0 ? HUGE_VAL : 0.0); - } + if ((e > DBL_MAX_EXP) || (e < DBL_MIN_EXP)) { + rb_warn("%s out of Float range", rb_obj_classname(self)); + return rb_float_new(e > 0 ? HUGE_VAL : 0.0); + } - f = NUM2DBL(num) / NUM2DBL(den); - if (minus) - f = -f; - f = ldexp(f, e); + f = NUM2DBL(num) / NUM2DBL(den); + if (minus) + f = -f; + f = ldexp(f, e); - if (isinf(f) || isnan(f)) - rb_warn("%s out of Float range", rb_obj_classname(self)); + if (isinf(f) || isnan(f)) + rb_warn("%s out of Float range", rb_obj_classname(self)); - return rb_float_new(f); + return rb_float_new(f); } static VALUE nurat_to_r(VALUE self) { - return self; + return self; } static VALUE nurat_hash(VALUE self) { - get_dat1(self); - return f_xor(dat->num, dat->den); + get_dat1(self); + return f_xor(dat->num, dat->den); } static VALUE nurat_to_s(VALUE self) { - get_dat1(self); + get_dat1(self); - if (f_one_p(dat->den)) - return f_to_s(dat->num); - else - return rb_funcall(rb_mKernel, id_format, 3, - rb_str_new2("%d/%d"), dat->num, dat->den); + if (f_one_p(dat->den)) + return f_to_s(dat->num); + else + return rb_funcall(rb_mKernel, id_format, 3, + rb_str_new2("%d/%d"), dat->num, dat->den); } static VALUE nurat_inspect(VALUE self) { - get_dat1(self); - return rb_funcall(rb_mKernel, id_format, 3, - rb_str_new2("Rational(%d, %d)"), dat->num, dat->den); + get_dat1(self); + return rb_funcall(rb_mKernel, id_format, 3, + rb_str_new2("Rational(%d, %d)"), dat->num, dat->den); } static VALUE nurat_marshal_dump(VALUE self) { - get_dat1(self); - return rb_assoc_new(dat->num, dat->den); + get_dat1(self); + return rb_assoc_new(dat->num, dat->den); } static VALUE nurat_marshal_load(VALUE self, VALUE a) { - get_dat1(self); - dat->num = RARRAY_PTR(a)[0]; - dat->den = RARRAY_PTR(a)[1]; - return self; + get_dat1(self); + dat->num = RARRAY_PTR(a)[0]; + dat->den = RARRAY_PTR(a)[1]; + return self; } /* --- */ @@ -1215,55 +1224,55 @@ nurat_marshal_load(VALUE self, VALUE a) VALUE rb_gcd(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - break; - default: - rb_raise(rb_eArgError, "not an integer"); - } + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + break; + default: + rb_raise(rb_eArgError, "not an integer"); + } - return f_gcd(self, other); + return f_gcd(self, other); } VALUE rb_lcm(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - break; - default: - rb_raise(rb_eArgError, "not an integer"); - } + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + break; + default: + rb_raise(rb_eArgError, "not an integer"); + } - return f_lcm(self, other); + return f_lcm(self, other); } VALUE rb_gcdlcm(VALUE self, VALUE other) { - switch (TYPE(other)) { - case T_FIXNUM: - case T_BIGNUM: - break; - default: - rb_raise(rb_eArgError, "not an integer"); - } + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + break; + default: + rb_raise(rb_eArgError, "not an integer"); + } - return rb_assoc_new(f_gcd(self, other), f_lcm(self, other)); + return rb_assoc_new(f_gcd(self, other), f_lcm(self, other)); } VALUE rb_rational_raw(VALUE x, VALUE y) { - return nurat_s_new_internal(rb_cRational, x, y); + return nurat_s_new_internal(rb_cRational, x, y); } VALUE rb_rational_new(VALUE x, VALUE y) { - return nurat_s_canonicalize_internal(rb_cRational, x, y); + return nurat_s_canonicalize_internal(rb_cRational, x, y); } static VALUE nurat_s_convert(int argc, VALUE *argv, VALUE klass); @@ -1271,22 +1280,22 @@ static VALUE nurat_s_convert(int argc, VALUE *argv, VALUE klass); VALUE rb_Rational(VALUE x, VALUE y) { - VALUE a[2]; - a[0] = x; - a[1] = y; - return nurat_s_convert(2, a, rb_cRational); + VALUE a[2]; + a[0] = x; + a[1] = y; + return nurat_s_convert(2, a, rb_cRational); } static VALUE nilclass_to_r(VALUE self) { - return rb_rational_new1(INT2FIX(0)); + return rb_rational_new1(INT2FIX(0)); } static VALUE integer_to_r(VALUE self) { - return rb_rational_new1(self); + return rb_rational_new1(self); } #include @@ -1294,20 +1303,21 @@ integer_to_r(VALUE self) static VALUE float_decode(VALUE self) { - double f; - int n; + double f; + int n; - f = frexp(RFLOAT_VALUE(self), &n); - f = ldexp(f, DBL_MANT_DIG); - n -= DBL_MANT_DIG; - return rb_assoc_new(f_to_i(rb_float_new(f)), INT2FIX(n)); + f = frexp(RFLOAT_VALUE(self), &n); + f = ldexp(f, DBL_MANT_DIG); + n -= DBL_MANT_DIG; + return rb_assoc_new(f_to_i(rb_float_new(f)), INT2FIX(n)); } static VALUE float_to_r(VALUE self) { - VALUE a = float_decode(self); - return f_mul(RARRAY_PTR(a)[0], f_expt(INT2FIX(FLT_RADIX), RARRAY_PTR(a)[1])); + VALUE a = float_decode(self); + return f_mul(RARRAY_PTR(a)[0], + f_expt(INT2FIX(FLT_RADIX), RARRAY_PTR(a)[1])); } static VALUE rat_pat, an_e_pat, a_dot_pat, underscores_pat, an_underscore; @@ -1320,26 +1330,26 @@ static VALUE rat_pat, an_e_pat, a_dot_pat, underscores_pat, an_underscore; static void make_patterns(void) { - static char *rat_pat_source = PATTERN; - static char *an_e_pat_source = "[eE]"; - static char *a_dot_pat_source = "\\."; - static char *underscores_pat_source = "_+"; + static char rat_pat_source[] = PATTERN; + static char an_e_pat_source[] = "[eE]"; + static char a_dot_pat_source[] = "\\."; + static char underscores_pat_source[] = "_+"; - rat_pat = rb_reg_new(rat_pat_source, strlen(rat_pat_source), 0); - rb_global_variable(&rat_pat); + rat_pat = rb_reg_new(rat_pat_source, sizeof rat_pat_source - 1, 0); + rb_global_variable(&rat_pat); - an_e_pat = rb_reg_new(an_e_pat_source, strlen(an_e_pat_source), 0); - rb_global_variable(&an_e_pat); + an_e_pat = rb_reg_new(an_e_pat_source, sizeof an_e_pat_source - 1, 0); + rb_global_variable(&an_e_pat); - a_dot_pat = rb_reg_new(a_dot_pat_source, strlen(a_dot_pat_source), 0); - rb_global_variable(&a_dot_pat); + a_dot_pat = rb_reg_new(a_dot_pat_source, sizeof a_dot_pat_source - 1, 0); + rb_global_variable(&a_dot_pat); - underscores_pat = rb_reg_new(underscores_pat_source, - strlen(underscores_pat_source), 0); - rb_global_variable(&underscores_pat); + underscores_pat = rb_reg_new(underscores_pat_source, + sizeof underscores_pat_source - 1, 0); + rb_global_variable(&underscores_pat); - an_underscore = rb_str_new2("_"); - rb_global_variable(&an_underscore); + an_underscore = rb_str_new2("_"); + rb_global_variable(&an_underscore); } #define id_strip rb_intern("strip") @@ -1362,80 +1372,80 @@ make_patterns(void) static VALUE string_to_r_internal(VALUE self) { - VALUE s, m; + VALUE s, m; - s = f_strip(self); + s = f_strip(self); - if (RSTRING_LEN(s) == 0) + if (RSTRING_LEN(s) == 0) + return rb_assoc_new(Qnil, self); + + m = f_match(rat_pat, s); + + if (!NIL_P(m)) { + VALUE v, ifp, exp, ip, fp; + VALUE si = f_aref(m, INT2FIX(1)); + VALUE nu = f_aref(m, INT2FIX(2)); + VALUE de = f_aref(m, INT2FIX(3)); + VALUE re = f_post_match(m); + + { + VALUE a; + + a = f_split(nu, an_e_pat); + ifp = RARRAY_PTR(a)[0]; + if (RARRAY_LEN(a) != 2) + exp = Qnil; + else + exp = RARRAY_PTR(a)[1]; + + a = f_split(ifp, a_dot_pat); + ip = RARRAY_PTR(a)[0]; + if (RARRAY_LEN(a) != 2) + fp = Qnil; + else + fp = RARRAY_PTR(a)[1]; + } + + v = rb_rational_new1(f_to_i(ip)); + + if (!NIL_P(fp)) { + char *p = StringValuePtr(fp); + long count = 0; + VALUE l; + + while (*p) { + if (isdigit(*p)) + count++; + p++; + } + + l = f_expt(INT2FIX(10), LONG2NUM(count)); + v = f_mul(v, l); + v = f_add(v, f_to_i(fp)); + v = f_div(v, l); + } + if (!NIL_P(exp)) + v = f_mul(v, f_expt(INT2FIX(10), f_to_i(exp))); + if (!NIL_P(si) && *StringValuePtr(si) == '-') + v = f_negate(v); + if (!NIL_P(de)) + v = f_div(v, f_to_i(de)); + + return rb_assoc_new(v, re); + } return rb_assoc_new(Qnil, self); - - m = f_match(rat_pat, s); - - if (!NIL_P(m)) { - VALUE v, ifp, exp, ip, fp; - VALUE si = f_aref(m, INT2FIX(1)); - VALUE nu = f_aref(m, INT2FIX(2)); - VALUE de = f_aref(m, INT2FIX(3)); - VALUE re = f_post_match(m); - - { - VALUE a; - - a = f_split(nu, an_e_pat); - ifp = RARRAY_PTR(a)[0]; - if (RARRAY_LEN(a) != 2) - exp = Qnil; - else - exp = RARRAY_PTR(a)[1]; - - a = f_split(ifp, a_dot_pat); - ip = RARRAY_PTR(a)[0]; - if (RARRAY_LEN(a) != 2) - fp = Qnil; - else - fp = RARRAY_PTR(a)[1]; - } - - v = rb_rational_new1(f_to_i(ip)); - - if (!NIL_P(fp)) { - char *p = StringValuePtr(fp); - long count = 0; - VALUE l; - - while (*p) { - if (isdigit(*p)) - count++; - p++; - } - - l = f_expt(INT2FIX(10), LONG2NUM(count)); - v = f_mul(v, l); - v = f_add(v, f_to_i(fp)); - v = f_div(v, l); - } - if (!NIL_P(exp)) - v = f_mul(v, f_expt(INT2FIX(10), f_to_i(exp))); - if (!NIL_P(si) && *StringValuePtr(si) == '-') - v = f_negate(v); - if (!NIL_P(de)) - v = f_div(v, f_to_i(de)); - - return rb_assoc_new(v, re); - } - return rb_assoc_new(Qnil, self); } static VALUE string_to_r_strict(VALUE self) { - VALUE a = string_to_r_internal(self); - if (NIL_P(RARRAY_PTR(a)[0]) || RSTRING_LEN(RARRAY_PTR(a)[1]) > 0) { - VALUE s = f_inspect(self); - rb_raise(rb_eArgError, "invalid value for Rational: %s", - StringValuePtr(s)); - } - return RARRAY_PTR(a)[0]; + VALUE a = string_to_r_internal(self); + if (NIL_P(RARRAY_PTR(a)[0]) || RSTRING_LEN(RARRAY_PTR(a)[1]) > 0) { + VALUE s = f_inspect(self); + rb_raise(rb_eArgError, "invalid value for Rational: %s", + StringValuePtr(s)); + } + return RARRAY_PTR(a)[0]; } #define id_gsub rb_intern("gsub") @@ -1444,11 +1454,11 @@ string_to_r_strict(VALUE self) static VALUE string_to_r(VALUE self) { - VALUE s = f_gsub(self, underscores_pat, an_underscore); - VALUE a = string_to_r_internal(s); - if (!NIL_P(RARRAY_PTR(a)[0])) - return RARRAY_PTR(a)[0]; - return rb_rational_new1(INT2FIX(0)); + VALUE s = f_gsub(self, underscores_pat, an_underscore); + VALUE a = string_to_r_internal(s); + if (!NIL_P(RARRAY_PTR(a)[0])) + return RARRAY_PTR(a)[0]; + return rb_rational_new1(INT2FIX(0)); } #define id_to_r rb_intern("to_r") @@ -1457,196 +1467,196 @@ string_to_r(VALUE self) static VALUE nurat_s_convert(int argc, VALUE *argv, VALUE klass) { - VALUE a1, a2; + VALUE a1, a2; - a1 = Qnil; - a2 = Qnil; - rb_scan_args(argc, argv, "02", &a1, &a2); + a1 = Qnil; + a2 = Qnil; + rb_scan_args(argc, argv, "02", &a1, &a2); - switch (TYPE(a1)) { - case T_COMPLEX: - if (k_float_p(RCOMPLEX(a1)->image) || !f_zero_p(RCOMPLEX(a1)->image)) { - VALUE s = f_to_s(a1); - rb_raise(rb_eRangeError, "can't accept %s", - StringValuePtr(s)); + switch (TYPE(a1)) { + case T_COMPLEX: + if (k_float_p(RCOMPLEX(a1)->image) || !f_zero_p(RCOMPLEX(a1)->image)) { + VALUE s = f_to_s(a1); + rb_raise(rb_eRangeError, "can't accept %s", + StringValuePtr(s)); + } + a1 = RCOMPLEX(a1)->real; } - a1 = RCOMPLEX(a1)->real; - } - switch (TYPE(a2)) { - case T_COMPLEX: - if (k_float_p(RCOMPLEX(a2)->image) || !f_zero_p(RCOMPLEX(a2)->image)) { - VALUE s = f_to_s(a2); - rb_raise(rb_eRangeError, "can't accept %s", - StringValuePtr(s)); + switch (TYPE(a2)) { + case T_COMPLEX: + if (k_float_p(RCOMPLEX(a2)->image) || !f_zero_p(RCOMPLEX(a2)->image)) { + VALUE s = f_to_s(a2); + rb_raise(rb_eRangeError, "can't accept %s", + StringValuePtr(s)); + } + a2 = RCOMPLEX(a2)->real; } - a2 = RCOMPLEX(a2)->real; - } - switch (TYPE(a1)) { - case T_FIXNUM: - case T_BIGNUM: - break; - case T_FLOAT: - a1 = f_to_r(a1); - break; - case T_STRING: - a1 = string_to_r_strict(a1); - break; - } + switch (TYPE(a1)) { + case T_FIXNUM: + case T_BIGNUM: + break; + case T_FLOAT: + a1 = f_to_r(a1); + break; + case T_STRING: + a1 = string_to_r_strict(a1); + break; + } - switch (TYPE(a2)) { - case T_FIXNUM: - case T_BIGNUM: - break; - case T_FLOAT: - a2 = f_to_r(a2); - break; - case T_STRING: - a2 = string_to_r_strict(a2); - break; - } + switch (TYPE(a2)) { + case T_FIXNUM: + case T_BIGNUM: + break; + case T_FLOAT: + a2 = f_to_r(a2); + break; + case T_STRING: + a2 = string_to_r_strict(a2); + break; + } - switch (TYPE(a1)) { - case T_RATIONAL: - if (NIL_P(a2) || f_zero_p(a2)) - return a1; - else - return f_div(a1, a2); - } + switch (TYPE(a1)) { + case T_RATIONAL: + if (NIL_P(a2) || f_zero_p(a2)) + return a1; + else + return f_div(a1, a2); + } - switch (TYPE(a2)) { - case T_RATIONAL: - return f_div(a1, a2); - } + switch (TYPE(a2)) { + case T_RATIONAL: + return f_div(a1, a2); + } - { - VALUE argv2[2]; - argv2[0] = a1; - argv2[1] = a2; - return nurat_s_new(argc, argv2, klass); - } + { + VALUE argv2[2]; + argv2[0] = a1; + argv2[1] = a2; + return nurat_s_new(argc, argv2, klass); + } } static VALUE nurat_s_induced_from(VALUE klass, VALUE n) { - return f_to_r(n); + return f_to_r(n); } void Init_Rational(void) { - assert(fprintf(stderr, "assert() is now active\n")); + assert(fprintf(stderr, "assert() is now active\n")); - id_Unify = rb_intern("Unify"); - id_abs = rb_intern("abs"); - id_cmp = rb_intern("<=>"); - id_coerce = rb_intern("coerce"); - id_convert = rb_intern("convert"); - id_equal_p = rb_intern("=="); - id_expt = rb_intern("**"); - id_floor = rb_intern("floor"); - id_format = rb_intern("format"); - id_idiv = rb_intern("div"); - id_inspect = rb_intern("inspect"); - id_negate = rb_intern("-@"); - id_new = rb_intern("new"); - id_new_bang = rb_intern("new!"); - id_to_f = rb_intern("to_f"); - id_to_i = rb_intern("to_i"); - id_to_s = rb_intern("to_s"); - id_truncate = rb_intern("truncate"); + id_Unify = rb_intern("Unify"); + id_abs = rb_intern("abs"); + id_cmp = rb_intern("<=>"); + id_coerce = rb_intern("coerce"); + id_convert = rb_intern("convert"); + id_equal_p = rb_intern("=="); + id_expt = rb_intern("**"); + id_floor = rb_intern("floor"); + id_format = rb_intern("format"); + id_idiv = rb_intern("div"); + id_inspect = rb_intern("inspect"); + id_negate = rb_intern("-@"); + id_new = rb_intern("new"); + id_new_bang = rb_intern("new!"); + id_to_f = rb_intern("to_f"); + id_to_i = rb_intern("to_i"); + id_to_s = rb_intern("to_s"); + id_truncate = rb_intern("truncate"); - rb_cRational = rb_define_class(RATIONAL_NAME, rb_cNumeric); + rb_cRational = rb_define_class(RATIONAL_NAME, rb_cNumeric); - rb_define_alloc_func(rb_cRational, nurat_s_alloc); - rb_funcall(rb_cRational, rb_intern("private_class_method"), 1, - ID2SYM(rb_intern("allocate"))); + rb_define_alloc_func(rb_cRational, nurat_s_alloc); + rb_funcall(rb_cRational, rb_intern("private_class_method"), 1, + ID2SYM(rb_intern("allocate"))); - rb_define_singleton_method(rb_cRational, "new!", nurat_s_new_bang, -1); - rb_funcall(rb_cRational, rb_intern("private_class_method"), 1, - ID2SYM(rb_intern("new!"))); + rb_define_singleton_method(rb_cRational, "new!", nurat_s_new_bang, -1); + rb_funcall(rb_cRational, rb_intern("private_class_method"), 1, + ID2SYM(rb_intern("new!"))); - rb_define_singleton_method(rb_cRational, "new", nurat_s_new, -1); - rb_funcall(rb_cRational, rb_intern("private_class_method"), 1, - ID2SYM(rb_intern("new"))); + rb_define_singleton_method(rb_cRational, "new", nurat_s_new, -1); + rb_funcall(rb_cRational, rb_intern("private_class_method"), 1, + ID2SYM(rb_intern("new"))); - rb_define_global_function(RATIONAL_NAME, nurat_f_rational, -1); + rb_define_global_function(RATIONAL_NAME, nurat_f_rational, -1); - rb_define_method(rb_cRational, "numerator", nurat_numerator, 0); - rb_define_method(rb_cRational, "denominator", nurat_denominator, 0); + rb_define_method(rb_cRational, "numerator", nurat_numerator, 0); + rb_define_method(rb_cRational, "denominator", nurat_denominator, 0); - rb_define_method(rb_cRational, "+", nurat_add, 1); - rb_define_method(rb_cRational, "-", nurat_sub, 1); - rb_define_method(rb_cRational, "*", nurat_mul, 1); - rb_define_method(rb_cRational, "/", nurat_div, 1); - rb_define_method(rb_cRational, "fdiv", nurat_fdiv, 1); - rb_define_method(rb_cRational, "**", nurat_expt, 1); + rb_define_method(rb_cRational, "+", nurat_add, 1); + rb_define_method(rb_cRational, "-", nurat_sub, 1); + rb_define_method(rb_cRational, "*", nurat_mul, 1); + rb_define_method(rb_cRational, "/", nurat_div, 1); + rb_define_method(rb_cRational, "fdiv", nurat_fdiv, 1); + rb_define_method(rb_cRational, "**", nurat_expt, 1); - rb_define_method(rb_cRational, "<=>", nurat_cmp, 1); - rb_define_method(rb_cRational, "==", nurat_equal_p, 1); - rb_define_method(rb_cRational, "coerce", nurat_coerce, 1); + rb_define_method(rb_cRational, "<=>", nurat_cmp, 1); + rb_define_method(rb_cRational, "==", nurat_equal_p, 1); + rb_define_method(rb_cRational, "coerce", nurat_coerce, 1); - rb_define_method(rb_cRational, "div", nurat_idiv, 1); + rb_define_method(rb_cRational, "div", nurat_idiv, 1); #if NUBY - rb_define_method(rb_cRational, "//", nurat_idiv, 1); + rb_define_method(rb_cRational, "//", nurat_idiv, 1); #endif - rb_define_method(rb_cRational, "modulo", nurat_mod, 1); - rb_define_method(rb_cRational, "%", nurat_mod, 1); - rb_define_method(rb_cRational, "divmod", nurat_divmod, 1); + rb_define_method(rb_cRational, "modulo", nurat_mod, 1); + rb_define_method(rb_cRational, "%", nurat_mod, 1); + rb_define_method(rb_cRational, "divmod", nurat_divmod, 1); #if 0 - rb_define_method(rb_cRational, "quot", nurat_quot, 1); + rb_define_method(rb_cRational, "quot", nurat_quot, 1); #endif - rb_define_method(rb_cRational, "remainder", nurat_rem, 1); + rb_define_method(rb_cRational, "remainder", nurat_rem, 1); #if 0 - rb_define_method(rb_cRational, "quotrem", nurat_quotrem, 1); + rb_define_method(rb_cRational, "quotrem", nurat_quotrem, 1); #endif - rb_define_method(rb_cRational, "abs", nurat_abs, 0); + rb_define_method(rb_cRational, "abs", nurat_abs, 0); #if 0 - rb_define_method(rb_cRational, "rational?", nurat_true, 0); - rb_define_method(rb_cRational, "exact?", nurat_true, 0); + rb_define_method(rb_cRational, "rational?", nurat_true, 0); + rb_define_method(rb_cRational, "exact?", nurat_true, 0); #endif - rb_define_method(rb_cRational, "floor", nurat_floor, 0); - rb_define_method(rb_cRational, "ceil", nurat_ceil, 0); - rb_define_method(rb_cRational, "truncate", nurat_truncate, 0); - rb_define_method(rb_cRational, "round", nurat_round, 0); + rb_define_method(rb_cRational, "floor", nurat_floor, 0); + rb_define_method(rb_cRational, "ceil", nurat_ceil, 0); + rb_define_method(rb_cRational, "truncate", nurat_truncate, 0); + rb_define_method(rb_cRational, "round", nurat_round, 0); - rb_define_method(rb_cRational, "to_i", nurat_truncate, 0); - rb_define_method(rb_cRational, "to_f", nurat_to_f, 0); - rb_define_method(rb_cRational, "to_r", nurat_to_r, 0); + rb_define_method(rb_cRational, "to_i", nurat_truncate, 0); + rb_define_method(rb_cRational, "to_f", nurat_to_f, 0); + rb_define_method(rb_cRational, "to_r", nurat_to_r, 0); - rb_define_method(rb_cRational, "hash", nurat_hash, 0); + rb_define_method(rb_cRational, "hash", nurat_hash, 0); - rb_define_method(rb_cRational, "to_s", nurat_to_s, 0); - rb_define_method(rb_cRational, "inspect", nurat_inspect, 0); + rb_define_method(rb_cRational, "to_s", nurat_to_s, 0); + rb_define_method(rb_cRational, "inspect", nurat_inspect, 0); - rb_define_method(rb_cRational, "marshal_dump", nurat_marshal_dump, 0); - rb_define_method(rb_cRational, "marshal_load", nurat_marshal_load, 1); + rb_define_method(rb_cRational, "marshal_dump", nurat_marshal_dump, 0); + rb_define_method(rb_cRational, "marshal_load", nurat_marshal_load, 1); - /* --- */ + /* --- */ - rb_define_method(rb_cInteger, "gcd", rb_gcd, 1); - rb_define_method(rb_cInteger, "lcm", rb_lcm, 1); - rb_define_method(rb_cInteger, "gcdlcm", rb_gcdlcm, 1); + rb_define_method(rb_cInteger, "gcd", rb_gcd, 1); + rb_define_method(rb_cInteger, "lcm", rb_lcm, 1); + rb_define_method(rb_cInteger, "gcdlcm", rb_gcdlcm, 1); - rb_define_method(rb_cNilClass, "to_r", nilclass_to_r, 0); - rb_define_method(rb_cInteger, "to_r", integer_to_r, 0); - rb_define_method(rb_cFloat, "to_r", float_to_r, 0); + rb_define_method(rb_cNilClass, "to_r", nilclass_to_r, 0); + rb_define_method(rb_cInteger, "to_r", integer_to_r, 0); + rb_define_method(rb_cFloat, "to_r", float_to_r, 0); - make_patterns(); + make_patterns(); - rb_define_method(rb_cString, "to_r", string_to_r, 0); + rb_define_method(rb_cString, "to_r", string_to_r, 0); - rb_define_singleton_method(rb_cRational, "convert", nurat_s_convert, -1); - rb_funcall(rb_cRational, rb_intern("private_class_method"), 1, - ID2SYM(rb_intern("convert"))); + rb_define_singleton_method(rb_cRational, "convert", nurat_s_convert, -1); + rb_funcall(rb_cRational, rb_intern("private_class_method"), 1, + ID2SYM(rb_intern("convert"))); - rb_include_module(rb_cRational, rb_mPrecision); - rb_define_singleton_method(rb_cRational, "induced_from", - nurat_s_induced_from, 1); + rb_include_module(rb_cRational, rb_mPrecision); + rb_define_singleton_method(rb_cRational, "induced_from", + nurat_s_induced_from, 1); }