private static final int BIT_SIZE = 64;

private static final long MAX = (1L << (BIT_SIZE - 1)) - 1;

public static final BigInteger LONG_MAX = BigInteger.valueOf(MAX);

public static final BigInteger LONG_MAX_PLUS_ONE = LONG_MAX.add(BigInteger.ONE);

public static final BigInteger LONG_MIN = BigInteger.valueOf(-MAX - 1);

public static final BigInteger LONG_MIN_MINUS_ONE = LONG_MIN.subtract(BigInteger.ONE);

public static final BigInteger INTEGER_MAX = BigInteger.valueOf(Integer.MAX_VALUE);

public static final BigInteger INTEGER_MIN = BigInteger.valueOf(Integer.MIN_VALUE);

public static final BigInteger ULONG_MAX = BigInteger.valueOf(1).shiftLeft(BIT_SIZE).subtract(BigInteger.valueOf(1));

final BigInteger value;

public RubyBignum(Ruby runtime, BigInteger value) {

super(runtime, runtime.getInteger());

this.value = value;

setFrozen(true);

}

@Override

public ClassIndex getNativeClassIndex() {

return ClassIndex.BIGNUM;

}

@Override

public Class<?> getJavaClass() {

return BigInteger.class;

}

public static RubyBignum newBignum(Ruby runtime, long value) {

return newBignum(runtime, BigInteger.valueOf(value));

}

/**

public static RubyBignum newBignum(Ruby runtime, double value) {

try {

return newBignum(runtime, toBigInteger(value));

} catch (NumberFormatException nfe) {

throw runtime.newFloatDomainError(Double.toString(value));

}

}

public static BigInteger toBigInteger(double value) {

return new BigDecimal(value).toBigInteger();

}

/**

public static RubyInteger newBignorm(Ruby runtime, double value) {

try {

return bignorm(runtime, toBigInteger(value));

} catch (NumberFormatException nfe) {

throw runtime.newFloatDomainError(Double.toString(value));

}

}

public static RubyBignum newBignum(Ruby runtime, BigInteger value) {

return new RubyBignum(runtime, value);

}

public static RubyBignum newBignum(Ruby runtime, String value) {

return new RubyBignum(runtime, new BigInteger(value));

}

@Override

@JRubyAPI

public BigInteger asBigInteger(ThreadContext context) {

return value;

}

@Override

@JRubyAPI

public double asDouble(ThreadContext context) {

return big2dbl(this);

}

@Override

@JRubyAPI

public int asInt(ThreadContext context) {

return getValue().intValue();

}

@Override

@JRubyAPI

public long asLong(ThreadContext context) {

return value.longValue();

}

@Override

public RubyClass singletonClass(ThreadContext context) {

throw typeError(context, "can't define singleton");

}

/** Getter for property value.

public BigInteger getValue() {

return value;

}

@Override

@JRubyAPI

public int signum(ThreadContext context) { return value.signum(); }

@Override

public RubyInteger negate(ThreadContext context) {

return bignorm(context.runtime, value.negate());

}

/* ================

/* If the value will fit in a Fixnum, return one of those. */

