ruby-changes:8380
From: keiju <ko1@a...>
Date: Fri, 24 Oct 2008 18:40:08 +0900 (JST)
Subject: [ruby-changes:8380] Ruby:r19911 (trunk): * lib/mathn.rb: moved into ext/mathn/rational/rational.c and
keiju 2008-10-24 18:39:53 +0900 (Fri, 24 Oct 2008) New Revision: 19911 http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=rev&revision=19911 Log: * lib/mathn.rb: moved into ext/mathn/rational/rational.c and ext/mathn/complex/complex.c. * ext/mathn: new mathn ext-libralies. Added directories: trunk/ext/mathn/ trunk/ext/mathn/complex/ trunk/ext/mathn/rational/ Added files: trunk/ext/mathn/complex/complex.c trunk/ext/mathn/complex/extconf.rb trunk/ext/mathn/rational/extconf.rb trunk/ext/mathn/rational/rational.c Modified files: trunk/ChangeLog trunk/lib/mathn.rb Index: ChangeLog =================================================================== --- ChangeLog (revision 19910) +++ ChangeLog (revision 19911) @@ -1,3 +1,9 @@ +Fri Oct 24 18:29:00 2008 Keiju Ishitsuka <keiju@r...> + + * lib/mathn.rb: moved into ext/mathn/rational/rational.c and + ext/mathn/complex/complex.c. + * ext/mathn: new mathn ext-libralies. + Fri Oct 24 18:21:31 2008 Yukihiro Matsumoto <matz@r...> * test/ruby/test_array.rb (TestArray#test_join): should restore Index: lib/mathn.rb =================================================================== --- lib/mathn.rb (revision 19910) +++ lib/mathn.rb (revision 19911) @@ -13,54 +13,18 @@ require "matrix.rb" require "prime.rb" +require "mathn/rational" +require "mathn/complex" + unless defined?(Math.exp!) Object.instance_eval{remove_const :Math} Math = CMath end -class Object - - def canon - if Rational === self - if denominator == 1 - return numerator - end - elsif Complex === self - if Integer === imag && imag == 0 - return real - end - end - self - end - - private :canon - - class << self - - def def_canon(*ids) - for id in ids - module_eval <<-"end;" - alias_method :__#{id.object_id}__, :#{id.to_s} - private :__#{id.object_id}__ - def #{id.to_s}(*args, &block) - __#{id.object_id}__(*args, &block).__send__(:canon) - end - end; - end - end - - private :def_canon - - end - -end - class Fixnum remove_method :/ alias / quo - def_canon(*(instance_methods - Object.methods - [:canon])) - alias power! ** unless defined?(0.power!) def ** (other) @@ -77,8 +41,6 @@ remove_method :/ alias / quo - def_canon(*(instance_methods - Object.methods - [:canon])) - alias power! ** unless defined?(0.power!) def ** (other) @@ -91,23 +53,7 @@ end -alias RationalOrig Rational -private :RationalOrig -def Rational(*args) RationalOrig(*args).__send__(:canon) end - class Rational - Unify = true - - class << self - alias convert_orig convert - private :convert_orig - def convert(*args) convert_orig(*args).__send__(:canon) end - end - - def_canon(*(instance_methods - Object.methods - [:canon])) - - alias power! ** - def ** (other) if other.kind_of?(Rational) other2 = other @@ -244,45 +190,7 @@ module_function :rsqrt end -alias ComplexOrig Complex -private :ComplexOrig -def Complex(*args) ComplexOrig(*args).__send__(:canon) end - -class Complex - Unify = true - - class << self - alias convert_orig convert - private :convert_orig - def convert(*args) convert_orig(*args).__send__(:canon) end - end - - def_canon(*(instance_methods - Object.methods - [:canon])) - -end - -class NilClass - - def_canon :to_r, :to_c - -end - -class Integer - - def_canon :to_r, :to_c - -end - -class String - - def_canon :to_r, :to_c - -end - class Float - - def_canon(*(instance_methods - Object.methods - [:canon])) - alias power! ** def ** (other) Index: ext/mathn/complex/complex.c =================================================================== --- ext/mathn/complex/complex.c (revision 0) +++ ext/mathn/complex/complex.c (revision 19911) @@ -0,0 +1,1511 @@ +/* + + complex.c of mathn version + + Original file is built-in complex.c: + -- + complex.c: Coded by Tadayoshi Funaba 2008 + + This implementation is based on Keiju Ishitsuka's Complex library + which is written in ruby. +*/ + +#include "ruby.h" +#include <math.h> + +#define NDEBUG +#include <assert.h> + +#ifndef COMPLEX_NAME +#define COMPLEX_NAME "Complex" +#endif + +#define ZERO INT2FIX(0) +#define ONE INT2FIX(1) +#define TWO INT2FIX(2) + +VALUE rb_cComplex; + +static ID id_abs, id_abs2, id_arg, id_cmp, id_conj, id_convert, + id_denominator, id_divmod, id_equal_p, id_expt, id_floor, id_hash, + id_idiv, id_inspect, id_negate, id_numerator, id_polar, id_quo, + id_real_p, id_to_f, id_to_i, id_to_r, id_to_s; + +#define f_boolcast(x) ((x) ? Qtrue : Qfalse) + +#define binop(n,op) \ +inline static VALUE \ +f_##n(VALUE x, VALUE 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);\ +} + +#define fun2(n) \ +inline static VALUE \ +f_##n(VALUE x, VALUE 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);\ +} + +#define math2(n) \ +inline static VALUE \ +m_##n(VALUE x, VALUE y)\ +{\ + return rb_funcall(rb_mMath, id_##n, 2, x, y);\ +} + +#define PRESERVE_SIGNEDZERO + +inline static VALUE +f_add(VALUE x, VALUE y) +{ +#ifndef PRESERVE_SIGNEDZERO + if (FIXNUM_P(y) && FIX2LONG(y) == 0) + return x; + else if (FIXNUM_P(x) && FIX2LONG(x) == 0) + return y; +#endif + return rb_funcall(x, '+', 1, y); +} + +inline static VALUE +f_cmp(VALUE x, VALUE y) +{ + if (FIXNUM_P(x) && FIXNUM_P(y)) { + long c = FIX2LONG(x) - FIX2LONG(y); + if (c > 0) + c = 1; + else if (c < 0) + c = -1; + return INT2FIX(c); + } + return rb_funcall(x, id_cmp, 1, y); +} + +inline static VALUE +f_div(VALUE x, VALUE y) +{ + if (FIXNUM_P(y) && FIX2LONG(y) == 1) + return x; + return rb_funcall(x, '/', 1, y); +} + +inline static VALUE +f_gt_p(VALUE x, VALUE y) +{ + if (FIXNUM_P(x) && FIXNUM_P(y)) + return f_boolcast(FIX2LONG(x) > FIX2LONG(y)); + return rb_funcall(x, '>', 1, y); +} + +inline static VALUE +f_lt_p(VALUE x, VALUE y) +{ + if (FIXNUM_P(x) && FIXNUM_P(y)) + return f_boolcast(FIX2LONG(x) < FIX2LONG(y)); + return rb_funcall(x, '<', 1, y); +} + +binop(mod, '%') + +inline static VALUE +f_mul(VALUE x, VALUE y) +{ +#ifndef PRESERVE_SIGNEDZERO + if (FIXNUM_P(y)) { + long iy = FIX2LONG(y); + if (iy == 0) { + if (FIXNUM_P(x) || TYPE(x) == T_BIGNUM) + return ZERO; + } + else if (iy == 1) + return x; + } + else if (FIXNUM_P(x)) { + long ix = FIX2LONG(x); + if (ix == 0) { + if (FIXNUM_P(y) || TYPE(y) == T_BIGNUM) + return ZERO; + } + else if (ix == 1) + return y; + } +#endif + return rb_funcall(x, '*', 1, y); +} + +inline static VALUE +f_sub(VALUE x, VALUE y) +{ +#ifndef PRESERVE_SIGNEDZERO + if (FIXNUM_P(y) && FIX2LONG(y) == 0) + return x; +#endif + return rb_funcall(x, '-', 1, y); +} + +binop(xor, '^') + +fun1(abs) +fun1(abs2) +fun1(arg) +fun1(conj) +fun1(denominator) +fun1(floor) +fun1(hash) +fun1(inspect) +fun1(negate) +fun1(numerator) +fun1(polar) +fun1(real_p) + +fun1(to_f) +fun1(to_i) +fun1(to_r) +fun1(to_s) + +fun2(divmod) + +inline static VALUE +f_equal_p(VALUE x, VALUE y) +{ + if (FIXNUM_P(x) && FIXNUM_P(y)) + return f_boolcast(FIX2LONG(x) == FIX2LONG(y)); + return rb_funcall(x, id_equal_p, 1, y); +} + +fun2(expt) +fun2(idiv) +fun2(quo) + +inline static VALUE +f_negative_p(VALUE x) +{ + if (FIXNUM_P(x)) + return f_boolcast(FIX2LONG(x) < 0); + return rb_funcall(x, '<', 1, ZERO); +} + +#define f_positive_p(x) (!f_negative_p(x)) + +inline static VALUE +f_zero_p(VALUE x) +{ + if (FIXNUM_P(x)) + return f_boolcast(FIX2LONG(x) == 0); + return rb_funcall(x, id_equal_p, 1, ZERO); +} + +#define f_nonzero_p(x) (!f_zero_p(x)) + +inline static VALUE +f_one_p(VALUE x) +{ + if (FIXNUM_P(x)) + return f_boolcast(FIX2LONG(x) == 1); + return rb_funcall(x, id_equal_p, 1, ONE); +} + +inline static VALUE +f_kind_of_p(VALUE x, VALUE 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); +} + +inline static VALUE +k_integer_p(VALUE x) +{ + return f_kind_of_p(x, rb_cInteger); +} + +inline static VALUE +k_float_p(VALUE x) +{ + return f_kind_of_p(x, rb_cFloat); +} + +inline static VALUE +k_rational_p(VALUE x) +{ + return f_kind_of_p(x, rb_cRational); +} + +inline static VALUE +k_complex_p(VALUE x) +{ + return f_kind_of_p(x, rb_cComplex); +} + +#define k_exact_p(x) (!k_float_p(x)) +#define k_inexact_p(x) k_float_p(x) + +#define get_dat1(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)) + +inline static VALUE +nucomp_s_new_internal(VALUE klass, VALUE real, VALUE imag) +{ + NEWOBJ(obj, struct RComplex); + OBJSETUP(obj, klass, T_COMPLEX); + + obj->real = real; + obj->imag = imag; + + return (VALUE)obj; +} + +static VALUE +nucomp_s_alloc(VALUE klass) +{ + return nucomp_s_new_internal(klass, ZERO, ZERO); +} + +#if 0 +static VALUE +nucomp_s_new_bang(int argc, VALUE *argv, VALUE klass) +{ + VALUE real, imag; + + switch (rb_scan_args(argc, argv, "11", &real, &imag)) { + case 1: + if (!k_numeric_p(real)) + real = f_to_i(real); + imag = ZERO; + break; + default: + if (!k_numeric_p(real)) + real = f_to_i(real); + if (!k_numeric_p(imag)) + imag = f_to_i(imag); + break; + } + + return nucomp_s_new_internal(klass, real, imag); +} +#endif + +inline static VALUE +f_complex_new_bang1(VALUE klass, VALUE x) +{ + assert(!k_complex_p(x)); + return nucomp_s_new_internal(klass, x, ZERO); +} + +inline static VALUE +f_complex_new_bang2(VALUE klass, VALUE x, VALUE y) +{ + assert(!k_complex_p(x)); + assert(!k_complex_p(y)); + return nucomp_s_new_internal(klass, x, y); +} + +#ifndef EXT_MATHN +#define f_unify_p(klass) rb_const_defined(klass, id_Unify) +#else +#define f_unify_p(klass) 1 +#endif + +inline static void +nucomp_real_check(VALUE num) +{ + switch (TYPE(num)) { + case T_FIXNUM: + case T_BIGNUM: + case T_FLOAT: + case T_RATIONAL: + break; + default: + if (!k_numeric_p(num) || !f_real_p(num)) + rb_raise(rb_eArgError, "not a real"); + } +} + +inline static VALUE +nucomp_s_canonicalize_internal(VALUE klass, VALUE real, VALUE imag) +{ +#ifdef CANON +#define CL_CANON +#ifdef CL_CANON + if (f_zero_p(imag) && k_exact_p(imag) && f_unify_p(klass)) + return real; +#else + if (f_zero_p(imag) && f_unify_p(klass)) + return real; +#endif +#endif + if (f_real_p(real) && f_real_p(imag)) + return nucomp_s_new_internal(klass, real, imag); + else if (f_real_p(real)) { + get_dat1(imag); + + return nucomp_s_new_internal(klass, + f_sub(real, dat->imag), + f_add(ZERO, dat->real)); + } + else if (f_real_p(imag)) { + get_dat1(real); + + return nucomp_s_new_internal(klass, + dat->real, + f_add(dat->imag, imag)); + } + else { + get_dat2(real, imag); + + return nucomp_s_new_internal(klass, + f_sub(adat->real, bdat->imag), + f_add(adat->imag, bdat->real)); + } +} + +static VALUE +nucomp_s_new(int argc, VALUE *argv, VALUE klass) +{ + VALUE real, imag; + + switch (rb_scan_args(argc, argv, "11", &real, &imag)) { + case 1: + nucomp_real_check(real); + imag = ZERO; + break; + default: + nucomp_real_check(real); + nucomp_real_check(imag); + break; + } + + return nucomp_s_canonicalize_internal(klass, real, imag); +} + +inline static VALUE +f_complex_new1(VALUE klass, VALUE x) +{ + 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); +} + +static VALUE +nucomp_f_complex(int argc, VALUE *argv, VALUE klass) +{ + return rb_funcall2(rb_cComplex, id_convert, argc, argv); +} + +extern VALUE math_atan2(VALUE obj, VALUE x, VALUE y); +extern VALUE math_cos(VALUE obj, VALUE x); +extern VALUE math_cosh(VALUE obj, VALUE x); +extern VALUE math_exp(VALUE obj, VALUE x); +extern VALUE math_hypot(VALUE obj, VALUE x, VALUE y); +extern VALUE math_log(int argc, VALUE *argv); +extern VALUE math_sin(VALUE obj, VALUE x); +extern VALUE math_sinh(VALUE obj, VALUE x); +extern VALUE math_sqrt(VALUE obj, VALUE x); + +#define m_atan2_bang(x,y) math_atan2(Qnil,x,y) +#define m_cos_bang(x) math_cos(Qnil,x) +#define m_cosh_bang(x) math_cosh(Qnil,x) +#define m_exp_bang(x) math_exp(Qnil,x) +#define m_hypot(x,y) math_hypot(Qnil,x,y) + +static VALUE +m_log_bang(VALUE x) +{ + return math_log(1, &x); +} + +#define m_sin_bang(x) math_sin(Qnil,x) +#define m_sinh_bang(x) math_sinh(Qnil,x) +#define m_sqrt_bang(x) math_sqrt(Qnil,x) + +static VALUE +m_cos(VALUE x) +{ + if (f_real_p(x)) + return m_cos_bang(x); + { + get_dat1(x); + return f_complex_new2(rb_cComplex, + f_mul(m_cos_bang(dat->real), + m_cosh_bang(dat->imag)), + f_mul(f_negate(m_sin_bang(dat->real)), + m_sinh_bang(dat->imag))); + } +} + +static VALUE +m_sin(VALUE x) +{ + if (f_real_p(x)) + return m_sin_bang(x); + { + get_dat1(x); + return f_complex_new2(rb_cComplex, + f_mul(m_sin_bang(dat->real), + m_cosh_bang(dat->imag)), + f_mul(m_cos_bang(dat->real), + m_sinh_bang(dat->imag))); + } +} + +#if 0 +static VALUE +m_sqrt(VALUE x) +{ + if (f_real_p(x)) { + if (f_positive_p(x)) + return m_sqrt_bang(x); + return f_complex_new2(rb_cComplex, ZERO, m_sqrt_bang(f_negate(x))); + } + else { + get_dat1(x); + + if (f_negative_p(dat->imag)) + return f_conj(m_sqrt(f_conj(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))); + } + } +} +#endif + +inline static VALUE +f_complex_polar(VALUE klass, VALUE x, VALUE y) +{ + assert(!k_complex_p(x)); + assert(!k_complex_p(y)); + return nucomp_s_canonicalize_internal(klass, + f_mul(x, m_cos(y)), + f_mul(x, m_sin(y))); +} + +static VALUE +nucomp_s_polar(VALUE klass, VALUE abs, VALUE arg) +{ + return f_complex_polar(klass, abs, arg); +} + +static VALUE +nucomp_real(VALUE self) +{ + get_dat1(self); + return dat->real; +} + +static VALUE +nucomp_imag(VALUE self) +{ + get_dat1(self); + return dat->imag; +} + +static VALUE +nucomp_negate(VALUE self) +{ + get_dat1(self); + return f_complex_new2(CLASS_OF(self), + f_negate(dat->real), f_negate(dat->imag)); +} + +static VALUE +nucomp_add(VALUE self, VALUE other) +{ + if (k_complex_p(other)) { + VALUE real, imag; + + get_dat2(self, other); + + real = f_add(adat->real, bdat->real); + imag = f_add(adat->imag, bdat->imag); + + return f_complex_new2(CLASS_OF(self), real, imag); + } + if (k_numeric_p(other) && f_real_p(other)) { + get_dat1(self); + + return f_complex_new2(CLASS_OF(self), + f_add(dat->real, other), dat->imag); + } + return rb_num_coerce_bin(self, other, '+'); +} + +static VALUE +nucomp_sub(VALUE self, VALUE other) +{ + if (k_complex_p(other)) { + VALUE real, imag; + + get_dat2(self, other); + + real = f_sub(adat->real, bdat->real); + imag = f_sub(adat->imag, bdat->imag); + + return f_complex_new2(CLASS_OF(self), real, imag); + } + if (k_numeric_p(other) && f_real_p(other)) { + get_dat1(self); + + return f_complex_new2(CLASS_OF(self), + f_sub(dat->real, other), dat->imag); + } + return rb_num_coerce_bin(self, other, '-'); +} + +static VALUE +nucomp_mul(VALUE self, VALUE other) +{ + if (k_complex_p(other)) { + VALUE real, imag; + + get_dat2(self, other); + + real = f_sub(f_mul(adat->real, bdat->real), + f_mul(adat->imag, bdat->imag)); + imag = f_add(f_mul(adat->real, bdat->imag), + f_mul(adat->imag, bdat->real)); + + return f_complex_new2(CLASS_OF(self), real, imag); + } + if (k_numeric_p(other) && f_real_p(other)) { + get_dat1(self); + + return f_complex_new2(CLASS_OF(self), + f_mul(dat->real, other), + f_mul(dat->imag, other)); + } + return rb_num_coerce_bin(self, other, '*'); +} + +#define f_div f_quo + +static VALUE +nucomp_div(VALUE self, VALUE other) +{ + if (k_complex_p(other)) { + get_dat2(self, other); + + if (TYPE(adat->real) == T_FLOAT || + TYPE(adat->imag) == T_FLOAT || + TYPE(bdat->real) == T_FLOAT || + TYPE(bdat->imag) == T_FLOAT) { + VALUE magn = m_hypot(bdat->real, bdat->imag); + VALUE tmp = f_complex_new_bang2(CLASS_OF(self), + f_div(bdat->real, magn), + f_div(bdat->imag, magn)); + return f_div(f_mul(self, f_conj(tmp)), magn); + } + return f_div(f_mul(self, f_conj(other)), f_abs2(other)); + } + if (k_numeric_p(other) && f_real_p(other)) { + get_dat1(self); + + return f_complex_new2(CLASS_OF(self), + f_div(dat->real, other), + f_div(dat->imag, other)); + } + return rb_num_coerce_bin(self, other, '/'); +} + +#undef f_div +#define nucomp_quo nucomp_div + +static VALUE +nucomp_fdiv(VALUE self, VALUE other) +{ + get_dat1(self); + + return f_div(f_complex_new2(CLASS_OF(self), + f_to_f(dat->real), + f_to_f(dat->imag)), other); +} + +static VALUE +nucomp_expt(VALUE self, VALUE other) +{ + if (k_exact_p(other) && 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_complex_p(other)) { + VALUE a, r, theta, ore, oim, nr, ntheta; + + get_dat1(other); + + a = f_polar(self); + r = RARRAY_PTR(a)[0]; + theta = RARRAY_PTR(a)[1]; + + ore = dat->real; + oim = dat->imag; + 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 f_complex_polar(CLASS_OF(self), nr, ntheta); + } + if (k_integer_p(other)) { + if (f_gt_p(other, ZERO)) { + VALUE x, z, n; + + x = self; + z = x; + n = f_sub(other, ONE); + + while (f_nonzero_p(n)) { + VALUE a; + + 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->imag, dat->imag)), + f_mul(f_mul(TWO, dat->real), dat->imag)); + n = RARRAY_PTR(a)[0]; + } + z = f_mul(z, x); + n = f_sub(n, ONE); + } + return z; + } + return f_expt(f_div(f_to_r(ONE), self), f_negate(other)); + } + if (k_numeric_p(other) && f_real_p(other)) { + VALUE a, r, theta; + + a = f_polar(self); + r = RARRAY_PTR(a)[0]; + theta = RARRAY_PTR(a)[1]; + return f_complex_polar(CLASS_OF(self), f_expt(r, other), + f_mul(theta, other)); + } + return rb_num_coerce_bin(self, other, id_expt); +} + +static VALUE +nucomp_equal_p(VALUE self, VALUE other) +{ + if (k_complex_p(other)) { + get_dat2(self, other); + + return f_boolcast(f_equal_p(adat->real, bdat->real) && + f_equal_p(adat->imag, bdat->imag)); + } + if (k_numeric_p(other) && f_real_p(other)) { + get_dat1(self); + + return f_boolcast(f_equal_p(dat->real, other) && f_zero_p(dat->imag)); + } + return f_equal_p(other, self); +} + +static VALUE +nucomp_coerce(VALUE self, VALUE other) +{ + if (k_numeric_p(other) && f_real_p(other)) + 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; +} + +static VALUE +nucomp_abs(VALUE self) +{ + get_dat1(self); + return m_hypot(dat->real, dat->imag); +} + +static VALUE +nucomp_abs2(VALUE self) +{ + get_dat1(self); + return f_add(f_mul(dat->real, dat->real), + f_mul(dat->imag, dat->imag)); +} + +static VALUE +nucomp_arg(VALUE self) +{ + get_dat1(self); + return m_atan2_bang(dat->imag, dat->real); +} + +static VALUE +nucomp_rect(VALUE self) +{ + get_dat1(self); + return rb_assoc_new(dat->real, dat->imag); +} + +static VALUE +nucomp_polar(VALUE self) +{ + return rb_assoc_new(f_abs(self), f_arg(self)); +} + +static VALUE +nucomp_conj(VALUE self) +{ + get_dat1(self); + return f_complex_new2(CLASS_OF(self), dat->real, f_negate(dat->imag)); +} + +#if 0 +static VALUE +nucomp_true(VALUE self) +{ + return Qtrue; +} +#endif + +static VALUE +nucomp_false(VALUE self) +{ + return Qfalse; +} + +#if 0 +static VALUE +nucomp_exact_p(VALUE self) +{ + get_dat1(self); + return f_boolcast(f_exact_p(dat->real) && f_exact_p(dat->imag)); +} + +static VALUE +nucomp_inexact_p(VALUE 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->imag)); +} + +static VALUE +nucomp_numerator(VALUE self) +{ + VALUE cd; + + 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->imag), + f_div(cd, f_denominator(dat->imag)))); +} + +static VALUE +nucomp_hash(VALUE self) +{ + get_dat1(self); + return f_xor(f_hash(dat->real), f_hash(dat->imag)); +} + +static VALUE +nucomp_eql_p(VALUE self, VALUE other) +{ + if (k_complex_p(other)) { + get_dat2(self, other); + + return f_boolcast((CLASS_OF(adat->real) == CLASS_OF(bdat->real)) && + (CLASS_OF(adat->imag) == CLASS_OF(bdat->imag)) && + f_equal_p(self, other)); + + } + return Qfalse; +} + +#ifndef HAVE_SIGNBIT +#ifdef signbit +#define HAVE_SIGNBIT 1 +#endif +#endif + +inline static VALUE +f_signbit(VALUE x) +{ + switch (TYPE(x)) { + case T_FLOAT: +#ifdef HAVE_SIGNBIT + return f_boolcast(signbit(RFLOAT_VALUE(x))); +#else + { + char s[2]; + + (void)snprintf(s, sizeof s, "%.0f", RFLOAT_VALUE(x)); + + return f_boolcast(s[0] == '-'); + } +#endif + } + return f_negative_p(x); +} + +inline static VALUE +f_tpositive_p(VALUE x) +{ + return f_boolcast(!f_signbit(x)); +} + +static VALUE +nucomp_to_s(VALUE self) +{ + VALUE s, impos; + + get_dat1(self); + + impos = f_tpositive_p(dat->imag); + + s = f_to_s(dat->real); + rb_str_cat2(s, !impos ? "-" : "+"); + + rb_str_concat(s, f_to_s(f_abs(dat->imag))); + rb_str_cat2(s, "i"); + + return s; +} + +static VALUE +nucomp_inspect(VALUE self) +{ + VALUE s, impos; + + get_dat1(self); + + impos = f_tpositive_p(dat->imag); + + s = rb_str_new2("("); + rb_str_concat(s, f_inspect(dat->real)); + rb_str_cat2(s, !impos ? "-" : "+"); + + rb_str_concat(s, f_inspect(f_abs(dat->imag))); + rb_str_cat2(s, "i)"); + + return s; +} + +static VALUE +nucomp_marshal_dump(VALUE self) +{ + VALUE a; + get_dat1(self); + + a = rb_assoc_new(dat->real, dat->imag); + rb_copy_generic_ivar(a, self); + return a; +} + +static VALUE +nucomp_marshal_load(VALUE self, VALUE a) +{ + get_dat1(self); + dat->real = RARRAY_PTR(a)[0]; + dat->imag = RARRAY_PTR(a)[1]; + rb_copy_generic_ivar(self, a); + return self; +} + +/* --- */ + +VALUE +rb_complex_raw(VALUE x, VALUE 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); +} + +VALUE +rb_complex_polar(VALUE x, VALUE y) +{ + return nucomp_s_polar(rb_cComplex, x, y); +} + +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); +} + +static VALUE +nucomp_to_i(VALUE self) +{ + get_dat1(self); + + if (k_inexact_p(dat->imag) || f_nonzero_p(dat->imag)) { + 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); + + if (k_inexact_p(dat->imag) || f_nonzero_p(dat->imag)) { + VALUE s = f_to_s(self); + rb_raise(rb_eRangeError, "can't convert %s into Float", + StringValuePtr(s)); + } + return f_to_f(dat->real); +} + +static VALUE +nucomp_to_r(VALUE self) +{ + get_dat1(self); + + if (k_inexact_p(dat->imag) || f_nonzero_p(dat->imag)) { + VALUE s = f_to_s(self); + rb_raise(rb_eRangeError, "can't convert %s into Rational", + StringValuePtr(s)); + } + return f_to_r(dat->real); +} + +static VALUE +nilclass_to_c(VALUE self) +{ + return rb_complex_new1(INT2FIX(0)); +} + +static VALUE +numeric_to_c(VALUE self) +{ + return rb_complex_new1(self); +} + +static VALUE comp_pat0, comp_pat1, comp_pat2, a_slash, a_dot_and_an_e, + null_string, underscores_pat, an_underscore; + +#define WS "\\s*" +#define DIGITS "(?:\\d(?:_\\d|\\d)*)" +#define NUMERATOR "(?:" DIGITS "?\\.)?" DIGITS "(?:[eE][-+]?" DIGITS ")?" +#define DENOMINATOR DIGITS +#define NUMBER "[-+]?" NUMERATOR "(?:\\/" DENOMINATOR ")?" +#define NUMBERNOS NUMERATOR "(?:\\/" DENOMINATOR ")?" +#define PATTERN0 "\\A" WS "(" NUMBER ")@(" NUMBER ")" WS +#define PATTERN1 "\\A" WS "([-+])?(" NUMBER ")?[iIjJ]" WS +#define PATTERN2 "\\A" WS "(" NUMBER ")(([-+])(" NUMBERNOS ")?[iIjJ])?" WS + +static void +make_patterns(void) +{ + static const char comp_pat0_source[] = PATTERN0; + static const char comp_pat1_source[] = PATTERN1; + static const char comp_pat2_source[] = PATTERN2; + static const char underscores_pat_source[] = "_+"; + + if (comp_pat0) return; + + comp_pat0 = rb_reg_new(comp_pat0_source, sizeof comp_pat0_source - 1, 0); + rb_gc_register_mark_object(comp_pat0); + + comp_pat1 = rb_reg_new(comp_pat1_source, sizeof comp_pat1_source - 1, 0); + rb_gc_register_mark_object(comp_pat1); + + comp_pat2 = rb_reg_new(comp_pat2_source, sizeof comp_pat2_source - 1, 0); + rb_gc_register_mark_object(comp_pat2); + + a_slash = rb_str_new2("/"); + rb_gc_register_mark_object(a_slash); + + a_dot_and_an_e = rb_str_new2(".eE"); + rb_gc_register_mark_object(a_dot_and_an_e); + + null_string = rb_str_new2(""); + rb_gc_register_mark_object(null_string); + + underscores_pat = rb_reg_new(underscores_pat_source, + sizeof underscores_pat_source - 1, 0); + rb_gc_register_mark_object(underscores_pat); + + an_underscore = rb_str_new2("_"); + rb_gc_register_mark_object(an_underscore); +} + +#define id_match rb_intern("match") +#define f_match(x,y) rb_funcall(x, id_match, 1, y) + +#define id_aref rb_intern("[]") +#define f_aref(x,y) rb_funcall(x, id_aref, 1, y) + +#define id_post_match rb_intern("post_match") +#define f_post_match(x) rb_funcall(x, id_post_match, 0) + +#define id_split rb_intern("split") +#define f_split(x,y) rb_funcall(x, id_split, 1, y) + +#define id_include_p rb_intern("include?") +#define f_include_p(x,y) rb_funcall(x, id_include_p, 1, y) + +#define id_count rb_intern("count") +#define f_count(x,y) rb_funcall(x, id_count, 1, y) + +#define id_gsub_bang rb_intern("gsub!") +#define f_gsub_bang(x,y,z) rb_funcall(x, id_gsub_bang, 2, y, z) + +static VALUE +string_to_c_internal(VALUE self) +{ + VALUE s; + + s = self; + + if (RSTRING_LEN(s) == 0) + return rb_assoc_new(Qnil, self); + + { + VALUE m, sr, si, re, r, i; + int po; + + m = f_match(comp_pat0, s); + if (!NIL_P(m)) { + sr = f_aref(m, INT2FIX(1)); + si = f_aref(m, INT2FIX(2)); + re = f_post_match(m); + po = 1; + } + if (NIL_P(m)) { + m = f_match(comp_pat1, s); + if (!NIL_P(m)) { + sr = Qnil; + si = f_aref(m, INT2FIX(1)); + if (NIL_P(si)) + si = rb_str_new2(""); + { + VALUE t; + + t = f_aref(m, INT2FIX(2)); + if (NIL_P(t)) + t = rb_str_new2("1"); + rb_str_concat(si, t); + } + re = f_post_match(m); + po = 0; + } + } + 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)); + if (NIL_P(f_aref(m, INT2FIX(2)))) + si = Qnil; + else { + VALUE t; + + si = f_aref(m, INT2FIX(3)); + t = f_aref(m, INT2FIX(4)); + if (NIL_P(t)) + t = rb_str_new2("1"); + rb_str_concat(si, t); + } + re = f_post_match(m); + po = 0; + } + 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)) { + 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); + } + if (po) + return rb_assoc_new(rb_complex_polar(r, i), re); + else + 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]; +} + +#define id_gsub rb_intern("gsub") +#define f_gsub(x,y,z) rb_funcall(x, id_gsub, 2, y, z) + +static VALUE +string_to_c(VALUE self) +{ + VALUE s, a, backref; + + backref = rb_backref_get(); + rb_match_busy(backref); + + s = f_gsub(self, underscores_pat, an_underscore); + a = string_to_c_internal(s); + + rb_backref_set(backref); + + 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, backref; + + rb_scan_args(argc, argv, "11", &a1, &a2); + + backref = rb_backref_get(); + rb_match_busy(backref); + + 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; + } + + rb_backref_set(backref); + + switch (TYPE(a1)) { + case T_COMPLEX: + { + get_dat1(a1); + + if (k_exact_p(dat->imag) && f_zero_p(dat->imag)) + a1 = dat->real; + } + } + + switch (TYPE(a2)) { + case T_COMPLEX: + { + get_dat1(a2); + + if (k_exact_p(dat->imag) && f_zero_p(dat->imag)) + a2 = dat->real; + } + } + + switch (TYPE(a1)) { + case T_COMPLEX: + if (argc == 1 || (k_exact_p(a2) && f_zero_p(a2))) + return a1; + } + + if (argc == 1) { + if (k_numeric_p(a1) && !f_real_p(a1)) + return a1; + } + else { + if ((k_numeric_p(a1) && k_numeric_p(a2)) && + (!f_real_p(a1) || !f_real_p(a2))) + return f_add(a1, + f_mul(a2, + f_complex_new_bang2(rb_cComplex, ZERO, ONE))); + } + + { + VALUE argv2[2]; + argv2[0] = a1; + argv2[1] = a2; + return nucomp_s_new(argc, argv2, klass); + } +} + +/* --- */ + +static VALUE +numeric_real(VALUE self) +{ + return self; +} + +static VALUE +numeric_imag(VALUE self) +{ + return INT2FIX(0); +} + +static VALUE +numeric_abs2(VALUE self) +{ + return f_mul(self, self); +} + +#define id_PI rb_intern("PI") + +static VALUE +numeric_arg(VALUE self) +{ + if (f_positive_p(self)) + return INT2FIX(0); + return rb_const_get(rb_mMath, id_PI); +} + +static VALUE +numeric_rect(VALUE self) +{ + return rb_assoc_new(self, INT2FIX(0)); +} + +static VALUE +numeric_polar(VALUE self) +{ + return rb_assoc_new(f_abs(self), f_arg(self)); +} + +static VALUE +numeric_conj(VALUE self) +{ + return self; +} + +void +#ifndef EXT_MATHN +Init_Complex(void) +#else +Init_complex(void) +#endif +{ +#undef rb_intern +#define rb_intern(str) rb_intern_const(str) + + assert(fprintf(stderr, "assert() is now active\n")); + + id_abs = rb_intern("abs"); + id_abs2 = rb_intern("abs2"); + id_arg = rb_intern("arg"); + id_cmp = rb_intern("<=>"); + id_conj = rb_intern("conj"); + id_convert = rb_intern("convert"); + id_denominator = rb_intern("denominator"); + id_divmod = rb_intern("divmod"); + id_equal_p = rb_intern("=="); + id_expt = rb_intern("**"); + id_floor = rb_intern("floor"); + id_hash = rb_intern("hash"); + id_idiv = rb_intern("div"); + id_inspect = rb_intern("inspect"); + id_negate = rb_intern("-@"); + id_numerator = rb_intern("numerator"); + id_polar = rb_intern("polar"); + id_quo = rb_intern("quo"); + id_real_p = rb_intern("real?"); + 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"); + + rb_cComplex = rb_define_class(COMPLEX_NAME, rb_cNumeric); + + rb_define_alloc_func(rb_cComplex, nucomp_s_alloc); + rb_undef_method(CLASS_OF(rb_cComplex), "allocate"); + +#if 0 + rb_define_private_method(CLASS_OF(rb_cComplex), "new!", nucomp_s_new_bang, -1); + rb_define_private_method(CLASS_OF(rb_cComplex), "new", nucomp_s_new, -1); +#else + rb_undef_method(CLASS_OF(rb_cComplex), "new"); +#endif + + 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, "polar", nucomp_s_polar, 2); + + 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"); + +#if NUBY + rb_undef_method(rb_cComplex, "//"); +#endif + + rb_define_method(rb_cComplex, "real", nucomp_real, 0); + rb_define_method(rb_cComplex, "imaginary", nucomp_imag, 0); + rb_define_method(rb_cComplex, "imag", nucomp_imag, 0); + + rb_define_method(rb_cComplex, "-@", nucomp_negate, 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_quo, 1); + rb_define_method(rb_cComplex, "fdiv", nucomp_fdiv, 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, "abs", nucomp_abs, 0); + rb_define_method(rb_cComplex, "magnitude", nucomp_abs, 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, "phase", nucomp_arg, 0); + rb_define_method(rb_cComplex, "rectangular", nucomp_rect, 0); + rb_define_method(rb_cComplex, "rect", nucomp_rect, 0); + rb_define_method(rb_cComplex, "polar", nucomp_polar, 0); + rb_define_method(rb_cComplex, "conjugate", nucomp_conj, 0); + rb_define_method(rb_cComplex, "conj", nucomp_conj, 0); +#if 0 + rb_define_method(rb_cComplex, "~", nucomp_conj, 0); /* gcc */ +#endif + + rb_define_method(rb_cComplex, "real?", nucomp_false, 0); +#if 0 + rb_define_method(rb_cComplex, "complex?", nucomp_true, 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, "hash", nucomp_hash, 0); + rb_define_method(rb_cComplex, "eql?", nucomp_eql_p, 1); + + 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, "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(); + + rb_define_method(rb_cString, "to_c", string_to_c, 0); + + rb_define_private_method(CLASS_OF(rb_cComplex), "convert", nucomp_s_convert, -1); + + /* --- */ + + rb_define_method(rb_cNumeric, "real", numeric_real, 0); + rb_define_method(rb_cNumeric, "imaginary", numeric_imag, 0); + rb_define_method(rb_cNumeric, "imag", numeric_imag, 0); + rb_define_method(rb_cNumeric, "abs2", numeric_abs2, 0); + rb_define_method(rb_cNumeric, "arg", numeric_arg, 0); + rb_define_method(rb_cNumeric, "angle", numeric_arg, 0); + rb_define_method(rb_cNumeric, "phase", numeric_arg, 0); + rb_define_method(rb_cNumeric, "rectangular", numeric_rect, 0); + rb_define_method(rb_cNumeric, "rect", numeric_rect, 0); + rb_define_method(rb_cNumeric, "polar", numeric_polar, 0); + rb_define_method(rb_cNumeric, "conjugate", numeric_conj, 0); + rb_define_method(rb_cNumeric, "conj", numeric_conj, 0); + +#ifndef EXT_MATHN + rb_define_const(rb_cComplex, "I", + f_complex_new_bang2(rb_cComplex, ZERO, ONE)); +#endif +} + +/* +Local variables: +c-file-style: "ruby" +End: +*/ Index: ext/mathn/complex/extconf.rb =================================================================== --- ext/mathn/complex/extconf.rb (revision 0) +++ ext/mathn/complex/extconf.rb (revision 19911) @@ -0,0 +1,5 @@ +require "mkmf" + +$CPPFLAGS = "-DEXT_MATHN -DCANON -DCLCANON " + +create_makefile "mathn/complex" Index: ext/mathn/rational/extconf.rb =================================================================== --- ext/mathn/rational/extconf.rb (revision 0) +++ ext/mathn/rational/extconf.rb (revision 19911) @@ -0,0 +1,5 @@ +require "mkmf" + +$CPPFLAGS = "-DEXT_MATHN -DCANON -DCLCANON" + +create_makefile "mathn/rational" Index: ext/mathn/rational/rational.c =================================================================== --- ext/mathn/rational/rational.c (revision 0) +++ ext/mathn/rational/rational.c (revision 19911) @@ -0,0 +1,1593 @@ +/* + + rational.c of mathn version + + Original file is built-in rational.c: + -- + rational.c: Coded by Tadayoshi Funaba 2008 + + This implementation is based on Keiju Ishitsuka's Rational library + which is written in ruby. + -- +*/ + +#include "ruby.h" +#include <math.h> +#include <float.h> + +#ifdef HAVE_IEEEFP_H +#include <ieeefp.h> +#endif + +#define NDEBUG +#include <assert.h> + +#ifndef RATIONAL_NAME +#define RATIONAL_NAME "Rational" +#endif + +#define ZERO INT2FIX(0) +#define ONE INT2FIX(1) +#define TWO INT2FIX(2) + +VALUE rb_cRational; + +static ID id_abs, id_cmp, id_convert, id_equal_p, id_expt, id_floor, + id_format, id_hash, id_idiv, id_inspect, id_integer_p, id_negate, + id_to_f, id_to_i, id_to_s, id_truncate; + +#define f_boolcast(x) ((x) ? Qtrue : Qfalse) + +#define binop(n,op) \ +inline static VALUE \ +f_##n(VALUE x, VALUE 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);\ +} + +#define fun2(n) \ +inline static VALUE \ +f_##n(VALUE x, VALUE y)\ +{\ + return rb_funcall(x, id_##n, 1, y);\ +} + +inline static VALUE +f_add(VALUE x, VALUE y) +{ + if (FIXNUM_P(y) && FIX2LONG(y) == 0) + return x; + else if (FIXNUM_P(x) && FIX2LONG(x) == 0) + return y; + return rb_funcall(x, '+', 1, y); +} + +inline static VALUE +f_cmp(VALUE x, VALUE y) +{ + if (FIXNUM_P(x) && FIXNUM_P(y)) { + long c = FIX2LONG(x) - FIX2LONG(y); + if (c > 0) + c = 1; + else if (c < 0) + c = -1; + return INT2FIX(c); + } + return rb_funcall(x, id_cmp, 1, y); +} + +inline static VALUE +f_div(VALUE x, VALUE y) +{ + if (FIXNUM_P(y) && FIX2LONG(y) == 1) + return x; + return rb_funcall(x, '/', 1, y); +} + +inline static VALUE +f_gt_p(VALUE x, VALUE y) +{ + if (FIXNUM_P(x) && FIXNUM_P(y)) + return f_boolcast(FIX2LONG(x) > FIX2LONG(y)); + return rb_funcall(x, '>', 1, y); +} + +inline static VALUE +f_lt_p(VALUE x, VALUE y) +{ + if (FIXNUM_P(x) && FIXNUM_P(y)) + return f_boolcast(FIX2LONG(x) < FIX2LONG(y)); + return rb_funcall(x, '<', 1, y); +} + +binop(mod, '%') + +inline static VALUE +f_mul(VALUE x, VALUE y) +{ + if (FIXNUM_P(y)) { + long iy = FIX2LONG(y); + if (iy == 0) { + if (FIXNUM_P(x) || TYPE(x) == T_BIGNUM) + return ZERO; + } + else if (iy == 1) + return x; + } + else if (FIXNUM_P(x)) { + long ix = FIX2LONG(x); + if (ix == 0) { + if (FIXNUM_P(y) || TYPE(y) == T_BIGNUM) + return ZERO; + } + else if (ix == 1) + return y; + } + return rb_funcall(x, '*', 1, y); +} + +inline static VALUE +f_sub(VALUE x, VALUE y) +{ + if (FIXNUM_P(y) && FIX2LONG(y) == 0) + return x; + return rb_funcall(x, '-', 1, y); +} + +binop(xor, '^') + +fun1(abs) +fun1(floor) +fun1(hash) +fun1(inspect) +fun1(integer_p) +fun1(negate) +fun1(to_f) +fun1(to_i) +fun1(to_s) +fun1(truncate) + +inline static VALUE +f_equal_p(VALUE x, VALUE y) +{ + if (FIXNUM_P(x) && FIXNUM_P(y)) + return f_boolcast(FIX2LONG(x) == FIX2LONG(y)); + return rb_funcall(x, id_equal_p, 1, y); +} + +fun2(expt) +fun2(idiv) + +inline static VALUE +f_negative_p(VALUE x) +{ + if (FIXNUM_P(x)) + return f_boolcast(FIX2LONG(x) < 0); + return rb_funcall(x, '<', 1, ZERO); +} + +#define f_positive_p(x) (!f_negative_p(x)) + +inline static VALUE +f_zero_p(VALUE x) +{ + if (FIXNUM_P(x)) + return f_boolcast(FIX2LONG(x) == 0); + return rb_funcall(x, id_equal_p, 1, ZERO); +} + +#define f_nonzero_p(x) (!f_zero_p(x)) + +inline static VALUE +f_one_p(VALUE x) +{ + if (FIXNUM_P(x)) + return f_boolcast(FIX2LONG(x) == 1); + return rb_funcall(x, id_equal_p, 1, ONE); +} + +inline static VALUE +f_kind_of_p(VALUE x, VALUE 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); +} + +inline static VALUE +k_integer_p(VALUE x) +{ + return f_kind_of_p(x, rb_cInteger); +} + +inline static VALUE +k_float_p(VALUE x) +{ + return f_kind_of_p(x, rb_cFloat); +} + +inline static VALUE +k_rational_p(VALUE x) +{ + return f_kind_of_p(x, rb_cRational); +} + +#define k_exact_p(x) (!k_float_p(x)) +#define k_inexact_p(x) k_float_p(x) + +#ifndef NDEBUG +#define f_gcd f_gcd_orig +#endif + +inline static long +i_gcd(long x, long y) +{ + if (x < 0) + x = -x; + if (y < 0) + y = -y; + + if (x == 0) + return y; + if (y == 0) + return x; + + while (x > 0) { + long t = x; + x = y % x; + y = t; + } + return y; +} + +inline static VALUE +f_gcd(VALUE x, VALUE y) +{ + 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)) + return LONG2NUM(i_gcd(FIX2LONG(x), FIX2LONG(y))); + } + z = x; + x = f_mod(y, x); + y = z; + } + /* NOTREACHED */ +} + +#ifndef NDEBUG +#undef f_gcd + +inline static VALUE +f_gcd(VALUE x, VALUE y) +{ + VALUE r = f_gcd_orig(x, y); + if (f_nonzero_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; + return f_abs(f_mul(f_div(x, f_gcd(x, y)), y)); +} + +#define get_dat1(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)) + +inline static VALUE +nurat_s_new_internal(VALUE klass, VALUE num, VALUE den) +{ + NEWOBJ(obj, struct RRational); + OBJSETUP(obj, klass, T_RATIONAL); + + obj->num = num; + obj->den = den; + + return (VALUE)obj; +} + +static VALUE +nurat_s_alloc(VALUE klass) +{ + return nurat_s_new_internal(klass, ZERO, ONE); +} + +#define rb_raise_zerodiv() rb_raise(rb_eZeroDivError, "divided by zero") + +#if 0 +static VALUE +nurat_s_new_bang(int argc, VALUE *argv, VALUE klass) +{ + 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 (FIX2INT(f_cmp(den, ZERO))) { + case -1: + num = f_negate(num); + den = f_negate(den); + break; + case 0: + rb_raise_zerodiv(); + break; + } + break; + } + + return nurat_s_new_internal(klass, num, den); +} +#endif + +inline static VALUE +f_rational_new_bang1(VALUE klass, VALUE x) +{ + return nurat_s_new_internal(klass, x, ONE); +} + +inline static VALUE +f_rational_new_bang2(VALUE klass, VALUE x, VALUE y) +{ + assert(f_positive_p(y)); + assert(f_nonzero_p(y)); + return nurat_s_new_internal(klass, x, y); +} + +#ifndef EXT_MATHN +#define f_unify_p(klass) rb_const_defined(klass, id_Unify) +#else +#define f_unify_p(klass) 1 +#endif + +inline static void +nurat_int_check(VALUE num) +{ + switch (TYPE(num)) { + case T_FIXNUM: + case T_BIGNUM: + break; + default: + if (!k_numeric_p(num) || !f_integer_p(num)) + rb_raise(rb_eArgError, "not an integer"); + } +} + +inline static VALUE +nurat_int_value(VALUE num) +{ + nurat_int_check(num); + if (!k_integer_p(num)) + num = f_to_i(num); + return num; +} + +inline static VALUE +nurat_s_canonicalize_internal(VALUE klass, VALUE num, VALUE den) +{ + VALUE gcd; + + switch (FIX2INT(f_cmp(den, ZERO))) { + case -1: + num = f_negate(num); + den = f_negate(den); + break; + case 0: + rb_raise_zerodiv(); + break; + } + + gcd = f_gcd(num, den); + num = f_idiv(num, gcd); + den = f_idiv(den, gcd); + +#ifdef CANON + if (f_one_p(den) && f_unify_p(klass)) + return num; +#endif + 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: + num = f_negate(num); + den = f_negate(den); + break; + case 0: + rb_raise_zerodiv(); + break; + } + +#ifdef CANON + if (f_one_p(den) && f_unify_p(klass)) + return num; +#endif + return nurat_s_new_internal(klass, num, den); +} + +static VALUE +nurat_s_new(int argc, VALUE *argv, VALUE klass) +{ + VALUE num, den; + + switch (rb_scan_args(argc, argv, "11", &num, &den)) { + case 1: + num = nurat_int_value(num); + den = ONE; + break; + default: + num = nurat_int_value(num); + den = nurat_int_value(den); + break; + } + + 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); +} + +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); +} + +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); +} + +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); +} + +static VALUE +nurat_f_rational(int argc, VALUE *argv, VALUE klass) +{ + return rb_funcall2(rb_cRational, id_convert, argc, argv); +} + +static VALUE +nurat_numerator(VALUE self) +{ + get_dat1(self); + return dat->num; +} + +static VALUE +nurat_denominator(VALUE self) +{ + get_dat1(self); + return dat->den; +} + +#ifndef NDEBUG +#define f_imul f_imul_orig +#endif + +inline static VALUE +f_imul(long a, long b) +{ + 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); + + 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 +#undef f_imul + +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; +} +#endif + +inline static VALUE +f_addsub(VALUE self, VALUE anum, VALUE aden, VALUE bnum, VALUE bden, int k) +{ + 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); + + 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); + + 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); + + 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); + + 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, '+'); + } + default: + return rb_num_coerce_bin(self, other, '+'); + } +} + +static VALUE +nurat_sub(VALUE self, VALUE other) +{ + 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, + adat->num, adat->den, + bdat->num, bdat->den, '-'); + } + default: + return rb_num_coerce_bin(self, other, '-'); + } +} + +inline static VALUE +f_muldiv(VALUE self, VALUE anum, VALUE aden, VALUE bnum, VALUE bden, int k) +{ + VALUE num, den; + + if (k == '/') { + VALUE t; + + if (f_negative_p(bnum)) { + anum = f_negate(anum); + bnum = f_negate(bnum); + } + 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); + + 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); +} + +static VALUE +nurat_mul(VALUE self, VALUE other) +{ + 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, + adat->num, adat->den, + bdat->num, bdat->den, '*'); + } + default: + return rb_num_coerce_bin(self, other, '*'); + } +} + +static VALUE +nurat_div(VALUE self, VALUE other) +{ + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + if (f_zero_p(other)) + rb_raise_zerodiv(); + { + get_dat1(self); + + return f_muldiv(self, + dat->num, dat->den, + other, ONE, '/'); + } + case T_FLOAT: + return rb_funcall(f_to_f(self), '/', 1, other); + case T_RATIONAL: + if (f_zero_p(other)) + rb_raise_zerodiv(); + { + get_dat2(self, other); + + return f_muldiv(self, + adat->num, adat->den, + bdat->num, bdat->den, '/'); + } + default: + return rb_num_coerce_bin(self, other, '/'); + } +} + +static VALUE +nurat_fdiv(VALUE self, VALUE other) +{ + return f_div(f_to_f(self), other); +} + +static VALUE +nurat_expt(VALUE self, VALUE other) +{ + if (k_exact_p(other) && f_zero_p(other)) + return f_rational_new_bang1(CLASS_OF(self), ONE); + + if (k_rational_p(other)) { + get_dat1(other); + + if (f_one_p(dat->den)) + other = dat->num; /* good? */ + } + + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + { + VALUE num, den; + + 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; + default: + num = ONE; + den = ONE; + break; + } + return f_rational_new2(CLASS_OF(self), num, den); + } + case T_FLOAT: + case T_RATIONAL: + return f_expt(f_to_f(self), other); + default: + return rb_num_coerce_bin(self, other, id_expt); + } +} + +static VALUE +nurat_cmp(VALUE self, VALUE other) +{ + 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); + 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: + return rb_num_coerce_bin(self, other, id_cmp); + } +} + +static VALUE +nurat_equal_p(VALUE self, VALUE other) +{ + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + { + get_dat1(self); + + if (f_zero_p(dat->num) && f_zero_p(other)) + return Qtrue; + + if (!FIXNUM_P(dat->den)) + return Qfalse; + if (FIX2LONG(dat->den) != 1) + return Qfalse; + if (f_equal_p(dat->num, other)) + return Qtrue; + return Qfalse; + } + case T_FLOAT: + return f_equal_p(f_to_f(self), other); + case T_RATIONAL: + { + get_dat2(self, other); + + if (f_zero_p(adat->num) && f_zero_p(bdat->num)) + return Qtrue; + + return f_boolcast(f_equal_p(adat->num, bdat->num) && + f_equal_p(adat->den, bdat->den)); + } + 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)); + } + + 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)); +} + +static VALUE +nurat_mod(VALUE self, VALUE other) +{ + 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))); +} + +#if 0 +static VALUE +nurat_quot(VALUE self, VALUE 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)); +} + +#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))); +} +#endif + +static VALUE +nurat_abs(VALUE self) +{ + if (f_positive_p(self)) + return self; + return f_negate(self); +} + +#if 0 +static VALUE +nurat_true(VALUE self) +{ + return Qtrue; +} +#endif + +static VALUE +nurat_floor(VALUE self) +{ + 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)); +} + +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); +} + +static VALUE +nurat_round(VALUE self) +{ + get_dat1(self); + + 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); + } +} + +#define f_size(x) rb_funcall(x, rb_intern("size"), 0) +#define f_rshift(x,y) rb_funcall(x, rb_intern(">>"), 1, y) + +inline static long +i_ilog2(VALUE x) +{ + long q, r, fx; + + assert(!f_lt_p(x, ONE)); + + q = (NUM2LONG(f_size(x)) - sizeof(long)) * 8 + 1; + + if (q > 0) + x = f_rshift(x, LONG2NUM(q)); + + fx = NUM2LONG(x); + + r = -1; + while (fx) { + fx >>= 1; + r += 1; + } + + return q + r; +} + +static long ml; + +static VALUE +nurat_to_f(VALUE self) +{ + VALUE num, den; + int minus = 0; + long nl, dl, ne, de; + int e; + double f; + + { + get_dat1(self); + + if (f_zero_p(dat->num)) + return rb_float_new(0.0); + + num = dat->num; + den = dat->den; + } + + if (f_negative_p(num)) { + num = f_negate(num); + minus = 1; + } + + nl = i_ilog2(num); + dl = i_ilog2(den); + + 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)); + } + + e = (int)(ne - de); + + if ((e > DBL_MAX_EXP) || (e < DBL_MIN_EXP)) { + rb_warning("%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); + + if (isinf(f) || isnan(f)) + rb_warning("%s out of Float range", rb_obj_classname(self)); + + return rb_float_new(f); +} + +static VALUE +nurat_to_r(VALUE self) +{ + return self; +} + +static VALUE +nurat_hash(VALUE self) +{ + get_dat1(self); + return f_xor(f_hash(dat->num), f_hash(dat->den)); +} + +static VALUE +nurat_to_s(VALUE self) +{ + get_dat1(self); + 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("(%d/%d)"), dat->num, dat->den); +} + +static VALUE +nurat_marshal_dump(VALUE self) +{ + VALUE a; + get_dat1(self); + + a = rb_assoc_new(dat->num, dat->den); + rb_copy_generic_ivar(a, self); + return a; +} + +static VALUE +nurat_marshal_load(VALUE self, VALUE a) +{ + get_dat1(self); + dat->num = RARRAY_PTR(a)[0]; + dat->den = RARRAY_PTR(a)[1]; + rb_copy_generic_ivar(self, a); + + if (f_zero_p(dat->den)) + rb_raise_zerodiv(); + + return self; +} + +/* --- */ + +VALUE +rb_gcd(VALUE self, VALUE other) +{ + other = nurat_int_value(other); + return f_gcd(self, other); +} + +VALUE +rb_lcm(VALUE self, VALUE other) +{ + other = nurat_int_value(other); + return f_lcm(self, other); +} + +VALUE +rb_gcdlcm(VALUE self, VALUE other) +{ + other = nurat_int_value(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); +} + +VALUE +rb_rational_new(VALUE x, VALUE y) +{ + return nurat_s_canonicalize_internal(rb_cRational, x, y); +} + +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); +} + +static VALUE +nilclass_to_r(VALUE self) +{ + return rb_rational_new1(INT2FIX(0)); +} + +static VALUE +integer_to_r(VALUE self) +{ + return rb_rational_new1(self); +} + +static void +float_decode_internal(VALUE self, VALUE *rf, VALUE *rn) +{ + double f; + int n; + + f = frexp(RFLOAT_VALUE(self), &n); + f = ldexp(f, DBL_MANT_DIG); + n -= DBL_MANT_DIG; + *rf = rb_dbl2big(f); + *rn = INT2FIX(n); +} + +#if 0 +static VALUE +float_decode(VALUE self) +{ + VALUE f, n; + + float_decode_internal(self, &f, &n); + return rb_assoc_new(f, n); +} +#endif + +static VALUE +float_to_r(VALUE self) +{ + VALUE f, n; + + float_decode_internal(self, &f, &n); + return f_mul(f, f_expt(INT2FIX(FLT_RADIX), n)); +} + +static VALUE rat_pat, an_e_pat, a_dot_pat, underscores_pat, an_underscore; + +#define WS "\\s*" +#define DIGITS "(?:\\d(?:_\\d|\\d)*)" +#define NUMERATOR "(?:" DIGITS "?\\.)?" DIGITS "(?:[eE][-+]?" DIGITS ")?" +#define DENOMINATOR DIGITS +#define PATTERN "\\A" WS "([-+])?(" NUMERATOR ")(?:\\/(" DENOMINATOR "))?" WS + +static void +make_patterns(void) +{ + static const char rat_pat_source[] = PATTERN; + static const char an_e_pat_source[] = "[eE]"; + static const char a_dot_pat_source[] = "\\."; + static const char underscores_pat_source[] = "_+"; + + if (rat_pat) return; + + rat_pat = rb_reg_new(rat_pat_source, sizeof rat_pat_source - 1, 0); + rb_gc_register_mark_object(rat_pat); + + an_e_pat = rb_reg_new(an_e_pat_source, sizeof an_e_pat_source - 1, 0); + rb_gc_register_mark_object(an_e_pat); + + a_dot_pat = rb_reg_new(a_dot_pat_source, sizeof a_dot_pat_source - 1, 0); + rb_gc_register_mark_object(a_dot_pat); + + underscores_pat = rb_reg_new(underscores_pat_source, + sizeof underscores_pat_source - 1, 0); + rb_gc_register_mark_object(underscores_pat); + + an_underscore = rb_str_new2("_"); + rb_gc_register_mark_object(an_underscore); +} + +#define id_match rb_intern("match") +#define f_match(x,y) rb_funcall(x, id_match, 1, y) + +#define id_aref rb_intern("[]") +#define f_aref(x,y) rb_funcall(x, id_aref, 1, y) + +#define id_post_match rb_intern("post_match") +#define f_post_match(x) rb_funcall(x, id_post_match, 0) + +#define id_split rb_intern("split") +#define f_split(x,y) rb_funcall(x, id_split, 1, y) + +#include <ctype.h> + +static VALUE +string_to_r_internal(VALUE self) +{ + VALUE s, m; + + s = self; + + 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 (rb_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(si) && *StringValuePtr(si) == '-') + v = f_negate(v); + if (!NIL_P(exp)) + v = f_mul(v, f_expt(INT2FIX(10), f_to_i(exp))); +#if 0 + if (!NIL_P(de) && (!NIL_P(fp) || !NIL_P(exp))) + return rb_assoc_new(v, rb_str_new2("dummy")); +#endif + 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]; +} + +#define id_gsub rb_intern("gsub") +#define f_gsub(x,y,z) rb_funcall(x, id_gsub, 2, y, z) + +static VALUE +string_to_r(VALUE self) +{ + VALUE s, a, backref; + + backref = rb_backref_get(); + rb_match_busy(backref); + + s = f_gsub(self, underscores_pat, an_underscore); + a = string_to_r_internal(s); + + rb_backref_set(backref); + + 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") +#define f_to_r(x) rb_funcall(x, id_to_r, 0) + +static VALUE +nurat_s_convert(int argc, VALUE *argv, VALUE klass) +{ + VALUE a1, a2, backref; + + rb_scan_args(argc, argv, "11", &a1, &a2); + + switch (TYPE(a1)) { + case T_COMPLEX: + if (k_exact_p(RCOMPLEX(a1)->imag) && f_zero_p(RCOMPLEX(a1)->imag)) + a1 = RCOMPLEX(a1)->real; + } + + switch (TYPE(a2)) { + case T_COMPLEX: + if (k_exact_p(RCOMPLEX(a2)->imag) && f_zero_p(RCOMPLEX(a2)->imag)) + a2 = RCOMPLEX(a2)->real; + } + + backref = rb_backref_get(); + rb_match_busy(backref); + + 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; + } + + rb_backref_set(backref); + + switch (TYPE(a1)) { + case T_RATIONAL: + if (argc == 1 || (k_exact_p(a2) && f_one_p(a2))) + return a1; + } + + if (argc == 1) { + if (k_numeric_p(a1) && !f_integer_p(a1)) + return a1; + } + else { + if ((k_numeric_p(a1) && k_numeric_p(a2)) && + (!f_integer_p(a1) || !f_integer_p(a2))) + return f_div(a1, a2); + } + + { + VALUE argv2[2]; + argv2[0] = a1; + argv2[1] = a2; + return nurat_s_new(argc, argv2, klass); + } +} + +#ifndef EXT_MATHN +void +Init_Rational(void) +#else +void +Init_rational(void) +#endif +{ +#undef rb_intern +#define rb_intern(str) rb_intern_const(str) + + assert(fprintf(stderr, "assert() is now active\n")); + + id_abs = rb_intern("abs"); + id_cmp = rb_intern("<=>"); + 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_hash = rb_intern("hash"); + id_idiv = rb_intern("div"); + id_inspect = rb_intern("inspect"); + id_integer_p = rb_intern("integer?"); + id_negate = rb_intern("-@"); + 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"); + + ml = (long)(log(DBL_MAX) / log(2.0) - 1); + + rb_cRational = rb_define_class(RATIONAL_NAME, rb_cNumeric); + + rb_define_alloc_func(rb_cRational, nurat_s_alloc); + rb_undef_method(CLASS_OF(rb_cRational), "allocate"); + +#if 0 + rb_define_private_method(CLASS_OF(rb_cRational), "new!", nurat_s_new_bang, -1); + rb_define_private_method(CLASS_OF(rb_cRational), "new", nurat_s_new, -1); +#else + rb_undef_method(CLASS_OF(rb_cRational), "new"); +#endif + + 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, "+", 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, "quo", 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, "div", nurat_idiv, 1); +#if NUBY + 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); + +#if 0 + rb_define_method(rb_cRational, "quot", nurat_quot, 1); +#endif + rb_define_method(rb_cRational, "remainder", nurat_rem, 1); +#if 0 + rb_define_method(rb_cRational, "quotrem", nurat_quotrem, 1); +#endif + + 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); +#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, "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, "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_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); + + make_patterns(); + + rb_define_method(rb_cString, "to_r", string_to_r, 0); + + rb_define_private_method(CLASS_OF(rb_cRational), "convert", nurat_s_convert, -1); +} + +/* +Local variables: +c-file-style: "ruby" +End: +*/ -- ML: ruby-changes@q... Info: http://www.atdot.net/~ko1/quickml/