int
main(void)
{
int i;
flint_rand_t state;
flint_randinit(state);
printf("init/clear....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
nmod_poly_mat_t a;
mp_limb_t mod;
long j, k;
long rows = n_randint(state, 100);
long cols = n_randint(state, 100);
mod = n_randtest_prime(state, 0);
nmod_poly_mat_init(a, rows, cols, mod);
for (j = 0; j < rows; j++)
for (k = 0; k < cols; k++)
nmod_poly_zero(nmod_poly_mat_entry(a, j, k));
nmod_poly_mat_clear(a);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int
main(void)
{
flint_rand_t state;
int iter;
printf("one/is_one....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
nmod_poly_mat_t A;
long m, n;
mp_limb_t mod;
mod = n_randtest_prime(state, 0);
m = n_randint(state, 10);
n = n_randint(state, 10);
nmod_poly_mat_init(A, m, n, mod);
nmod_poly_mat_randtest(A, state, n_randint(state, 5));
nmod_poly_mat_one(A);
if (!nmod_poly_mat_is_one(A))
{
printf("FAIL: expected matrix to be one\n");
abort();
}
if (m > 0 && n > 0)
{
m = n_randint(state, m);
n = n_randint(state, n);
if (m != n)
nmod_poly_randtest_not_zero(nmod_poly_mat_entry(A, m, n),
state, 5);
else
do { nmod_poly_randtest_not_zero(nmod_poly_mat_entry(A, m, n),
state, 5); }
while (nmod_poly_is_one(nmod_poly_mat_entry(A, m, n)));
if (nmod_poly_mat_is_one(A))
{
printf("FAIL: expected matrix not to be one\n");
abort();
}
}
nmod_poly_mat_clear(A);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
void nmod_poly_mat_right_tmul(nmod_poly_mat_t C, const nmod_poly_mat_t L, const nmod_poly_mat_t Bin, long m, long k){
long qq = nmod_poly_mat_nrows(Bin);
long rr = nmod_poly_mat_ncols(Bin);
long pp = nmod_poly_mat_nrows(L);
nmod_poly_mat_t B;
nmod_poly_mat_init(B, rr, qq, nmod_poly_mat_modulus(Bin));
long i, j;
for (i = 0; i < rr; i++)
for (j = 0; j < qq; j++)
nmod_poly_reverse(nmod_poly_mat_entry(B, i, j), nmod_poly_mat_entry(Bin, j, i), m+1);
nmod_poly_mat_mul(C, L, B);
for (i = 0; i < pp; i++)
for (j = 0; j < qq; j++){
nmod_poly_truncate(nmod_poly_mat_entry(C, i, j), k+m);
nmod_poly_shift_right(nmod_poly_mat_entry(C, i, j), nmod_poly_mat_entry(C, i, j), m);
}
nmod_poly_mat_clear(B);
}
int
main(void)
{
flint_rand_t state;
long i;
printf("pow....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 1000; i++)
{
nmod_poly_mat_t A, B, C;
long m, j, exp, deg;
mp_limb_t mod;
mod = n_randtest_prime(state, 0);
m = n_randint(state, 6);
deg = 1 + n_randint(state, 6);
exp = n_randint(state, 20);
nmod_poly_mat_init(A, m, m, mod);
nmod_poly_mat_init(B, m, m, mod);
nmod_poly_mat_init(C, m, m, mod);
nmod_poly_mat_randtest(A, state, deg);
nmod_poly_mat_pow(B, A, exp);
nmod_poly_mat_one(C);
for (j = 0; j < exp; j++)
nmod_poly_mat_mul(C, C, A);
if (!nmod_poly_mat_equal(C, B))
{
printf("FAIL:\n");
printf("exp = %ld\n", exp);
printf("A:\n");
nmod_poly_mat_print(A, "x");
printf("B:\n");
nmod_poly_mat_print(B, "x");
printf("C:\n");
nmod_poly_mat_print(C, "x");
printf("\n");
abort();
}
nmod_poly_mat_clear(A);
nmod_poly_mat_clear(B);
nmod_poly_mat_clear(C);
}
/* Check aliasing B and A */
for (i = 0; i < 1000; i++)
{
nmod_poly_mat_t A, B;
long m, exp, deg;
mp_limb_t mod;
mod = n_randtest_prime(state, 0);
m = n_randint(state, 6);
deg = 1 + n_randint(state, 6);
exp = n_randint(state, 20);
nmod_poly_mat_init(A, m, m, mod);
nmod_poly_mat_init(B, m, m, mod);
nmod_poly_mat_randtest(A, state, deg);
nmod_poly_mat_pow(B, A, exp);
nmod_poly_mat_pow(A, A, exp);
if (!nmod_poly_mat_equal(A, B))
{
printf("FAIL (aliasing)\n");
printf("exp = %ld\n", exp);
printf("A:\n");
nmod_poly_mat_print(A, "x");
printf("B:\n");
nmod_poly_mat_print(B, "x");
printf("\n");
abort();
}
nmod_poly_mat_clear(A);
nmod_poly_mat_clear(B);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
flint_rand_t state;
long i;
printf("mul_interpolate....");
fflush(stdout);
flint_randinit(state);
/* Check evaluation homomorphism */
for (i = 0; i < 1000; i++)
{
nmod_poly_mat_t A, B, C;
nmod_mat_t a, b, c, d;
mp_limb_t mod, x;
long m, n, k, deg;
mod = n_randtest_prime(state, 0);
m = n_randint(state, 20);
n = n_randint(state, 20);
k = n_randint(state, 20);
deg = 1 + n_randint(state, 10);
nmod_poly_mat_init(A, m, n, mod);
nmod_poly_mat_init(B, n, k, mod);
nmod_poly_mat_init(C, m, k, mod);
nmod_mat_init(a, m, n, mod);
nmod_mat_init(b, n, k, mod);
nmod_mat_init(c, m, k, mod);
nmod_mat_init(d, m, k, mod);
nmod_poly_mat_randtest(A, state, deg);
nmod_poly_mat_randtest(B, state, deg);
nmod_poly_mat_randtest(C, state, deg); /* noise in output */
if (nmod_poly_mat_max_length(A)
+ nmod_poly_mat_max_length(B) - 1 <= mod)
{
nmod_poly_mat_mul_interpolate(C, A, B);
x = n_randint(state, mod);
nmod_poly_mat_evaluate_nmod(a, A, x);
nmod_poly_mat_evaluate_nmod(b, B, x);
nmod_poly_mat_evaluate_nmod(d, C, x);
nmod_mat_mul(c, a, b);
if (!nmod_mat_equal(c, d))
{
printf("FAIL:\n");
printf("A:\n");
nmod_poly_mat_print(A, "x");
printf("B:\n");
nmod_poly_mat_print(B, "x");
printf("C:\n");
nmod_poly_mat_print(C, "x");
printf("\n");
abort();
}
}
nmod_poly_mat_clear(A);
nmod_poly_mat_clear(B);
nmod_poly_mat_clear(C);
nmod_mat_clear(a);
nmod_mat_clear(b);
nmod_mat_clear(c);
nmod_mat_clear(d);
}
/* Check aliasing C and A */
for (i = 0; i < 1000; i++)
{
nmod_poly_mat_t A, B, C;
long m, n, deg;
mp_limb_t mod;
mod = n_randtest_prime(state, 0);
m = n_randint(state, 20);
n = n_randint(state, 20);
deg = 1 + n_randint(state, 10);
nmod_poly_mat_init(A, m, n, mod);
nmod_poly_mat_init(B, n, n, mod);
nmod_poly_mat_init(C, m, n, mod);
nmod_poly_mat_randtest(A, state, deg);
nmod_poly_mat_randtest(B, state, deg);
nmod_poly_mat_randtest(C, state, deg); /* noise in output */
if (nmod_poly_mat_max_length(A)
+ nmod_poly_mat_max_length(B) - 1 <= mod)
{
nmod_poly_mat_mul_interpolate(C, A, B);
nmod_poly_mat_mul_interpolate(A, A, B);
if (!nmod_poly_mat_equal(C, A))
{
printf("FAIL:\n");
printf("A:\n");
nmod_poly_mat_print(A, "x");
printf("B:\n");
nmod_poly_mat_print(B, "x");
printf("C:\n");
nmod_poly_mat_print(C, "x");
printf("\n");
abort();
}
}
nmod_poly_mat_clear(A);
nmod_poly_mat_clear(B);
nmod_poly_mat_clear(C);
}
/* Check aliasing C and B */
for (i = 0; i < 1000; i++)
{
nmod_poly_mat_t A, B, C;
long m, n, deg;
mp_limb_t mod;
mod = n_randtest_prime(state, 0);
m = n_randint(state, 20);
n = n_randint(state, 20);
deg = 1 + n_randint(state, 10);
nmod_poly_mat_init(A, m, m, mod);
nmod_poly_mat_init(B, m, n, mod);
nmod_poly_mat_init(C, m, n, mod);
nmod_poly_mat_randtest(A, state, deg);
nmod_poly_mat_randtest(B, state, deg);
nmod_poly_mat_randtest(C, state, deg); /* noise in output */
if (nmod_poly_mat_max_length(A)
+ nmod_poly_mat_max_length(B) - 1 <= mod)
{
nmod_poly_mat_mul_interpolate(C, A, B);
nmod_poly_mat_mul_interpolate(B, A, B);
if (!nmod_poly_mat_equal(C, B))
{
printf("FAIL:\n");
printf("A:\n");
nmod_poly_mat_print(A, "x");
printf("B:\n");
nmod_poly_mat_print(B, "x");
printf("C:\n");
nmod_poly_mat_print(C, "x");
printf("\n");
abort();
}
}
nmod_poly_mat_clear(A);
nmod_poly_mat_clear(B);
nmod_poly_mat_clear(C);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
long
nmod_poly_mat_nullspace(nmod_poly_mat_t res, const nmod_poly_mat_t mat)
{
long i, j, k, m, n, rank, nullity;
long * pivots;
long * nonpivots;
nmod_poly_mat_t tmp;
nmod_poly_t den;
m = mat->r;
n = mat->c;
nmod_poly_init(den, nmod_poly_mat_modulus(mat));
nmod_poly_mat_init_set(tmp, mat);
rank = nmod_poly_mat_rref(tmp, den, NULL, tmp);
nullity = n - rank;
nmod_poly_mat_zero(res);
if (rank == 0)
{
for (i = 0; i < nullity; i++)
nmod_poly_one(res->rows[i] + i);
}
else if (nullity)
{
pivots = flint_malloc(rank * sizeof(long));
nonpivots = flint_malloc(nullity * sizeof(long));
for (i = j = k = 0; i < rank; i++)
{
while (nmod_poly_is_zero(tmp->rows[i] + j))
{
nonpivots[k] = j;
k++;
j++;
}
pivots[i] = j;
j++;
}
while (k < nullity)
{
nonpivots[k] = j;
k++;
j++;
}
nmod_poly_set(den, tmp->rows[0] + pivots[0]);
for (i = 0; i < nullity; i++)
{
for (j = 0; j < rank; j++)
nmod_poly_set(res->rows[pivots[j]] + i,
tmp->rows[j] + nonpivots[i]);
nmod_poly_neg(res->rows[nonpivots[i]] + i, den);
}
flint_free(pivots);
flint_free(nonpivots);
}
nmod_poly_clear(den);
nmod_poly_mat_clear(tmp);
return nullity;
}
int
main(void)
{
flint_rand_t state;
long i;
printf("sqr....");
fflush(stdout);
flint_randinit(state);
/* Check evaluation homomorphism */
for (i = 0; i < 1000; i++)
{
nmod_poly_mat_t A, C;
nmod_mat_t a, c, d;
mp_limb_t x, mod;
long m, deg;
mod = n_randtest_prime(state, 0);
m = n_randint(state, 20);
deg = 1 + n_randint(state, 10);
nmod_poly_mat_init(A, m, m, mod);
nmod_poly_mat_init(C, m, m, mod);
nmod_mat_init(a, m, m, mod);
nmod_mat_init(c, m, m, mod);
nmod_mat_init(d, m, m, mod);
nmod_poly_mat_randtest(A, state, deg);
nmod_poly_mat_randtest(C, state, deg); /* noise in output */
nmod_poly_mat_sqr(C, A);
x = n_randint(state, 0);
nmod_poly_mat_evaluate_nmod(a, A, x);
nmod_poly_mat_evaluate_nmod(d, C, x);
nmod_mat_mul(c, a, a);
if (!nmod_mat_equal(c, d))
{
printf("FAIL:\n");
printf("A:\n");
nmod_poly_mat_print(A, "x");
printf("C:\n");
nmod_poly_mat_print(C, "x");
printf("\n");
abort();
}
nmod_poly_mat_clear(A);
nmod_poly_mat_clear(C);
nmod_mat_clear(a);
nmod_mat_clear(c);
nmod_mat_clear(d);
}
/* Check aliasing B and A */
for (i = 0; i < 1000; i++)
{
nmod_poly_mat_t A, B;
long m, deg;
mp_limb_t mod;
mod = n_randtest_prime(state, 0);
m = n_randint(state, 20);
deg = 1 + n_randint(state, 10);
nmod_poly_mat_init(A, m, m, mod);
nmod_poly_mat_init(B, m, m, mod);
nmod_poly_mat_randtest(A, state, deg);
nmod_poly_mat_randtest(B, state, deg); /* noise in output */
nmod_poly_mat_sqr(B, A);
nmod_poly_mat_sqr(A, A);
if (!nmod_poly_mat_equal(B, A))
{
printf("FAIL (aliasing):\n");
printf("A:\n");
nmod_poly_mat_print(A, "x");
printf("B:\n");
nmod_poly_mat_print(B, "x");
printf("\n");
abort();
}
nmod_poly_mat_clear(A);
nmod_poly_mat_clear(B);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
nmod_poly_mat_inv(nmod_poly_mat_t Ainv, nmod_poly_t den,
const nmod_poly_mat_t A)
{
slong n = nmod_poly_mat_nrows(A);
if (n == 0)
{
nmod_poly_one(den);
return 1;
}
else if (n == 1)
{
nmod_poly_set(den, E(A, 0, 0));
nmod_poly_one(E(Ainv, 0, 0));
return !nmod_poly_is_zero(den);
}
else if (n == 2)
{
nmod_poly_mat_det(den, A);
if (nmod_poly_is_zero(den))
{
return 0;
}
else if (Ainv == A)
{
nmod_poly_swap(E(A, 0, 0), E(A, 1, 1));
nmod_poly_neg(E(A, 0, 1), E(A, 0, 1));
nmod_poly_neg(E(A, 1, 0), E(A, 1, 0));
return 1;
}
else
{
nmod_poly_set(E(Ainv, 0, 0), E(A, 1, 1));
nmod_poly_set(E(Ainv, 1, 1), E(A, 0, 0));
nmod_poly_neg(E(Ainv, 0, 1), E(A, 0, 1));
nmod_poly_neg(E(Ainv, 1, 0), E(A, 1, 0));
return 1;
}
}
else
{
nmod_poly_mat_t LU, I;
slong * perm;
int result;
perm = _perm_init(n);
nmod_poly_mat_init_set(LU, A);
result = (nmod_poly_mat_fflu(LU, den, perm, LU, 1) == n);
if (result)
{
nmod_poly_mat_init(I, n, n, nmod_poly_mat_modulus(A));
nmod_poly_mat_one(I);
nmod_poly_mat_solve_fflu_precomp(Ainv, perm, LU, I);
nmod_poly_mat_clear(I);
}
else
nmod_poly_zero(den);
if (_perm_parity(perm, n))
{
nmod_poly_mat_neg(Ainv, Ainv);
nmod_poly_neg(den, den);
}
_perm_clear(perm);
nmod_poly_mat_clear(LU);
return result;
}
}
void embeddings_isomorphism_2(nmod_poly_t G, mp_srcptr F,
const embeddings_t FP, const embeddings_t FQ, const embeddings_t FR){
nmod_t mod = G->mod;
long m = nmod_poly_degree(FP->P);
long n = nmod_poly_degree(FQ->P);
long np = n + m - 1;
long p = ceil(sqrt(np));
long q = ceil((1.0*np)/p);
long i, j, k;
nmod_poly_t iT, iTm, T, X, tmp;
nmod_poly_struct *TT;
nmod_poly_init(iTm, mod.n);
nmod_poly_init(iT, mod.n);
nmod_poly_init(T, mod.n);
nmod_poly_init(X, mod.n);
nmod_poly_init(tmp, mod.n);
nmod_poly_mat_t MT, MH, MV;
nmod_poly_mat_init(MT, q, n, mod.n);
nmod_poly_mat_init(MH, p, q, mod.n);
nmod_poly_mat_init(MV, p, n, mod.n);
TT = flint_malloc(sizeof(nmod_poly_struct) * (q+1));
for (i = 0; i < q+1; i++)
nmod_poly_init(TT+i, mod.n);
nmod_poly_set_coeff_ui(X, 1, 1);
embeddings_embed(T, X, FQ, FP, FR);
nmod_poly_invmod(iT, T, FR->P);
nmod_poly_powmod_ui_binexp(iTm, iT, m-1, FR->P);
nmod_poly_zero(TT);
nmod_poly_set_coeff_ui(TT, 0, 1);
for (i = 1; i < q+1; i++)
nmod_poly_mulmod(TT+i, TT+(i-1), T, FR->P);
for (i = 0; i < q; i++)
for (j = 0; j < n; j++){
long jm = j*m;
for (k = 0; k < m; k++)
nmod_poly_set_coeff_ui(nmod_poly_mat_entry(MT, i, j), k, nmod_poly_get_coeff_ui(TT+i, k+jm));
}
for (i = 0; i < p; i++)
for (j = 0; j < q; j++){
long idx = i*q+j;
long lo = FLINT_MAX(0,m-1-idx);
long hi = FLINT_MIN(m,n+m-1-idx);
for (k = lo; k < hi; k++)
nmod_poly_set_coeff_ui(nmod_poly_mat_entry(MH, i, j), k, F[k*n+k+idx-m+1]);
}
nmod_poly_mat_mul(MV, MH, MT);
nmod_poly_zero(G);
for (i = p-1; i >= 0; i--){
nmod_poly_zero(tmp);
for (j = 0; j < n; j++){
long len = nmod_poly_mat_entry(MV, i, j)->length;
mp_ptr coefs = nmod_poly_mat_entry(MV, i, j)->coeffs;
long jm = j*m;
for (k = 0; k < len; k++)
nmod_poly_set_coeff_ui(tmp, k+jm, n_addmod(nmod_poly_get_coeff_ui(tmp, k+jm), coefs[k], mod.n));
}
nmod_poly_rem(tmp, tmp, FR->P);
nmod_poly_mulmod(G, G, TT+q, FR->P);
nmod_poly_add(G, G, tmp);
}
nmod_poly_mulmod(G, G, iTm, FR->P);
nmod_poly_clear(tmp);
nmod_poly_mat_clear(MT);
nmod_poly_mat_clear(MH);
nmod_poly_mat_clear(MV);
for (i = 0; i < q+1; i++)
nmod_poly_clear(TT+i);
flint_free(TT);
nmod_poly_clear(iTm);
nmod_poly_clear(iT);
nmod_poly_clear(T);
nmod_poly_clear(X);
}
