Can I factorize a rectangular matrix with QR?

Yes, QR factorization is especially useful for rectangular matrices. For an m×n matrix with m ≥ n, full QR gives an m×m Q and m×n R. Economy (reduced) QR computes only the first n columns of Q (m×n) and first n rows of R (n×n), which is more efficient and what most applications use. This calculator supports both via the Economy QR toggle.

Why does my QR decomposition look different from another calculator?

QR factorization is not unique. The columns of Q can have their signs flipped (multiplying a column by −1 is still orthonormal), and R's diagonal entries may be positive or negative depending on the method. Both are valid as long as Q is orthogonal (QᵀQ = I) and QR = A. This calculator shows verification checks so you can confirm correctness regardless of sign conventions.

What does Economy/Reduced QR mean?

For an m×n matrix where m > n (more rows than columns), full QR produces an m×m Q matrix, but only the first n columns of Q are actually needed since R only has n non-zero rows. Economy QR computes only those first n columns of Q and the first n rows of R, saving memory and computation. The result is identical: Q (m×n) and R (n×n) still satisfy A = QR.

What happens if my matrix columns are linearly dependent?

Gram-Schmidt will encounter a near-zero vector during orthonormalization, producing a zero column in Q. Householder and Givens rotations will produce an R matrix with zeros on the diagonal. The calculator detects this and reports the numerical rank (independent columns above the tolerance threshold). The factorization A = QR is still valid, but R will not be full rank.

Is QR factorization better than LU factorization?

They serve different purposes. QR is more numerically stable (no pivoting needed) and handles rectangular matrices, making it the preferred method for least squares problems. LU factorization is faster for square matrices when solving Ax = b for multiple right-hand sides. Use QR for stability and rectangular matrices; use LU for speed with square systems.

How do I verify my QR factorization is correct?

Two checks confirm correctness: (1) Orthogonality check: compute QᵀQ; it should equal the identity matrix I (all diagonal ≈ 1, off-diagonal ≈ 0). This calculator displays the Frobenius norm ||QᵀQ − I||. (2) Reconstruction check: compute QR; it should equal the original matrix A. This calculator displays the relative error ||QR − A|| / ||A||. Both should be near zero.

What are the numerical stability considerations?

Classical Gram-Schmidt can lose orthogonality for ill-conditioned matrices due to floating-point error accumulation. Householder reflections are backward stable: the computed Q and R satisfy (A + ΔA) = QR where ||ΔA|| is on the order of machine epsilon. Givens rotations are also stable but slower. For production use or sparse matrices, Householder is the recommended default.

QR Factorization Calculator

Rows

Columns

Matrix A

Show Steps

Step-by-step decomposition

Fraction Mode

Show approximate fractions where possible

Economy QR

Reduced Q (m×n) for rectangular matrices

Householder Reflections

A = Q × R

|det(R)| = 3

Rank = 3

3×3

Q (Orthogonal Matrix)

Full Q 3×3 orthogonal matrix, QᵀQ = I

-0.1231

0.9045

0.4082

-0.4924

0.3015

-0.8165

-0.8616

-0.3015

0.4082

R (Upper Triangular)

Full R 3×3 upper triangular, zeros below diagonal

-8.124

-9.601

-11.94

0.9045

1.508

0.4082

Verification

Numerical checks to confirm the decomposition is correct

QᵀQ ≈ I check

Frobenius norm of QᵀQ − I = 1.493e-10 ✓ Passed

QR ≈ A check

Relative error ∥QR − A∥ / ∥A∥ = 2.695e-10 ✓ Passed

Step-by-Step Solution

See how the decomposition is computed

1.Starting Householder QR decomposition.

2.Column 1: x = [0.1, 0.4, 0.7], ||x|| = 0.8124038405, α = -0.8124038405. Householder vector u = v / ||v||.

3.Column 2: x = [-0.008596557002, -0.09004397475], ||x|| = 0.09045340337, α = 0.09045340337. Householder vector u = v / ||v||.

