Matrix Equality, Addition and Scalar Multiplication

Overview

A matrix is a rectangular array of complex numbers, and until an algebra is defined on that array it is nothing more than a storage format. Three definitions supply the algebra: when two matrices count as the same object, how two matrices of matching shape combine into a third, and how a single number rescales an entire array. All three are stated entry by entry, so each reduces immediately to arithmetic already understood in $\mathbb{C}$ .

The entry-by-entry style is a deliberate engineering choice rather than a notational accident. It means no proof about these operations ever needs to write out a general matrix with rows of dots; instead a proof fixes arbitrary indices $i$ and $j$ , works with the single complex number $[A]_{ij}$ , and concludes that the matrices agree because every entry agrees. That method scales to matrices of unspecified size and is used repeatedly throughout matrix algebra.

The size restrictions matter more than they first appear. Addition is defined only between matrices of identical dimensions — there is no meaningful sum of a $3 \times 4$ and a $4 \times 3$ array, because the entries do not correspond. Scalar multiplication has no restriction at all and preserves the shape exactly. Later operations, notably matrix multiplication, relax the shape requirement in a different direction and change the result size, so the discipline of checking conformability starts here.

In application these two operations are the mathematical statement of superposition and of scaling. A load case combined with a second load case, a signal added to a disturbance, a measurement matrix converted from one unit system to another: each is a matrix sum or a scalar multiple. Because the operations act independently on each entry, they parallelise perfectly and their cost is governed by memory bandwidth rather than arithmetic.

Definition

Vector Space of $m \times n$ Matrices

VSM

The set $M_{mn}$ consists of every $m \times n$ matrix whose entries are complex numbers, equipped with the addition and scalar multiplication defined below. Writing $A \in M_{mn}$ fixes both the dimensions of $A$ and the field its entries are drawn from.

Real matrices are the special case in which every entry has zero imaginary part. Everything on this page holds verbatim over $\mathbb{R}$ .

Matrix Equality

Two $m \times n$ matrices $A$ and $B$ are equal, written $A = B$ , exactly when $[A]_{ij} = [B]_{ij}$ for every index pair with $1 \le i \le m$ and $1 \le j \le n$ . Equality of matrices is therefore $m n$ simultaneous equalities of complex numbers, and matrices of different sizes are never equal.

This is the standard route to proving any theorem whose conclusion is a matrix identity: fix arbitrary $i$ and $j$ , and chase a single entry.

Matrix Addition

Given $m \times n$ matrices $A$ and $B$ , their sum $A + B$ is the $m \times n$ matrix defined by $[A + B]_{ij} = [A]_{ij} + [B]_{ij}$ for all $1 \le i \le m$ , $1 \le j \le n$ . The plus sign on the left denotes the new operation on matrices; the plus sign on the right is ordinary addition in $\mathbb{C}$ .

Matrix Scalar Multiplication

MSM

Given an $m \times n$ matrix $A$ and a scalar $\alpha \in \mathbb{C}$ , the scalar multiple $\alpha A$ is the $m \times n$ matrix defined by $[\alpha A]_{ij} = \alpha [A]_{ij}$ for all $1 \le i \le m$ , $1 \le j \le n$ . The operation is written by juxtaposition, with the scalar conventionally placed on the left.

Concepts

Overloading is disciplined, not careless

The symbols $=$ , $+$ and juxtaposition now each carry several meanings: equality of numbers and equality of matrices; addition of numbers and addition of matrices; multiplication of numbers and scaling of a matrix. The overloading is safe because each definition reduces the new meaning to the old one on a single entry. In practice the reader resolves the ambiguity by inspecting the objects flanking the symbol, which is why every statement in matrix algebra should begin by declaring the type and size of each object it names.

Why entry-by-entry proofs are the right technique

A proof that writes out $A + B$ as a large array with ellipses becomes unreadable and does not generalise. Fixing arbitrary indices $i, j$ and manipulating the scalar $[A]_{ij}$ produces a chain of equalities in $\mathbb{C}$ , each step justified by a definition or by a familiar field property such as commutativity or distributivity. The chain establishes the identity for every entry, so matrix equality delivers the conclusion. This template proves every result on this page and most of the algebra that follows.

Conformability is a type constraint

Addition is a partial operation: $A + B$ exists only when $A$ and $B$ have identical row and column counts. Scalar multiplication is total and shape-preserving. Treating these constraints as a type system — where the type of an object is its size — catches the majority of algebraic and programming errors before any arithmetic is done. Numerical libraries that silently broadcast a $1 \times n$ row against an $m \times n$ matrix are performing a convenience operation that is not matrix addition, and the distinction has caused real defects.

