public static decimal ToDecimal(this BigInteger bi, bool noThrow = false) { var thirtyTwoBits = BigInteger.ValueOf(0xFFFFFFFFL); if (bi.SignValue == 0) { return(decimal.Zero); } var signed = bi.SignValue < 0; if (signed) { bi = bi.Negate(); } var low = unchecked ((int)(uint)bi.And(thirtyTwoBits).LongValue); bi = bi.ShiftRight(32); var med = unchecked ((int)(uint)bi.And(thirtyTwoBits).LongValue); bi = bi.ShiftRight(32); var high = unchecked ((int)(uint)bi.And(thirtyTwoBits).LongValue); bi = bi.ShiftRight(32); if (!noThrow && bi.SignValue != 0) { throw new OverflowException("BigInteger too big to conform to decimal."); } return(new decimal(low, med, high, signed, 0)); }
public static string ToCheckSumAddress(string address) { if (!Validation.IsAddress(address)) { throw new Exception("not a valid base 16 address"); } address = address.ToLower().Replace("0x", ""); string hash = ByteUtil.ByteArrayToHexString(HashUtil.Sha256(ByteUtil.HexStringToByteArray(address))); StringBuilder ret = new StringBuilder("0x"); byte[] x = ByteUtil.HexStringToByteArray(hash); BigInteger v = new BigInteger(ByteUtil.HexStringToByteArray(hash)); for (int i = 0; i < address.Length; i++) { if ("1234567890".IndexOf(address.ToCharArray()[i]) != -1) { ret.Append(address.ToCharArray()[i]); } else { BigInteger checker = v.And(BigInteger.ValueOf(2).Pow(255 - 6 * i));//(BigInteger.valueOf(2l).pow(255 - 6 * i)) ret.Append(checker.CompareTo(BigInteger.ValueOf(1)) < 0 ? address.ToCharArray()[i].ToString().ToLower() : address.ToCharArray()[i].ToString().ToUpper()); } } return(ret.ToString()); }
private void SetKey(byte[] key, byte[] nonce) { byte[] z = new byte[key.Length]; Array.Copy(key, z, key.Length); Array.Reverse(z); // Extract r portion of key r = new BigInteger(1, z, 16, 16); r = r.And(clamp); s = new BigInteger(1, z, 0, 16); }
public DataWord ShiftRight(DataWord value) { if (value.ToBigInteger().CompareTo(BigInteger.ValueOf(MAX_POW)) >= 0) { return(DataWord.ZERO); } BigInteger result = ToBigInteger().ShiftRight(value.ToIntSafety()); return(new DataWord(CopyTo(result.And(MAX_VALUE)))); }
public void MultipyMod(DataWord word1, DataWord word2) { if (this.IsZero || word1.IsZero || word2.IsZero) { this.data = new byte[32]; return; } BigInteger result = ToBigInteger().Multiply(word1.ToBigInteger().Mod(word2.ToBigInteger())); this.data = CopyTo(result.And(MAX_VALUE)); }
public void Mod(DataWord value) { if (value.IsZero) { this.AND(value); return; } BigInteger result = ToBigInteger().Mod(value.ToBigInteger()); this.data = CopyTo(result.And(MAX_VALUE)); }
/// <summary> /// Gene bytemask function extracts a gene bit from <paramref name="input"/>. /// </summary> /// <param name="input">The <see cref="BigInteger"/> containing gene data.</param> /// <param name="start">The offset bit</param> /// <param name="numberOfBytes">Number of bits.</param> /// <returns>The masked byte.</returns> private static byte GeneByteMask(BigInteger input, int start, int numberOfBytes) { // mask = 2**numbytes - 1 var mask = BigInteger.Two.Pow(numberOfBytes).Subtract(BigInteger.One); // mask = mask << start mask = mask.ShiftLeft(start); var ret = input.And(mask); ret = ret.ShiftRight(start); return((byte)ret.IntValue); }
public void Div(DataWord word) { if (word.IsZero()) { this.And(ZERO); return; } BigInteger result = GetValue().Divide(word.GetValue()); _data = ByteUtil.CopyToArray(result.And(MAX_VALUE)); }
public void TestDivideAndRemainder() { // TODO More basic tests BigInteger n = new BigInteger(48, random); BigInteger[] qr = n.DivideAndRemainder(n); Assert.AreEqual(one, qr[0]); Assert.AreEqual(zero, qr[1]); qr = n.DivideAndRemainder(one); Assert.AreEqual(n, qr[0]); Assert.AreEqual(zero, qr[1]); for (int rep = 0; rep < 10; ++rep) { BigInteger a = new BigInteger(100 - rep, 0, random); BigInteger b = new BigInteger(100 + rep, 0, random); BigInteger c = new BigInteger(10 + rep, 0, random); BigInteger d = a.Multiply(b).Add(c); BigInteger[] es = d.DivideAndRemainder(a); Assert.AreEqual(b, es[0]); Assert.AreEqual(c, es[1]); } // Special tests for power of two since uses different code path internally for (int i = 0; i < 100; ++i) { int shift = random.Next(64); BigInteger a = one.ShiftLeft(shift); BigInteger b = new BigInteger(64 + random.Next(64), random); BigInteger bShift = b.ShiftRight(shift); BigInteger bMod = b.And(a.Subtract(one)); string data = "shift=" + shift + ", b=" + b.ToString(16); qr = b.DivideAndRemainder(a); Assert.AreEqual(bShift, qr[0], data); Assert.AreEqual(bMod, qr[1], data); qr = b.DivideAndRemainder(a.Negate()); Assert.AreEqual(bShift.Negate(), qr[0], data); Assert.AreEqual(bMod, qr[1], data); qr = b.Negate().DivideAndRemainder(a); Assert.AreEqual(bShift.Negate(), qr[0], data); Assert.AreEqual(bMod.Negate(), qr[1], data); qr = b.Negate().DivideAndRemainder(a.Negate()); Assert.AreEqual(bShift, qr[0], data); Assert.AreEqual(bMod.Negate(), qr[1], data); } }
public void AndLBigInteger() { foreach (BigInteger[] element in booleanPairs) { BigInteger i1 = element[0], i2 = element[1]; BigInteger res = i1.And(i2); IsTrue(res.Equals(i2.And(i1)), "symmetry of and"); int len = System.Math.Max(i1.BitLength, i2.BitLength) + 66; for (int i = 0; i < len; i++) { IsTrue((i1.TestBit(i) && i2.TestBit(i)) == res.TestBit(i), "and"); } } }
public SqlNumber And(SqlNumber value) { if (State == NumericState.NotANumber) { return(this); } if (Scale == 0 && value.Scale == 0) { BigInteger bi1 = innerValue.ToBigInteger(); BigInteger bi2 = value.innerValue.ToBigInteger(); return(new SqlNumber(NumericState.None, new BigDecimal(bi1.And(bi2)))); } return(Null); }
public void TestMod() { // TODO Basic tests for (int rep = 0; rep < 100; ++rep) { int diff = random.Next(25); BigInteger a = new BigInteger(100 - diff, 0, random); BigInteger b = new BigInteger(100 + diff, 0, random); BigInteger c = new BigInteger(10 + diff, 0, random); BigInteger d = a.Multiply(b).Add(c); BigInteger e = d.Mod(a); Assert.AreEqual(c, e); BigInteger pow2 = one.ShiftLeft(random.Next(128)); Assert.AreEqual(b.And(pow2.Subtract(one)), b.Mod(pow2)); } }
public void Multiply(DataWord value) { BigInteger result = ToBigInteger().Multiply(value.ToBigInteger()); this.data = CopyTo(result.And(MAX_VALUE)); }
public void Sub(DataWord value) { BigInteger result = ToBigInteger().Subtract(value.ToBigInteger()); this.data = CopyTo(result.And(MAX_VALUE)); }
public void Sub(DataWord word) { BigInteger result = GetValue().Subtract(word.GetValue()); _data = ByteUtil.CopyToArray(result.And(MAX_VALUE)); }
//x1~=2^w+(x1 AND (2^w-1)) private BigInteger Reduce(BigInteger x) { return(x.And(BigInteger.One.ShiftLeft(mW).Subtract(BigInteger.One)).SetBit(mW)); }
private void MultiplyOverField(int blockSizeBits, byte[] x, byte[] y, byte[] x_mult_y) { //Multiplication over GF(2^m), GF(2^256), GF(2^512) with correspondent extension polynomials: /// /// GF(2^128) | x^128 + x^7 + x^2 + x /// GF(2^256) | x^256 + x^10 + x^5 + x^2 + 1 /// GF(2^512) | x^512 + x^8 + x^5 + x^2 + 1 /// //Thanks to João H de A Franco script. https://jhafranco.com/2012/02/17/multiplication-over-the-binary-finite-field-gf2m/ byte[] copy1 = new byte[cipher.GetBlockSize()]; byte[] copy2 = new byte[cipher.GetBlockSize()]; Array.Copy(x, 0, copy1, 0, cipher.GetBlockSize()); Array.Copy(y, 0, copy2, 0, cipher.GetBlockSize()); Array.Reverse(copy1); Array.Reverse(copy2); BigInteger mask1; BigInteger mask2; BigInteger polyred; switch (blockSizeBits) { case 128: mask1 = mask1_128; mask2 = mask2_128; polyred = polyred_128; break; case 256: mask1 = mask1_256; mask2 = mask2_256; polyred = polyred_256; break; case 512: mask1 = mask1_512; mask2 = mask2_512; polyred = polyred_512; break; default: mask1 = mask1_128; mask2 = mask2_128; polyred = polyred_128; break; } BigInteger p = BigInteger.Zero; BigInteger p1 = new BigInteger(1, copy1); BigInteger p2 = new BigInteger(1, copy2); while (!p2.Equals(BigInteger.Zero)) { if (p2.And(BigInteger.One).Equals(BigInteger.One)) { p = p.Xor(p1); } p1 = p1.ShiftLeft(1); if (!p1.And(mask1).Equals(BigInteger.Zero)) { p1 = p1.Xor(polyred); } p2 = p2.ShiftRight(1); } byte[] got = p.And(mask2).ToByteArrayUnsigned(); Array.Clear(x_mult_y, 0, cipher.GetBlockSize()); Array.Copy(got, 0, x_mult_y, 0, got.Length); }
public void TestDivideAndRemainder() { // TODO More basic tests var n = new BigInteger(48, Rnd); BigInteger[] qr = n.DivideAndRemainder(One); Assert.AreEqual(n, qr[0]); Assert.AreEqual(Zero, qr[1]); for (int rep = 0; rep < 10; ++rep) { var a = new BigInteger(100 - rep, 0, Rnd); var b = new BigInteger(100 + rep, 0, Rnd); var c = new BigInteger(10 + rep, 0, Rnd); BigInteger d = a.Multiply(b).Add(c); BigInteger[] es = d.DivideAndRemainder(a); Assert.AreEqual(b, es[0]); Assert.AreEqual(c, es[1]); } // Special tests for power of two since uses different code path internally for (int i = 0; i < 100; ++i) { int shift = Rnd.Next(64); BigInteger a = One.ShiftLeft(shift); var b = new BigInteger(64 + Rnd.Next(64), Rnd); BigInteger bShift = b.ShiftRight(shift); BigInteger bMod = b.And(a.Subtract(One)); string data = "shift=" + shift + ", b=" + b.ToString(16); qr = b.DivideAndRemainder(a); Assert.AreEqual(bShift, qr[0], data); Assert.AreEqual(bMod, qr[1], data); qr = b.DivideAndRemainder(a.Negate()); Assert.AreEqual(bShift.Negate(), qr[0], data); Assert.AreEqual(bMod, qr[1], data); qr = b.Negate().DivideAndRemainder(a); Assert.AreEqual(bShift.Negate(), qr[0], data); Assert.AreEqual(bMod.Negate(), qr[1], data); qr = b.Negate().DivideAndRemainder(a.Negate()); Assert.AreEqual(bShift, qr[0], data); Assert.AreEqual(bMod.Negate(), qr[1], data); } }
public void TestMod() { // TODO Basic tests for (int rep = 0; rep < 100; ++rep) { int diff = Rnd.Next(25); var a = new BigInteger(100 - diff, 0, Rnd); var b = new BigInteger(100 + diff, 0, Rnd); var c = new BigInteger(10 + diff, 0, Rnd); BigInteger d = a.Multiply(b).Add(c); BigInteger e = d.Mod(a); Assert.AreEqual(c, e); BigInteger pow2 = One.ShiftLeft(Rnd.Next(128)); Assert.AreEqual(b.And(pow2.Subtract(One)), b.Mod(pow2)); } }
public void Mul(DataWord word) { BigInteger result = GetValue().Multiply(word.GetValue()); _data = ByteUtil.CopyToArray(result.And(MAX_VALUE)); }