Vectors

A vector is a mathematical object with two properties: magnitude (size) and direction. Vectors are used to represent quantities such as velocity, displacement, and forces — things where direction matters, not just amount.

In computing, a vector is represented as an ordered list of numbers — one number per dimension:

2D vector:  v = (3, 4)       ← x-component, y-component
3D vector:  v = (1, -2, 5)   ← x, y, z components
n-D vector: v = (v₁, v₂, ..., vₙ)

Geometric interpretation — a 2D vector (3, 4) means "3 units right, 4 units up." The magnitude (length) is calculated using Pythagoras:

$|\mathbf{v}|=\sqrt{3^2+4^2}=\sqrt{9+16}=\sqrt{25}=5$

In a program, a vector is stored just like a 1D array — or a list in Python:

v ← [3, 4]        // 2D vector
u ← [1, -2, 5]    // 3D vector

Vector addition adds corresponding components. Two vectors must have the same number of dimensions to be added.

$\mathbf{a}+\mathbf{b}=(a_1+b_1,a_2+b_2,\dots ,a_n+b_n)$

Example:

$\mathbf{a}=(1,3),\mathbf{b}=(4,-1)$ $\mathbf{a}+\mathbf{b}=(1+4,3+(-1))=(5,2)$

Scalar multiplication multiplies every component by a single number (the scalar):

$\alpha \mathbf{v}=(\alpha v_1,\alpha v_2,\dots ,\alpha v_n)$

Example:

$3\times (2,-1)=(6,-3)$

FUNCTION vectorAdd(a, b)
    result ← []
    FOR i ← 1 TO LEN(a)
        result[i] ← a[i] + b[i]
    NEXT i
    RETURN result
ENDFUNCTION

FUNCTION scalarMult(scalar, v)
    result ← []
    FOR i ← 1 TO LEN(v)
        result[i] ← scalar * v[i]
    NEXT i
    RETURN result
ENDFUNCTION

(Extra context — not required by AQA 7517) Vector addition and scalar multiplication are not explicitly listed in the AQA 4.2.8 spec bullets, but they underpin the dot product and convex combination calculations.

The dot product (scalar product) of two vectors produces a single number, not a vector. It is defined as:

$\mathbf{a}\cdot \mathbf{b}={\sum }_{i=1}^n{a}_i\cdot b_i=a_1{b}_1+a_2{b}_2+\cdots +a_n{b}_n$

Worked example:

$\mathbf{a}=(2,3,1),\mathbf{b}=(4,-1,5)$ $\mathbf{a}\cdot \mathbf{b}=(2\times 4)+(3\times (-1))+(1\times 5)=8-3+5=10$

FUNCTION dotProduct(a, b)
    total ← 0
    FOR i ← 1 TO LEN(a)
        total ← total + a[i] * b[i]
    NEXT i
    RETURN total
ENDFUNCTION

(Extra context — not required by AQA 7517) Geometric meaning: the dot product is related to the angle $\theta$ between the two vectors: $\mathbf{a}\cdot \mathbf{b}=|\mathbf{a}||\mathbf{b}|\cos \theta$. If the dot product is 0, the vectors are perpendicular ($\cos 90°=0$) — used in 3D graphics, physics simulations, and machine learning.

A convex combination of two vectors $\mathbf{u}$ and $\mathbf{v}$ is a weighted average that produces a point on the line segment between them.

$\mathbf{w}=\alpha \mathbf{u}+\beta \mathbf{v}$

where $\alpha \ge 0$, $\beta \ge 0$, and $\alpha +\beta =1$.

Key property: the constraint $\alpha +\beta =1$ with both non-negative ensures $\mathbf{w}$ always lies on or between $\mathbf{u}$ and $\mathbf{v}$ — never outside the segment.

Worked example — find the midpoint of two 2D vectors:

$\mathbf{u}=(0,0),\mathbf{v}=(6,4),\alpha =0.5,\beta =0.5$ $\mathbf{w}=0.5\times (0,0)+0.5\times (6,4)=(0,0)+(3,2)=(3,2)$

Setting $\alpha =0$ gives $\mathbf{v}$; setting $\alpha =1$ gives $\mathbf{u}$; any value in between gives an intermediate point.

Application — linear interpolation ("lerp") in computer graphics: smoothly animate a point from position $\mathbf{u}$ to position $\mathbf{v}$ by varying $\alpha$ from 1 to 0 over time.

Vectors are implemented in code using arrays or lists — one slot per component. All vector operations follow naturally from array indexing.

Representing a 2D game object:

// Position and velocity as 2D vectors
position ← [100, 200]    // x=100, y=200
velocity ← [3, -1]       // 3 units/frame right, 1 up

// Update position each frame
FOR i ← 1 TO 2
    position[i] ← position[i] + velocity[i]
NEXT i

Computing magnitude (length):

FUNCTION magnitude(v)
    sumSquares ← 0
    FOR i ← 1 TO LEN(v)
        sumSquares ← sumSquares + v[i] ^ 2
    NEXT i
    RETURN sumSquares ^ 0.5   // Square root
ENDFUNCTION

(Extra context — not required by AQA 7517) Normalising a vector scales it to magnitude 1 while preserving direction — divide each component by the magnitude. In code: RETURN scalarMult(1 / magnitude(v), v).

1. Confusing the dot product result type

The dot product of two vectors is a scalar (a single number), not a vector. Describing it as producing a vector is incorrect.

2. Adding vectors of different dimensions

Vector addition is only defined when both vectors have the same number of components. Adding a 2D vector to a 3D vector is undefined.

3. Getting the convex combination constraints wrong

Both weights must be non-negative and they must sum to 1. Forgetting either condition means the result may lie outside the segment between $\mathbf{u}$ and $\mathbf{v}$.

4. Treating $\alpha +\beta =1$ as optional

In a convex combination, $\alpha +\beta =1$ is a requirement, not a coincidence. Omitting this constraint in an exam answer loses the mark that distinguishes a convex combination from general linear interpolation.

5. Indexing errors in dot product loops

The dot product sums $n$ terms for $n$-dimensional vectors. Starting a loop at index 0 in AQA pseudocode (which uses 1-based indexing) or ending one step early produces an incorrect result.