Subtraction and the zero matrix are derived, not primitive

There is no separate definition of matrix subtraction. The difference $A - B$ is shorthand for $A + (-1)B$ , obtained by composing scalar multiplication with addition. Likewise the $m \times n$ zero matrix $O$ , every entry of which is $0$ , is the unique matrix satisfying $A + O = A$ for all $A \in M_{mn}$ , and the additive inverse $-A$ is simply $(-1)A$ . Building these from the two primitives keeps the axiom count minimal and the proofs short.

Linear combinations of matrices

Composing the two operations gives expressions of the form $\alpha_1 A_1 + \alpha_2 A_2 + \cdots + \alpha_p A_p$ , a linear combination of matrices. Every concept built on linear combinations of column vectors — span, linear independence, basis, dimension — transfers to $M_{mn}$ without modification, because the two operations satisfy exactly the same ten properties. The set of $3 \times 3$ symmetric matrices, for example, is a span of six specific matrices, and that description is only available once linear combinations of matrices are defined.

Column vectors are a special case

A column vector of size $m$ is an $m \times 1$ matrix, so the definitions of vector equality, vector addition and vector scalar multiplication are precisely the definitions above with $n = 1$ . Nothing is lost by regarding vectors as matrices, and the unification pays off later: the matrix-vector product, the inner product and the transpose can all be expressed in a single algebra rather than two parallel ones.

Decision path: evaluating a matrix expression safely

Classify every symbolDecide for each name whether it denotes a scalar in

\mathbb{C}

or a matrix in

M_{mn}

. The meaning of

+

and of juxtaposition depends entirely on this.

Resolve scalar multiples firstEvaluate each

\alpha A

term. Shape is preserved, so no conformability question arises at this stage.

Check conformability of every sumAll terms to be added must share both dimensions. A mismatch is a modelling error; stop and resolve it rather than reshaping to fit.

Add entry by entryCompute

[A]_{ij} + [B]_{ij}

at each of the

m n

positions. Order is irrelevant and no entry influences another.

Verify by row sumsThe sum of each row of the result must equal the sum of the corresponding row sums of the operands. This catches transcription and sign errors in a single pass.

Equations

Matrix equality, entry-by-entry

EQ-MO-01

A = B \Leftrightarrow [A]_{i j} = [B]_{i j} 1 \leq i \leq m, 1 \leq j \leq n

Both matrices must be $m \times n$ . Equality of matrices is $m n$ simultaneous equalities of complex numbers.

Matrix addition

EQ-MO-02

[A + B]_{i j} = [A]_{i j} + [B]_{i j} 1 \leq i \leq m, 1 \leq j \leq n

Defined only when $A$ and $B$ share both dimensions; the sum has the same dimensions.

Scalar multiplication of a matrix

EQ-MO-03

[α A]_{i j} = α [A]_{i j} α \in ℂ, 1 \leq i \leq m, 1 \leq j \leq n

No conformability restriction; the shape of $A$ is preserved for every scalar, including $\alpha = 0$ .

Worked sum of two matrices in $M_{23}$

EQ-MO-04

Worked sum of two matrices in $M_{23}$

Each entry of the result is the sum of the two entries in the corresponding position. No entry influences any other.

Derived operations: zero matrix, negative, difference

EQ-MO-05

[O]_{i j} = 0, - A = (- 1) A, A - B = A + (- 1) B

Subtraction and additive inverses are compositions of the two primitive operations rather than separate definitions.

Linear combination of matrices

EQ-MO-06

α_{1} A_{1} + α_{2} A_{2} + \dots + α_{p} A_{p}, A_{k} \in M_{m n}, α_{k} \in ℂ

Composing the two operations yields the construction on which span, independence and basis for matrix sets are built.

Variable Definitions

Symbols used on this page
Symbol	Name	Meaning	Domain / type
$A$	Matrix	An $m \times n$ array of complex entries	M_{mn}
$[A]_{i j}$	Matrix entry	The complex number in row $i$ , column $j$ of $A$	complex number
$m$	Row count	Number of rows in the matrix	positive integer
$n$	Column count	Number of columns in the matrix	positive integer
$α$	Scalar	A single complex number multiplying every entry	complex number
$M_{m n}$	Matrix set	The set of all $m \times n$ matrices with complex entries	vector space over C
$O$	Zero matrix	The additive identity of $M_{mn}$ ; every entry is $0$	M_{mn}
$- A$	Additive inverse	The matrix $(-1)A$ , satisfying $A + (-A) = O$	M_{mn}

