Column Vectors: Equality, Addition and Scalar Multiplication

Overview

A column vector is an ordered list of scalars written vertically. That is the whole object — no direction, no magnitude, no arrow is assumed. Geometric readings are available and often useful, but they are interpretations layered on top of the list, and the algebra developed here works identically for a list of three displacements, a list of two hundred nodal temperatures, or a list of complex phasors.

The collection of all column vectors of a fixed size $m$ with complex entries is written $\mathbb{C}^m$ . When the entries are restricted to real numbers the set is written $\mathbb{R}^m$ and called Euclidean $m$ -space. Working over the complex field costs nothing at this stage and pays back later, when eigenvalues of real matrices turn out to be complex and real vectors are no longer sufficient to describe the structure.

Three definitions equip the set. Two vectors are equal when they agree in every corresponding entry; their sum is formed by adding corresponding entries; a scalar multiple is formed by multiplying every entry by the same scalar. Each definition looks unavoidable, and each must nonetheless be stated, because the symbols $=$ and $+$ are being extended to a new class of object and the extension must be made explicit before anything can be proved about it.

The immediate return is notational compression that turns out to be conceptual. Because equality of vectors means equality in every entry, a single vector equation carries exactly the same content as a system of $m$ simultaneous scalar equations. Rewriting a linear system as a vector equation, and then as a linear combination of the columns of its coefficient matrix, is what converts questions about solving into questions about spans, independence and subspaces — the entire second half of the subject.

Definition

Vector Space of Column Vectors

VSCV

$\mathbb{C}^m$ is the set of all column vectors of size $m$ with entries drawn from the complex numbers. A typical element is written $\vec{u}$ , and its $i$ -th entry is written $[\vec{u}]_i$ .

The corresponding set with real entries is $\mathbb{R}^m$ , Euclidean $m$ -space. Every definition and theorem on this page holds verbatim over either field.

Column Vector Equality

CVE

Vectors $\vec{u}$ and $\vec{v}$ of the same size $m$ are equal, written $\vec{u} = \vec{v}$ , provided $[\vec{u}]_i = [\vec{v}]_i$ for every $i$ with $1 \le i \le m$ .

The symbol $=$ now carries several meanings at once: equality of scalars, equality of sets, and equality of vectors. Each proof must be explicit about which is in play, because the method of establishing each differs.

Column Vector Addition

CVA

Given vectors $\vec{u}$ and $\vec{v}$ of the same size $m$ , their sum $\vec{u} + \vec{v}$ is the vector of size $m$ defined by $[\vec{u} + \vec{v}]_i = [\vec{u}]_i + [\vec{v}]_i$ for $1 \le i \le m$ .

Addition of vectors of different sizes is undefined, not merely inconvenient. The symbol $+$ on the left denotes the new operation; on the right it denotes ordinary addition of scalars.

Column Vector Scalar Multiplication

CVSM

Given a vector $\vec{u}$ of size $m$ and a scalar $\alpha \in \mathbb{C}$ , the scalar multiple $\alpha \vec{u}$ is the vector of size $m$ defined by $[\alpha \vec{u}]_i = \alpha [\vec{u}]_i$ for $1 \le i \le m$ .

The operation is written by juxtaposition, with no symbol between the scalar and the vector. A scalar always appears on the left of the vector it multiplies.

Concepts

Why obvious definitions still have to be written down

Entrywise equality, entrywise addition and entrywise scaling are all the natural choices, and each is nonetheless a decision rather than a discovery. The set of lists of length $m$ admits other operations — entrywise multiplication, concatenation, lexicographic comparison — and nothing about the notation forces one over another. Fixing the definitions is what makes proof possible: every subsequent theorem about vectors is ultimately reduced to these three statements plus the arithmetic of the underlying field.

There is also a practical warning here. Later in the subject the obvious definition is sometimes the wrong one. Equality of functions, equality of matrix representations, and equality of cosets each require care, and the discipline of asking “which equality is this?” is established at exactly this point, where the answer is still easy.

Symbol overloading and how to read through it

The definitions deliberately recycle notation. In $[\vec{u} + \vec{v}]_i = [\vec{u}]_i + [\vec{v}]_i$ , the first plus sign is the operation being defined and the second is ordinary addition of complex numbers. In $\alpha \vec{u}$ the juxtaposition denotes the new scaling operation, whereas in $\alpha \beta$ it denotes ordinary multiplication.

