∑MathIntermediate

Matrix Operations & Properties

Key Points

•
Matrix operations like multiplication and transpose combine or reorient data tables and linear transformations in predictable ways.
•
Trace, rank, and determinant are core properties that summarize a matrix’s behavior: self-influence sum, independent directions, and volume scaling.
•
Matrix multiplication is not commutative (A $B \neq = B A$ in general) but is associative and distributes over addition.
•
The trace is only defined for square matrices and is invariant under cyclic permutations: tr(AB) = tr(BA).
•
Rank tells you how many independent rows/columns exist and can be computed by Gaussian elimination.
•
The determinant measures how a linear transformation scales volume and whether it flips orientation; det(AB) = det(A)det(B).
•
Efficient C++ implementations rely on nested loops for multiplication and elimination-based methods for rank and determinant.
•
Numerical stability matters: use partial pivoting and tolerances when working with floating-point matrices.

Prerequisites

→2D arrays and vector usage in C++ — Matrices are represented as nested vectors; understanding memory layout and iteration is necessary for efficient implementations.
→Algebra of linear equations — Matrix operations generalize systems of linear equations and linear transformations.
→Floating-point arithmetic and rounding — Gaussian elimination and determinant computations are sensitive to numerical error; pivoting and tolerances are essential.
→Big-O notation — To reason about performance of multiplication and elimination algorithms.
→Gaussian elimination basics — Rank and determinant computations rely on row operations and triangular forms.
→Properties of transpose, trace, and determinant — To correctly apply identities like (AB)^T=B^T A^T, tr(AB)=tr(BA), and det(AB)=det(A)det(B).

Detailed Explanation

Tap terms for definitions

01Overview

Matrices are rectangular arrays of numbers that represent data tables or linear transformations. Core operations include addition, scalar multiplication, transpose (swapping rows and columns), and matrix multiplication (composing transformations). Key properties—trace, rank, and determinant—summarize important aspects of a matrix. The trace (sum of diagonal entries) reflects the “total self-effect” of a linear map, the rank measures the number of independent directions a matrix acts on, and the determinant indicates volume-scaling and orientation changes of a linear transformation. Matrix multiplication ties these ideas together: while it is not commutative, it is associative and consistent with linearity, which underpins many algorithms in computer graphics, systems of equations, and machine learning. In programming, matrices are stored as 2D arrays or vectors of vectors, and operations are implemented using nested loops and elimination techniques. Understanding both the mathematical properties and the algorithmic implementations helps you write correct, efficient C++ code and reason about numerical accuracy and complexity.

02Intuition & Analogies

Think of a matrix as a spreadsheet: rows might be students and columns might be test scores. Transposing is like turning the spreadsheet sideways—students become columns and tests become rows. Multiplication is more interesting: imagine first converting scores to standardized z-scores (matrix A), then computing weighted subject averages (matrix B). Doing both steps in sequence is like composing two actions—this composition corresponds to matrix multiplication AB. Doing them in reverse (BA) usually does something different, explaining why AB ≠ BA in general. The trace is the sum along the main diagonal; if a matrix describes how each subject contributes to itself and other subjects, the trace is the “total self-contribution.” Rank is like the number of truly different subjects—if some columns are combinations of others, you don’t gain new information, so the rank is smaller. The determinant acts like a scaling factor for area or volume when your matrix is a geometric transformation: stretching a square into a parallelogram changes its area by |det(A)|, and a negative determinant means the shape was flipped (mirrored). In C++, implementing these ideas means carefully arranging loops (for multiplication), swapping rows to find the best pivot (for elimination), and using tolerances to avoid being tricked by tiny rounding errors.

03Formal Definition

Let A be an m×n matrix and B an n×p matrix over a field (e.g., real numbers). The product

C = A B

is the m×p matrix with entries

C_{ij}

\sum_{k = 1}^{n}

A_{ik}

B_{kj}

. The transpose

A^{T}

of an m×n matrix A is the n×m matrix with entries (

A^{T}

)_{ij} =

A_{ji}

. For a square matrix A ∈

R^{n \times n}

, the trace is

tr

(A) =

\sum_{i = 1}^{n}

a_{ii}