Worked Numerical Example

Problem statement

A rosette of strain gauges on a plate reports readings in microstrain for two independent load cases. Case 1 is a $2 \times 3$ matrix $A$ (two gauge rows, three axial channels); case 2 is $B$ . Combine the cases, then form the design combination $1.5A + 0.5B$ required by a load-factor rule.

State the two matrices and confirm conformability
Both readings sets are $2 \times 3$ , so they are conformable for addition and the sum will also be $2 \times 3$ . Confirm this before touching any arithmetic.
$A = [\begin{matrix} 120 & - 45 & 60 \\ 30 & 15 & - 90 \end{matrix}], B = [\begin{matrix} - 20 & 55 & 40 \\ 70 & - 15 & 25 \end{matrix}]$
Add entry by entry
Apply $[A + B]_{ij} = [A]_{ij} + [B]_{ij}$ across all six positions. For instance $[A+B]_{12} = -45 + 55 = 10$ and $[A+B]_{23} = -90 + 25 = -65$ . Each entry is independent, so the six sums can be evaluated in any order.
$A + B = [\begin{matrix} 120 + (- 20) & - 45 + 55 & 60 + 40 \\ 30 + 70 & 15 + (- 15) & - 90 + 25 \end{matrix}] = [\begin{matrix} 100 & 10 & 100 \\ 100 & 0 & - 65 \end{matrix}]$
Note the cancellation is local
Entry $(2,2)$ of the sum is $0$ because the two load cases produce equal and opposite strain at that gauge. This is a statement about one channel only: it says nothing about any other entry, and the sum is not the zero matrix.
Scale the first load case
Apply $[\alpha A]_{ij} = \alpha[A]_{ij}$ with $\alpha = 1.5$ . Every entry, including the negatives, is multiplied by the same factor and the $2 \times 3$ shape is unchanged.
$1.5 A = [\begin{matrix} 180 & - 67.5 & 90 \\ 45 & 22.5 & - 135 \end{matrix}]$
Scale the second load case
With $\alpha = 0.5$ the same rule gives the half-magnitude case.
$0.5 B = [\begin{matrix} - 10 & 27.5 & 20 \\ 35 & - 7.5 & 12.5 \end{matrix}]$
Form the linear combination
Add the two scaled matrices entry by entry. The result is a linear combination of $A$ and $B$ with coefficients $1.5$ and $0.5$ — the composite factored load case.
$1.5 A + 0.5 B = [\begin{matrix} 170 & - 40 & 110 \\ 80 & 15 & - 122.5 \end{matrix}]$
Check one entry independently
Verify position $(2,3)$ by direct arithmetic: $1.5(-90) + 0.5(25) = -135 + 12.5 = -122.5$ . Because the operations are entrywise, spot-checking a single entry is a genuine and cheap verification of the procedure, though not of every value.

Result

The composite load case peaks at $170$ microstrain in tension and $-122.5$ microstrain in compression. Superposition is legitimate here precisely because the structural response is linear: the matrix operations mirror the physical assumption, and if the material yielded under either case the arithmetic would remain valid while the model would not.

Applications & Industry Use

Structural engineering

Load case superposition

Dead load, live load, wind and thermal effects are each analysed separately and stored as matrices of member forces or nodal displacements. A design combination is a linear combination of those matrices with code-prescribed load factors, computed by exactly the two operations defined here.

Image and signal processing

Frame differencing and blending

A greyscale image is a matrix of intensities. Subtracting consecutive frames isolates motion, scaling adjusts exposure, and an alpha blend of two images is the linear combination $\alpha A + (1-\alpha)B$ . All are entrywise and map directly onto vectorised hardware.

Finance and risk

Portfolio and covariance aggregation

Covariance matrices estimated over separate periods are combined by weighted averaging, a linear combination in $M_{nn}$ . The shape constraint enforces that the same asset ordering is used in every period, which is the most common source of silent error in such pipelines.

Control systems

Parameter-varying state matrices

A linear parameter-varying plant is often modelled as $A(\theta) = A_0 + \theta_1 A_1 + \cdots + \theta_p A_p$ , a linear combination of fixed state matrices with scheduling parameters as scalars. Interpolating between operating points is scalar multiplication and addition, nothing more.

Process and chemical engineering

