NTL_START_IMPL
void add(mat_ZZ_p& X, const mat_ZZ_p& A, const mat_ZZ_p& B)
{
long n = A.NumRows();
long m = A.NumCols();
if (B.NumRows() != n || B.NumCols() != m)
LogicError("matrix add: dimension mismatch");
X.SetDims(n, m);
long i, j;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
add(X(i,j), A(i,j), B(i,j));
}
void plain_mul_transpose_aux(mat_ZZ_p& X, const mat_ZZ_p& A, const mat_ZZ_p& B)
{
long n = A.NumRows();
long l = A.NumCols();
long m = B.NumRows();
if (l != B.NumCols())
LogicError("matrix mul: dimension mismatch");
X.SetDims(n, m);
ZZ_pContext context;
context.save();
long sz = ZZ_p::ModulusSize();
bool seq = (double(n)*double(l)*double(m)*double(sz)*double(sz) < PAR_THRESH);
NTL_GEXEC_RANGE(seq, m, first, last)
NTL_IMPORT(n)
NTL_IMPORT(l)
NTL_IMPORT(m)
context.restore();
long i, j, k;
ZZ acc, tmp;
for (j = first; j < last; j++) {
const ZZ_p *B_col = B[j].elts();
for (i = 0; i < n; i++) {
clear(acc);
for (k = 0; k < l; k++) {
mul(tmp, rep(A[i][k]), rep(B_col[k]));
add(acc, acc, tmp);
}
conv(X[i][j], acc);
}
}
NTL_GEXEC_RANGE_END
}
void kernel(mat_ZZ_p& X, const mat_ZZ_p& A)
{
long m = A.NumRows();
long n = A.NumCols();
mat_ZZ_p M;
long r;
transpose(M, A);
r = gauss(M);
X.SetDims(m-r, m);
long i, j, k, s;
ZZ t1, t2;
ZZ_p T3;
vec_long D;
D.SetLength(m);
for (j = 0; j < m; j++) D[j] = -1;
vec_ZZ_p inverses;
inverses.SetLength(m);
j = -1;
for (i = 0; i < r; i++) {
do {
j++;
} while (IsZero(M[i][j]));
D[j] = i;
inv(inverses[j], M[i][j]);
}
for (k = 0; k < m-r; k++) {
vec_ZZ_p& v = X[k];
long pos = 0;
for (j = m-1; j >= 0; j--) {
if (D[j] == -1) {
if (pos == k)
set(v[j]);
else
clear(v[j]);
pos++;
}
else {
i = D[j];
clear(t1);
for (s = j+1; s < m; s++) {
mul(t2, rep(v[s]), rep(M[i][s]));
add(t1, t1, t2);
}
conv(T3, t1);
mul(T3, T3, inverses[j]);
negate(v[j], T3);
}
}
}
}
void inv(ZZ_p& d, mat_ZZ_p& X, const mat_ZZ_p& A)
{
long n = A.NumRows();
if (A.NumCols() != n)
Error("inv: nonsquare matrix");
if (n == 0) {
set(d);
X.SetDims(0, 0);
return;
}
long i, j, k, pos;
ZZ t1, t2;
ZZ *x, *y;
const ZZ& p = ZZ_p::modulus();
vec_ZZVec M;
sqr(t1, p);
mul(t1, t1, n);
M.SetLength(n);
for (i = 0; i < n; i++) {
M[i].SetSize(2*n, t1.size());
for (j = 0; j < n; j++) {
M[i][j] = rep(A[i][j]);
clear(M[i][n+j]);
}
set(M[i][n+i]);
}
ZZ det;
set(det);
for (k = 0; k < n; k++) {
pos = -1;
for (i = k; i < n; i++) {
rem(t1, M[i][k], p);
M[i][k] = t1;
if (pos == -1 && !IsZero(t1)) {
pos = i;
}
}
if (pos != -1) {
if (k != pos) {
swap(M[pos], M[k]);
NegateMod(det, det, p);
}
MulMod(det, det, M[k][k], p);
// make M[k, k] == -1 mod p, and make row k reduced
InvMod(t1, M[k][k], p);
NegateMod(t1, t1, p);
for (j = k+1; j < 2*n; j++) {
rem(t2, M[k][j], p);
MulMod(M[k][j], t2, t1, p);
}
for (i = k+1; i < n; i++) {
// M[i] = M[i] + M[k]*M[i,k]
t1 = M[i][k]; // this is already reduced
x = M[i].elts() + (k+1);
y = M[k].elts() + (k+1);
for (j = k+1; j < 2*n; j++, x++, y++) {
// *x = *x + (*y)*t1
mul(t2, *y, t1);
add(*x, *x, t2);
}
}
}
else {
clear(d);
return;
}
}
X.SetDims(n, n);
for (k = 0; k < n; k++) {
for (i = n-1; i >= 0; i--) {
clear(t1);
for (j = i+1; j < n; j++) {
mul(t2, rep(X[j][k]), M[i][j]);
add(t1, t1, t2);
}
sub(t1, t1, M[i][n+k]);
conv(X[i][k], t1);
}
}
conv(d, det);
}
NTL_START_IMPL
// ******************** Matrix Multiplication ************************
#ifdef NTL_HAVE_LL_TYPE
#define NTL_USE_MM_MATMUL (1)
#else
#define NTL_USE_MM_MATMUL (0)
#endif
#define PAR_THRESH (40000.0)
// *********************** Plain Matrix Multiplication ***************
void plain_mul_aux(mat_ZZ_p& X, const mat_ZZ_p& A, const mat_ZZ_p& B)
{
long n = A.NumRows();
long l = A.NumCols();
long m = B.NumCols();
if (l != B.NumRows())
LogicError("matrix mul: dimension mismatch");
X.SetDims(n, m);
ZZ_pContext context;
context.save();
long sz = ZZ_p::ModulusSize();
bool seq = (double(n)*double(l)*double(m)*double(sz)*double(sz) < PAR_THRESH);
NTL_GEXEC_RANGE(seq, m, first, last)
NTL_IMPORT(n)
NTL_IMPORT(l)
NTL_IMPORT(m)
context.restore();
long i, j, k;
ZZ acc, tmp;
vec_ZZ_p B_col;
B_col.SetLength(l);
for (j = first; j < last; j++) {
for (k = 0; k < l; k++) B_col[k] = B[k][j];
for (i = 0; i < n; i++) {
clear(acc);
for (k = 0; k < l; k++) {
mul(tmp, rep(A[i][k]), rep(B_col[k]));
add(acc, acc, tmp);
}
conv(X[i][j], acc);
}
}
NTL_GEXEC_RANGE_END
}