. The rank of A,

rank

(A), is the dimension of its column space (equivalently, the number of pivots in its row-echelon form). The determinant

det

(A) is a scalar function

R^{n \times n}

→

R

characterized by multilinearity in rows, alternation (swapping two rows multiplies by −1), and normalization

det

(I)=1; it can be defined by the Leibniz formula or computed efficiently via Gaussian elimination. Important identities include (AB)^{T} =

B^{T} A^{T}

tr

(AB) =

tr

(BA),

det

(AB) =

det

(A)

det

(B),

det

(

A^{T}

) =

det

(A), and

rank

(A) =

rank

(

A^{T}

). For invertible A,

A^{- 1}

exists with A

A^{- 1} = I

. These definitions underpin linear systems solving, eigen-analysis, and numerical algorithms.

04When to Use

Use matrix multiplication to chain linear operations, such as in computer graphics (rotate, then scale, then translate), neural network layers, and coordinate transforms.
Use transpose to switch between row and column viewpoints, align inner dimensions for multiplication, or leverage symmetry (e.g., forming A^{T}A in least squares).
Use trace when cyclic invariance simplifies expressions (e.g., proofs, optimization with Frobenius inner products) or to summarize diagonal dominance.
Use rank to diagnose redundancy: detect linear dependence in features, decide if a linear system has unique/infinitely many/no solutions, or assess information content.
Use determinant to test invertibility (det ≠ 0), measure volume scaling in transformations, compute changes of variables in integrals (Jacobian), or reason about orientation. In C++, choose elimination (O(n^3)) for determinant and rank in moderate sizes; prefer specialized libraries (Eigen, BLAS/LAPACK) for performance and stability on large or ill-conditioned problems. For sparse or structured matrices, use algorithms that exploit sparsity or structure instead of dense O(n^3) methods.

⚠️Common Mistakes

Assuming AB = BA. Matrix multiplication is not commutative; changing the order can change the result or even make multiplication invalid (dimension mismatch).
Forgetting dimension rules: to multiply A (m×n) by B (p×q), you must have n = p, and the result is m×q. The trace and determinant are only defined for square matrices.
Computing determinants via cofactor expansion on large matrices. This is O(n!) and becomes infeasible quickly; use Gaussian elimination (O(n^3)) instead.
Ignoring numerical stability. Without partial pivoting, elimination can be catastrophically inaccurate; always swap in the largest available pivot and use a tolerance (EPS) to test for near-zero values.
Misinterpreting rank. Rank counts independent rows/columns (pivots), not the number of non-zero rows before elimination. Also, rank(A) = rank(A^{T})—don’t compute both redundantly.
Overlooking property domains. Identities like tr(AB)=tr(BA) require square compatibility (AB and BA are both square), and det is only for square matrices. Be careful with integer overflow when using integer matrices; consider doubles, long doubles, or modular arithmetic.

Key Formulas

Matrix Multiplication Entry

C_{ij} = k = 1 \sum n a_{ik} b_{kj}

Explanation: Each entry of the product C=AB is the dot product of row i of A with column j of B. This is valid when A is m×n and B is n×p.

Transpose Entry

(A^{T})_{ij} = a_{ji}

Explanation: The transpose swaps matrix indices, turning rows into columns. It changes an m×n matrix into an n×m matrix.

Trace

tr (A) = i = 1 \sum n a_{ii}

Explanation: The trace is the sum of diagonal entries of a square matrix. It is often used to summarize a linear transformation and appears in many identities.

Cyclic Trace Property

tr (A B) = tr (B A)

Explanation: The trace of a product is invariant under cyclic permutations. This enables algebraic simplifications, provided the products are defined and result in square matrices.

Leibniz Determinant Formula

det (A) = σ \in S_{n} \sum sgn (σ) i = 1 \prod n a_{i, σ (i)}

Explanation: The determinant equals a signed sum over all permutations of products of one entry from each row and column. Useful conceptually but inefficient computationally.

Determinant Multiplicativity

det (A B) = det (A) det (B)

Explanation: The determinant of a product equals the product of determinants. This helps relate invertibility and volume-scaling across composed transformations.

Determinant and Transpose

