∑MathIntermediate

Determinant

Key Points

•
The determinant of a square matrix measures how a linear transformation scales volume and whether it flips orientation.
•
A matrix is invertible if and only if its determinant is nonzero, and det(AB) = det(A) det(B).
•
Geometrically, |det(A)| is the area (2D) or volume (3D) scale factor, while the sign indicates a flip (mirror) or preservation of orientation.
•
Cofactor (Laplace) expansion defines the determinant but runs in O(n!) time, so it is only practical for tiny matrices.
•
Gaussian elimination or LU decomposition compute determinants in O( $n^{3}$ ) time and are the standard approach in practice.
•
Row operations affect the determinant in predictable ways: swapping rows flips the sign, scaling a row scales the determinant, and adding a multiple of a row leaves it unchanged.
•
Determinants appear across math: Jacobians in calculus, oriented area/volume in geometry, eigenvalue products in linear algebra, and counting structures in combinatorics.
•
Numerically, partial pivoting is essential for stability; near-zero determinants indicate maps that nearly squash space to lower dimension.

Prerequisites

→Matrices and matrix multiplication — Determinants are defined on square matrices and interact strongly with multiplication (det(AB) = det(A) det(B)).
→Linear transformations and geometric interpretation — Understanding how matrices act on vectors clarifies the determinant’s meaning as a volume/area scaling and orientation indicator.
→Row operations and Gaussian elimination — Efficient determinant computation relies on elimination and row-operation effects on det.
→Permutations and parity — The Leibniz formula and cofactor signs depend on permutation parity (even/odd).
→Basic calculus (multivariable) — Jacobian determinants appear in change-of-variables formulas.
→Vector geometry (dot and cross product) — In 3D, det equals the scalar triple product u·(v×w); in 2D, the determinant equals a signed cross product.
→Floating-point arithmetic and numerical stability — Practical computation of det requires understanding rounding errors and pivoting.

Detailed Explanation

Tap terms for definitions

01Overview

The determinant is a single number attached to a square matrix that encodes how the matrix’s linear transformation stretches, squeezes, and flips space. In two dimensions, imagine a unit square turned into a parallelogram by a matrix A; the determinant det(A) equals the signed area of that parallelogram. In three dimensions, det(A) gives the signed volume scaling of a unit cube to a parallelepiped. The magnitude |det(A)| is the scale factor of area/volume, and the sign tells whether orientation is preserved (+) or reversed (−). Algebraically, determinants connect many cornerstones of linear algebra: they vanish exactly when a matrix is singular (non-invertible), multiply over products (det(AB) = det(A) det(B)), and are unchanged by adding a multiple of one row to another while flipping sign under row swaps. These properties make determinants a powerful diagnostic and computational tool. While the cofactor expansion offers a clean recursive definition and is ideal for hand calculations on 2×2 or 3×3 matrices, it grows factorially in time. Practical computation uses O(n^3) algorithms such as Gaussian elimination or LU decomposition, often with pivoting for numerical stability. Determinants also appear in calculus (Jacobian for change of variables), geometry (oriented areas/volumes, orientation tests), and combinatorics (e.g., Matrix–Tree theorem).

02Intuition & Analogies

Picture a stretchy rubber sheet (2D) or a jelly block (3D). A linear transformation A presses, pulls, shears, and possibly flips the object. If you stamp a 1×1 square onto the sheet and apply A, the stamped region becomes a tilted parallelogram. Its area tells you how much A scaled the sheet—twice as big means a factor of 2; half as big means a factor of 1/2. If A also mirrors the sheet (like reflecting in a line), then the shape’s orientation reverses: what used to be “counterclockwise” becomes “clockwise.” The determinant captures both effects in one number: the magnitude |det(A)| is the area or volume scale, and the sign is + for preserving orientation and − for flipping. In 2D, the determinant of [a b; c d] equals ad − bc. This is exactly the signed area of the parallelogram spanned by the column vectors (a, c) and (b, d). In 3D, det(A) equals the scalar triple product u · (v × w), the signed volume of the parallelepiped spanned by the three columns u, v, w. If det(A) = 0, your rubber sheet is squashed onto a line or point—area/volume collapses to zero—which is why A cannot be inverted: information is lost. Now think of row operations as simple physical moves: swapping two rows flips orientation (sign changes), scaling a row scales area/volume (det multiplies by that scale), and sliding one row by adding another does not change area (det unchanged). These intuitive moves underlie efficient computational methods (elimination/LU) that transform A to triangular form, where the determinant is simply the product of diagonal entries—just like counting how the edges of a distorted box determine its volume.