Unit conversion of measurement arrays

A table of sensor readings held as a matrix is converted between unit systems by a single scalar multiple, provided all channels share a unit. Where they do not, the failure is invisible to the arithmetic, which is why unit metadata must travel alongside the matrix.

Computing and numerical software

Memory-bound kernel design

Matrix addition performs one arithmetic operation per three memory accesses, so its throughput is set by bandwidth rather than by the arithmetic unit. Library implementations therefore fuse chains such as $\alpha A + \beta B$ into a single pass to avoid materialising intermediate arrays.

Design Considerations

Verify dimensions before verifying values

A dimension mismatch is a modelling error, not an arithmetic one, and it is cheap to detect. Assert both row and column counts at every interface where matrices are combined. A silent broadcast that turns a mismatch into a plausible-looking result is far more expensive than an immediate failure.

Distinguish entrywise product from matrix product

Addition and scalar multiplication act entrywise, and it is tempting to assume multiplication does too. It does not. The entrywise (Hadamard) product is a distinct operation with different algebraic properties, written $A \circ B$ in most texts and A * B in NumPy, whereas the matrix product is A @ B. Confusing the two produces arrays of the right shape and the wrong meaning.

Prefer fused operations over chained ones

Evaluating $\alpha A + \beta B$ as three separate array expressions allocates two temporaries and traverses memory three times. Reference kernels such as BLAS axpy combine scale-and-add in one pass. For large matrices this is the difference between bandwidth-limited and bandwidth-wasteful code.

Scaling changes conditioning of nothing, but changes representation

Multiplying a matrix by a scalar leaves its condition number unchanged, since every singular value scales identically. It does change the exponent range of the stored entries, which matters for fixed-point targets and for overflow in single precision. Choose scale factors that keep entries within the representable band of the arithmetic in use.

Preserve sparsity structure under addition

The sum of two sparse matrices has a non-zero pattern equal to the union of the two patterns, so repeated addition steadily fills in a sparse array. Where the summands have differing patterns, budget for the growth or accumulate in a format designed for it, such as coordinate list, before converting once to compressed storage.

Treat exact zero entries as data, not absence

An entry that is genuinely zero and an entry that has not been measured are different facts, and matrix addition cannot distinguish them. Missing data must be carried in a separate mask; encoding it as $0$ makes it silently participate in every sum and scalar multiple.

Standards & Codes

Notation, interchange and numerical standards that govern how this material is written down, stored and computed in production systems.

Applicable standards, conventions and reference implementations
Reference	Title	Relevance to this topic
`ISO 80000-2`	Quantities and units — Part 2: Mathematics	Fixes the notation used here: italic capitals for matrices, square-bracket delimiters for arrays, and the convention that the first index is the row.
`BLAS Level 1`	Basic Linear Algebra Subprograms, vector-vector operations	The `xAXPY` and `xSCAL` routines are the reference implementations of scaled addition and scalar multiplication; matrix addition on contiguous storage is a single `xAXPY` call over $m n$ elements.
`IEEE 754-2019`	IEEE Standard for Floating-Point Arithmetic	Governs rounding of every entrywise sum. Because each entry is independent, matrix addition introduces at most one rounding error per entry and no error growth — unusually benign among matrix operations.
`ISO/IEC 14882`	Programming languages — C++	Defines `std::valarray` and the expression-template idiom used by libraries such as Eigen to fuse chained matrix sums into a single traversal without temporaries.
`ISO/IEC 40314`	Mathematical Markup Language (MathML) Version 3.0	Encodes the matrix displays on this page as semantic `mtable` structures, so row and column positions remain machine-readable rather than pictorial.

Material Selection

For a mathematical topic, "material" is the numeric representation: the scalar field, storage format and precision the computation is built from.