det (A^{T}) = det (A)

Explanation: Transposing a matrix does not change its determinant. This follows from properties of permutations or LU factorization.

Rank Invariance under Transpose

rank (A) = rank (A^{T})

Explanation: The number of independent rows equals the number of independent columns. This reflects the duality of row and column spaces.

Rank-Nullity Theorem

rank (A) + nullity (A) = n

Explanation: For an m×n matrix A, the dimension of the column space plus the dimension of the null space equals the number of columns. It connects solvability of Ax=0 with rank.

Transpose of a Product

(A B)^{T} = B^{T} A^{T}

Explanation: When transposing a product, the order reverses. This is crucial in proofs and implementations to avoid dimension errors.

Upper Triangular Determinant

det (U) = i = 1 \prod n u_{ii}

Explanation: The determinant of an upper (or lower) triangular matrix is the product of its diagonal entries. Elimination reduces matrices to triangular form to exploit this.

Naive Multiplication Complexity

T (m, n, p) = O (mn p)

Explanation: The standard triple-loop matrix multiplication of an m×n by n×p matrix runs in proportional time to m×n×p. This sets a baseline for performance in code.

Complexity Analysis

For dense matrices stored in row-major 2D arrays or vectors, the standard algorithms have clear complexity bounds. Multiplying an m×n matrix A by an n×p matrix B via the triple-nested loop takes O(mnp) time and O(mp) extra space if you store the result, besides the inputs. This is optimal for the naive method; asymptotically faster algorithms exist (e.g., Strassen’s O(

n^{2.807}

) and Coppersmith–Winograd variants), but they have large constants and are seldom used for small to medium sizes in hand-written C++. Transposing an m×n matrix is O(mn) time and O(1) extra space if done in-place for square matrices (careful swapping) or O(mn) extra space to create a new transposed matrix. The trace of an n×n matrix is O(n) time and O(1) space since it sums diagonal entries. Computing rank and determinant efficiently uses Gaussian elimination (or LU decomposition with partial pivoting). Transforming an n×n matrix to upper triangular form is O(

n^{3}

) time and O(

n^{2}

) space (to hold the matrix). The determinant can be obtained as the product of the diagonal of the triangular matrix times the sign of row swaps, preserving O(

n^{3}

) time. The rank can be read off as the number of pivots encountered during elimination, also O(

n^{3}

). Numerical stability often requires pivoting; the overhead for pivot searches is O(

n^{2}

) and included in the O(

n^{3}

) bound. Space-wise, dense matrices inherently need O(mn) storage. Temporary copies for elimination add another O(

n^{2}

). For large or sparse problems, using sparse data structures and algorithms can reduce time and memory significantly, but the presented dense methods are standard for education and moderate sizes.

Code Examples

Matrix multiplication, transpose, and trace (basic operations)