The reliable way to read such an expression is by the types of its operands. Scalar next to scalar is field multiplication; scalar next to vector is scalar multiplication; vector next to vector is not defined at all by these three definitions. The library convention that supports this reading is consistent notation — lower-case Greek letters for scalars, arrowed lower-case Latin letters for vectors, upper-case Latin letters for matrices — and it should be maintained even when a source in another discipline does not.

One vector equation replaces $m$ scalar equations

Consider a system of $m$ linear equations in $n$ unknowns. Collecting the left-hand sides into a column vector of size $m$ and the constants into another gives a single equation between two vectors of $\mathbb{C}^m$ . By the definition of vector equality, that one statement is exactly equivalent to the $m$ simultaneous scalar equalities of the original system — no more, no less.

This is the first step of a chain that reshapes the subject. The next step recognises the left-hand vector as a linear combination of the columns of the coefficient matrix with the unknowns as weights, giving $x_1 \vec{A}_1 + \cdots + x_n \vec{A}_n = \vec{b}$ . The question “is this system consistent?” then becomes “does $\vec{b}$ lie in the span of the columns?”, and the geometry of the answer replaces the bookkeeping of elimination.

The zero vector and additive inverses

The zero vector $\vec{0}$ of size $m$ has every entry equal to zero and satisfies $\vec{u} + \vec{0} = \vec{u}$ for every $\vec{u} \in \mathbb{C}^m$ . The additive inverse $-\vec{u}$ is the vector satisfying $\vec{u} + (-\vec{u}) = \vec{0}$ .

Note the order of ideas: $-\vec{u}$ is defined by what it does under addition, not by a formula. That it can be computed as $(-1)\vec{u}$ is a small theorem, verified entrywise by $[-\vec{u}]_i = -[\vec{u}]_i = (-1)[\vec{u}]_i = [(-1)\vec{u}]_i$ . The distinction matters because in more abstract settings the additive inverse is still guaranteed by the axioms while the scalar $-1$ may act in an unfamiliar way, and the connection has to be re-established rather than assumed.

Linear combinations as the composite operation

Addition and scalar multiplication are almost never used in isolation. The compound operation $\alpha_1 \vec{u}_1 + \alpha_2 \vec{u}_2 + \cdots + \alpha_n \vec{u}_n$ — a linear combination — is the object that actually appears in practice, and every span, every solution set and every basis expansion is built from it.

Computationally it is a single sweep: entry $i$ of the result is $\sum_{j} \alpha_j [\vec{u}_j]_i$ , costing $n$ multiply-add operations per entry and $m n$ in total. This is exactly the arithmetic of a matrix-vector product, which is why a linear combination of $n$ vectors of size $m$ and a product of an $m \times n$ matrix with a vector of size $n$ are the same computation viewed from two directions.

Interpretations layered on the list

The same list of numbers supports several readings. As a point in $m$ dimensions, $(3, 4, -2)$ names a location relative to coordinate axes. As an arrow from the origin to that point it acquires direction and magnitude, and vector addition becomes the parallelogram rule. As a signal sample, a stock of materials, or a set of nodal temperatures it has no geometric content at all.

All of these readings are compatible because the algebra is identical in each. Adding two force vectors, adding two material inventories and adding two sampled waveforms are the same operation on the same kind of object. The strength of the abstraction is precisely that it does not commit to any one interpretation, and its safety condition is that any geometric intuition imported from three dimensions must be checked against the entrywise definitions before it is relied on.

Equations

Column vector and its entries

EQ-CVO-01

\vec{u} = [\begin{matrix} [\vec{u}]_{1} \\ [\vec{u}]_{2} \\ ⋮ \\ [\vec{u}]_{m} \end{matrix}] \in ℂ^{m}

A column vector of size $m$ and the notation for its entries. The set of all such vectors with complex entries is $\mathbb{C}^m$ ; with real entries it is $\mathbb{R}^m$ .

Column vector equality

EQ-CVO-02

\vec{u} = \vec{v} \Leftrightarrow [\vec{u}]_{i} = [\vec{v}]_{i} \forall i, 1 \leq i \leq m

