/**
* Computes the inverse mod 3.
* Returns <code>null</code> if the polynomial is not invertible.
*
* @return a new polynomial
*/
public IntegerPolynomial InvertF3()
{
int N = coeffs.Length;
int k = 0;
IntegerPolynomial b = new IntegerPolynomial(N + 1);
b.coeffs[0] = 1;
IntegerPolynomial c = new IntegerPolynomial(N + 1);
IntegerPolynomial f = new IntegerPolynomial(N + 1);
Array.Copy(coeffs, f.coeffs, N);
f.ModPositive(3);
// set g(x) = x^N − 1
IntegerPolynomial g = new IntegerPolynomial(N + 1);
g.coeffs[0] = -1;
g.coeffs[N] = 1;
while (true)
{
while (f.coeffs[0] == 0)
{
for (int i = 1; i <= N; i++)
{
f.coeffs[i - 1] = f.coeffs[i]; // f(x) = f(x) / x
c.coeffs[N + 1 - i] = c.coeffs[N - i]; // c(x) = c(x) * x
}
f.coeffs[N] = 0;
c.coeffs[0] = 0;
k++;
if (f.EqualsZero())
{
return(null); // not invertible
}
}
if (f.EqualsAbsOne())
{
break;
}
if (f.Degree() < g.Degree())
{
// exchange f and g
IntegerPolynomial temp = f;
f = g;
g = temp;
// exchange b and c
temp = b;
b = c;
c = temp;
}
if (f.coeffs[0] == g.coeffs[0])
{
f.Sub(g, 3);
b.Sub(c, 3);
}
else
{
f.Add(g, 3);
b.Add(c, 3);
}
}
if (b.coeffs[N] != 0)
{
return(null);
}
// Fp(x) = [+-] x^(N-k) * b(x)
IntegerPolynomial Fp = new IntegerPolynomial(N);
int j = 0;
k %= N;
for (int i = N - 1; i >= 0; i--)
{
j = i - k;
if (j < 0)
{
j += N;
}
Fp.coeffs[j] = f.coeffs[0] * b.coeffs[i];
}
Fp.EnsurePositive(3);
return(Fp);
}
/**
* Multithreaded version of {@link #resultant()}.
*
* @return <code>(rho, res)</code> satisfying <code>res = rho*this + t*(x^n-1)</code> for some integer <code>t</code>.
*/
/* Taking out Async for now, harder problem than just translating.
* public async Task<Resultant> ResultantMultiThread()
* {
* int N = coeffs.Length;
*
* // upper bound for resultant(f, g) = ||f, 2||^deg(g) * ||g, 2||^deg(f) = squaresum(f)^(N/2) * 2^(deg(f)/2) because g(x)=x^N-1
* // see http://jondalon.mathematik.uni-osnabrueck.de/staff/phpages/brunsw/CompAlg.pdf chapter 3
* BigInteger max = squareSum().pow((N + 1) / 2);
* max = max.multiply(BigInteger.ValueOf(2).pow((degree() + 1) / 2));
* BigInteger max2 = max.multiply(BigInteger.ValueOf(2));
*
* // compute resultants modulo prime numbers
* BigInteger prime = BigInteger.ValueOf(10000);
* BigInteger pProd = Constants.BIGINT_ONE;
* LinkedBlockingQueue<Task<ModularResultant>> resultantTasks = new LinkedBlockingQueue<Task<ModularResultant>>();
* Iterator<BigInteger> primes = BIGINT_PRIMES.Iterator();
* ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
* while (pProd.CompareTo(max2) < 0)
* {
* if (primes.hasNext())
* {
* prime = primes.next();
* }
* else
* {
* prime = prime.NextProbablePrime();
* }
* Task<ModularResultant> task = executor.submit(new ModResultantTask(prime.IntValue));
* resultantTasks.add(task);
* pProd = pProd.Multiply(prime);
* }
*
* // Combine modular resultants to obtain the resultant.
* // For efficiency, first combine all pairs of small resultants to bigger resultants,
* // then combine pairs of those, etc. until only one is left.
* ModularResultant overallResultant = null;
* while (!resultantTasks.isEmpty())
* {
* try
* {
* Task<ModularResultant> modRes1 = resultantTasks.take();
* Task<ModularResultant> modRes2 = resultantTasks.poll();
* if (modRes2 == null)
* {
* // modRes1 is the only one left
* overallResultant = await modRes1; //modRes1..get();
* break;
* }
* Task<ModularResultant> newTask = executor.submit(new CombineTask(modRes1.get(), modRes2.get()));
* resultantTasks.add(newTask);
* }
* catch (Exception e)
* {
* throw new InvalidOperationException(e.ToString());
* }
* }
* executor.shutdown();
* BigInteger res = overallResultant.res;
* BigIntPolynomial rhoP = overallResultant.rho;
*
* BigInteger pProd2 = pProd.divide(BigInteger.ValueOf(2));
* BigInteger pProd2n = pProd2.negate();
*
* if (res.compareTo(pProd2) > 0)
* {
* res = res.subtract(pProd);
* }
* if (res.compareTo(pProd2n) < 0)
* {
* res = res.add(pProd);
* }
*
* for (int i = 0; i < N; i++)
* {
* BigInteger c = rhoP.coeffs[i];
* if (c.compareTo(pProd2) > 0)
* {
* rhoP.coeffs[i] = c.subtract(pProd);
* }
* if (c.compareTo(pProd2n) < 0)
* {
* rhoP.coeffs[i] = c.add(pProd);
* }
* }
*
* return new Resultant(rhoP, res);
* }
*/
/**
* Resultant of this polynomial with <code>x^n-1 mod p</code>.
*
* @return <code>(rho, res)</code> satisfying <code>res = rho*this + t*(x^n-1) mod p</code> for some integer <code>t</code>.
*/
public ModularResultant Resultant(int p)
{
// Add a coefficient as the following operations involve polynomials of degree deg(f)+1
int[] fcoeffs = new int[coeffs.Length + 1];
Array.Copy(coeffs, fcoeffs, coeffs.Length);
IntegerPolynomial f = new IntegerPolynomial(fcoeffs);
int N = fcoeffs.Length;
IntegerPolynomial a = new IntegerPolynomial(N);
a.coeffs[0] = -1;
a.coeffs[N - 1] = 1;
IntegerPolynomial b = new IntegerPolynomial(f.coeffs);
IntegerPolynomial v1 = new IntegerPolynomial(N);
IntegerPolynomial v2 = new IntegerPolynomial(N);
v2.coeffs[0] = 1;
int da = N - 1;
int db = b.Degree();
int ta = da;
int c = 0;
int r = 1;
while (db > 0)
{
c = Util.Util.Invert(b.coeffs[db], p);
c = (c * a.coeffs[da]) % p;
a.MultShiftSub(b, c, da - db, p);
v1.MultShiftSub(v2, c, da - db, p);
da = a.Degree();
if (da < db)
{
r *= Util.Util.Pow(b.coeffs[db], ta - da, p);
r %= p;
if (ta % 2 == 1 && db % 2 == 1)
{
r = (-r) % p;
}
IntegerPolynomial temp = a;
a = b;
b = temp;
int tempdeg = da;
da = db;
temp = v1;
v1 = v2;
v2 = temp;
ta = db;
db = tempdeg;
}
}
r *= Util.Util.Pow(b.coeffs[0], da, p);
r %= p;
c = Util.Util.Invert(b.coeffs[0], p);
v2.Multiply(c);
v2.Mod(p);
v2.Multiply(r);
v2.Mod(p);
// drop the highest coefficient so #coeffs matches the original input
int[] newCoeffs = new int[v2.coeffs.Length - 1];
Array.Copy(v2.coeffs, newCoeffs, v2.coeffs.Length - 1);
v2.coeffs = newCoeffs;
return(new ModularResultant(new BigIntPolynomial(v2), BigInteger.ValueOf(r), BigInteger.ValueOf(p)));
}
/**
* Computes the inverse mod <code>q; q</code> must be a power of 2.<br>
* Returns <code>null</code> if the polynomial is not invertible.
*
* @param q the modulus
* @return a new polynomial
*/
public IntegerPolynomial InvertFq(int q)
{
int N = coeffs.Length;
int k = 0;
IntegerPolynomial b = new IntegerPolynomial(N + 1);
b.coeffs[0] = 1;
IntegerPolynomial c = new IntegerPolynomial(N + 1);
IntegerPolynomial f = new IntegerPolynomial(N + 1);
Array.Copy(coeffs, f.coeffs, N);
f.ModPositive(2);
// set g(x) = x^N − 1
IntegerPolynomial g = new IntegerPolynomial(N + 1);
g.coeffs[0] = 1;
g.coeffs[N] = 1;
while (true)
{
while (f.coeffs[0] == 0)
{
for (int i = 1; i <= N; i++)
{
f.coeffs[i - 1] = f.coeffs[i]; // f(x) = f(x) / x
c.coeffs[N + 1 - i] = c.coeffs[N - i]; // c(x) = c(x) * x
}
f.coeffs[N] = 0;
c.coeffs[0] = 0;
k++;
if (f.EqualsZero())
{
return(null); // not invertible
}
}
if (f.EqualsOne())
{
break;
}
if (f.Degree() < g.Degree())
{
// exchange f and g
IntegerPolynomial temp = f;
f = g;
g = temp;
// exchange b and c
temp = b;
b = c;
c = temp;
}
f.Add(g, 2);
b.Add(c, 2);
}
if (b.coeffs[N] != 0)
{
return(null);
}
// Fq(x) = x^(N-k) * b(x)
IntegerPolynomial Fq = new IntegerPolynomial(N);
int j = 0;
k %= N;
for (int i = N - 1; i >= 0; i--)
{
j = i - k;
if (j < 0)
{
j += N;
}
Fq.coeffs[j] = b.coeffs[i];
}
return(Mod2ToModq(Fq, q));
}