03Formal Definition

For an n×n matrix A = (

a_{ij}

), the determinant is the unique function det:

M_{n \times n}

→ ℝ (or a field) that is multilinear in rows, alternating (det is 0 if two rows are equal), and normalized by det(

I_{n}

) = 1. Equivalently, the Leibniz formula defines it explicitly: det(A) =

\sum_{σ \in S_{n}}

sgn

(

σ

)

\prod_{i = 1}^{n}

a_{i, σ (i)}

, a sum over all permutations σ of {1,…,n}, weighted by their sign (±1). Important properties include: (1) det(AB) = det(A) det(B); (2) det(

A^{T}

) = det(A); (3) a row swap multiplies det by −1; scaling a row by k multiplies det by k; adding a multiple of one row to another leaves det unchanged; (4) det is linear in each row when the others are fixed (multilinearity); (5) det(A) ≠ 0 if and only if A is invertible; (6) if A is triangular

\frac{u pp er}{l o w er}

, det(A) =

\prod_{i = 1}^{n}

a_{ii}

. The Laplace (cofactor) expansion gives a recursive computation: det(A) =

\sum_{j = 1}^{n}

(-1)^{i+j}

a_{ij}

M_{ij}

, where

M_{ij}

is the (i,j)-minor’s determinant, and i is any fixed row (or similarly expand along a fixed column). While this definition is conceptually clean, its naive computational cost is O(n!). Practical computation relies on Gaussian elimination or LU decomposition to reduce A to triangular form, then multiply diagonal entries, adjusting for row swaps and scalings.

04When to Use

Use determinants when you need to: (1) Diagnose invertibility: det(A) ≠ 0 indicates full rank and a unique inverse; (2) Measure geometric scaling: compute area/volume of images of shapes under a linear map; find oriented area of a parallelogram (2D) or oriented volume of a parallelepiped (3D); (3) Change variables in integrals: the Jacobian determinant |det J_g(x)| gives the local volume scale factor when transforming coordinates; (4) Connect to eigenvalues: det(A) = \prod_i \lambda_i and det(\lambda I − A) is the characteristic polynomial; (5) Perform orientation tests in computational geometry (e.g., whether three 2D points are clockwise/counterclockwise using a 2×2 determinant, or whether four 3D points are coplanar via a 4×4 affine determinant); (6) Count combinatorial objects in special cases (e.g., number of spanning trees via the Matrix–Tree theorem). Do not use determinants to solve large linear systems directly via Cramer’s rule—it is exponentially slower and numerically unstable compared to Gaussian elimination/QR. For numerical work, prefer LU with partial pivoting to compute determinants robustly, and treat near-zero determinants with caution: they signal ill-conditioning and potential numerical error amplification.

⚠️Common Mistakes

