public override IResidue <BigInteger> Multiply(IResidue <BigInteger> x) { // Use SOS for everything. r.Multiply(GetRep(x), reducer.store); reducer.Reduce(r); return(this); }
public override IResidue <UInt128> Add(IResidue <UInt128> x) { var rRep = r; var xRep = GetRep(x); UInt128.ModAdd(out r, ref rRep, ref xRep, ref reducer.modulus); return(this); }
public override IResidue <UInt128> Multiply(IResidue <UInt128> x) { var xRep = GetRep(x); var rRep = r; reducer.Reduce(out r, ref rRep, ref xRep); return(this); }
public IResidue <BigInteger> Subtract(IResidue <BigInteger> x) { r -= ((Residue)x).r; if (r < 0) { r += reducer.Modulus; } return(this); }
public IResidue <BigInteger> Add(IResidue <BigInteger> x) { r += ((Residue)x).r; if (r >= reducer.Modulus) { r -= reducer.Modulus; } return(this); }
public IResidue <int> Add(IResidue <int> x) { r += ((Residue)x).r; if (r >= reducer.Modulus) { r -= reducer.Modulus; } return(this); }
public IResidue <int> Subtract(IResidue <int> x) { var xr = ((Residue)x).r; if (r < xr) { r += reducer.Modulus - xr; } else { r -= xr; } return(this); }
public override IResidue <BigInteger> Multiply(IResidue <BigInteger> x) { var reg1 = reducer.store.Allocate().Set(r); if (x == this) { r.SetSquare(reg1); } else { r.SetProduct(reg1, GetRep(x)); } r.Modulo(reducer.modulus); reducer.store.Release(reg1); return(this); }
public override IResidue <BigInteger> Multiply(IResidue <BigInteger> x) { // Use CIOS for everything. var reg1 = reducer.store.Allocate().Set(r); if (x == this) { reducer.Reduce(r, reg1, reg1); } else { reducer.Reduce(r, reg1, GetRep(x)); } reducer.store.Release(reg1); return(this); }
public override IResidue <BigInteger> Multiply(IResidue <BigInteger> x) { // Use SOS for squaring and CIOS otherwise. if (x == this) { r.Multiply(r, reducer.store); reducer.Reduce(r); } else { var reg1 = reducer.store.Allocate().Set(r); reg1.Set(r); reducer.Reduce(r, reg1, GetRep(x)); reducer.store.Release(reg1); } return(this); }
public static void Power <T>(IResidue <T> value, T exponent) { var reducer = value.Reducer; var ops = Operations.Get <T>(); var result = reducer.ToResidue(ops.One); while (!ops.IsZero(exponent)) { var word = ops.LeastSignificantWord(exponent); exponent = ops.RightShift(exponent, 32); if (!ops.IsZero(exponent)) { for (int i = 0; i < 32; i++) { if ((word & 1) != 0) { result.Multiply(value); } value.Multiply(value); word >>= 1; } } else { while (word != 0) { if ((word & 1) != 0) { result.Multiply(value); } if (word != 1) { value.Multiply(value); } word >>= 1; } } } value.Set(result); }
public IResidue <int> Set(IResidue <int> x) { r = ((Residue)x).r; return(this); }
public bool Equals(IResidue <int> other) { return(r == ((Residue)other).r); }
public int CompareTo(IResidue <int> other) { return(r.CompareTo(((Residue)other).r)); }
public override IResidue <ulong> Add(IResidue <ulong> x) { r = IntegerMath.ModularSum(r, GetRep(x), reducer.modulus); return(this); }
public override IResidue <ulong> Subtract(IResidue <ulong> x) { r = IntegerMath.ModularDifference(r, GetRep(x), reducer.modulus); return(this); }
public override IResidue <ulong> Set(IResidue <ulong> x) { r = GetRep(x); return(this); }
public override IResidue <ulong> Multiply(IResidue <ulong> x) { r = IntegerMath.ModularProduct(r, GetRep(x), reducer.modulus); return(this); }
/// <summary> /// Add this forcefield to the instantiated topology. /// </summary> /// <param name="parentTopology">The topology.</param> /// <param name="residue">The atom group this forcefield is associated with.</param> /// <param name="context">The spawn context this forcefield is associated with.</param> public void AddToTopology(InstantiatedTopology parentTopology, IResidue residue, ref SpawnContext context) { //TODO generalize this to multiple templates/atom groups. parentTopology.ForceFieldTerms.Add(this); }
public int CompareTo(IResidue <BigInteger> other) { return(r.CompareTo(((Residue)other).r)); }
public IResidue <int> Multiply(IResidue <int> x) { r = IntegerMath.ModularProduct(r, ((Residue)x).r, reducer.Modulus); return(this); }
private bool LoadBooks(IPacket packet) { if (!ValidateHeader(packet, PacketSignatureBooks)) { return(false); } var mdct = _factory.CreateMdct(); var huffman = _factory.CreateHuffman(); // read the books var books = new ICodebook[packet.ReadBits(8) + 1]; for (var i = 0; i < books.Length; i++) { books[i] = _factory.CreateCodebook(); books[i].Init(packet, huffman); } // Vorbis never used this feature, so we just skip the appropriate number of bits var times = (int)packet.ReadBits(6) + 1; packet.SkipBits(16 * times); // read the floors var floors = new IFloor[packet.ReadBits(6) + 1]; for (var i = 0; i < floors.Length; i++) { floors[i] = _factory.CreateFloor(packet); floors[i].Init(packet, _channels, _block0Size, _block1Size, books); } // read the residues var residues = new IResidue[packet.ReadBits(6) + 1]; for (var i = 0; i < residues.Length; i++) { residues[i] = _factory.CreateResidue(packet); residues[i].Init(packet, _channels, books); } // read the mappings var mappings = new IMapping[packet.ReadBits(6) + 1]; for (var i = 0; i < mappings.Length; i++) { mappings[i] = _factory.CreateMapping(packet); mappings[i].Init(packet, _channels, floors, residues, mdct); } // read the modes _modes = new IMode[packet.ReadBits(6) + 1]; for (var i = 0; i < _modes.Length; i++) { _modes[i] = _factory.CreateMode(); _modes[i].Init(packet, _channels, _block0Size, _block1Size, mappings); } // verify the closing bit if (!packet.ReadBit()) { throw new InvalidDataException("Book packet did not end on correct bit!"); } // save off the number of bits to read to determine packet mode _modeFieldBits = Utils.ilog(_modes.Length - 1); _stats.AddPacket(-1, packet.BitsRead, packet.BitsRemaining, packet.ContainerOverheadBits); return(true); }
public override IResidue <BigInteger> Set(IResidue <BigInteger> x) { r.Set(GetRep(x)); return(this); }
public override IResidue <BigInteger> Subtract(IResidue <BigInteger> x) { r.SubtractModulo(GetRep(x), reducer.nRep); return(this); }
public override IResidue <BigInteger> Add(IResidue <BigInteger> x) { r.AddModulo(GetRep(x), reducer.nRep); return(this); }
public IResidue <BigInteger> Multiply(IResidue <BigInteger> x) { r.Multiply(((Residue)x).r, reducer.store); reducer.Reduce(r); return(this); }
public bool Equals(IResidue <BigInteger> other) { return(r == ((Residue)other).r); }
private static void AdvanceF(IResidue<BigInteger> x, IResidue<BigInteger> c) { x.Multiply(x).Add(c); }
public IResidue <BigInteger> Add(IResidue <BigInteger> x) { r.AddModulo(((Residue)x).r, reducer.pRep); return(this); }
private static void AdvanceF(IResidue <T> x, IResidue <T> c) { x.Multiply(x).Add(c); }
public IResidue <BigInteger> Subtract(IResidue <BigInteger> x) { r.Subtract(((Residue)x).r); return(this); }