void
nmod_poly_mat_det(nmod_poly_t det, const nmod_poly_mat_t A)
{
slong n = A->r;
if (n == 0)
{
nmod_poly_one(det);
}
else if (n == 1)
{
nmod_poly_set(det, nmod_poly_mat_entry(A, 0, 0));
}
else if (n == 2)
{
nmod_poly_t tmp;
nmod_poly_init(tmp, nmod_poly_mat_modulus(A));
nmod_poly_mul(det, nmod_poly_mat_entry(A, 0, 0),
nmod_poly_mat_entry(A, 1, 1));
nmod_poly_mul(tmp, nmod_poly_mat_entry(A, 0, 1),
nmod_poly_mat_entry(A, 1, 0));
nmod_poly_sub(det, det, tmp);
nmod_poly_clear(tmp);
}
else if (n < 15) /* should be entry sensitive too */
{
nmod_poly_mat_det_fflu(det, A);
}
else
{
nmod_poly_mat_det_interpolate(det, A);
}
}
long
nmod_poly_mat_find_pivot_partial(const nmod_poly_mat_t mat,
long start_row, long end_row, long c)
{
long best_row, best_length, i;
best_row = start_row;
best_length = nmod_poly_length(nmod_poly_mat_entry(mat, start_row, c));
for (i = start_row + 1; i < end_row; i++)
{
long l;
l = nmod_poly_length(nmod_poly_mat_entry(mat, i, c));
if (l != 0 && (best_length == 0 || l <= best_length))
{
best_row = i;
best_length = l;
}
}
if (best_length == 0)
return -1;
return best_row;
}
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_scalar_mul_nmod_poly(nmod_poly_mat_t B, const nmod_poly_mat_t A,
const nmod_poly_t c)
{
long i, j;
for (i = 0; i < nmod_poly_mat_nrows(B); i++)
for (j = 0; j < nmod_poly_mat_ncols(B); j++)
nmod_poly_mul(nmod_poly_mat_entry(B, i, j),
nmod_poly_mat_entry(A, i, j), c);
}
void
nmod_poly_mat_add(nmod_poly_mat_t C,
const nmod_poly_mat_t A, const nmod_poly_mat_t B)
{
long i, j;
for (i = 0; i < A->r; i++)
for (j = 0; j < A->c; j++)
nmod_poly_add(nmod_poly_mat_entry(C, i, j),
nmod_poly_mat_entry(A, i, j),
nmod_poly_mat_entry(B, i, j));
}
void
nmod_poly_mat_set(nmod_poly_mat_t B, const nmod_poly_mat_t A)
{
if (A != B)
{
long i, j;
for (i = 0; i < A->r; i++)
for (j = 0; j < A->c; j++)
nmod_poly_set(nmod_poly_mat_entry(B, i, j),
nmod_poly_mat_entry(A, i, j));
}
}
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;
}
void
nmod_poly_mat_evaluate_nmod(nmod_mat_t B, const nmod_poly_mat_t A, mp_limb_t x)
{
slong i, j;
for (i = 0; i < A->r; i++)
for (j = 0; j < A->c; j++)
nmod_mat_entry(B, i, j) = nmod_poly_evaluate_nmod(
nmod_poly_mat_entry(A, i, j), x);
}
void
nmod_poly_mat_randtest_sparse(nmod_poly_mat_t A, flint_rand_t state, long len,
float density)
{
long i, j;
for (i = 0; i < A->r; i++)
{
for (j = 0; j < A->c; j++)
{
if (n_randint(state, 1000) < density * 1000)
{
long l = n_randint(state, len + 1);
l = FLINT_MAX(l, 1);
nmod_poly_randtest(nmod_poly_mat_entry(A, i, j), state, l);
}
else
{
nmod_poly_zero(nmod_poly_mat_entry(A, i, j));
}
}
}
}
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);
}
long
nmod_poly_mat_max_length(const nmod_poly_mat_t A)
{
long i, j, len, max;
max = 0;
for (i = 0; i < A->r; i++)
{
for (j = 0; j < A->c; j++)
{
len = nmod_poly_length(nmod_poly_mat_entry(A, i, j));
max = FLINT_MAX(len, max);
}
}
return max;
}
slong
nmod_poly_mat_rref(nmod_poly_mat_t R, nmod_poly_t den, const nmod_poly_mat_t A)
{
slong i, j, k, m, n, rank;
slong *pivots, *nonpivots;
rank = nmod_poly_mat_fflu(R, den, NULL, A, 0);
m = nmod_poly_mat_nrows(R);
n = nmod_poly_mat_ncols(R);
/* clear bottom */
for (i = rank; i < m; i++)
for (j = 0; j < n; j++)
nmod_poly_zero(nmod_poly_mat_entry(R, i, j));
/* Convert row echelon form to reduced row echelon form */
if (rank > 1)
{
nmod_poly_t tmp, tmp2;
nmod_poly_init(tmp, nmod_poly_mat_modulus(R));
nmod_poly_init(tmp2, nmod_poly_mat_modulus(R));
pivots = flint_malloc(sizeof(slong) * n);
nonpivots = pivots + rank;
/* find pivot positions */
for (i = j = k = 0; i < rank; i++)
{
while (nmod_poly_is_zero(nmod_poly_mat_entry(R, i, j)))
{
nonpivots[k] = j;
k++;
j++;
}
pivots[i] = j;
j++;
}
while (k < n - rank)
{
nonpivots[k] = j;
k++;
j++;
}
for (k = 0; k < n - rank; k++)
{
for (i = rank - 2; i >= 0; i--)
{
nmod_poly_mul(tmp, den, nmod_poly_mat_entry(R, i, nonpivots[k]));
for (j = i + 1; j < rank; j++)
{
nmod_poly_mul(tmp2, nmod_poly_mat_entry(R, i, pivots[j]),
nmod_poly_mat_entry(R, j, nonpivots[k]));
nmod_poly_sub(tmp, tmp, tmp2);
}
nmod_poly_div(nmod_poly_mat_entry(R, i, nonpivots[k]),
tmp, nmod_poly_mat_entry(R, i, pivots[i]));
}
}
/* clear pivot columns */
for (i = 0; i < rank; i++)
{
for (j = 0; j < rank; j++)
{
if (i == j)
nmod_poly_set(nmod_poly_mat_entry(R, j, pivots[i]), den);
else
nmod_poly_zero(nmod_poly_mat_entry(R, j, pivots[i]));
}
}
flint_free(pivots);
nmod_poly_clear(tmp);
nmod_poly_clear(tmp2);
}
return rank;
}
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);
}