Using cofactor expansion for large n: The recursive method is O(n!) and becomes intractable beyond tiny sizes. Prefer Gaussian elimination or LU (O(n^3)).
Ignoring pivoting: Eliminating without partial pivoting can divide by tiny numbers, magnifying roundoff errors. Always use partial pivoting for floating-point matrices.
Mixing up row operations: Swapping rows flips the determinant’s sign; scaling a row by k multiplies the determinant by k; adding a multiple of one row to another does not change the determinant. Forgetting to track these changes yields wrong results.
Confusing magnitude with sign: |det(A)| gives scale; the sign indicates orientation. Taking absolute values blindly loses important orientation information in geometry tasks.
Using det to test singularity with a hard zero check in floating point: Due to rounding, a very small nonzero determinant might represent a near-singular matrix. Use a tolerance (e.g., compare |det| to ε) and consider conditioning/row norms.
Solving systems via determinants (Cramer’s rule): It is numerically unstable and far slower than elimination/QR for anything but tiny systems.
Integer overflow in exact computations: Determinants of integer matrices can grow fast. Use wider integers, modular arithmetic with CRT, or fraction-preserving algorithms like Bareiss for exact results.
Forgetting that det(A^T) = det(A) and det(AB) = det(A) det(B): These identities often simplify problems and sanity-check results.

Key Formulas

2×2 Determinant

det (a c b d) = a d - b c

Explanation: Signed area scaling of the unit square under the linear map with columns (a,c) and (b,d).

Scalar Triple Product

det ([u v w]) = u \cdot (v \times w)

Explanation: The determinant of a 3×3 matrix with columns u, v, w equals the signed volume of the parallelepiped they span.

Leibniz Formula

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

Explanation: Explicit definition as a sum over all permutations with signs; useful conceptually but not computationally for large n.

Multiplicativity

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

Explanation: The determinant of a product equals the product of determinants; enables many algebraic simplifications.

Transpose Invariance

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

Explanation: Determinant is unchanged by transposing; rows and columns play symmetric roles.

Invertibility Criterion

det (A) \neq = 0 ⟺ A is invertible

Explanation: A nonzero determinant exactly characterizes nonsingular matrices (full rank).

Triangular Product Rule

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

Explanation: For upper or lower triangular matrices, the determinant is the product of diagonal entries.

Laplace Expansion (row i)

det (A) = j = 1 \sum n (- 1)^{i + j} a_{ij} M_{ij}

Explanation: Expands along a fixed row i using cofactors; equivalent expansion works for any column too.

Change of Variables

\int_{g (U)} f (y) d y = \int_{U} f (g (x)) ∣ det J_{g} (x) ∣ d x

Explanation: The Jacobian determinant scales volumes during coordinate transformations in multivariable integrals.

Eigenvalue Product

det (A) = i = 1 \prod n λ_{i}

Explanation: The determinant equals the product of eigenvalues (counted with algebraic multiplicity).

Characteristic Polynomial

p (λ) = det (λ I - A)

Explanation: A polynomial whose roots are eigenvalues; the constant term is (±)det(A).

Cofactor Complexity

T_{cofactor} (n) = O (n!)

Explanation: Naive Laplace expansion grows factorially; impractical beyond small n.

Elimination Complexity

T_{elim} (n) = O (n^{3}), S (n) = O (n^{2})

Explanation: Gaussian elimination or LU runs in cubic time and quadratic space to store the matrix.

LU Determinant

det (A) = sgn (P) i = 1 \prod n U_{ii} if A = P LU

Explanation: With permutation matrix P and triangular U from LU factorization, determinant is sign(P) times product of U’s diagonal.

Row Operation Effects

row swap \Rightarrow det \mapsto - det, row scale by k \Rightarrow det \mapsto k det, R_{i} \leftarrow R_{i} + c R_{j} \Rightarrow det unchanged

Explanation: How elementary row operations change the determinant; crucial for elimination-based computation.

Complexity Analysis

The cofactor (Laplace) expansion computes det(A) by recursively expanding along a row/column. Its naive time complexity is O(n!) because it branches over all permutations implicitly; even with small constant-factor optimizations (choosing a sparsest row), it remains exponential. Space is O(n) for recursion depth plus O(

n^{2}

) to hold the matrix or to form minors. This makes it suitable only for tiny matrices (

n \leq 8

or so) or symbolic derivations. Gaussian elimination and LU decomposition reduce A to triangular form via O(

n^{3}

) arithmetic operations. With partial pivoting, the algorithm performs roughly

\frac{2}{3}

n^{3}

