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; }