internal static string /*!*/ ConvertToHostString(BigInteger /*!*/ address) { Assert.NotNull(address); ulong u; if (address.AsUInt64(out u)) { if (u <= UInt32.MaxValue) { // IPv4: return(ConvertToHostString((uint)u)); } else { // IPv6: byte[] bytes = new byte[8]; for (int i = bytes.Length - 1; i >= 0; --i) { bytes[i] = (byte)(u & 0xff); u >>= 8; } return(new IPAddress(bytes).ToString()); } } else { throw RubyExceptions.CreateRangeError("bignum too big to convert into `quad long'"); } }
internal static UInt64 ToUInt64(BigInteger value) { UInt64 result; if (value.AsUInt64(out result)) { return(result); } throw RubyExceptions.CreateRangeError("number too big to convert into System::UInt64"); }
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); } } }
/// <summary> /// Try to convert to an UInt64. /// </summary> /// <param name="ret">Set to the converted value</param> /// <returns><value>true</value> if successful; <value>false</value> if the value cannot be represented.</returns> public bool AsUInt64(out ulong ret) { ret = 0; if (_bipart != null) { return(_bipart.AsUInt64(out ret)); } if (_lpart < 0) { return(false); } ret = (ulong)_lpart; return(true); }
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 bool AsUInt64(BigInteger self, out ulong res) { return(self.AsUInt64(out res)); }
private void AsUInt64Test(BigInteger i, bool expRet, ulong expInt) { ulong v; bool b = i.AsUInt64(out v); Expect(b, EqualTo(expRet)); Expect(v, EqualTo(expInt)); }
public static Variable MakeFixRat(BigInteger num, BigInteger den) { ulong sden; SimplifyFrac(ref num, ref den); if (den.AsUInt64(out sden) && sden != 0) return Kernel.BoxAnyMO<Rat>(new Rat(num, sden), Kernel.RatMO); return MakeFloat(RatToFloat(num, den)); }
public static object EvalExpression(string code, Dictionary <string, object> localScope) { var missing = Imports.Except(Engine.Modules.Keys).ToList(); foreach (string import in missing) { Engine.Modules.Add(import, Engine.Instance.ImportModule(import)); } ScriptScope scope = Engine.Instance.CreateScope(); foreach (var kv in Engine.Modules) { scope.SetVariable(kv.Key, kv.Value); } foreach (var kv in GlobalScope) { scope.SetVariable(kv.Key, kv.Value); } foreach (var kv in localScope) { scope.SetVariable(kv.Key, kv.Value); } 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); } } }