flops for dense matrices. Space usage is O(

n^{2}

) to store the matrix; in-place LU reuses A’s storage by packing L (strictly lower) and U (upper including diagonal) into one array, plus O(n) for pivot indices. The determinant is then the product of U’s diagonal, possibly multiplied by −1 for each row swap (or by sgn(P) from a permutation matrix P). Numerically, partial pivoting greatly improves stability, reducing growth in roundoff errors by avoiding division by tiny pivots. However, determinants can be ill-conditioned: when

∣ d e t (A) ∣

is very small relative to the matrix’s scale, small input perturbations can cause large relative changes. In floating point, it is common to accumulate the log of absolute diagonal entries and adjust sign separately to mitigate under/overflow. For exact integer matrices, fraction-free methods (e.g., Bareiss) compute determinants in O(

n^{3}

) arithmetic steps while controlling intermediate growth, or one can work modulo primes and reconstruct the result via the Chinese Remainder Theorem. Sparse matrices benefit from sparse LU/Cholesky, which can reduce both time and memory depending on fill-in structure.

Code Examples

Determinant via Gaussian Elimination with Partial Pivoting (O(n^3))

1 #include <bits/stdc++.h>
2 using namespace std;
3 
4 // Compute determinant using Gaussian elimination with partial pivoting.
5 // Returns a long double (floating-point). For integer/exact results, prefer fraction-free methods.
6 // Time: O(n^3), Space: O(n^2) due to matrix copy.
7 
8 long double determinantGaussian(vector<vector<long double>> A) {
9     int n = (int)A.size();
10     for (auto &row : A) if ((int)row.size() != n) throw runtime_error("Matrix must be square");
11 
12     const long double EPS = 1e-18L; // tolerance for near-zero pivots
13     long double det_sign = 1.0L;
14 
15     for (int col = 0; col < n; ++col) {
16         // Find pivot with maximal absolute value in this column (partial pivoting)
17         int pivot = col;
18         for (int r = col + 1; r < n; ++r) {
19             if (fabsl(A[r][col]) > fabsl(A[pivot][col])) pivot = r;
20         }
21         if (fabsl(A[pivot][col]) < EPS) {
22             return 0.0L; // singular (or numerically very close)
23         }
24         if (pivot != col) {
25             swap(A[pivot], A[col]);
26             det_sign = -det_sign; // row swap flips the sign of determinant
27         }
28         // Eliminate entries below the pivot
29         for (int r = col + 1; r < n; ++r) {
30             long double factor = A[r][col] / A[col][col];
31             A[r][col] = 0.0L; // explicitly zero the entry
32             for (int c = col + 1; c < n; ++c) {
33                 A[r][c] -= factor * A[col][c];
34             }
35         }
36     }
37     // Product of diagonal entries gives det of the triangular matrix
38     long double det = det_sign;
39     for (int i = 0; i < n; ++i) det *= A[i][i];
40     return det;
41 }
42 
43 int main() {
44     // Example: compute determinant of a 3x3 matrix
45     vector<vector<long double>> A = {
46         { 2.0L,  -1.0L,  0.0L },
47         { -1.0L,  2.0L, -1.0L },
48         { 0.0L,  -1.0L,  2.0L }
49     };
50 
51     long double detA = determinantGaussian(A);
52     cout.setf(std::ios::fixed); cout << setprecision(10);
53     cout << "det(A) = " << detA << "\n"; // Expected: 4
54 
55     return 0;
56 }
57

This program computes the determinant by reducing the matrix to upper triangular form using Gaussian elimination with partial pivoting. Row swaps are tracked to adjust the sign of the determinant. The determinant of the resulting triangular matrix is the product of its diagonal entries, multiplied by −1 for each row swap. Partial pivoting improves numerical stability by choosing the largest available pivot in magnitude.

Time: O(n^3)Space: O(n^2)

Cofactor (Laplace) Expansion — Educational Recursive Determinant