4.Q and R computed via Householder reflections. Verification: QᵀQ ≈ I, QR ≈ A.

What Is QR Factorization?

Decomposing a matrix into orthogonal and triangular factors

QR factorization (also called QR decomposition) writes a matrix A as the product A = QR, where Q is an orthogonal matrix (QᵀQ = I) and R is an upper triangular matrix. It is a cornerstone algorithm in numerical linear algebra.

The columns of Q form an orthonormal basis for the column space of A , meaning they are perpendicular unit vectors. This property makes QR ideal for solving least squares problems and computing eigenvalues stably.

Core Identity

A = Q × R

Q = orthogonal (QᵀQ = I)

R = upper triangular

Q (Orthogonal)

Orthonormal columns: qᵢ·qⱼ = 0 for i≠j, ||qᵢ|| = 1

R (Upper Triangular)

Non-zero only on and above diagonal

Why QR over LU? QR factorization is more numerically stable and handles rectangular matrices. For least squares problems, QR avoids the explicit formation of AᵀA (which squares the condition number), making it the method of choice.

QR Decomposition Methods Compared

Gram-Schmidt, Householder, and Givens , when to use each

Gram-Schmidt

qⱼ = aⱼ − Σ(qᵢ·aⱼ)qᵢ, then normalize

Orthonormalizes columns one at a time. Intuitive and matches textbook presentations, but can lose orthogonality for ill-conditioned matrices.

Householder

H = I − 2vvᵀ/vᵀv (reflection matrix)

Uses mirror-reflection matrices to zero entire columns. The standard production method , backward stable and most numerically robust. ★ Recommended.

Givens

G = [[c, s], [−s, c]] (2D rotation)

Zeroes elements one at a time using rotation matrices. Best for sparse matrices and parallel processing. More operations but finer control.

Property	Gram-Schmidt	Householder	Givens
Q matrix	Column-by-column	Product of H matrices	Product of G matrices
Stability	Fragile	Backward stable ★	Stable
Sparsity	Not preserved	Not preserved	Well preserved
Cost (m≥n)	2mn²	2mn² − ⅔n³	3mn² − n³
Parallelism	Sequential	Good	Excellent
Pedagogical	Excellent	Moderate	Moderate

Worked Examples

Step-by-step calculations with numerical outputs

Example 1 , 3×3 Matrix (All Methods)

A = [[1, 2, 3], [4, 5, 6], [7, 8, 10]]

Gram-Schmidt: Q has orthonormal columns, R is upper triangular

Householder: 2 reflections zero columns 1–2 below diagonal

Givens: 3 rotations (G₂₁, G₃₁, G₃₂) zero sub-diagonal entries

Output: QᵀQ ≈ I with error < 10⁻¹⁰, QR ≈ A with error < 10⁻¹⁰

Matrix

3×3

input

|det(R)|

det

Rank

full rank

QᵀQ Error

~10⁻¹⁵

orthogonal

Example 2 , 4×2 Rectangular Matrix

A = [[1, 2], [3, 4], [5, 6], [7, 8]] (overdetermined system)

Full QR: Q is 4×4, R is 4×2 with zeros below row 2

Economy QR: Q is 4×2, R is 2×2 , more efficient, same A = QR

Rank = 2 (linearly independent columns)

Formulas & Algorithms

How each method computes Q and R

Classical Gram-Schmidt

rᵢⱼ = qᵢ · aⱼ (for i < j), vⱼ = aⱼ − Σᵢ₌₁ʲ⁻¹ rᵢⱼ·qᵢ

rⱼⱼ = ||vⱼ||, qⱼ = vⱼ / rⱼⱼ

Compute one column at a time: project out previous components, normalize. Intuitive but susceptible to loss of orthogonality.

Householder Reflections

v = x − αe₁ where α = −sign(x₁)·||x||

H = I − 2vvᵀ/(vᵀv), Q = H₁H₂...Hₙ

Each Householder matrix H reflects the current sub-column onto the first coordinate axis, zeroing everything below in one operation. Backward stable.

Givens Rotations