Representation and precision selection
Representation	Select when	Trade-off
IEEE 754 binary64 (double precision)	General engineering computation where entries carry measurement uncertainty and dynamic range is wide.	Sixteen significant decimal digits with negligible accumulation risk for entrywise work, at 8 bytes per entry; often bandwidth-limited for large arrays.
IEEE 754 binary32 (single precision)	Image and sensor arrays, GPU pipelines, and any case where the source data has fewer than seven significant digits anyway.	Halves memory traffic and typically doubles throughput on a bandwidth-bound kernel; overflow becomes a real risk when scalars are large.
Fixed-point integers	Embedded targets without floating-point hardware, where all entries share a known scale.	Deterministic and fast, but sums can overflow silently and the common scale must be tracked outside the matrix; a mixed-unit matrix cannot use this representation safely.
Exact rational arithmetic	Symbolic derivations and small basis constructions where a coefficient must be provably exact.	No rounding at all, but entries grow in memory as denominators accumulate and the operation is orders of magnitude slower per entry.
Complex entries stored as interleaved pairs	Phasor, impedance and frequency-domain matrices where entries are genuinely complex.	Doubles storage and halves effective bandwidth relative to real matrices; interleaved layout suits entrywise work but split real/imaginary arrays vectorise better.
Sparse compressed storage (CSR or CSC)	Large structural, network or finite-element matrices where the non-zero fraction is small.	Storage proportional to non-zeros, but addition requires merging two index patterns and produces fill-in equal to their union, so repeated sums degrade sparsity.

Manufacturing Notes

Implementation notes — how the result is actually produced by hand, by algorithm and by library, including cost and numerical behaviour.

Operation count and memory behaviour

Adding two $m \times n$ matrices costs exactly $m n$ complex or real additions and touches $3mn$ entries of memory — two reads and one write per result. The arithmetic intensity is therefore $1/3$ operation per element accessed, far below the balance point of any modern processor, so the kernel is memory-bound and no amount of arithmetic optimisation helps.

Hand procedure and checking

Work row by row and write the sum directly beneath, keeping the two operands aligned. The reliable check is not to re-add every entry but to sum each row of $A$ , each row of $B$ and each row of $A + B$ : because addition is commutative and associative, the third row sum must equal the sum of the first two. This catches transcription and sign errors in one pass.

Library conventions

NumPy, MATLAB and Eigen all bind + to matrix addition with a shape check, and * or scalar juxtaposition to scalar multiplication. NumPy additionally applies broadcasting rules, so A + b with b of shape (n,) succeeds and adds a row vector to every row. That is a useful convenience and is not the operation defined here; disable it with an explicit shape assertion where the mathematics requires strict conformability.

Parallelisation and vectorisation

Every output entry depends on exactly two input entries and on nothing else, so the operation is embarrassingly parallel with no synchronisation, no reduction and no ordering constraint. Compilers auto-vectorise it reliably on contiguous storage. Any performance shortfall comes from strided access patterns caused by mixing row-major and column-major layouts, not from the arithmetic.

Numerical stability

Entrywise addition is backward stable in the strongest sense: each computed entry is the exactly rounded sum of the two inputs, with relative error bounded by one unit round-off. There is no accumulation across entries and no possibility of growth. The only hazard is catastrophic cancellation within a single entry when two nearly equal values of opposite sign are added, which destroys significant digits at that position alone.

Failure Modes & Common Mistakes

Failure modes, root causes and prevention
Failure mode / mistake	Impact	Root cause	Prevention & detection
Adding non-conformable matrices	high	Two arrays of different shape are combined, often after a transpose or reshape elsewhere in the pipeline.	Assert both dimensions at the point of combination and fail loudly; never rely on a library's broadcasting to reconcile shapes.
Silent broadcasting instead of matrix addition	high	A vector or a $1 \times n$ array is added to an $m \times n$ matrix and the library expands it, producing a numerically plausible but mathematically different result.	Compare shapes explicitly before the operation, or use a library mode that disables implicit expansion.
Confusing the entrywise product with the matrix product	high	Assuming multiplication is entrywise because addition is; in NumPy this is the `*` versus `@` distinction.	Verify the result size: an entrywise product of two $m \times n$ matrices is $m \times n$ , whereas the matrix product requires the inner dimensions to agree and generally has a different shape.
Placing the scalar in an ambiguous position	low	Writing $A\alpha$ or interleaving scalars with matrices in a way that reads as a matrix product.	Keep scalars to the left of the matrix by convention, and parenthesise any expression where the type of a symbol is not obvious from context.
Mixing units within one matrix	medium	A single array holds channels in differing units, so a scalar multiple applies the wrong conversion factor to some entries.	Enforce a single unit per matrix, or carry a per-column unit vector and convert by an explicit diagonal scaling rather than a scalar.
Overflow after scaling in reduced precision	medium	A large scalar multiple pushes entries beyond the representable range of binary32 or a fixed-point format.	Bound the maximum absolute entry against the format range before scaling, and rescale the problem rather than the result where headroom is tight.
Treating a zero entry as evidence of a zero matrix	medium	Observing cancellation at one position and concluding the sum vanishes everywhere.	Test $A + B = O$ by checking every entry, or by a norm; a single cancelled channel is a local fact only.
Uncontrolled fill-in when summing sparse matrices	low	Repeatedly adding sparse matrices with different non-zero patterns, so the pattern grows to the union at every step.	Accumulate into a coordinate-list or hashed structure and compress once, or precompute the union pattern and allocate for it up front.