Equality is entrywise and is defined only between vectors of the same size. This single definition is what allows one vector equation to encode $m$ scalar equations.

Column vector addition

EQ-CVO-03

[\vec{u} + \vec{v}]_{i} = [\vec{u}]_{i} + [\vec{v}]_{i}, 1 \leq i \leq m

The sum is a vector of the same size $m$ . The plus sign on the left is the operation being defined; the one on the right is ordinary addition in $\mathbb{C}$ .

Column vector scalar multiplication

EQ-CVO-04

[α \vec{u}]_{i} = α [\vec{u}]_{i}, α \in ℂ, 1 \leq i \leq m

Every entry is multiplied by the same scalar. The result is a vector of the same size, and the scalar is written to the left with no operator symbol.

Worked addition and scaling in $\mathbb{C}^4$

EQ-CVO-05

Worked addition and scaling in $\mathbb{C}^4$

Both operations are performed entry by entry, with no interaction between different positions. This independence is what makes them trivially parallelisable.

Zero vector and additive inverse

EQ-CVO-06

\vec{u} + \vec{0} = \vec{u}, \vec{u} + (- \vec{u}) = \vec{0}, - \vec{u} = (- 1) \vec{u}

The first two identities define the roles of $\vec{0}$ and $-\vec{u}$ under addition; the third is a small theorem verified entrywise, connecting the additive inverse to scalar multiplication.

A linear system as a single vector equality

EQ-CVO-07

[\begin{matrix} a_{11} x_{1} + \dots + a_{1 n} x_{n} \\ ⋮ \\ a_{m 1} x_{1} + \dots + a_{m n} x_{n} \end{matrix}] = [\begin{matrix} b_{1} \\ ⋮ \\ b_{m} \end{matrix}]

By the definition of vector equality this one statement is exactly the system of $m$ simultaneous scalar equations. Recognising the left side as a linear combination of the columns of $A$ gives $x_1 \vec{A}_1 + \cdots + x_n \vec{A}_n = \vec{b}$ .

Variable Definitions

Symbols used on this page
Symbol	Name	Meaning	Domain / type
$\vec{u}$	Column vector	An ordered list of $m$ scalars written vertically	vector in C^m
$[\vec{u}]_{i}$	Entry $i$	The $i$ -th component of the vector $\vec{u}$ , a single scalar	complex scalar
$m$	Size	Number of entries in the vector; addition requires both operands to share it	positive integer
$α$	Scalar	Multiplier applied to every entry of a vector	complex scalar
$ℂ^{m}$	Vector space of column vectors	The set of all column vectors of size $m$ with complex entries	set
$Euclidean $m$-space$	Euclidean $m$ -space	The set of all column vectors of size $m$ with real entries	set
$\vec{0}$	Zero vector	Vector of size $m$ with every entry zero; neutral element for addition	vector in C^m
$- \vec{u}$	Additive inverse	The vector satisfying $\vec{u} + (-\vec{u}) = \vec{0}$ ; computable as $(-1)\vec{u}$	vector in C^m
${\vec{A}}_{j}$	Column $j$ of a matrix	The $j$ -th column of $A$ , regarded as a vector in $\mathbb{C}^m$	vector in C^m

Worked Numerical Example

Problem statement

A four-storey frame is analysed under three unit load cases. Each case produces a vector of storey drifts in millimetres: $\vec{u} = (3, -1, 2, 0)$ from wind, $\vec{v} = (-2, 4, 1, 5)$ from an eccentric live load, and $\vec{w} = (1, 1, -3, 2)$ from a thermal gradient. The design combination applies factors $2$ , $3$ and $-1$ respectively. Compute the combined drift vector entry by entry.