1 #include <iostream>
2 #include <vector>
3 #include <iomanip>
4 #include <stdexcept>
5 
6 struct Matrix {
7     int rows, cols;
8     std::vector<std::vector<double>> a;
9 
10     Matrix(int r=0, int c=0, double val=0.0) : rows(r), cols(c), a(r, std::vector<double>(c, val)) {}
11 
12     static Matrix from2D(const std::vector<std::vector<double>>& data) {
13         if (data.empty()) return Matrix();
14         int r = (int)data.size();
15         int c = (int)data[0].size();
16         Matrix M(r, c);
17         for (int i = 0; i < r; ++i) {
18             if ((int)data[i].size() != c) throw std::runtime_error("Jagged input rows");
19             for (int j = 0; j < c; ++j) M.a[i][j] = data[i][j];
20         }
21         return M;
22     }
23 
24     Matrix transpose() const {
25         Matrix T(cols, rows);
26         for (int i = 0; i < rows; ++i)
27             for (int j = 0; j < cols; ++j)
28                 T.a[j][i] = a[i][j];
29         return T;
30     }
31 
32     Matrix operator*(const Matrix& o) const {
33         if (cols != o.rows) throw std::runtime_error("Dimension mismatch for multiplication");
34         Matrix C(rows, o.cols, 0.0);
35         for (int i = 0; i < rows; ++i) {
36             for (int k = 0; k < cols; ++k) {
37                 double aik = a[i][k];
38                 for (int j = 0; j < o.cols; ++j) {
39                     C.a[i][j] += aik * o.a[k][j];
40                 }
41             }
42         }
43         return C;
44     }
45 
46     double trace() const {
47         if (rows != cols) throw std::runtime_error("Trace requires a square matrix");
48         double t = 0.0;
49         for (int i = 0; i < rows; ++i) t += a[i][i];
50         return t;
51     }
52 
53     void print(const std::string& name) const {
54         std::cout << name << " (" << rows << "x" << cols << "):\n";
55         std::cout << std::fixed << std::setprecision(3);
56         for (int i = 0; i < rows; ++i) {
57             for (int j = 0; j < cols; ++j) {
58                 std::cout << std::setw(10) << a[i][j] << ' ';
59             }
60             std::cout << '\n';
61         }
62     }
63 };
64 
65 int main() {
66     try {
67         Matrix A = Matrix::from2D({{1, 2, 3}, {4, 5, 6}});      // 2x3
68         Matrix B = Matrix::from2D({{7, 8}, {9, 10}, {11, 12}}); // 3x2
69 
70         Matrix C = A * B;          // 2x2
71         Matrix At = A.transpose(); // 3x2
72 
73         A.print("A");
74         B.print("B");
75         C.print("C = A*B");
76         At.print("A^T");
77 
78         std::cout << "trace(C) = " << C.trace() << "\n"; // Only valid for square C
79     } catch (const std::exception& e) {
80         std::cerr << "Error: " << e.what() << '\n';
81         return 1;
82     }
83     return 0;
84 }
85

This program defines a simple Matrix type and implements three fundamental operations: multiplication (composition of linear maps), transpose (swap rows/columns), and trace (sum of diagonal entries of a square matrix). It demonstrates dimension checks to prevent invalid operations and prints results in a readable format.

Time: Multiplication: O(m n p) for an m×n times n×p product; transpose: O(m n); trace: O(n).Space: O(m n) to store each matrix; O(m p) additional for the multiplication result; O(1) extra for trace.

Determinant and rank via Gaussian elimination with partial pivoting

1 #include <bits/stdc++.h>
2 using namespace std;
3 
4 static const double EPS = 1e-9;
5 
6 // Compute determinant using elimination (O(n^3)). Returns 0 if singular (within EPS).
7 double determinant(vector<vector<double>> A) {
8     int n = (int)A.size();
9     if (n == 0 || (int)A[0].size() != n) throw runtime_error("Determinant requires a non-empty square matrix");
10     int sign = 1;
11     for (int i = 0; i < n; ++i) {
12         // Find pivot in column i at or below row i
13         int piv = i;
14         for (int r = i + 1; r < n; ++r) if (fabs(A[r][i]) > fabs(A[piv][i])) piv = r;
15         if (fabs(A[piv][i]) < EPS) return 0.0; // Singular
16         if (piv != i) { swap(A[piv], A[i]); sign = -sign; }
17         // Eliminate entries below pivot
18         for (int r = i + 1; r < n; ++r) {
19             double f = A[r][i] / A[i][i];
20             if (fabs(f) < EPS) continue;
21             for (int c = i; c < n; ++c) A[r][c] -= f * A[i][c];
22         }
23     }
24     // Product of diagonal of upper triangular matrix times sign
25     long double det = sign;
26     for (int i = 0; i < n; ++i) det *= A[i][i];
27     return (double)det;
28 }
29 
30 // Compute rank via Gaussian elimination to row-echelon form (O(min(m,n)^2 * max(m,n))).
31 int rank_of(vector<vector<double>> A) {
32     int m = (int)A.size();
33     if (m == 0) return 0;
34     int n = (int)A[0].size();
35     int r = 0; // number of pivots found
36     for (int c = 0; c < n && r < m; ++c) {
37         // Find pivot in column c at or below row r
38         int piv = r;
39         for (int i = r + 1; i < m; ++i) if (fabs(A[i][c]) > fabs(A[piv][c])) piv = i;
40         if (fabs(A[piv][c]) < EPS) continue; // no pivot in this column
41         swap(A[piv], A[r]);
42         // Eliminate below pivot
43         for (int i = r + 1; i < m; ++i) {
44             double f = A[i][c] / A[r][c];
45             if (fabs(f) < EPS) continue;
46             for (int j = c; j < n; ++j) A[i][j] -= f * A[r][j];
47         }
48         ++r;
49     }
50     return r; // number of pivots equals rank
51 }
52 
53 int main() {
54     vector<vector<double>> A = {
55         { 2,  1,  3},
56         { 0, -1,  4},
57         { 5,  2,  0}
58     };
59 
60     cout << fixed << setprecision(6);
61     double detA = determinant(A);
62     int rA = rank_of(A);
63 
64     cout << "det(A) = " << detA << "\n";
65     cout << "rank(A) = " << rA << "\n";
66 
67     if (fabs(detA) > EPS) cout << "A is invertible (full rank).\n";
68     else cout << "A is singular (not full rank).\n";
69 
70     return 0;
71 }
72