FAQs

Why is matrix addition defined entrywise rather than in some other way?

Because the entrywise definition is the one that makes matrices behave like vectors, satisfying the ten vector space properties, and because it is the definition that matches superposition in every linear physical model. Other combining rules are certainly definable, but they do not give an additive identity, additive inverses and distributivity simultaneously, so they do not support the algebra that follows.

Can I add a

2 \times 3

matrix to a

3 \times 2

matrix?

No. The two arrays have no correspondence between positions, so there is no entry to add to $[A]_{13}$ . The operation is undefined, and a library that appears to accept it is doing something else, such as transposing implicitly or broadcasting. If the intent is to combine the two, one of them must be transposed first, and that is a modelling decision rather than an arithmetic one.

Is there a matrix subtraction operation?

Not as a primitive. The expression $A - B$ is defined to mean $A + (-1)B$ , composing scalar multiplication with addition. Keeping the primitive set to two operations halves the number of definitions and theorems required, and every property of subtraction follows from the properties of the two operations it is built from.

What happens when the scalar is zero?

The result is the $m \times n$ zero matrix, since every entry becomes $0 \cdot [A]_{ij} = 0$ . Note that the shape is preserved: $0A$ is the zero matrix of $A$ 's size, not the scalar zero. This distinction matters in code, where returning a scalar in place of an array breaks downstream shape assumptions.

Do these operations work for real matrices as well as complex ones?

Yes, without any change. Real matrices are the subset of $M_{mn}$ whose entries have zero imaginary part, and both operations map real matrices to real matrices. The definitions are stated over $\mathbb{C}$ because the eigenvalue theory that comes later requires it, not because complex entries are needed here.

Why do matrix additions run slower than I expect for large arrays?

Because the kernel is limited by memory bandwidth, not arithmetic. Each result entry requires two reads and one write for a single addition, so the processor spends most of its time waiting on memory. Fusing chained expressions into one traversal, keeping storage contiguous, and reducing precision where accuracy allows are the interventions that help; faster arithmetic does not.

Does adding matrices affect their rank or invertibility?

Unpredictably, and no useful general rule exists. The rank of $A + B$ can be anything from $0$ up to $\operatorname{rank}(A) + \operatorname{rank}(B)$ , capped by the dimensions, and the sum of two invertible matrices can be singular. Structural properties are not preserved by addition, which is one reason matrix algebra is more subtle than scalar algebra.

References

Beezer, R. A. A First Course in Linear Algebra, Version 0.70. University of Puget Sound, 2006. Section MO, Subsection MEASM. Licensed under the GNU Free Documentation License v1.2.
ISO 80000-2:2019, Quantities and units — Part 2: Mathematics. International Organization for Standardization.
IEEE 754-2019, IEEE Standard for Floating-Point Arithmetic. Institute of Electrical and Electronics Engineers.
Golub, G. H. and Van Loan, C. F. Matrix Computations, 4th edition. Johns Hopkins University Press, 2013.
Lawson, C. L. et al. Basic Linear Algebra Subprograms for Fortran Usage. ACM Transactions on Mathematical Software, 5(3), 1979.

AI Suggested Questions

Give me two 3x3 matrices, each of rank 2, whose sum has rank 1, and explain why rank is not additive.
How does NumPy's broadcasting rule differ from strict matrix addition, and what assertion should I write to enforce the strict version?
Show that the set of 3x3 symmetric matrices is closed under addition and scalar multiplication, and find a spanning set of six matrices for it.
Why is matrix addition memory-bound, and how much speedup should I expect from moving a large addition from binary64 to binary32?
Construct two invertible 2x2 matrices whose sum is singular, and explain what that says about superposition of transformations.
Explain the difference between the Hadamard product and the matrix product with a small example where both are defined.

Related Calculators

Matrix Addition & Scaling Calculator

Add, subtract and scale matrices of any size with automatic conformability checking and exact rational output.

Matrix Linear Combination Builder

Evaluate $\alpha_1 A_1 + \cdots + \alpha_p A_p$ for any number of matrices and report the result entry by entry.

Matrix Property Checker

Test a matrix for the zero matrix, symmetry, and equality against another matrix, with a per-entry difference report.