Comparison of C and Java versions of complex_pow_for_special_angle from CRuby

complex_pow_for_special_angle.c

static VALUE
complex_pow_for_special_angle(VALUE self, VALUE other)
{
    if (!rb_integer_type_p(other)) {
        return Qundef;
    }

    get_dat1(self);
    VALUE x = Qundef;
    int dir;
    if (f_zero_p(dat->imag)) {
        x = dat->real;
        dir = 0;
    }
    else if (f_zero_p(dat->real)) {
        x = dat->imag;
        dir = 2;
    }
    else if (f_eqeq_p(dat->real, dat->imag)) {
        x = dat->real;
        dir = 1;
    }
    else if (f_eqeq_p(dat->real, f_negate(dat->imag))) {
        x = dat->imag;
        dir = 3;
    } else {
        dir = 0;
    }

    if (UNDEF_P(x)) return x;

    if (f_negative_p(x)) {
        x = f_negate(x);
        dir += 4;
    }

    VALUE zx;
    if (dir % 2 == 0) {
        zx = rb_num_pow(x, other);
    }
    else {
        zx = rb_num_pow(
            rb_funcall(rb_int_mul(TWO, x), '*', 1, x),
            rb_int_div(other, TWO)
        );
        if (rb_int_odd_p(other)) {
            zx = rb_funcall(zx, '*', 1, x);
        }
    }
    static const int dirs[][2] = {
        {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}
    };
    int z_dir = FIX2INT(rb_int_modulo(rb_int_mul(INT2FIX(dir), other), INT2FIX(8)));

    VALUE zr = Qfalse, zi = Qfalse;
    switch (dirs[z_dir][0]) {
      case 0: zr = zero_for(zx); break;
      case 1: zr = zx; break;
      case -1: zr = f_negate(zx); break;
    }
    switch (dirs[z_dir][1]) {
      case 0: zi = zero_for(zx); break;
      case 1: zi = zx; break;
      case -1: zi = f_negate(zx); break;
    }
    return nucomp_s_new_internal(CLASS_OF(self), zr, zi);
}

complexPowForSpecialAngle.java

private IRubyObject complexPowForSpecialAngle(ThreadContext context, IRubyObject other) {
    if (!(other instanceof RubyInteger integer)) {
        return UNDEF;
    }

    IRubyObject x = UNDEF;
    int dir;
    if (f_zero_p(context, image)) {
        x = real;
        dir = 0;
    }
    else if (f_zero_p(context, real)) {
        x = image;
        dir = 2;
    }
    else if (Numeric.f_eqeq_p(context, real, image)) {
        x = real;
        dir = 1;
    }
    else if (Numeric.f_eqeq_p(context, real, Numeric.f_negate(context, image))) {
        x = image;
        dir = 3;
    } else {
        dir = 0;
    }

    if (x == UNDEF) return x;

    if (f_negative_p(context, x)) {
        x = f_negate(context, x);
        dir += 4;
    }

    IRubyObject zx;
    if (dir % 2 == 0) {
        zx = num_pow(context, x, other);
    }
    else {
        RubyFixnum two = RubyFixnum.two(context.runtime);
        zx = num_pow(context,
                sites(context).op_times.call(context, two.op_mul(context, x), x),
                integer.div(context, two)
        );
        if (f_odd_p(context, other)) {
            zx = sites(context).op_times.call(context, zx, x);
        }
    }
    int dirs[][] = {
        {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}
    };
    int z_dir = fix2int(asFixnum(context, dir).modulo(context, 8));

    IRubyObject zr = context.fals, zi = context.fals;
    switch (dirs[z_dir][0]) {
        case 0: zr = zero_for(context, zx); break;
        case 1: zr = zx; break;
        case -1: zr = f_negate(context, zx); break;
    }
    switch (dirs[z_dir][1]) {
        case 0: zi = zero_for(context, zx); break;
        case 1: zi = zx; break;
        case -1: zi = f_negate(context, zx); break;
    }
    return newComplex(context, metaClass, zr, zi);
}