This program computes the determinant and rank using Gaussian elimination with partial pivoting. For the determinant, it transforms the matrix to upper triangular form and multiplies the diagonal entries, adjusting the sign for row swaps. For the rank, it counts the number of pivots encountered while reducing to row-echelon form. Pivoting improves numerical stability and robustness against small pivots.

Time: Determinant: O(n^3) for an n×n matrix. Rank: O(min(m,n)^2 · max(m,n)) ≈ O(m n min(m,n)).Space: O(n^2) to store the matrix; elimination is done in-place on a copy (no extra asymptotic space).

Verifying key properties: tr(AB)=tr(BA), rank(A)=rank(A^T), and det(AB)=det(A)det(B)

1 #include <bits/stdc++.h>
2 using namespace std;
3 static const double EPS = 1e-9;
4 
5 using Mat = vector<vector<double>>;
6 
7 Mat multiply(const Mat& A, const Mat& B) {
8     int m = (int)A.size(), n = (int)A[0].size();
9     if ((int)B.size() != n) throw runtime_error("Dimension mismatch");
10     int p = (int)B[0].size();
11     Mat C(m, vector<double>(p, 0.0));
12     for (int i = 0; i < m; ++i)
13         for (int k = 0; k < n; ++k) {
14             double aik = A[i][k];
15             for (int j = 0; j < p; ++j)
16                 C[i][j] += aik * B[k][j];
17         }
18     return C;
19 }
20 
21 Mat transpose(const Mat& A) {
22     int m = (int)A.size(), n = (int)A[0].size();
23     Mat T(n, vector<double>(m));
24     for (int i = 0; i < m; ++i)
25         for (int j = 0; j < n; ++j)
26             T[j][i] = A[i][j];
27     return T;
28 }
29 
30 double trace(const Mat& A) {
31     int n = (int)A.size();
32     if ((int)A[0].size() != n) throw runtime_error("Trace requires square matrix");
33     double t = 0.0; for (int i = 0; i < n; ++i) t += A[i][i];
34     return t;
35 }
36 
37 double determinant(Mat A) {
38     int n = (int)A.size();
39     if (n == 0 || (int)A[0].size() != n) throw runtime_error("Square matrix required for determinant");
40     int sign = 1;
41     for (int i = 0; i < n; ++i) {
42         int piv = i; for (int r = i+1; r < n; ++r) if (fabs(A[r][i]) > fabs(A[piv][i])) piv = r;
43         if (fabs(A[piv][i]) < EPS) return 0.0;
44         if (piv != i) { swap(A[piv], A[i]); sign = -sign; }
45         for (int r = i+1; r < n; ++r) {
46             double f = A[r][i] / A[i][i];
47             if (fabs(f) < EPS) continue;
48             for (int c = i; c < n; ++c) A[r][c] -= f * A[i][c];
49         }
50     }
51     long double det = sign;
52     for (int i = 0; i < n; ++i) det *= A[i][i];
53     return (double)det;
54 }
55 
56 int rank_of(Mat A) {
57     int m = (int)A.size(); if (m == 0) return 0; int n = (int)A[0].size();
58     int r = 0;
59     for (int c = 0; c < n && r < m; ++c) {
60         int piv = r; for (int i = r+1; i < m; ++i) if (fabs(A[i][c]) > fabs(A[piv][c])) piv = i;
61         if (fabs(A[piv][c]) < EPS) continue;
62         swap(A[piv], A[r]);
63         for (int i = r+1; i < m; ++i) {
64             double f = A[i][c] / A[r][c]; if (fabs(f) < EPS) continue;
65             for (int j = c; j < n; ++j) A[i][j] -= f * A[r][j];
66         }
67         ++r;
68     }
69     return r;
70 }
71 
72 int main() {
73     cout << fixed << setprecision(6);
74 
75     Mat A = {
76         { 2,  1,  3},
77         { 0, -1,  4},
78         { 5,  2,  0}
79     };
80     Mat B = {
81         { 1,  0,  2},
82         {-3,  1,  1},
83         { 4, -2,  0}
84     };
85 
86     // Check tr(AB) = tr(BA)
87     Mat AB = multiply(A, B);
88     Mat BA = multiply(B, A);
89     double trAB = trace(AB);
90     double trBA = trace(BA);
91     cout << "tr(AB) = " << trAB << ", tr(BA) = " << trBA
92          << ", |diff| = " << fabs(trAB - trBA) << "\n";
93 
94     // Check rank(A) = rank(A^T)
95     int rA = rank_of(A);
96     int rAT = rank_of(transpose(A));
97     cout << "rank(A) = " << rA << ", rank(A^T) = " << rAT << "\n";
98 
99     // Check det(AB) = det(A) det(B)
100     double dA = determinant(A);
101     double dB = determinant(B);
102     double dAB = determinant(AB);
103     cout << "det(A) = " << dA << ", det(B) = " << dB
104          << ", det(AB) = " << dAB
105          << ", |diff| = " << fabs(dAB - dA * dB) << "\n";
106 
107     return 0;
108 }
109

