private int[] ToIntArray(BigIntPolynomial A, int K)
{
int N = A.Coeffs.Length;
int sign = A.Coeffs[A.Degree()].Signum();
int[] aInt = new int[N * K];
for (int i = N - 1; i >= 0; i--)
{
int[] cArr = SchonhageStrassen.ToIntArray(A.Coeffs[i].Abs());
if (A.Coeffs[i].Signum() * sign < 0)
{
SubShifted(aInt, cArr, i * K);
}
else
{
AddShifted(aInt, cArr, i * K);
}
}
return(aInt);
}
private int[] ToIntArray(BigIntPolynomial A, int K)
{
int N = A.Coeffs.Length;
int sign = A.Coeffs[A.Degree()].Signum();
int[] aInt = new int[N * K];
for (int i = N - 1; i >= 0; i--)
{
int[] cArr = SchonhageStrassen.ToIntArray(A.Coeffs[i].Abs());
if (A.Coeffs[i].Signum() * sign < 0)
SubShifted(aInt, cArr, i * K);
else
AddShifted(aInt, cArr, i * K);
}
return aInt;
}
/// <summary>
/// Multiplies the polynomial by another, taking the indices mod N.
/// <para>Does not change this polynomial but returns the result as a new polynomial.
/// Both polynomials must have the same number of coefficients.
/// This method is designed for large polynomials and uses Schönhage-Strassen multiplication
/// in combination with <a href="http://en.wikipedia.org/wiki/Kronecker_substitution">Kronecker substitution</a>.
/// See <a href="http://math.stackexchange.com/questions/58946/karatsuba-vs-schonhage-strassen-for-multiplication-of-polynomials#58955">here</a> for details.</para>
/// </summary>
///
/// <param name="Factor">The polynomial to multiply by</param>
///
/// <returns>The product polynomial</returns>
public BigIntPolynomial MultBig(BigIntPolynomial Factor)
{
int N = Coeffs.Length;
// determine #bits needed per coefficient
int logMinDigits = 32 - IntUtils.NumberOfLeadingZeros(N - 1);
int maxLengthA = 0;
for (int i = 0; i < Coeffs.Length; i++)
{
BigInteger coeff = Coeffs[i];
maxLengthA = Math.Max(maxLengthA, coeff.BitLength);
}
int maxLengthB = 0;
for (int i = 0; i < Factor.Coeffs.Length; i++)
{
BigInteger coeff = Factor.Coeffs[i];
maxLengthB = Math.Max(maxLengthB, coeff.BitLength);
}
int k = logMinDigits + maxLengthA + maxLengthB + 1; // in bits
k = (k + 31) / 32; // in ints
// encode each polynomial into an int[]
int aDeg = Degree();
int bDeg = Factor.Degree();
if (aDeg < 0 || bDeg < 0)
return new BigIntPolynomial(N); // return zero
int[] aInt = ToIntArray(this, k);
int[] bInt = ToIntArray(Factor, k);
int[] cInt = SchonhageStrassen.Multiply(aInt, bInt);
// decode poly coefficients from the product
BigInteger _2k = BigInteger.One.ShiftLeft(k * 32);
BigIntPolynomial cPoly = new BigIntPolynomial(N);
for (int i = 0; i < 2 * N - 1; i++)
{
int[] coeffInt = cInt.CopyOfRange(i * k, (i + 1) * k);
BigInteger coeff = SchonhageStrassen.ToBigInteger(coeffInt);
if (coeffInt[k - 1] < 0)
{ // if coeff > 2^(k-1)
coeff = coeff.Subtract(_2k);
// add 2^k to cInt which is the same as subtracting coeff
bool carry = false;
int cIdx = (i + 1) * k;
do
{
cInt[cIdx]++;
carry = cInt[cIdx] == 0;
cIdx++;
} while (carry);
}
cPoly.Coeffs[i % N] = cPoly.Coeffs[i % N].Add(coeff);
}
int aSign = Coeffs[aDeg].Signum();
int bSign = Factor.Coeffs[bDeg].Signum();
if (aSign * bSign < 0)
{
for (int i = 0; i < N; i++)
cPoly.Coeffs[i] = cPoly.Coeffs[i].Negate();
}
return cPoly;
}
/// <summary>
/// Multiplies the polynomial by another, taking the indices mod N.
/// <para>Does not change this polynomial but returns the result as a new polynomial.
/// Both polynomials must have the same number of coefficients.
/// This method is designed for large polynomials and uses Schönhage-Strassen multiplication
/// in combination with <a href="http://en.wikipedia.org/wiki/Kronecker_substitution">Kronecker substitution</a>.
/// See <a href="http://math.stackexchange.com/questions/58946/karatsuba-vs-schonhage-strassen-for-multiplication-of-polynomials#58955">here</a> for details.</para>
/// </summary>
///
/// <param name="Factor">The polynomial to multiply by</param>
///
/// <returns>The product polynomial</returns>
public BigIntPolynomial MultBig(BigIntPolynomial Factor)
{
int N = Coeffs.Length;
// determine #bits needed per coefficient
int logMinDigits = 32 - IntUtils.NumberOfLeadingZeros(N - 1);
int maxLengthA = 0;
for (int i = 0; i < Coeffs.Length; i++)
{
BigInteger coeff = Coeffs[i];
maxLengthA = Math.Max(maxLengthA, coeff.BitLength);
}
int maxLengthB = 0;
for (int i = 0; i < Factor.Coeffs.Length; i++)
{
BigInteger coeff = Factor.Coeffs[i];
maxLengthB = Math.Max(maxLengthB, coeff.BitLength);
}
int k = logMinDigits + maxLengthA + maxLengthB + 1; // in bits
k = (k + 31) / 32; // in ints
// encode each polynomial into an int[]
int aDeg = Degree();
int bDeg = Factor.Degree();
if (aDeg < 0 || bDeg < 0)
{
return(new BigIntPolynomial(N)); // return zero
}
int[] aInt = ToIntArray(this, k);
int[] bInt = ToIntArray(Factor, k);
int[] cInt = SchonhageStrassen.Multiply(aInt, bInt);
// decode poly coefficients from the product
BigInteger _2k = BigInteger.One.ShiftLeft(k * 32);
BigIntPolynomial cPoly = new BigIntPolynomial(N);
for (int i = 0; i < 2 * N - 1; i++)
{
int[] coeffInt = cInt.CopyOfRange(i * k, (i + 1) * k);
BigInteger coeff = SchonhageStrassen.ToBigInteger(coeffInt);
if (coeffInt[k - 1] < 0)
{ // if coeff > 2^(k-1)
coeff = coeff.Subtract(_2k);
// add 2^k to cInt which is the same as subtracting coeff
bool carry = false;
int cIdx = (i + 1) * k;
do
{
cInt[cIdx]++;
carry = cInt[cIdx] == 0;
cIdx++;
} while (carry);
}
cPoly.Coeffs[i % N] = cPoly.Coeffs[i % N].Add(coeff);
}
int aSign = Coeffs[aDeg].Signum();
int bSign = Factor.Coeffs[bDeg].Signum();
if (aSign * bSign < 0)
{
for (int i = 0; i < N; i++)
{
cPoly.Coeffs[i] = cPoly.Coeffs[i].Negate();
}
}
return(cPoly);
}