**(p1) public

No documentation

This method has no description. You can help the Ruby community by adding new notes.

Hide source
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;


        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])) {

                    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);
Register or log in to add new notes.