This program verifies three cornerstone identities numerically on concrete 3×3 matrices: trace cyclicity tr(AB)=tr(BA), rank invariance under transpose, and determinant multiplicativity det(AB)=det(A)det(B). Small floating-point differences can appear due to rounding; the absolute differences should be near zero.

Time: Dominated by O(n^3) for matrix multiplications and eliminations on n×n matrices.Space: O(n^2) to store matrices and intermediate results.

1	#include <iostream>
2	#include <vector>
3	#include <iomanip>
4	#include <stdexcept>
5
6	struct Matrix {
7	int rows, cols;
8	std::vector<std::vector<double>> a;
9
10	Matrix(int r=0, int c=0, double val=0.0) : rows(r), cols(c), a(r, std::vector<double>(c, val)) {}
11
12	static Matrix from2D(const std::vector<std::vector<double>>& data) {
13	if (data.empty()) return Matrix();
14	int r = (int)data.size();
15	int c = (int)data[0].size();
16	Matrix M(r, c);
17	for (int i = 0; i < r; ++i) {
18	if ((int)data[i].size() != c) throw std::runtime_error("Jagged input rows");
19	for (int j = 0; j < c; ++j) M.a[i][j] = data[i][j];
20	}
21	return M;
22	}
23
24	Matrix transpose() const {
25	Matrix T(cols, rows);
26	for (int i = 0; i < rows; ++i)
27	for (int j = 0; j < cols; ++j)
28	T.a[j][i] = a[i][j];
29	return T;
30	}
31
32	Matrix operator*(const Matrix& o) const {
33	if (cols != o.rows) throw std::runtime_error("Dimension mismatch for multiplication");
34	Matrix C(rows, o.cols, 0.0);
35	for (int i = 0; i < rows; ++i) {
36	for (int k = 0; k < cols; ++k) {
37	double aik = a[i][k];
38	for (int j = 0; j < o.cols; ++j) {
39	C.a[i][j] += aik * o.a[k][j];
40	}
41	}
42	}
43	return C;
44	}
45
46	double trace() const {
47	if (rows != cols) throw std::runtime_error("Trace requires a square matrix");
48	double t = 0.0;
49	for (int i = 0; i < rows; ++i) t += a[i][i];
50	return t;
51	}
52
53	void print(const std::string& name) const {
54	std::cout << name << " (" << rows << "x" << cols << "):\n";
55	std::cout << std::fixed << std::setprecision(3);
56	for (int i = 0; i < rows; ++i) {
57	for (int j = 0; j < cols; ++j) {
58	std::cout << std::setw(10) << a[i][j] << ' ';
59	}
60	std::cout << '\n';
61	}
62	}
63	};
64
65	int main() {
66	try {
67	Matrix A = Matrix::from2D({{1, 2, 3}, {4, 5, 6}}); // 2x3
68	Matrix B = Matrix::from2D({{7, 8}, {9, 10}, {11, 12}}); // 3x2
69
70	Matrix C = A * B; // 2x2
71	Matrix At = A.transpose(); // 3x2
72
73	A.print("A");
74	B.print("B");
75	C.print("C = A*B");
76	At.print("A^T");
77
78	std::cout << "trace(C) = " << C.trace() << "\n"; // Only valid for square C
79	} catch (const std::exception& e) {
80	std::cerr << "Error: " << e.what() << '\n';
81	return 1;
82	}
83	return 0;
84	}
85