1 #include <bits/stdc++.h>
2 using namespace std;
3 
4 // WARNING: Exponential-time demonstration. Practical only for small n (<= 8).
5 // Uses long long; beware of overflow for large entries.
6 
7 long long detCofactor(const vector<vector<long long>>& A) {
8     int n = (int)A.size();
9     for (auto &row : A) if ((int)row.size() != n) throw runtime_error("Matrix must be square");
10 
11     if (n == 0) return 1; // det of 0x0 is 1 by convention
12     if (n == 1) return A[0][0];
13     if (n == 2) return A[0][0]*A[1][1] - A[0][1]*A[1][0];
14 
15     // Expand along the first row
16     long long det = 0;
17     for (int j = 0; j < n; ++j) {
18         if (A[0][j] == 0) continue; // small prune
19         vector<vector<long long>> M(n-1, vector<long long>(n-1));
20         // Build minor by removing row 0 and column j
21         for (int r = 1; r < n; ++r) {
22             int cc = 0;
23             for (int c = 0; c < n; ++c) if (c != j) {
24                 M[r-1][cc++] = A[r][c];
25             }
26         }
27         long long cofactor = ((j % 2 == 0) ? +1 : -1) * A[0][j] * detCofactor(M);
28         det += cofactor;
29     }
30     return det;
31 }
32 
33 int main() {
34     vector<vector<long long>> A = {
35         {3, 2, 1},
36         {4, 5, 6},
37         {7, 8, 9}
38     };
39     cout << "det(A) = " << detCofactor(A) << "\n"; // Expected: 0
40     return 0;
41 }
42

This educational implementation follows the Laplace expansion definition: recursively compute minors and combine them with alternating signs. It is excellent for understanding but has factorial complexity and quickly becomes infeasible beyond small sizes. The 2×2 base case uses ad−bc for speed.

Time: O(n!)Space: O(n^2) for minors plus O(n) recursion depth

Determinant from LU Decomposition with Partial Pivoting (PLU)

1 #include <bits/stdc++.h>
2 using namespace std;
3 
4 struct LUDecomposition {
5     vector<vector<double>> LU; // combined L (unit diagonal) and U
6     vector<int> piv;           // pivot permutation
7     int n = 0;
8     int parity = 1;            // +1 or -1 depending on number of row swaps
9     bool singular = false;
10 
11     explicit LUDecomposition(const vector<vector<double>>& A) { factor(A); }
12 
13     void factor(const vector<vector<double>>& A) {
14         n = (int)A.size();
15         for (auto &row : A) if ((int)row.size() != n) throw runtime_error("Matrix must be square");
16         LU = A;
17         piv.resize(n);
18         iota(piv.begin(), piv.end(), 0);
19         parity = 1; singular = false;
20 
21         const double EPS = 1e-15;
22         for (int k = 0; k < n; ++k) {
23             // Find pivot
24             int p = k;
25             double maxAbs = fabs(LU[k][k]);
26             for (int r = k + 1; r < n; ++r) {
27                 double val = fabs(LU[r][k]);
28                 if (val > maxAbs) { maxAbs = val; p = r; }
29             }
30             if (maxAbs < EPS) { singular = true; return; }
31             if (p != k) {
32                 swap(LU[p], LU[k]);
33                 swap(piv[p], piv[k]);
34                 parity = -parity; // row swap flips sign
35             }
36             // Elimination step: build L below diagonal; update U to the right
37             for (int i = k + 1; i < n; ++i) {
38                 LU[i][k] /= LU[k][k]; // L(i,k)
39                 for (int j = k + 1; j < n; ++j) {
40                     LU[i][j] -= LU[i][k] * LU[k][j];
41                 }
42             }
43         }
44     }
45 
46     double determinant() const {
47         if (singular) return 0.0;
48         double detU = 1.0;
49         for (int i = 0; i < n; ++i) detU *= LU[i][i];
50         return (parity == 1 ? +1.0 : -1.0) * detU;
51     }
52 };
53 
54 int main() {
55     vector<vector<double>> A = {
56         {1.0, 2.0, 3.0},
57         {0.0, 4.0, 5.0},
58         {1.0, 0.0, 6.0}
59     };
60     LUDecomposition lu(A);
61     cout.setf(std::ios::fixed); cout << setprecision(10);
62     cout << "det(A) = " << lu.determinant() << "\n"; // Expected: 22
63     return 0;
64 }
65

