acb_mat.h

Returns a pointer to the entry in row i and column j of mat; the same as acb_mat_entry, as a function.

Initialises mat as the zero matrix with r rows and c columns.

Frees the memory used by mat.

Swap two matrices. acb_mat_swap swaps the structures (also when the dimensions differ); acb_mat_swap_entrywise swaps the entries one by one and requires equal dimensions, which also works for windows.

Returns the number of bytes allocated on the heap by x, excluding sizeof(acb_mat_struct).

Initialise window as a view of the submatrix of mat formed by rows r_1 \le i < r_2 and columns c_1 \le j < c_2, sharing its entries, and release it again (which frees nothing). Require 0 \le r_1 \le r_2 \le the number of rows and likewise for the columns. A window must not be used after mat has been cleared.

Set dest to src, which must have the same dimensions: exactly, or with the entries rounded to prec bits. Real input gives entries with imaginary part exactly zero.

Extract the real or imaginary parts of the entries of mat, or set mat to \mathit{re} + i \cdot \mathit{im}, exactly.

Sets mat to a random matrix of random density whose nonzero entries have midpoints of up to prec bits and exponents of up to mag_bits bits.

Sets the square matrix mat to a random matrix with the eigenvalues given by the vector E (with their multiplicities), constructed as Q U Q^{*} with Q the exponential of a random skew-Hermitian matrix (unitary up to rounding) and U a random upper triangular matrix with diagonal E. The result is computed in ball arithmetic and contains a matrix with exactly these eigenvalues. For testing.

Print mat to standard output or to file, one row per line as [a, b, ...], each entry printed with acb_fprintd to digits decimal digits.

Returns whether the matrices have the same dimensions and identical balls as entries.

Returns whether the matrices have the same dimensions and each entry of mat1 overlaps the corresponding entry of mat2.

Return whether the matrices have the same dimensions and each entry of mat2 is contained in the corresponding entry of mat1.

Return whether mat1 and mat2 certainly represent the same matrix (same dimensions and all entries exact and equal), respectively certainly represent different matrices (different dimensions, or some pair of entries that do not overlap).

Return whether mat has zero rows or zero columns, respectively as many rows as columns.

Return whether all entries of mat have zero radius, are exactly zero, or are finite.

Returns whether all entries of mat have imaginary part exactly zero.

Return whether all entries below, above, respectively off the main diagonal of mat are exactly zero. The matrix need not be square.

Set all entries of mat to zero; the diagonal entries to one and the others to zero; all entries to one; the diagonal entries to i and the others to zero; or all entries to indeterminate balls.

Sets mat to the unitary DFT matrix of order n, the smaller dimension of mat,

which satisfies A^{-1} = A^{*} (if mat is not square, the formula is used for all entries). type is ignored and should be 0.

Set dest to the transpose, respectively the conjugate transpose, of src, exactly. Aliasing is allowed for square matrices.

Sets dest to the entrywise complex conjugate of src.

Sets b to an upper bound for the infinity norm \max_i \sum_j |a_{ij}| of every matrix in A.

Set res to an enclosure, respectively an upper bound, of the Frobenius norm (\sum_{i,j} |a_{ij}|^2)^{1/2}.

Sets dest to -\mathit{src}, exactly.

Set res to the sum or difference of matrices of equal dimensions.

Set res to the matrix product. The classical version computes each entry with acb_dot, and the threaded version does the same with the rows of the output distributed over flint_get_num_threads() threads. The reorder version writes the operands as A = A_r + iA_i, B = B_r + iB_i with real matrices and computes the product with real matrix multiplications by arb_mat_mul (one if both operands are real, two if one is, otherwise four, A_r B_r - A_i B_i and A_r B_i + A_i B_r), which benefits from the block algorithm of arb_mat_mul_block.

Sets res to the entrywise product of matrices of equal dimensions.

Set res to A^2 for a square matrix A.

Sets res to A^e for a square matrix A, by binary exponentiation. A wrapper of gr_mat_pow_ui.

Approximate matrix multiplication: the input radii are ignored and the output is a floating-point approximation of the product of the midpoints. The output radii carry no meaning.

Sets B to 2^c A, exactly.

Set B to B + cA.

Set B to cA.

Set B to A / c.

Set res to the product vA of the row vector v (of length the number of rows of A) by A, respectively the product Av of A by the column vector v, each entry computed by acb_dot. The underscore versions do not allow res to alias v.

Compute an LU decomposition PA = LU of an n \times n matrix A by Gaussian elimination with partial pivoting in ball arithmetic. Return nonzero if n pivots that do not contain zero are found, which proves that A is invertible; then L (unit lower triangular, without its diagonal) and U are stored in LU, and perm[i] is the row of A that became row i. Return zero, leaving perm and LU undefined, otherwise. LU may be the same object as A.

Solve LX = B for a lower triangular L, respectively UX = B for an upper triangular U, by substitution. Only the relevant triangle is read; the diagonal must not contain zero (not checked; otherwise the output is not finite). If unit is nonzero, the diagonal is taken to be all ones and is not read. The recursive versions use block substitution with matrix products; the defaults use them when B has at least 40 rows and 40 columns.

Solves AX = B given an LU decomposition PA = LU computed by acb_mat_lu (assumed valid, not checked). X may be the same object as B but not as LU.