Confirm the operands are compatible
All three vectors have size $4$ , one entry per storey, and the entries are ordered consistently from ground floor upwards. Vector addition is defined only for equal sizes, and only for lists whose positions carry the same meaning — a compatibility requirement that the algebra cannot enforce and the engineer must.
$\vec{u}, \vec{v}, \vec{w} \in ℝ^{4}$
Form the first scalar multiple
Apply $\alpha = 2$ to $\vec{u}$ . Every entry is multiplied by the same factor: $2 \cdot 3 = 6$ , $2 \cdot (-1) = -2$ , $2 \cdot 2 = 4$ , $2 \cdot 0 = 0$ .
$2 \vec{u} = 2 [\begin{matrix} 3 \\ - 1 \\ 2 \\ 0 \end{matrix}] = [\begin{matrix} 6 \\ - 2 \\ 4 \\ 0 \end{matrix}]$
Form the second scalar multiple
Apply $\alpha = 3$ to $\vec{v}$ , giving $3 \cdot (-2) = -6$ , $3 \cdot 4 = 12$ , $3 \cdot 1 = 3$ and $3 \cdot 5 = 15$ .
$3 \vec{v} = [\begin{matrix} - 6 \\ 12 \\ 3 \\ 15 \end{matrix}]$
Form the third scalar multiple
The factor $-1$ applied to $\vec{w}$ produces its additive inverse, $-\vec{w}$ . This is the computational content of the identity $-\vec{w} = (-1)\vec{w}$ : reversing the sense of a load case is the same as scaling it by $-1$ .
$(- 1) \vec{w} = [\begin{matrix} - 1 \\ - 1 \\ 3 \\ - 2 \end{matrix}]$
Add the three results entry by entry
Addition is independent in each position, so the four sums can be computed in any order or simultaneously. Storey 1: $6 + (-6) + (-1) = -1$ . Storey 2: $-2 + 12 + (-1) = 9$ . Storey 3: $4 + 3 + 3 = 10$ . Storey 4: $0 + 15 + (-2) = 13$ .
$2 \vec{u} + 3 \vec{v} - \vec{w} = [\begin{matrix} - 1 \\ 9 \\ 10 \\ 13 \end{matrix}]$
Re-read the result as a linear combination
The whole calculation is one linear combination of three vectors with weights $2$ , $3$ and $-1$ . Written as a matrix-vector product with the load-case vectors as columns, it becomes a single object — and the equivalence between these two views is what allows load combination tables to be handled as matrix algebra rather than as itemised arithmetic.
$Re-read the result as a linear combination$
Check by vector equality
Verification means confirming agreement in all four entries, not in one representative entry. Comparing the direct sum with the matrix-vector product entry by entry gives $-1 = -1$ , $9 = 9$ , $10 = 10$ and $13 = 13$ , so by the definition of column vector equality the two vectors are equal.
$[\vec{d}]_{i} = [A \vec{c}]_{i} \forall i, 1 \leq i \leq 4$

Result

The combined design drift profile is $(-1, 9, 10, 13)$ millimetres from ground floor to roof. Only twelve multiplications and eight additions were required, and every entry was independent of every other — which is why load combination is cheap to evaluate for hundreds of cases and why the operation vectorises perfectly on any modern processor.

Applications & Industry Use

Structural engineering

Load case combination

Design codes prescribe factored combinations of dead, live, wind and seismic effects. Each analysis result is a vector of member forces or nodal displacements, and each combination is a linear combination of those vectors. Linearity of the structural model is exactly what licenses combining the results rather than re-analysing for every combination.

Signal processing

Sampled signals as vectors

A block of $m$ samples is a vector in $\mathbb{C}^m$ , complex when the signal is represented in analytic or baseband form. Mixing two channels is vector addition, applying gain is scalar multiplication, and the whole apparatus of filtering and transformation is built on these two operations plus the inner product.

Chemical & process engineering

Composition and inventory vectors

A stream composition, expressed as component flow rates, is a column vector. Blending streams adds the vectors; changing throughput scales one. Because entries carry different units and meanings, the ordering convention must be fixed once and documented, since the algebra offers no protection against a mismatched ordering.

Computer graphics

Positions, displacements and interpolation

Vertex positions and displacements are vectors in $\mathbb{R}^3$ or $\mathbb{R}^4$ in homogeneous coordinates. Linear interpolation between two states is the linear combination $(1-t)\vec{u} + t\vec{v}$ , and blend-shape animation is a linear combination of many stored displacement vectors with animator-controlled weights.

Machine learning & data science

Feature vectors and gradient updates

An observation is a column vector of $m$ features, and a model parameter set is another vector. Every gradient descent step is a single scalar-multiply-and-add, $\vec{\theta} \leftarrow \vec{\theta} + (-\eta) \vec{g}$ , executed billions of times — making this the most frequently performed operation in the field.

Aerospace & navigation