/** rb_big_norm

public static RubyInteger bignorm(Ruby runtime, BigInteger bi) {

return (bi.compareTo(LONG_MIN) < 0 || bi.compareTo(LONG_MAX) > 0) ?

newBignum(runtime, bi) : runtime.newFixnum(bi.longValue());

}

/** rb_big2long

public static long big2long(RubyBignum val) {

BigInteger big = val.value;

if (big.compareTo(LONG_MIN) < 0 || big.compareTo(LONG_MAX) > 0) {

throw val.getRuntime().newRangeError("bignum too big to convert into 'long'");

}

return big.longValue();

}

/** rb_big2ulong

public static long big2ulong(RubyBignum value) {

Ruby runtime = value.getRuntime();

BigInteger big = value.getValue();

return big2ulong(runtime, big);

}

public static long big2ulong(Ruby runtime, BigInteger big) {

if (big.compareTo(BigInteger.ZERO) < 0 || big.compareTo(ULONG_MAX) > 0) {

throw runtime.newRangeError("bignum out of range of unsigned long");

}

return big.longValue();

}

/** rb_big2dbl

public static double big2dbl(RubyBignum val) {

BigInteger big = val.value;

double dbl = convertToDouble(big);

if (dbl == Double.NEGATIVE_INFINITY || dbl == Double.POSITIVE_INFINITY) {

warning(val.getRuntime().getCurrentContext(), "Integer out of Float range");

}

return dbl;

}

private RubyFixnum checkShiftDown(ThreadContext context, RubyBignum other) {

if (other.value.signum() == 0) return zero(context.runtime);

if (value.compareTo(LONG_MIN) < 0 || value.compareTo(LONG_MAX) > 0) {

return other.value.signum() >= 0 ? zero(context.runtime) : RubyFixnum.minus_one(context.runtime);

}

return null;

}

/**

static double convertToDouble(BigInteger bigint) {

long signum = (bigint.signum() == -1) ? 1l << 63 : 0;

bigint = bigint.abs();

int len = bigint.bitLength();

if (len == 0) return 0d;

long exp = len + 1022; // 1023 (bias) - 1 (sign)

long frac = 0;

if (exp > 0x7ff) exp = 0x7ff; // inf, frac = 0;

else {

// Deep breath...

// Shift bigint to get 52 significant bits, adjusting for sign bit

// (-52 -1), but * 2, add 1, then / 2 to round correctly

frac = ((bigint.shiftRight(len - 54).longValue() + 1l) >> 1);

if (frac == 0x20000000000000l) { // corner case: rounding overflowed

exp += 1l;

if (exp > 0x7ff) exp = 0x7ff;

}

}

return Double.longBitsToDouble(signum | (exp << 52) | frac & 0xfffffffffffffl);

}

/** rb_int2big

public static BigInteger fix2big(RubyFixnum arg) {

return long2big(arg.getValue());

}

public static BigInteger long2big(long arg) {

return BigInteger.valueOf(arg);

}

/* ================

/** rb_big_ceil

@Override

public IRubyObject ceil(ThreadContext context, IRubyObject arg){

RubyInteger num = this;

long ndigits = toLong(context, arg);

if (ndigits >= 0) return num;

RubyInteger f = (RubyInteger) int_pow(context, 10, -ndigits);

return integerCeil(context, f);

}

/** rb_big_floor

@Override

public IRubyObject floor(ThreadContext context, IRubyObject arg){

long ndigits = toLong(context, arg);

if (ndigits >= 0) return this;

RubyInteger f = (RubyInteger) int_pow(context, 10, -ndigits);

return integerFloor(context, f);

}

/** rb_big_truncate

@Override

public IRubyObject truncate(ThreadContext context, IRubyObject arg){

BigInteger self = value;

if (self.compareTo(BigInteger.ZERO) == 1){

return floor(context, arg);

} else if (self.compareTo(BigInteger.ZERO) == -1){

return ceil(context, arg);

} else {

return this;

}

}

/** rb_big_digits

@Override

public RubyArray digits(ThreadContext context, IRubyObject baseArg) {

BigInteger self = value;

if (self.compareTo(BigInteger.ZERO) == -1) throw context.runtime.newMathDomainError("out of domain");

RubyInteger base = Convert.toInteger(context, baseArg);

BigInteger bigBase = base instanceof RubyBignum bignum ? bignum.value : long2big(base.asLong(context));

if (bigBase.signum() == -1) throw argumentError(context, "negative radix");

if (bigBase.compareTo(BigInteger.valueOf(2)) == -1) throw argumentError(context, "invalid radix: " + bigBase);

if (self.signum() == 0) return newArray(context, asFixnum(context, 0));

if (self.signum() <= 0) return newEmptyArray(context);

// Bignum only kicks in > 0xFFFFFFFFFFFFFFFF so pick 16 digits for highest typical base 16

RubyArray res = Create.allocArray(context, 16);

do {

BigInteger q = self.mod(bigBase);

res.append(context, RubyBignum.newBignum(context.runtime, q));

self = self.divide(bigBase);

} while (self.signum() > 0);

return res;

}

/** rb_big_to_s

@Deprecated(since = "10.0.0.0")

public IRubyObject to_s(IRubyObject[] args) {

var context = getRuntime().getCurrentContext();

return switch (args.length) {

case 0 -> to_s(context);

case 1 -> to_s(context, args[0]);

default -> throw argumentError(context, args.length, 1);

};

}

@Override

public RubyString to_s(ThreadContext context) {

return RubyString.newUSASCIIString(context.runtime, value.toString(10));

}

@Override

public RubyString to_s(ThreadContext context, IRubyObject arg0) {

int base = toInt(context, arg0);

if (base < 2 || base > 36) throw argumentError(context, "illegal radix " + base);

return RubyString.newUSASCIIString(context.runtime, value.toString(base));

}

// MRI: rb_big_coerce

public IRubyObject coerce(ThreadContext context, IRubyObject other) {

if (other instanceof RubyFixnum fix) return newArray(context, newBignum(context.runtime, fix.getValue()), this);

if (other instanceof RubyBignum big) return newArray(context, newBignum(context.runtime, big.value), this);

return newArray(context, RubyKernel.new_float(context, other), RubyKernel.new_float(context, this));

}

/** rb_big_uminus

@Override

public IRubyObject op_uminus(ThreadContext context) {

return bignorm(context.runtime, value.negate());

}

/** rb_big_plus

@Override

public IRubyObject op_plus(ThreadContext context, IRubyObject other) {

return switch (other) {

case RubyFixnum fix -> op_plus(context, fix.getValue());

case RubyBignum big -> op_plus(context, big.value);

case RubyFloat flote -> addFloat(context, flote);

default -> addOther(context, other);

};

}

@Override

public final IRubyObject op_plus(ThreadContext context, long other) {

BigInteger result = value.add(BigInteger.valueOf(other));

if (other > 0 && value.signum() > 0) return new RubyBignum(context.runtime, result);

return bignorm(context.runtime, result);

}

public final IRubyObject op_plus(ThreadContext context, BigInteger other) {

BigInteger result = value.add(other);

if (value.signum() > 0 && other.signum() > 0) return new RubyBignum(context.runtime, result);

return bignorm(context.runtime, result);

}

private IRubyObject addFloat(ThreadContext context, RubyFloat other) {

return asFloat(context, big2dbl(this) + other.value);

}

private IRubyObject addOther(ThreadContext context, IRubyObject other) {

return coerceBin(context, sites(context).op_plus, other);

}

/** rb_big_minus

@Override

public IRubyObject op_minus(ThreadContext context, IRubyObject other) {

return switch (other) {

case RubyFixnum fixnum -> op_minus(context, fixnum.getValue());

case RubyBignum bignum -> op_minus(context, bignum.value);

case RubyFloat flote -> subtractFloat(flote);

default -> subtractOther(context, other);

};

}

@Override

public final IRubyObject op_minus(ThreadContext context, long other) {

BigInteger result = value.subtract(BigInteger.valueOf(other));

if (value.signum() < 0 && other > 0) return new RubyBignum(context.runtime, result);

return bignorm(context.runtime, result);

}

public final IRubyObject op_minus(ThreadContext context, BigInteger other) {

BigInteger result = value.subtract(other);

if (value.signum() < 0 && other.signum() > 0) return new RubyBignum(context.runtime, result);

return bignorm(context.runtime, result);

}

private IRubyObject subtractFloat(RubyFloat other) {

return RubyFloat.newFloat(getRuntime(), big2dbl(this) - other.value);

}

private IRubyObject subtractOther(ThreadContext context, IRubyObject other) {

return coerceBin(context, sites(context).op_minus, other);

}

/** rb_big_mul

@JRubyMethod(name = "*")

public IRubyObject op_mul(ThreadContext context, IRubyObject other) {

if (other instanceof RubyFixnum) {

return op_mul(context, ((RubyFixnum) other).getValue());

} else if (other instanceof RubyBignum) {

} else if (other instanceof RubyFloat) {

return RubyFloat.newFloat(context.runtime, big2dbl(this) * ((RubyFloat) other).value);

} else {

return coerceBin(context, sites(context).op_times, other);

}

return bignorm(context.runtime, value.multiply(((RubyBignum) other).value));

}

@Override

public final IRubyObject op_mul(ThreadContext context, long other) {

return bignorm(context.runtime, value.multiply(long2big(other)));

}

/**

private IRubyObject op_divide(ThreadContext context, IRubyObject other, boolean slash) {

final BigInteger otherValue;

if (other instanceof RubyFixnum fixnum) {

otherValue = fix2big(fixnum);

} else if (other instanceof RubyBignum bignum) {

otherValue = bignum.getValue();

} else if (other instanceof RubyFloat flote) {

double otherFloatValue = flote.getValue();

if (!slash) {

if (otherFloatValue == 0.0) throw zeroDivisionError(context);

}

double div = big2dbl(this) / otherFloatValue;

return slash ?

asFloat(context, div) :

asInteger(context, div);

} else {

return coerceBin(context, slash ? sites(context).op_quo : sites(context).div, other);

}

return divideImpl(context, otherValue);

}

private RubyInteger divideImpl(ThreadContext context, BigInteger otherValue) {

if (otherValue.signum() == 0) throw zeroDivisionError(context);

final BigInteger result;

if (value.signum() * otherValue.signum() == -1) {

BigInteger[] results = value.divideAndRemainder(otherValue);

result = results[1].signum() != 0 ? results[0].subtract(BigInteger.ONE) : results[0];

} else {

result = value.divide(otherValue);

}

return bignorm(context.runtime, result);

}

/** rb_big_div

@Override

public IRubyObject op_div(ThreadContext context, IRubyObject other) {

return op_divide(context, other, true);

}

public IRubyObject op_div(ThreadContext context, long other) {

return divideImpl(context, long2big(other));

}

/** rb_big_idiv

@Override

public IRubyObject idiv(ThreadContext context, IRubyObject other) {

return op_divide(context, other, false);

}

@Override

public IRubyObject idiv(ThreadContext context, long other) {

return divideImpl(context, long2big(other));

}

/** rb_big_divmod

@Override

@JRubyMethod(name = "divmod")

public IRubyObject divmod(ThreadContext context, IRubyObject other) {

final BigInteger otherValue;

if (other instanceof RubyFixnum fix) {

otherValue = fix2big(fix);

} else if (other instanceof RubyBignum big) {

otherValue = big.value;

} else {

if (other instanceof RubyFloat flote && flote.value == 0) throw context.runtime.newZeroDivisionError();

return coerceBin(context, sites(context).divmod, other);

}

if (otherValue.signum() == 0) throw context.runtime.newZeroDivisionError();

BigInteger[] results = value.divideAndRemainder(otherValue);

if ((value.signum() * otherValue.signum()) == -1 && results[1].signum() != 0) {

results[0] = results[0].subtract(BigInteger.ONE);

results[1] = otherValue.add(results[1]);

}

return newArray(context, bignorm(context.runtime, results[0]), bignorm(context.runtime, results[1]));

}

/** rb_big_modulo

@JRubyMethod(name = {"%", "modulo"})

public IRubyObject op_mod(ThreadContext context, IRubyObject other) {

if (other instanceof RubyFixnum) {

return op_mod(context, ((RubyFixnum) other).getValue());

}

final BigInteger otherValue;

if (other instanceof RubyBignum) {

otherValue = ((RubyBignum) other).value;

if (otherValue.signum() == 0) throw context.runtime.newZeroDivisionError();

BigInteger result = value.mod(otherValue.abs());

if (otherValue.signum() == -1 && result.signum() != 0) result = otherValue.add(result);

return bignorm(context.runtime, result);

}

if (other instanceof RubyFloat && ((RubyFloat) other).value == 0) {

throw context.runtime.newZeroDivisionError();

}

return coerceBin(context, sites(context).op_mod, other);

}

@Override

public IRubyObject op_mod(ThreadContext context, long other) {

if (other == 0) throw context.runtime.newZeroDivisionError();

BigInteger result = value.mod(long2big(other < 0 ? -other : other));

if (other < 0 && result.signum() != 0) result = long2big(other).add(result);

return bignorm(context.runtime, result);

}

@Override

public IRubyObject modulo(ThreadContext context, IRubyObject other) {

return op_mod(context, other);

}

@Override

IRubyObject modulo(ThreadContext context, long other) {

return op_mod(context, other);

}

/** rb_big_remainder

@Override

@JRubyMethod(name = "remainder")

public IRubyObject remainder(ThreadContext context, IRubyObject other) {

if (other instanceof RubyFloat && ((RubyFloat) other).value == 0) {

throw context.runtime.newZeroDivisionError();

}

final BigInteger otherValue;

if (other instanceof RubyFixnum) {

otherValue = fix2big(((RubyFixnum) other));

} else if (other instanceof RubyBignum) {

otherValue = ((RubyBignum) other).value;

} else {

if (other instanceof RubyFloat && ((RubyFloat) other).value == 0) {

throw context.runtime.newZeroDivisionError();

}

return coerceBin(context, sites(context).remainder, other);

}

if (otherValue.signum() == 0) throw context.runtime.newZeroDivisionError();

return bignorm(context.runtime, value.remainder(otherValue));

}

/**

@Deprecated(since = "10.0.0.0")

public IRubyObject quo(ThreadContext context, IRubyObject otherArg) {

return super.quo(context, otherArg);

}

/** rb_big_pow

@Override

@JRubyMethod(name = {"**", "power"})

public IRubyObject op_pow(ThreadContext context, IRubyObject other) {

if (other == asFixnum(context, 0)) return asFixnum(context, 1);

final double d;

if (other instanceof RubyFloat flote) {

d = flote.value;

if (compareTo(asFixnum(context, 0)) == -1 && d != Math.round(d)) {

RubyComplex complex = RubyComplex.newComplexRaw(context.runtime, this);

return sites(context).op_exp.call(context, complex, complex, other);

}

} else if (other instanceof RubyBignum) {

throw argumentError(context, "exponent is too large");

} else if (other instanceof RubyFixnum fixnum) {

return op_pow(context, fixnum.getValue());

} else {

return coerceBin(context, sites(context).op_exp, other);

}

return pow(context, d);

}

private RubyNumeric pow(ThreadContext context, final double d) {

double pow = Math.pow(big2dbl(this), d);

return Double.isInfinite(pow) ?

asFloat(context, pow) : asInteger(context, pow);

}

// adjusted for JDK BigInteger limits

private static final long BIGLEN_LIMIT = 1L << 31;

public final IRubyObject op_pow(final ThreadContext context, final long other) {

if (other < 0) {

IRubyObject x = op_pow(context, -other);

if (x instanceof RubyInteger) {

return RubyRational.newRationalRaw(context.runtime, asFixnum(context, 1), x);

} else {

return asFloat(context, 1.0 / toDouble(context, x));

}

}

// number of words, not number of bits

final int xbits = value.bitLength() / 8;

if (xbits * other > BIGLEN_LIMIT) {

throw argumentError(context, "exponent is too large");

} else {

return newBignum(context.runtime, value.pow((int) other));

}

}

/** rb_big_and

@Override

public IRubyObject op_and(ThreadContext context, IRubyObject other) {

if (other instanceof RubyBignum) {

return bignorm(context.runtime, value.and(((RubyBignum) other).value));

}

if (other instanceof RubyFixnum) {

return op_and(context, (RubyFixnum) other);

}

return coerceBit(context, sites(context).checked_op_and, other);

}

final RubyInteger op_and(ThreadContext context, RubyFixnum other) {

return bignorm(context.runtime, value.and(fix2big(other)));

}

/** rb_big_or

@Override

public IRubyObject op_or(ThreadContext context, IRubyObject other) {

if (other instanceof RubyBignum) {

return bignorm(context.runtime, value.or(((RubyBignum) other).value));

}

if (other instanceof RubyFixnum) { // no bignorm here needed

return op_or(context, (RubyFixnum) other);

}

return coerceBit(context, sites(context).checked_op_or, other);

}

final RubyInteger op_or(ThreadContext context, RubyFixnum other) {

return bignorm(context.runtime, value.or(fix2big(other))); // no bignorm here needed

}

@Override

public IRubyObject bit_length(ThreadContext context) {

return asFixnum(context, value.bitLength());

}

/** rb_big_xor

@Override

public IRubyObject op_xor(ThreadContext context, IRubyObject other) {

if (other instanceof RubyBignum) {

return bignorm(context.runtime, value.xor(((RubyBignum) other).value));

}

if (other instanceof RubyFixnum) {

return bignorm(context.runtime, value.xor(BigInteger.valueOf(((RubyFixnum) other).getValue())));

}

return coerceBit(context, sites(context).checked_op_xor, other);

}

/** rb_big_neg

@Override

public IRubyObject op_neg(ThreadContext context) {

return RubyBignum.newBignum(context.runtime, value.not());

}

/** rb_big_lshift

@Override

public IRubyObject op_lshift(ThreadContext context, IRubyObject other) {

long shift;

for (;;) {

if (other instanceof RubyFixnum fixnum) {

shift = fixnum.getValue();

if (shift < 0) {

if (value.bitLength() <= -shift ) {

return value.signum() >= 0 ?

asFixnum(context, 0) :

RubyFixnum.minus_one(context.runtime);

}

}

break;

} else if (other instanceof RubyBignum otherBignum) {

if (value.signum() == 0) return asFixnum(context, 0);

if (otherBignum.value.signum() < 0) {

IRubyObject tmp = otherBignum.checkShiftDown(context, this);

if (tmp != null) return tmp;

}

if (otherBignum.value.compareTo(INTEGER_MAX) > 0) {

throw rangeError(context, "shift width too big");

}

shift = otherBignum.asLong(context);

break;

}

other = Convert.toInteger(context, other);

}

return op_lshift(context, shift);

}

@Override

public RubyInteger op_lshift(ThreadContext context, long shift) {

if (value.signum() == 0) {

return zero(context.runtime);

}

if (shift > Integer.MAX_VALUE) {

throw rangeError(context, "shift width too big");

}

return bignorm(context.runtime, value.shiftLeft((int) shift));

}

/** rb_big_rshift

@Override

public IRubyObject op_rshift(ThreadContext context, IRubyObject other) {

long shift;

for (;;) {

if (other instanceof RubyFixnum fixnum) {

shift = fixnum.getValue();

if (value.bitLength() <= shift) {

return value.signum() >= 0 ?

asFixnum(context, 0) :

RubyFixnum.minus_one(context.runtime);

}

break;

} else if (other instanceof RubyBignum otherBignum) {

if (value == BigInteger.ZERO) return asFixnum(context, 0);

if (otherBignum.value.signum() >= 0) {

IRubyObject tmp = otherBignum.checkShiftDown(context, this);

if (tmp != null) return tmp;

}

if (otherBignum.value.compareTo(INTEGER_MIN) < 0) {

throw rangeError(context, "shift width too big");

}

shift = otherBignum.asLong(context);

break;

}

other = Convert.toInteger(context, other);

}

return op_rshift(context, shift);

}

@Override

public RubyInteger op_rshift(ThreadContext context, long shift) {

if (value.signum() == 0) {

return zero(context.runtime);

}

if (shift < Integer.MIN_VALUE) {

throw rangeError(context, "shift width too big");

}

return bignorm(context.runtime, value.shiftRight((int) shift));

}

@Override

public RubyBoolean odd_p(ThreadContext context) {

return value.testBit(0) ? context.tru : context.fals;

}

@Override

public RubyBoolean even_p(ThreadContext context) {

return value.testBit(0) ? context.fals : context.tru;

}

/** rb_big_aref

@Override

protected IRubyObject op_aref_subclass(ThreadContext context, IRubyObject other) {

if (other instanceof RubyBignum bignum) { // Need to normalize first

other = bignorm(context.runtime, bignum.value);

if (other instanceof RubyBignum bignum2) { // '!=' for negative value

return asFixnum(context, (bignum2.value.signum() >= 0) != (value.signum() == -1) ? 0 : 1);

}

}

long position = toLong(context, other);

if (position < 0 || position > Integer.MAX_VALUE) return asFixnum(context, 0);

return asFixnum(context, value.testBit((int)position) ? 1: 0);

}

// MRI: rb_big_aref2

@Override

public IRubyObject op_aref(ThreadContext context, IRubyObject index, IRubyObject length) {

long shift = index.convertToInteger().asLong(context);

if (shift >= Integer.MAX_VALUE) {

throw rangeError(context, "offset too big");

}

if (shift <= Integer.MIN_VALUE) {

return RubyFixnum.zero(context.runtime);

}

BigInteger shifted = value.shiftRight((int) shift);

long bitLength = length.convertToInteger().asLong(context);

long len = bitLength;

if (value.signum() > 0) {

len = Math.min(bitLength, shifted.bitLength());

}

if (len >= Integer.MAX_VALUE) {

throw rangeError(context, "length too big");

}

BigInteger mask = BigInteger.ONE.shiftLeft((int) bitLength).subtract(BigInteger.ONE);

BigInteger slice = shifted.and(mask);

return bignorm(context.runtime, slice);

}

private enum BIGNUM_OP_T {

BIGNUM_OP_GT,

BIGNUM_OP_GE,

BIGNUM_OP_LT,

BIGNUM_OP_LE

};

// mri : big_op

private IRubyObject big_op(ThreadContext context, IRubyObject other, BIGNUM_OP_T op) {

IRubyObject rel;

if (other instanceof RubyInteger) {

rel = op_cmp(context, other);

} else if (other instanceof RubyFloat) {

rel = float_cmp(context, (RubyFloat)other);

} else {

CallSite site = sites(context).op_gt;

switch (op) {

case BIGNUM_OP_GT:

site = sites(context).op_gt;

break;

case BIGNUM_OP_GE:

site = sites(context).op_ge;

break;

case BIGNUM_OP_LT:

site = sites(context).op_lt;

break;

case BIGNUM_OP_LE:

site = sites(context).op_le;

break;

}

return coerceRelOp(context, site, other);

}

if (rel.isNil()) return context.fals;

int n = toInt(context, rel);

IRubyObject ret = context.nil;

switch (op) {

case BIGNUM_OP_GT:

ret = n > 0 ? context.tru : context.fals;

break;

case BIGNUM_OP_GE:

ret = n >= 0 ? context.tru : context.fals;

break;

case BIGNUM_OP_LT:

ret = n < 0 ? context.tru : context.fals;

break;

case BIGNUM_OP_LE:

ret = n <= 0 ? context.tru : context.fals;

break;

}

return ret;

}

@Override

@JRubyMethod(name = ">")

public IRubyObject op_gt(ThreadContext context, IRubyObject other) {

return big_op(context, other, BIGNUM_OP_T.BIGNUM_OP_GT);

}

@Override

@JRubyMethod(name = "<")

public IRubyObject op_lt(ThreadContext context, IRubyObject other) {

return big_op(context, other, BIGNUM_OP_T.BIGNUM_OP_LT);

}

@Override

@JRubyMethod(name = ">=")