r = √(a² + b²), c = a/r, s = −b/r

G = [[c, −s], [s, c]], applied to rows (j, i)

Each Givens rotation zeros a single element using a 2D rotation. Builds Q incrementally. Preserves sparsity patterns and is easy to parallelize.

Tips & Best Practices

When to use each method and how to avoid pitfalls

Which method should I choose?

Householder is the recommended default , it is numerically stable and fast. Use Gram-Schmidt when learning the concept (matches textbooks). Use Givens when working with sparse matrices or implementing in parallel.

How to interpret the verification checks

The Frobenius norm ||QᵀQ − I|| should be near zero (≪10⁻⁸). The relative error ||QR − A|| / ||A|| should also be near zero. If both pass, your decomposition is correct regardless of sign conventions in Q columns.

Economy QR for rectangular matrices

When rows > columns, enable Economy QR to get a compact Q (same size as A) and square R. This is what most numerical libraries (LAPACK, NumPy, MATLAB) do by default.

When Gram-Schmidt fails

For nearly linearly dependent columns, Classical Gram-Schmidt can produce Q matrices that are not orthogonal. If the orthogonality check shows a large error, switch to Householder , it handles these cases reliably.

Common Mistakes

Pitfalls to avoid when computing or interpreting QR factorization

Ignoring orthogonality drift

Classical Gram-Schmidt can produce Q that is far from orthogonal for ill-conditioned matrices. Always check QᵀQ ≈ I , if it fails, switch to Householder.

Assuming Q is unique

QR factorization is not unique. Columns of Q can have sign flips, and R diagonal signs compensate. Comparing two valid QR decompositions may show different numbers.

Confusing full vs economy QR

For an m×n rectangular matrix (m > n), full Q is m×m but only n columns are 'active.' Economy QR gives the compact m×n Q , most real-world applications use this.

Using QR for square linear systems instead of LU

QR costs ~2× more than LU for square matrices. If you just need to solve Ax = b for a well-conditioned square A, LU factorization is faster.

Applications of QR Factorization

Where QR decomposition is used in science and engineering

Least Squares

Solve min||Ax − b|| via R₁x = Qᵀb. No explicit AᵀA , avoids squaring condition number.

QR Algorithm

Iterate Aₖ = QₖRₖ, Aₖ₊₁ = RₖQₖ to converge to eigenvalues. The foundation of LAPACK's eigenvalue routines.

Linear Systems

For Ax = b, solve Rx = Qᵀb. More stable than LU for ill-conditioned systems at ~2× the cost.

ML & Statistics

Orthogonal initialization of neural network weights. QR decomposition for PCA and dimensionality reduction.

Frequently Asked Questions

Common questions and detailed answers

Classical Gram-Schmidt orthonormalizes columns one at a time by subtracting projections onto previous vectors. It is intuitive but numerically unstable for ill-conditioned matrices. Householder reflections use mirror-reflection matrices to zero out entire columns below the diagonal at once. It is the standard production method and most numerically stable. Givens rotations zero out elements one at a time using 2D rotation matrices. It is best for sparse matrices and parallel implementations.

QR factorization has many applications: (1) Solving least squares problems (minimizing ||Ax − b||) — the most numerically stable approach. (2) Computing eigenvalues via the QR algorithm: iterate A = QR, then set A' = RQ to converge to a diagonal matrix of eigenvalues. (3) Solving linear systems Ax = b via Qᵀb = Rx. (4) In machine learning for orthogonal weight initialization and dimensionality reduction.

Embed QR Factorization Calculator

Add this calculator to your website or blog for free.

Related calculators from other categories

Last updated May 5, 2026

QR Factorization Calculator

Q (Orthogonal Matrix)

R (Upper Triangular)

Verification

Step-by-Step Solution

What Is QR Factorization?

QR Decomposition Methods Compared

Worked Examples

Formulas & Algorithms

Tips & Best Practices

Common Mistakes

Applications of QR Factorization

Frequently Asked Questions

Embed QR Factorization Calculator

You Might Also Like