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