This code computes a PLU factorization in-place: LU stores L (unit diagonal, below main diagonal) and U (on/above the diagonal). A permutation due to partial pivoting tracks row swaps and their parity. The determinant equals sgn(P) times the product of U’s diagonal. This method is efficient (O(n^3)) and numerically stable for many matrices.

Time: O(n^3)Space: O(n^2)

Geometric Applications: Oriented Area (2D) and Polygon Area (Shoelace)

1 #include <bits/stdc++.h>
2 using namespace std;
3 
4 struct Pt { double x, y; };
5 
6 double orientedAreaParallelogram(const Pt& a, const Pt& b) {
7     // det([a b]) = a.x*b.y - a.y*b.x
8     return a.x * b.y - a.y * b.x; // signed area of parallelogram
9 }
10 
11 double orientedAreaTriangle(const Pt& A, const Pt& B, const Pt& C) {
12     // 1/2 of parallelogram area formed by AB and AC
13     return 0.5 * orientedAreaParallelogram({B.x - A.x, B.y - A.y}, {C.x - A.x, C.y - A.y});
14 }
15 
16 int orientation(const Pt& A, const Pt& B, const Pt& C) {
17     // returns +1 if counterclockwise, -1 if clockwise, 0 if collinear
18     double val = orientedAreaParallelogram({B.x - A.x, B.y - A.y}, {C.x - A.x, C.y - A.y});
19     const double EPS = 1e-12;
20     if (val > EPS) return +1;
21     if (val < -EPS) return -1;
22     return 0;
23 }
24 
25 double polygonAreaShoelace(const vector<Pt>& P) {
26     int n = (int)P.size();
27     long double sum = 0.0L;
28     for (int i = 0; i < n; ++i) {
29         int j = (i + 1) % n;
30         sum += (long double)P[i].x * P[j].y - (long double)P[j].x * P[i].y;
31     }
32     return 0.5 * (double)fabsl(sum); // absolute area (unsigned)
33 }
34 
35 int main() {
36     Pt a{2,1}, b{1,3};
37     cout << "Oriented area (parallelogram spanned by a,b) = "
38          << orientedAreaParallelogram(a,b) << "\n"; // 2*triangle area; can be negative
39 
40     Pt A{0,0}, B{2,0}, C{1,1};
41     cout << "Oriented area (triangle ABC) = " << orientedAreaTriangle(A,B,C) << "\n";
42     cout << "Orientation of A->B->C = " << orientation(A,B,C) << " (1=CCW,-1=CW,0=collinear)\n";
43 
44     vector<Pt> poly = {{0,0},{4,0},{4,1},{0,1}}; // rectangle 4x1, area=4
45     cout << "Polygon area (shoelace) = " << polygonAreaShoelace(poly) << "\n";
46     return 0;
47 }
48

These geometric functions use 2×2 determinants (cross products in 2D) to compute oriented areas and to decide orientation (clockwise/counterclockwise). The shoelace formula sums edge-wise 2×2 determinants to obtain a polygon’s area. This directly reflects the geometric meaning of the determinant as signed area scaling.

Time: O(n) for polygon area; O(1) for triangle/orientationSpace: O(1)

