~/ntl-11.4.2/doc/mat_ZZ.cpp.html

    /**************************************************************************\

    MODULE: mat_ZZ

    SUMMARY:

    Defines the class mat_ZZ.

    \**************************************************************************/

    #include <NTL/matrix.h>
    #include <NTL/vec_vec_ZZ.h>

    typedef Mat<ZZ> mat_ZZ; // backward compatibility

    void add(mat_ZZ& X, const mat_ZZ& A, const mat_ZZ& B);
    // X = A + B

    void sub(mat_ZZ& X, const mat_ZZ& A, const mat_ZZ& B);
    // X = A - B

    void negate(mat_ZZ& X, const mat_ZZ& A);
    // X = - A

    void mul(mat_ZZ& X, const mat_ZZ& A, const mat_ZZ& B);
    // X = A * B

    void mul(vec_ZZ& x, const mat_ZZ& A, const vec_ZZ& b);
    // x = A * b

    void mul(vec_ZZ& x, const vec_ZZ& a, const mat_ZZ& B);
    // x = a * B

    void mul(mat_ZZ& X, const mat_ZZ& A, const ZZ& b);
    void mul(mat_ZZ& X, const mat_ZZ& A, long b);
    // X = A * b

    void mul(mat_ZZ& X, const ZZ& a, const mat_ZZ& B);
    void mul(mat_ZZ& X, long a, const mat_ZZ& B);
    // X = a * B

    void determinant(ZZ& d, const mat_ZZ& A, long deterministic=0);
    ZZ determinant(const mat_ZZ& a, long deterministic=0);
    // d = determinant(A).  If !deterministic, a randomized strategy may
    // be used that errs with probability at most 2^{-80}.

    void solve(ZZ& d, vec_ZZ& x,
               const mat_ZZ& A, const vec_ZZ& b,
               long deterministic=0)
    // computes d = determinant(A) and solves x*A = b*d if d != 0; A must
    // be a square matrix and have compatible dimensions with b.  If
    // !deterministic, the computation of d may use a randomized strategy
    // that errs with probability 2^{-80}.

    void solve1(ZZ& d, vec_ZZ& x, const mat_ZZ& A, const vec_ZZ& b);
    // A must be a square matrix.
    // If A is singular, this routine sets d = 0 and returns.
    // Otherwise, it computes d, x such that x*A == b*d,
    // such that d > 0 and minimal.
    // Note that d is a positive divisor of the determinant,
    // and is not in general equal to the determinant.
    // The routine is deterministic, and uses a Hensel lifting strategy.

    // For backward compatability, there is also a routine called
    // HenselSolve1 that simply calls solve1.

    void inv(ZZ& d, mat_ZZ& X, const mat_ZZ& A, long deterministic=0);
    // computes d = determinant(A) and solves X*A = I*d if d != 0; A must
    // be a square matrix.  If !deterministic, the computation of d may
    // use a randomized strategy that errs with probability 2^{-80}.

    // NOTE:  See LLL.txt for routines that compute the kernel and
    // image of an integer matrix.

    // NOTE: See HNF.txt for a routine that computes Hermite Normal Forms.

    void sqr(mat_ZZ& X, const mat_ZZ& A);
    mat_ZZ sqr(const mat_ZZ& A);
    // X = A*A

    void inv(mat_ZZ& X, const mat_ZZ& A);
    mat_ZZ inv(const mat_ZZ& A);
    // X = A^{-1}; error is raised if |det(A)| != 1.

    void power(mat_ZZ& X, const mat_ZZ& A, const ZZ& e);
    mat_ZZ power(const mat_ZZ& A, const ZZ& e);

    void power(mat_ZZ& X, const mat_ZZ& A, long e);
    mat_ZZ power(const mat_ZZ& A, long e);
    // X = A^e; e may be negative (in which case A must be nonsingular).

    void ident(mat_ZZ& X, long n);
    mat_ZZ ident_mat_ZZ(long n);
    // X = n x n identity matrix

    long IsIdent(const mat_ZZ& A, long n);
    // test if A is the n x n identity matrix

    void diag(mat_ZZ& X, long n, const ZZ& d);
    mat_ZZ diag(long n, const ZZ& d);
    // X = n x n diagonal matrix with d on diagonal

    long IsDiag(const mat_ZZ& A, long n, const ZZ& d);
    // test if X is an  n x n diagonal matrix with d on diagonal

    void transpose(mat_ZZ& X, const mat_ZZ& A);
    mat_ZZ transpose(const mat_ZZ& A);
    // X = transpose of A

    long CRT(mat_ZZ& a, ZZ& prod, const mat_zz_p& A);
    // Incremental Chinese Remaindering: If p is the current zz_p modulus with
    // (p, prod) = 1; Computes a' such that a' = a mod prod and a' = A mod p,
    // with coefficients in the interval (-p*prod/2, p*prod/2];
    // Sets a := a', prod := p*prod, and returns 1 if a's value changed.

    // miscellaneous:

    void clear(mat_ZZ& a);
    // x = 0 (dimension unchanged)

    long IsZero(const mat_ZZ& a);
    // test if a is the zero matrix (any dimension)

    // operator notation:

    mat_ZZ operator+(const mat_ZZ& a, const mat_ZZ& b);
    mat_ZZ operator-(const mat_ZZ& a, const mat_ZZ& b);
    mat_ZZ operator*(const mat_ZZ& a, const mat_ZZ& b);

    mat_ZZ operator-(const mat_ZZ& a);

    // matrix/scalar multiplication:

    mat_ZZ operator*(const mat_ZZ& a, const ZZ& b);
    mat_ZZ operator*(const mat_ZZ& a, long b);

    mat_ZZ operator*(const ZZ& a, const mat_ZZ& b);
    mat_ZZ operator*(long a, const mat_ZZ& b);

    // matrix/vector multiplication:

    vec_ZZ operator*(const mat_ZZ& a, const vec_ZZ& b);

    vec_ZZ operator*(const vec_ZZ& a, const mat_ZZ& b);

    // assignment operator notation:

    mat_ZZ& operator+=(mat_ZZ& x, const mat_ZZ& a);
    mat_ZZ& operator-=(mat_ZZ& x, const mat_ZZ& a);
    mat_ZZ& operator*=(mat_ZZ& x, const mat_ZZ& a);

    mat_ZZ& operator*=(mat_ZZ& x, const ZZ& a);
    mat_ZZ& operator*=(mat_ZZ& x, long a);

    vec_ZZ& operator*=(vec_ZZ& x, const mat_ZZ& a);