private static Expression BigIntegerConstant(BigInteger value) {
int ival;
if (value.AsInt32(out ival)) {
return Expression.Call(
typeof(BigInteger).GetMethod("Create", new Type[] { typeof(int) }),
Expression.Constant(ival)
);
}
long lval;
if (value.AsInt64(out lval)) {
return Expression.Call(
typeof(BigInteger).GetMethod("Create", new Type[] { typeof(long) }),
Expression.Constant(lval)
);
}
return Expression.New(
typeof(BigInteger).GetConstructor(new Type[] { typeof(int), typeof(uint[]) }),
Expression.Constant((int)value.Sign),
CreateUIntArray(value.GetBits())
);
}
internal static Int64 ToInt64(BigInteger value) {
Int64 result;
if (value.AsInt64(out result)) {
return result;
}
throw RubyExceptions.CreateRangeError("number too big to convert into System::Int64");
}
public static bool AsInt64(BigInteger self, out long res) {
return self.AsInt64(out res);
}
public static int __hash__(BigInteger self) {
#if CLR4 // TODO: we might need our own hash code implementation. This avoids assertion failure.
if (self == -2147483648) {
return -2147483648;
}
#endif
// check if it's in the Int64 or UInt64 range, and use the built-in hashcode for that instead
// this ensures that objects added to dictionaries as (U)Int64 can be looked up with Python longs
Int64 i64;
if (self.AsInt64(out i64)) {
return Int64Ops.__hash__(i64);
} else {
UInt64 u64;
if (self.AsUInt64(out u64)) {
return UInt64Ops.__hash__(u64);
}
}
// Call the DLR's BigInteger hash function, which will return an int32 representation of
// b if b is within the int32 range. We use that as an optimization for hashing, and
// assert the assumption below.
int hash = self.GetHashCode();
#if DEBUG
int i;
if (self.AsInt32(out i)) {
Debug.Assert(i == hash, String.Format("hash({0}) == {1}", i, hash));
}
#endif
return hash;
}