1	#include <bits/stdc++.h>
2	using namespace std;
3
4	// Compute determinant using Gaussian elimination with partial pivoting.
5	// Returns a long double (floating-point). For integer/exact results, prefer fraction-free methods.
6	// Time: O(n^3), Space: O(n^2) due to matrix copy.
7
8	long double determinantGaussian(vector<vector<long double>> A) {
9	int n = (int)A.size();
10	for (auto &row : A) if ((int)row.size() != n) throw runtime_error("Matrix must be square");
11
12	const long double EPS = 1e-18L; // tolerance for near-zero pivots
13	long double det_sign = 1.0L;
14
15	for (int col = 0; col < n; ++col) {
16	// Find pivot with maximal absolute value in this column (partial pivoting)
17	int pivot = col;
18	for (int r = col + 1; r < n; ++r) {
19	if (fabsl(A[r][col]) > fabsl(A[pivot][col])) pivot = r;
20	}
21	if (fabsl(A[pivot][col]) < EPS) {
22	return 0.0L; // singular (or numerically very close)
23	}
24	if (pivot != col) {
25	swap(A[pivot], A[col]);
26	det_sign = -det_sign; // row swap flips the sign of determinant
27	}
28	// Eliminate entries below the pivot
29	for (int r = col + 1; r < n; ++r) {
30	long double factor = A[r][col] / A[col][col];
31	A[r][col] = 0.0L; // explicitly zero the entry
32	for (int c = col + 1; c < n; ++c) {
33	A[r][c] -= factor * A[col][c];
34	}
35	}
36	}
37	// Product of diagonal entries gives det of the triangular matrix
38	long double det = det_sign;
39	for (int i = 0; i < n; ++i) det *= A[i][i];
40	return det;
41	}
42
43	int main() {
44	// Example: compute determinant of a 3x3 matrix
45	vector<vector<long double>> A = {
46	{ 2.0L, -1.0L, 0.0L },
47	{ -1.0L, 2.0L, -1.0L },
48	{ 0.0L, -1.0L, 2.0L }
49	};
50
51	long double detA = determinantGaussian(A);
52	cout.setf(std::ios::fixed); cout << setprecision(10);
53	cout << "det(A) = " << detA << "\n"; // Expected: 4
54
55	return 0;
56	}
57

1	#include <bits/stdc++.h>
2	using namespace std;
3
4	// WARNING: Exponential-time demonstration. Practical only for small n (<= 8).
5	// Uses long long; beware of overflow for large entries.
6
7	long long detCofactor(const vector<vector<long long>>& A) {
8	int n = (int)A.size();
9	for (auto &row : A) if ((int)row.size() != n) throw runtime_error("Matrix must be square");
10
11	if (n == 0) return 1; // det of 0x0 is 1 by convention
12	if (n == 1) return A[0][0];
13	if (n == 2) return A[0][0]A[1][1] - A[0][1]A[1][0];
14
15	// Expand along the first row
16	long long det = 0;
17	for (int j = 0; j < n; ++j) {
18	if (A[0][j] == 0) continue; // small prune
19	vector<vector<long long>> M(n-1, vector<long long>(n-1));
20	// Build minor by removing row 0 and column j
21	for (int r = 1; r < n; ++r) {
22	int cc = 0;
23	for (int c = 0; c < n; ++c) if (c != j) {
24	M[r-1][cc++] = A[r][c];
25	}
26	}
27	long long cofactor = ((j % 2 == 0) ? +1 : -1) * A[0][j] * detCofactor(M);
28	det += cofactor;
29	}
30	return det;
31	}
32
33	int main() {
34	vector<vector<long long>> A = {
35	{3, 2, 1},
36	{4, 5, 6},
37	{7, 8, 9}
38	};
39	cout << "det(A) = " << detCofactor(A) << "\n"; // Expected: 0
40	return 0;
41	}
42