Solve AX = B for a square matrix A and X, B with m columns. Return nonzero if A is proved invertible, in which case X contains the exact solution for every pair of matrices in the balls A and B; return zero (with X undefined) if m > 0 and this could not be proved. The lu version uses Gaussian elimination in ball arithmetic, the precond version preconditions with an approximate inverse [HS1967], and the default uses the lu version if n \le 4 or \mathit{prec} > 10n and the precond version otherwise. See Solving linear systems with ball matrices.

Sets X to A^{-1} by solving AX = I with acb_mat_solve. Returns nonzero if A is proved invertible (and X contains the exact inverse) and zero otherwise, with X undefined.

Set det to an enclosure of the determinant of the square matrix A. The lu version uses Gaussian elimination and bounds the remaining submatrix by Hadamard's inequality when no more pivots can be found; the precond version multiplies A by approximate inverses of the factors of an approximate LU decomposition and encloses the determinant of the result, which is close to the identity [Rum2010]. The default uses direct formulas for n \le 3 and triangular matrices, the lu version if n \le 14 or \mathit{prec} > 10n, and the precond version otherwise; it throws an exception for a non-square matrix.

Approximately solve UX = B or LX = B for a triangular matrix with nonzero diagonal (not checked); with unit set, the diagonal is taken to be ones and not read.

Compute an approximate LU decomposition with partial pivoting, returning zero if an exactly zero pivot column is encountered, and solve with such a decomposition (assumed to come from acb_mat_approx_lu).

Approximately solve AX = B or invert A. Return zero if the approximate LU decomposition fails, nonzero otherwise; a nonzero return value says nothing about the accuracy of the result.

Set poly to the characteristic polynomial \det(xI - A) of the square n \times n matrix A (an exception is raised otherwise). The underscore version writes n + 1 coefficients. Wrappers of _gr_mat_charpoly_berkowitz, the division-free algorithm of Berkowitz with O(n^4) operations, which avoids divisions by balls that contain zero (Characteristic and minimal polynomials). A non-finite matrix gives indeterminate coefficients.

Set the n \times n matrix mat to the companion matrix of the polynomial of degree n (the underscore version reads n + 1 coefficients). If the leading coefficient cannot be inverted, the result is indeterminate. Wrappers of _gr_mat_companion and gr_mat_companion.

Sets S to the truncated exponential series \sum_{k=0}^{N-1} A^k / k!, using rectangular splitting with O(\sqrt{N}) matrix multiplications. The factorials are generated by their recurrence so that the scalars are small integers, and the divisions are postponed by computing partial factorials of length O(\sqrt{N}) [Joh2014b].

Sets B to the exponential \exp(A) = \sum_{k \ge 0} A^k/k! of the square matrix A.

Sets trace to the sum of the diagonal entries of the square matrix mat.

Set res to the product of the diagonal entries of mat; the underscore version takes the product of the entries with index a \le i < b (which must be in range; the empty product is 1).

Sets B to the matrix of midpoints of A, with zero radii.

Adds err to the radius of every entry of mat.

Computes floating-point approximations of the n eigenvalues of the n \times n matrix A (in no particular order) in E, and optionally of the corresponding left eigenvectors in the rows of L and right eigenvectors in the columns of R (either may be NULL), without error bounds. Returns nonzero if the QR iteration converged numerically; this is only a heuristic, and the output may be accurate even if zero is returned.

Given approximations E of the eigenvalues and R of the right eigenvectors of the n \times n matrix A, computes \varepsilon such that every eigenvalue of A lies within distance \varepsilon of some \hat\lambda_k \in E, by Theorem 1 of [Miy2010], an extension of the Bauer–Fike theorem. If \|YR - I\|_\infty \ge 1 for the approximate inverse Y of R, eps is set to infinity.

Given an approximate eigenvalue lambda_approx of A and an n \times k matrix R_approx of approximate eigenvectors (a basis of the invariant subspace of a presumed cluster of k eigenvalues), computes a ball lambda that contains at least k eigenvalues of A (counted with multiplicity) and an n \times k matrix R that contains a basis of the corresponding invariant subspace. If J is not NULL, it is set to a k \times k matrix J \approx \lambda I such that AR - RJ contains zero; the Jordan form of A then has a k \times k block equal to the Jordan form of a matrix in J. For k = 1, AR - R \lambda contains zero. On failure, the outputs are set to indeterminate values.

Attempt to prove that the n \times n matrix A has n simple eigenvalues, given approximations of the eigenvalues and right eigenvectors. Return 1 on success, writing pairwise disjoint enclosures of the eigenvalues to E (in no particular order), and if L or R is not NULL, enclosures of the corresponding left eigenvectors (rows of L) and right eigenvectors (columns of R), normalised so that L = R^{-1}, which gives a diagonalisation LAR = D. Return 0 otherwise.

Compute enclosures of all n eigenvalues of A with multiplicities, given approximations of the eigenvalues and right eigenvectors. On success (return value 1), the n entries of E are either disjoint or identical, identical entries are consecutive, and a run of k identical entries is a ball that contains exactly k eigenvalues (a cluster that could not be separated at this precision) and is disjoint from the other n - k eigenvalues. Return 0 otherwise.

Swaps rows r and s of mat and, if perm is not NULL, the entries r and s of perm.

Returns the index i with \mathit{start\_row} \le i < \mathit{end\_row} of an entry in column c that does not contain zero and has the largest midpoint (comparing the larger of the absolute values of the real and imaginary parts), or -1 if every entry in that range contains zero.