State vectors in guidance systems

Position, velocity and attitude error are assembled into a single state vector. Propagating the state, applying a correction and combining estimates from multiple sensors are all vector additions and scalings, performed at the update rate of the filter with strictly bounded arithmetic on embedded hardware.

Design Considerations

Fix and document the ordering convention

The mathematics treats a vector as an ordered list and attaches no meaning to any position. All the meaning — which entry is which degree of freedom, which storey, which chemical species — lives in an external convention. Silent disagreement between two modules about that ordering produces answers that are numerically well formed and physically wrong, and no amount of numerical checking will detect it.

Do not mix units within a vector without care

Assembling displacements and rotations, or masses and concentrations, into one vector is common and legitimate, but the resulting object has no consistent physical dimension. Norms, tolerances and convergence tests on such a vector are meaningless unless the entries are first non-dimensionalised or scaled by reference values. Scaling is itself a scalar multiplication applied per entry, so it belongs in a diagonal matrix rather than in a single scalar.

Prefer real arithmetic when the problem is real

Working in $\mathbb{R}^m$ halves storage and roughly halves arithmetic compared with $\mathbb{C}^m$ . Complex entries are needed for phasor analysis, frequency-domain signals and eigenvector computations of non-symmetric real matrices; elsewhere they are pure overhead. Choose the field deliberately at the interface rather than defaulting to complex throughout.

Exploit the independence of entries

No entry of a sum or scalar multiple depends on any other entry, so these operations map directly onto vector instructions, GPU threads and distributed partitions with no communication at all. The practical limit is memory bandwidth, not arithmetic: an addition performs one operation per two values loaded, which is why chains of vector operations should be fused into a single pass over the data.

Guard the size-compatibility precondition

Adding vectors of different sizes is undefined. Numerical libraries differ in how they respond: some raise an error, while broadcasting rules in array libraries may silently produce a result of a third size that is mathematically meaningless. Assert equal sizes explicitly at module boundaries rather than relying on the library to object.

Treat vector equality as an entrywise test, and rarely as an exact one

Mathematical equality requires agreement in every entry. In floating point, exact agreement is the wrong test after any non-trivial computation; the practical criterion is that a suitable norm of the difference falls below a tolerance scaled to the magnitudes involved. State the norm and the tolerance rather than leaving both implicit.

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	Prescribes the notation used for vectors — bold or arrow-accented italic symbols — and for the sets $\mathbb{R}^m$ and $\mathbb{C}^m$ , together with the conventions for indexing and for the zero vector.
`BLAS Level 1`	Basic Linear Algebra Subprograms, vector operations	Standardises exactly these operations: `xSCAL` for scalar multiplication, `xAXPY` for the combined scale-and-add, and `xCOPY` for assignment. Separate real and complex variants exist, which is the interface-level reflection of the choice of scalar field.
`IEEE 754-2019`	IEEE Standard for Floating-Point Arithmetic	Defines the entrywise arithmetic and the behaviour of the fused multiply-add on which linear combinations are built, and explains why exact vector equality is an unreliable test after computation.
`ISO/IEC 14882`	Programming languages — C++	Specifies `std::valarray` and `std::complex`, giving standardised entrywise vector semantics and a complex scalar type that matches $\mathbb{C}$ directly, including the expression-level fusion of chained operations.
`ISO/IEC 40314`	Mathematical Markup Language (MathML) Version 3.0	Encodes column vectors as structured matrix markup with a single column, so entries remain individually addressable and readable by assistive technology instead of being flattened into an image.

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 real entries	The general default for engineering quantities: displacements, flows, temperatures, forces.	About sixteen significant decimal digits with wide dynamic range, at eight bytes per entry; sufficient for essentially all engineering data but memory-bandwidth-bound in large vector operations.
IEEE 754 binary32 real entries	Graphics, large-scale simulation and machine learning where throughput and memory dominate.	Halves storage and often doubles throughput, leaving roughly seven significant digits — adequate for display and for stochastic optimisation, marginal for accumulation over long chains.
Complex entries in $\mathbb{C}^m$	Phasor analysis, frequency-domain signals, and eigenvector computations for non-symmetric real matrices.	Doubles storage and roughly quadruples multiplication cost, but is unavoidable where the mathematics genuinely lives in the complex field; forcing a real representation doubles the vector length and obscures the structure.
Exact rational entries	Symbolic derivations, stoichiometric coefficients, and small verification cases where the answer must be exact.	No rounding at all, but entry sizes grow through repeated combination and the cost per operation is unbounded rather than constant.
Fixed-point entries	Embedded control and DSP targets with no floating-point unit.	Deterministic timing and small footprint, at the price of explicit range analysis: every scalar multiplication risks overflow and every addition requires headroom in the chosen format.
Sparse vector storage (index-value pairs)	Very long vectors with few non-zero entries, such as one-hot encodings or localised load patterns.	Storage proportional to the number of non-zeros rather than to $m$ , but addition requires merging index lists and random access to a single entry is no longer constant time.