1	#include <bits/stdc++.h>
2	using namespace std;
3
4	struct LUDecomposition {
5	vector<vector<double>> LU; // combined L (unit diagonal) and U
6	vector<int> piv; // pivot permutation
7	int n = 0;
8	int parity = 1; // +1 or -1 depending on number of row swaps
9	bool singular = false;
10
11	explicit LUDecomposition(const vector<vector<double>>& A) { factor(A); }
12
13	void factor(const vector<vector<double>>& A) {
14	n = (int)A.size();
15	for (auto &row : A) if ((int)row.size() != n) throw runtime_error("Matrix must be square");
16	LU = A;
17	piv.resize(n);
18	iota(piv.begin(), piv.end(), 0);
19	parity = 1; singular = false;
20
21	const double EPS = 1e-15;
22	for (int k = 0; k < n; ++k) {
23	// Find pivot
24	int p = k;
25	double maxAbs = fabs(LU[k][k]);
26	for (int r = k + 1; r < n; ++r) {
27	double val = fabs(LU[r][k]);
28	if (val > maxAbs) { maxAbs = val; p = r; }
29	}
30	if (maxAbs < EPS) { singular = true; return; }
31	if (p != k) {
32	swap(LU[p], LU[k]);
33	swap(piv[p], piv[k]);
34	parity = -parity; // row swap flips sign
35	}
36	// Elimination step: build L below diagonal; update U to the right
37	for (int i = k + 1; i < n; ++i) {
38	LU[i][k] /= LU[k][k]; // L(i,k)
39	for (int j = k + 1; j < n; ++j) {
40	LU[i][j] -= LU[i][k] * LU[k][j];
41	}
42	}
43	}
44	}
45
46	double determinant() const {
47	if (singular) return 0.0;
48	double detU = 1.0;
49	for (int i = 0; i < n; ++i) detU *= LU[i][i];
50	return (parity == 1 ? +1.0 : -1.0) * detU;
51	}
52	};
53
54	int main() {
55	vector<vector<double>> A = {
56	{1.0, 2.0, 3.0},
57	{0.0, 4.0, 5.0},
58	{1.0, 0.0, 6.0}
59	};
60	LUDecomposition lu(A);
61	cout.setf(std::ios::fixed); cout << setprecision(10);
62	cout << "det(A) = " << lu.determinant() << "\n"; // Expected: 22
63	return 0;
64	}
65

1	#include <bits/stdc++.h>
2	using namespace std;
3
4	struct Pt { double x, y; };
5
6	double orientedAreaParallelogram(const Pt& a, const Pt& b) {
7	// det([a b]) = a.xb.y - a.yb.x
8	return a.x * b.y - a.y * b.x; // signed area of parallelogram
9	}
10
11	double orientedAreaTriangle(const Pt& A, const Pt& B, const Pt& C) {
12	// 1/2 of parallelogram area formed by AB and AC
13	return 0.5 * orientedAreaParallelogram({B.x - A.x, B.y - A.y}, {C.x - A.x, C.y - A.y});
14	}
15
16	int orientation(const Pt& A, const Pt& B, const Pt& C) {
17	// returns +1 if counterclockwise, -1 if clockwise, 0 if collinear
18	double val = orientedAreaParallelogram({B.x - A.x, B.y - A.y}, {C.x - A.x, C.y - A.y});
19	const double EPS = 1e-12;
20	if (val > EPS) return +1;
21	if (val < -EPS) return -1;
22	return 0;
23	}
24
25	double polygonAreaShoelace(const vector<Pt>& P) {
26	int n = (int)P.size();
27	long double sum = 0.0L;
28	for (int i = 0; i < n; ++i) {
29	int j = (i + 1) % n;
30	sum += (long double)P[i].x * P[j].y - (long double)P[j].x * P[i].y;
31	}
32	return 0.5 * (double)fabsl(sum); // absolute area (unsigned)
33	}
34
35	int main() {
36	Pt a{2,1}, b{1,3};
37	cout << "Oriented area (parallelogram spanned by a,b) = "
38	<< orientedAreaParallelogram(a,b) << "\n"; // 2*triangle area; can be negative
39
40	Pt A{0,0}, B{2,0}, C{1,1};
41	cout << "Oriented area (triangle ABC) = " << orientedAreaTriangle(A,B,C) << "\n";
42	cout << "Orientation of A->B->C = " << orientation(A,B,C) << " (1=CCW,-1=CW,0=collinear)\n";
43
44	vector<Pt> poly = {{0,0},{4,0},{4,1},{0,1}}; // rectangle 4x1, area=4
45	cout << "Polygon area (shoelace) = " << polygonAreaShoelace(poly) << "\n";
46	return 0;
47	}
48