public static object Power([NotNull] BigInteger x, [NotNull] BigInteger y) { int yl; long y2; if (y.AsInt32(out yl)) { return(Power(x, yl)); } else if (y.AsInt64(out y2)) { return(Power(x, y2)); } else { if (x == BigInteger.Zero) { if (y.Sign < 0) { throw PythonOps.ZeroDivisionError("0.0 cannot be raised to a negative power"); } return(BigInteger.Zero); } else if (x == BigInteger.One) { return(BigInteger.One); } else { throw PythonOps.ValueError("Number too big"); } } }
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()) )); }
public static object ParseInteger(string text, int b) { //!!! From experiments, CPython-1.3 appears to highly optimize this pattern //!!! Unfortunately, this has a small impact on parrotbench scores if (b == 0 && text.StartsWith("0x")) { int shift = 0; int ret = 0; for (int i = text.Length - 1; i >= 2; i--) { ret |= HexValue(text[i]) << shift; shift += 4; } return(ret); } if (b == 0) { b = DetectRadix(ref text); } try { return(ParseInt(text, b)); } catch (OverflowException) { BigInteger ret = ParseBigInteger(text, b); int iret; if (ret.AsInt32(out iret)) { return(iret); } return(ret); } }
private static Expression BigIntegerConstant(BigInteger value) { int ival; if (value.AsInt32(out ival)) { return(Expression.Call( new Func <int, BigInteger>(BigInteger.Create).GetMethodInfo(), Constant(ival) )); } long lval; if (value.AsInt64(out lval)) { return(Expression.Call( new Func <long, BigInteger>(BigInteger.Create).GetMethodInfo(), Constant(lval) )); } #if !FEATURE_NUMERICS return(Expression.Call( new Func <int, uint[], BigInteger>(CompilerHelpers.CreateBigInteger).Method, Constant((int)value.Sign), CreateArray <uint>(value.GetWords()) )); #else return(Expression.Call( new Func <bool, byte[], BigInteger>(CompilerHelpers.CreateBigInteger).GetMethodInfo(), Constant(value.Sign < 0), CreateArray <byte>(value.Abs().ToByteArray()) )); }
private static Expression BigIntegerConstant(BigInteger value) { int ival; if (value.AsInt32(out ival)) { return(Expression.Call( new Func <int, BigInteger>(BigInteger.Create).GetMethodInfo(), Constant(ival) )); } long lval; if (value.AsInt64(out lval)) { return(Expression.Call( new Func <long, BigInteger>(BigInteger.Create).GetMethodInfo(), Constant(lval) )); } return(Expression.Call( new Func <bool, byte[], BigInteger>(CompilerHelpers.CreateBigInteger).GetMethodInfo(), Constant(value.Sign < 0), CreateArray <byte>(value.Abs().ToByteArray()) )); }
public static char ToChar(BigInteger self, IFormatProvider provider) { int res; if (self.AsInt32(out res) && res <= Char.MaxValue && res >= Char.MinValue) { return (char)res; } throw new OverflowException("big integer won't fit into char"); }
public static int Compare(BigInteger x, int y) { int ix; if (x.AsInt32(out ix)) { return ix == y ? 0 : ix > y ? 1 : -1; } return BigInteger.Compare(x, y); }
public static object __int__(BigInteger x) { // The python spec says __int__ should return a long if needed, rather than overflow. int i32; if (x.AsInt32(out i32)) { return Microsoft.Scripting.Runtime.ScriptingRuntimeHelpers.Int32ToObject(i32); } return x; }
public static BigInteger Random(this Random generator, BigInteger limit) { ContractUtils.Requires(limit.Sign > 0, "limit"); ContractUtils.RequiresNotNull(generator, "generator"); BigInteger res = BigInteger.Zero; while (true) { // if we've run out of significant digits, we can return the total if (limit == BigInteger.Zero) { return(res); } // if we're small enough to fit in an int, do so int iLimit; if (limit.AsInt32(out iLimit)) { return(res + generator.Next(iLimit)); } // get the 3 or 4 uppermost bytes that fit into an int int hiData; byte[] data = limit.ToByteArray(); int index = data.Length; while (data[--index] == 0) { ; } if (data[index] < 0x80) { hiData = data[index] << 24; data[index--] = (byte)0; } else { hiData = 0; } hiData |= data[index] << 16; data[index--] = (byte)0; hiData |= data[index] << 8; data[index--] = (byte)0; hiData |= data[index]; data[index--] = (byte)0; // get a uniform random number for the uppermost portion of the bigint byte[] randomData = new byte[index + 2]; generator.NextBytes(randomData); randomData[index + 1] = (byte)0; res += new BigInteger(randomData); res += (BigInteger)generator.Next(hiData) << ((index + 1) * 8); // sum it with a uniform random number for the remainder of the bigint limit = new BigInteger(data); } }
/// <summary> /// Converts a BigInteger to int if it is small enough /// </summary> /// <param name="x">The value to convert</param> /// <returns>An int if x is small enough, otherwise x.</returns> /// <remarks> /// Use this helper to downgrade BigIntegers as necessary. /// </remarks> public static object Normalize(BigInteger x) { int result; if (x.AsInt32(out result)) { return(ScriptingRuntimeHelpers.Int32ToObject(result)); } return(x); }
internal static byte ToByteChecked(this BigInteger item) { int val; if (item.AsInt32(out val)) { return(ToByteChecked(val)); } throw PythonOps.ValueError("byte must be in range(0, 256)"); }
public static int ConvertToInt32(BigInteger self) { int res; if (self.AsInt32(out res)) { return(res); } throw Converter.CannotConvertOverflow("int", self); }
public object this[CodeContext /*!*/ context, BigInteger index] { get { int iVal; if (index.AsInt32(out iVal)) { return(this[context, iVal]); } throw PythonOps.IndexError("cannot fit long in index"); } }
public static object EvalExpression(string code, Dictionary <string, object> localScope) { var scope = Prepare(localScope); try { ScriptSource source = scope.Engine.CreateScriptSourceFromString(code, SourceCodeKind.Expression); object obj = source.Execute(scope); if (obj != null && obj.GetType() == typeof(BigInteger)) { BigInteger bint = (BigInteger)obj; int i32; uint ui32; long i64; ulong ui64; if (bint.AsInt32(out i32)) { return(i32); } if (bint.AsInt64(out i64)) { return(i64); } if (bint.AsUInt32(out ui32)) { return(ui32); } if (bint.AsUInt64(out ui64)) { return(ui64); } } return(obj); } catch (Exception ex) { throw new PeachException("Error executing expression [" + code + "]: " + ex.ToString(), ex); } finally { var names = scope.GetVariableNames().ToList(); foreach (var name in names) { scope.RemoveVariable(name); } } }
public object this[BigInteger index] { get { int iVal; if (index.AsInt32(out iVal)) { return(this[iVal]); } throw PythonOps.IndexError("cannot fit long in index"); } set { int iVal; if (index.AsInt32(out iVal)) { this[iVal] = value; return; } throw PythonOps.IndexError("cannot fit long in index"); } }
public static object /*!*/ BitwiseOr(int self, [NotNull] BigInteger /*!*/ other) { BigInteger result = other | self; int ret; if (result.AsInt32(out ret)) { return(ret); } else { return(result); } }
public int ToInt32() { int result; if (IsFixnum) { result = _fixnum; } else if (!_bignum.AsInt32(out result)) { throw RubyExceptions.CreateRangeError("Bignum too big to convert into 32-bit signed integer"); } return(result); }
private static object rangeWorker(BigInteger stop) { if (stop < BigInteger.Zero) { return(Range(0)); } int istop; if (stop.AsInt32(out istop)) { return(Range(istop)); } throw Ops.OverflowError("too many items in the range"); }
public static object ParseInteger(string text, int b) { Debug.Assert(b != 0); int iret; if (!ParseInt(text, b, out iret)) { BigInteger ret = ParseBigInteger(text, b); if (!ret.AsInt32(out iret)) { return(ret); } } return(ScriptingRuntimeHelpers.Int32ToObject(iret)); }
public static object ParseInteger(string text, int b) { Debug.Assert(b != 0); int iret; if (!ParseInt(text, b, out iret)) { BigInteger ret = ParseBigInteger(text, b); if (!ret.AsInt32(out iret)) { return(ret); } } return(iret); }
public static object RightShift(BigInteger x, object other) { if (other is int) { return(RightShift(x, (int)other)); } else if (other is BigInteger) { BigInteger y = (BigInteger)other; if (y < BigInteger.Zero) { throw Ops.ValueError("negative shift count"); } int yint; if (y.AsInt32(out yint)) { return(RightShift(x, yint)); } } else if (other is long) { long y = (long)other; if (y < 0) { throw Ops.ValueError("negative shift count"); } if (y <= Int32.MaxValue) { return(RightShift(x, (int)y)); } } else if (other is bool) { return(RightShift(x, (bool)other ? 1 : 0)); } else if (other is ExtensibleInt) { return(RightShift(x, ((ExtensibleInt)other).value)); } else if (other is byte) { return(RightShift(x, (int)((byte)other))); } return(Ops.NotImplemented); }
private static object rangeWorker(BigInteger start, BigInteger stop) { if (start > stop) { stop = start; } BigInteger length = stop - start; int ilength; if (length.AsInt32(out ilength)) { List ret = List.MakeEmptyList(ilength); for (int i = 0; i < ilength; i++) { ret.AddNoLock(start + i); } return(ret); } throw Ops.OverflowError("too many items in the range"); }
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 // 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); }
private static object LeftShift(BigInteger x, BigInteger y) { if (y < BigInteger.Zero) { throw Ops.ValueError("negative shift count"); } int yint; if (y.AsInt32(out yint)) { return(x << yint); } if (x == BigInteger.Zero) { return(BigInteger.Zero); } else { throw Ops.OverflowError("number too big"); } }
public static int __hash__(BigInteger self) { // TODO: we might need our own hash code implementation. This avoids assertion failure. if (self == -2147483648) { return(-2147483648); } // 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); }
public static object LeftShift(long x, object other) { if (other is int) { return(LeftShift(x, (int)other)); } else if (other is long) { long y = (long)other; if (Int32.MinValue <= y && y <= Int32.MaxValue) { return(LeftShift(x, (int)y)); } } else if (other is bool) { return(LeftShift(x, (bool)other ? 1 : 0)); } else if (other is BigInteger) { BigInteger big = (BigInteger)other; int y; if (big.AsInt32(out y)) { return(LeftShift(x, y)); } } else if (other is ExtensibleInt) { return(LeftShift(x, ((ExtensibleInt)other).value)); } else if (other is byte) { return(LeftShift(x, (int)((byte)other))); } return(Ops.NotImplemented); }
public static bool AsInt32(BigInteger self, out int res) { return(self.AsInt32(out res)); }
public static string /*!*/ __format__(CodeContext /*!*/ context, BigInteger /*!*/ self, [NotNull] string /*!*/ formatSpec) { StringFormatSpec spec = StringFormatSpec.FromString(formatSpec); if (spec.Precision != null) { throw PythonOps.ValueError("Precision not allowed in integer format specifier"); } BigInteger val = self; if (self < 0) { val = -self; } string digits; switch (spec.Type) { case 'n': CultureInfo culture = context.LanguageContext.NumericCulture; if (culture == CultureInfo.InvariantCulture) { // invariant culture maps to CPython's C culture, which doesn't // include any formatting info. goto case 'd'; } digits = FormattingHelper.ToCultureString(val, context.LanguageContext.NumericCulture.NumberFormat, spec); break; case null: case 'd': if (spec.ThousandsComma) { var width = spec.Width ?? 0; // If we're inserting commas, and we're padding with leading zeros. // AlignNumericText won't know where to place the commas, // so force .Net to help us out here. if (spec.Fill.HasValue && spec.Fill.Value == '0' && width > 1) { digits = val.ToString(FormattingHelper.ToCultureString(self, FormattingHelper.InvariantCommaNumberInfo, spec)); } else { digits = val.ToString("#,0", CultureInfo.InvariantCulture); } } else { digits = val.ToString("D", CultureInfo.InvariantCulture); } break; case '%': if (spec.ThousandsComma) { digits = val.ToString("#,0.000000%", CultureInfo.InvariantCulture); } else { digits = val.ToString("0.000000%", CultureInfo.InvariantCulture); } break; case 'e': if (spec.ThousandsComma) { digits = val.ToString("#,0.000000e+00", CultureInfo.InvariantCulture); } else { digits = val.ToString("0.000000e+00", CultureInfo.InvariantCulture); } break; case 'E': if (spec.ThousandsComma) { digits = val.ToString("#,0.000000E+00", CultureInfo.InvariantCulture); } else { digits = val.ToString("0.000000E+00", CultureInfo.InvariantCulture); } break; case 'f': case 'F': if (spec.ThousandsComma) { digits = val.ToString("#,########0.000000", CultureInfo.InvariantCulture); } else { digits = val.ToString("#########0.000000", CultureInfo.InvariantCulture); } break; case 'g': if (val >= 1000000) { digits = val.ToString("0.#####e+00", CultureInfo.InvariantCulture); } else if (spec.ThousandsComma) { goto case 'd'; } else { digits = val.ToString(CultureInfo.InvariantCulture); } break; case 'G': if (val >= 1000000) { digits = val.ToString("0.#####E+00", CultureInfo.InvariantCulture); } else if (spec.ThousandsComma) { goto case 'd'; } else { digits = val.ToString(CultureInfo.InvariantCulture); } break; case 'X': digits = AbsToHex(val, false); break; case 'x': digits = AbsToHex(val, true); break; case 'o': // octal digits = ToOctal(val, true); break; case 'b': // binary digits = ToBinary(val, false, true); break; case 'c': // single char int iVal; if (spec.Sign != null) { throw PythonOps.ValueError("Sign not allowed with integer format specifier 'c'"); } else if (!self.AsInt32(out iVal)) { throw PythonOps.OverflowError("long int too large to convert to int"); } else if (iVal < 0 || iVal > 0xFF) { throw PythonOps.OverflowError("%c arg not in range(0x10000)"); } digits = ScriptingRuntimeHelpers.CharToString((char)iVal); break; default: throw PythonOps.ValueError("Unknown format code '{0}'", spec.Type.ToString()); } Debug.Assert(digits[0] != '-'); return(spec.AlignNumericText(digits, self.IsZero(), self.IsPositive())); }
public static Variable MakeInt(BigInteger v) { int vs; if (v.AsInt32(out vs)) return Kernel.BoxAnyMO<int>(vs, Kernel.IntMO); else return Kernel.BoxAnyMO<BigInteger>(v, Kernel.IntMO); }
public static string /*!*/ __format__(CodeContext /*!*/ context, BigInteger /*!*/ self, [NotNull] string /*!*/ formatSpec) { StringFormatSpec spec = StringFormatSpec.FromString(formatSpec); if (spec.Precision != null) { throw PythonOps.ValueError("Precision not allowed in integer format specifier"); } BigInteger val = self; if (self < 0) { val = -self; } string digits; switch (spec.Type) { case 'n': CultureInfo culture = PythonContext.GetContext(context).NumericCulture; if (culture == CultureInfo.InvariantCulture) { // invariant culture maps to CPython's C culture, which doesn't // include any formatting info. goto case 'd'; } digits = ToCultureString(val, PythonContext.GetContext(context).NumericCulture); break; #if CLR2 case null: case 'd': digits = val.ToString(); break; case '%': if (val == BigInteger.Zero) { digits = "0.000000%"; } else { digits = val.ToString() + "00.000000%"; } break; case 'e': digits = ToExponent(val, true, 6, 7); break; case 'E': digits = ToExponent(val, false, 6, 7); break; case 'f': if (val != BigInteger.Zero) { digits = val.ToString() + ".000000"; } else { digits = "0.000000"; } break; case 'F': if (val != BigInteger.Zero) { digits = val.ToString() + ".000000"; } else { digits = "0.000000"; } break; case 'g': if (val >= 1000000) { digits = ToExponent(val, true, 0, 6); } else { digits = val.ToString(); } break; case 'G': if (val >= 1000000) { digits = ToExponent(val, false, 0, 6); } else { digits = val.ToString(); } break; #else case null: case 'd': if (spec.ThousandsComma) { digits = val.ToString("#,0", CultureInfo.InvariantCulture); } else { digits = val.ToString("D", CultureInfo.InvariantCulture); } break; case '%': if (spec.ThousandsComma) { digits = val.ToString("#,0.000000%", CultureInfo.InvariantCulture); } else { digits = val.ToString("0.000000%", CultureInfo.InvariantCulture); } break; case 'e': if (spec.ThousandsComma) { digits = val.ToString("#,0.000000e+00", CultureInfo.InvariantCulture); } else { digits = val.ToString("0.000000e+00", CultureInfo.InvariantCulture); } break; case 'E': if (spec.ThousandsComma) { digits = val.ToString("#,0.000000E+00", CultureInfo.InvariantCulture); } else { digits = val.ToString("0.000000E+00", CultureInfo.InvariantCulture); } break; case 'f': case 'F': if (spec.ThousandsComma) { digits = val.ToString("#,########0.000000", CultureInfo.InvariantCulture); } else { digits = val.ToString("#########0.000000", CultureInfo.InvariantCulture); } break; case 'g': if (val >= 1000000) { digits = val.ToString("0.#####e+00", CultureInfo.InvariantCulture); } else if (spec.ThousandsComma) { digits = val.ToString("#,0", CultureInfo.InvariantCulture); } else { digits = val.ToString(CultureInfo.InvariantCulture); } break; case 'G': if (val >= 1000000) { digits = val.ToString("0.#####E+00", CultureInfo.InvariantCulture); } else if (spec.ThousandsComma) { digits = val.ToString("#,0", CultureInfo.InvariantCulture); } else { digits = val.ToString(CultureInfo.InvariantCulture); } break; #endif case 'X': digits = AbsToHex(val, false); break; case 'x': digits = AbsToHex(val, true); break; case 'o': // octal digits = ToOctal(val, true); break; case 'b': // binary digits = ToBinary(val, false, true); break; case 'c': // single char int iVal; if (spec.Sign != null) { throw PythonOps.ValueError("Sign not allowed with integer format specifier 'c'"); } else if (!self.AsInt32(out iVal)) { throw PythonOps.OverflowError("long int too large to convert to int"); } else if (iVal < 0 || iVal > 0xFF) { throw PythonOps.OverflowError("%c arg not in range(0x10000)"); } digits = ScriptingRuntimeHelpers.CharToString((char)iVal); break; default: throw PythonOps.ValueError("Unknown format code '{0}'", spec.Type.ToString()); } Debug.Assert(digits[0] != '-'); return(spec.AlignNumericText(digits, self.IsZero(), self.IsPositive())); }
private void AsInt32Test(BigInteger i, bool expRet, int expInt) { int v; bool b = i.AsInt32(out v); Expect(b, EqualTo(expRet)); Expect(v, EqualTo(expInt)); }
public static object Compare(BigInteger x, object y) { if (y == null) { return(1); } int intVal; if (y is int) { if (x.AsInt32(out intVal)) { return(IntOps.Compare(intVal, y)); } } else if (y is ExtensibleInt) { if (x.AsInt32(out intVal)) { return(IntOps.Compare(intVal, ((ExtensibleInt)y).value)); } } else if (y is double) { double dbl = x.ToFloat64(); return(FloatOps.Compare(dbl, y)); } else if (y is ExtensibleFloat) { double dbl = x.ToFloat64(); return(FloatOps.Compare(dbl, ((ExtensibleFloat)y).value)); } else if (y is bool) { if (x.AsInt32(out intVal)) { return(IntOps.Compare(intVal, ((bool)y) ? 1 : 0)); } } else if (y is decimal) { double dbl = x.ToFloat64(); return(FloatOps.Compare(dbl, y)); } Conversion conv; BigInteger bi = Converter.TryConvertToBigInteger(y, out conv); if (conv == Conversion.None) { object res = Ops.GetDynamicType(y).Coerce(y, x); if (res != Ops.NotImplemented && !(res is OldInstance)) { return(Ops.Compare(((Tuple)res)[1], ((Tuple)res)[0])); } return(Ops.NotImplemented); } BigInteger diff = x - bi; if (diff == 0) { return(0); } else if (diff < 0) { return(-1); } else { return(1); } }
public static object reduce(BigInteger val) { //int bitLength = val.bitLength(); //return (bitLength < 32) // ? (object)val.intValue() // : (bitLength < 64) // ? (object)val.longValue() // : val; int ival; if (val.AsInt32(out ival)) return ival; long lval; if (val.AsInt64(out lval)) return lval; return val; }