Manufacturing Notes

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

Operation counts

Addition of two vectors of size $m$ costs $m$ additions; scalar multiplication costs $m$ multiplications; a linear combination of $n$ vectors costs $m n$ multiply-add operations. Every one of these is memory-bound in isolation, performing at most one arithmetic operation per operand loaded, which is why libraries provide the fused xAXPY rather than separate scale and add routines.

Fusing chains of operations

Evaluating $\alpha \vec{u} + \beta \vec{v} + \gamma \vec{w}$ naively makes three passes over memory and allocates two temporaries. Expression templates in C++ libraries such as Eigen, and NumPy's out= parameter, collapse the chain into a single pass. On large vectors the difference is a factor of two or three in wall-clock time with no change in the arithmetic performed.

Library conventions

NumPy represents a size- $m$ vector as a one-dimensional array; a genuine column vector of shape $(m, 1)$ behaves differently under broadcasting and the distinction is a frequent source of silent errors. MATLAB and Julia treat column vectors as $m \times 1$ matrices, so the column orientation is intrinsic. Fix the convention per codebase and assert it at interfaces.

Accumulation order and accuracy

A linear combination of many vectors sums a long series in each entry, and floating-point addition is not associative, so the result depends on the order. Where the terms vary widely in magnitude, sort by magnitude or use compensated summation. This matters most in iterative methods, where a single entry may accumulate contributions over thousands of steps.

Verifying an implementation

Test the algebraic identities directly: commutativity of addition, associativity, $1\vec{u} = \vec{u}$ , $\vec{u} + (-1)\vec{u} = \vec{0}$ , and both distributive laws. In exact arithmetic these must hold identically; in floating point they hold to rounding, and a violation larger than that indicates an indexing or aliasing defect rather than a numerical one.

Failure Modes & Common Mistakes

Failure modes, root causes and prevention
Failure mode / mistake	Impact	Root cause	Prevention & detection
Adding vectors of different sizes	high	Concatenating results from models with different degree-of-freedom counts, or relying on broadcasting to reconcile shapes.	Assert equal sizes at every interface. Treat a shape mismatch as a modelling error rather than something for the library to resolve silently.
Inconsistent entry ordering	high	Two modules assign different physical meanings to the same index position.	Define the ordering once, document it with the data, and validate it at module boundaries using labelled containers rather than bare arrays.
Row and column orientation confusion	medium	Treating a NumPy one-dimensional array as a column vector, so that a broadcast produces an $m \times m$ matrix rather than a vector of size $m$ .	Fix a shape convention per codebase and check the shape of every result, not merely its values.
Assuming an entrywise product exists	medium	Reading juxtaposition of two vectors as multiplication by analogy with scalars.	Only two operations are defined here: addition of two vectors and multiplication of a vector by a scalar. Entrywise products, inner products and cross products are separate constructions with separate definitions.
Testing floating-point vectors for exact equality	medium	Comparing computed vectors entry by entry with `==` after a non-trivial calculation.	Compare a norm of the difference against a tolerance scaled to the magnitudes involved, and state both the norm and the tolerance.
Scaling a vector with mixed units by one factor	medium	Applying a single scalar to a state vector containing both displacements and rotations, or both masses and concentrations.	Non-dimensionalise first, or apply a diagonal scaling matrix with one factor per entry rather than a single scalar.
Overflow in fixed-point scaling	medium	Multiplying a vector by a large scalar on an embedded target without headroom analysis.	Bound the dynamic range of every entry at design time and choose a fixed-point format with sufficient integer bits, or saturate explicitly and flag it.
Cancellation in long linear combinations	low	Summing many terms of similar magnitude and opposite sign in a single entry.	Order the summation by magnitude or apply compensated summation, and monitor the growth of the intermediate sums relative to the final result.