1	#include <bits/stdc++.h>
2	using namespace std;
3
4	static const double EPS = 1e-9;
5
6	// Compute determinant using elimination (O(n^3)). Returns 0 if singular (within EPS).
7	double determinant(vector<vector<double>> A) {
8	int n = (int)A.size();
9	if (n == 0 \|\| (int)A[0].size() != n) throw runtime_error("Determinant requires a non-empty square matrix");
10	int sign = 1;
11	for (int i = 0; i < n; ++i) {
12	// Find pivot in column i at or below row i
13	int piv = i;
14	for (int r = i + 1; r < n; ++r) if (fabs(A[r][i]) > fabs(A[piv][i])) piv = r;
15	if (fabs(A[piv][i]) < EPS) return 0.0; // Singular
16	if (piv != i) { swap(A[piv], A[i]); sign = -sign; }
17	// Eliminate entries below pivot
18	for (int r = i + 1; r < n; ++r) {
19	double f = A[r][i] / A[i][i];
20	if (fabs(f) < EPS) continue;
21	for (int c = i; c < n; ++c) A[r][c] -= f * A[i][c];
22	}
23	}
24	// Product of diagonal of upper triangular matrix times sign
25	long double det = sign;
26	for (int i = 0; i < n; ++i) det *= A[i][i];
27	return (double)det;
28	}
29
30	// Compute rank via Gaussian elimination to row-echelon form (O(min(m,n)^2 * max(m,n))).
31	int rank_of(vector<vector<double>> A) {
32	int m = (int)A.size();
33	if (m == 0) return 0;
34	int n = (int)A[0].size();
35	int r = 0; // number of pivots found
36	for (int c = 0; c < n && r < m; ++c) {
37	// Find pivot in column c at or below row r
38	int piv = r;
39	for (int i = r + 1; i < m; ++i) if (fabs(A[i][c]) > fabs(A[piv][c])) piv = i;
40	if (fabs(A[piv][c]) < EPS) continue; // no pivot in this column
41	swap(A[piv], A[r]);
42	// Eliminate below pivot
43	for (int i = r + 1; i < m; ++i) {
44	double f = A[i][c] / A[r][c];
45	if (fabs(f) < EPS) continue;
46	for (int j = c; j < n; ++j) A[i][j] -= f * A[r][j];
47	}
48	++r;
49	}
50	return r; // number of pivots equals rank
51	}
52
53	int main() {
54	vector<vector<double>> A = {
55	{ 2, 1, 3},
56	{ 0, -1, 4},
57	{ 5, 2, 0}
58	};
59
60	cout << fixed << setprecision(6);
61	double detA = determinant(A);
62	int rA = rank_of(A);
63
64	cout << "det(A) = " << detA << "\n";
65	cout << "rank(A) = " << rA << "\n";
66
67	if (fabs(detA) > EPS) cout << "A is invertible (full rank).\n";
68	else cout << "A is singular (not full rank).\n";
69
70	return 0;
71	}
72