FAQs

Why define vector equality at all when it seems self-evident?

Because the symbol $=$ is being extended to a new class of object, and the extension has to be stated before it can be used in a proof. It also earns its keep immediately: because equality means agreement in every entry, one vector equation carries exactly the content of $m$ simultaneous scalar equations, which is the step that converts systems of equations into vector algebra.

Can I add a vector of size 3 to a vector of size 4?

No. Addition is defined only between vectors of the same size, so the expression has no meaning. Some array libraries will broadcast or pad and return something, which is worse than an error because the result is well formed and wrong. Assert equal sizes explicitly.

What is the difference between

\mathbb{R}^m

and

\mathbb{C}^m

Only the field the entries are drawn from. Every definition and every theorem on this page holds identically in both. The complex field is preferred as the default because eigenvalues of real matrices can be complex, so restricting to real entries would make parts of the later theory false rather than merely inapplicable.

Is a vector the same thing as a point, or as an arrow?

Those are interpretations, not definitions. A vector here is an ordered list of scalars. Reading it as a point in $m$ dimensions, or as an arrow from the origin with direction and magnitude, is often useful and always optional. The algebra is identical under every interpretation, which is exactly why the abstraction is worth having.

Why is

-\vec{u}

defined by addition rather than simply as

(-1)\vec{u}

Because the additive inverse is a property of the addition operation: it is the vector that returns $\vec{0}$ when added to $\vec{u}$ . That it happens to equal $(-1)\vec{u}$ is a theorem, verified entrywise. Keeping the two ideas separate matters in abstract vector spaces, where the axioms guarantee the inverse exists and the connection to the scalar $-1$ must be re-derived.

Do these operations have a cost worth thinking about?

Individually they are the cheapest operations in linear algebra — $m$ arithmetic operations for $m$ entries — but they are memory-bound rather than compute-bound. Performance is governed by how many times the data is read, not by the arithmetic, which is why fused operations such as xAXPY and single-pass expression evaluation matter far more than the operation count suggests.

How do these definitions connect to matrices?

A linear combination of the columns of a matrix, weighted by the entries of a vector, is precisely the matrix-vector product. So a system of equations written as a vector equality becomes $x_1\vec{A}_1 + \cdots + x_n\vec{A}_n = \vec{b}$ , and then $A\vec{x} = \vec{b}$ . The three definitions here are the foundation on which that entire notation is built.

References

Beezer, R. A. A First Course in Linear Algebra, Version 0.70. University of Puget Sound, 2006. Section VO, Definition VSCV, Definition CVE, Definition CVA and Definition CVSM. 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.
Lawson, C. L., Hanson, R. J., Kincaid, D. R. and Krogh, F. T. “Basic Linear Algebra Subprograms for Fortran Usage.” ACM Transactions on Mathematical Software, 5(3), 1979.
Golub, G. H. and Van Loan, C. F. Matrix Computations, 4th edition. Johns Hopkins University Press, 2013.
ISO/IEC 14882:2020, Programming languages — C++. International Organization for Standardization.

AI Suggested Questions

Show how a system of four equations in three unknowns becomes a single equality between vectors in $\mathbb{C}^4$ , and then a linear combination of three columns.
What breaks in the later theory if column vectors are restricted to real entries throughout?
Compare the memory traffic of evaluating a three-term linear combination in three passes against a single fused pass.
Why is exact equality the wrong test for computed floating-point vectors, and what tolerance criterion should replace it?
Give an example where an entrywise product of two vectors is the operation actually wanted, and explain why it is not part of the vector space structure.
How do sparse vector formats change the cost of addition and of random access to a single entry?

Related Calculators

Vector Arithmetic Calculator

Add, subtract and scale column vectors of any size over the real or complex numbers, with entrywise working shown.

Linear Combination Calculator

Evaluate $\alpha_1\vec{u}_1 + \cdots + \alpha_n\vec{u}_n$ and display the equivalent matrix-vector product.

Load Combination Tool

Combine analysis result vectors using factored design combinations and export the governing envelope.