Angle Between Vectors

The angle between two vectors is defined as the geometric angle that separates their directions in space, independent of their lengths. For vectors $$\mathbf{a}$$ and $$\mathbf{b}$$, this angle $$\theta$$ is computed via the dot product, which links algebraic operations on coordinates to geometric concepts like length and angle. In Euclidean space, the dot product captures how much one vector “points in the direction” of another.

Formally, the dot product satisfies

$$\mathbf{a} \cdot \mathbf{b} = \|\mathbf{a}\| \,\|\mathbf{b}\| \cos\theta,$$

where $\|$\mathbf{a}$\|$ and $\|$\mathbf{b}$\|$ are the vector magnitudes. Rearranging gives

$$\theta = \arccos\left(\frac{\mathbf{a} \cdot \mathbf{b}}{\|\mathbf{a}\| \,\|\mathbf{b}\|}\right).$$

In computer vision, this is widely used to measure similarity between feature descriptors (e.g., embeddings, SIFT-like features) and to compare orientations (e.g., normals, motion vectors).

---

1. Background Knowledge

• Dot product (inner product) For vectors in $\mathbb{R}^n$,

$$\mathbf{a} \cdot \mathbf{b} = \sum_{i=1}^{n} a_i b_i.$$

Geometrically, this equals $\|$\mathbf{a}$\| \,\|$\mathbf{b}$\| \cos$\theta$$.

• If $$\mathbf{a}$\cdot$\mathbf{b}$> 0$: angle $< 90^\circ$ (acute).

• If $$\mathbf{a}$\cdot$\mathbf{b}$= 0$: vectors are orthogonal.

• If $$\mathbf{a}$\cdot$\mathbf{b}$< 0$: angle $> 90^\circ$ (obtuse).

• Norm (magnitude) of a vector

$$\|\mathbf{a}\| = \sqrt{\sum_{i=1}^{n} a_i^2}.$$

This is the Euclidean length. The denominator $\|$\mathbf{a}$\| \,\|$\mathbf{b}$\|$ normalizes for length so the angle depends only on direction, not scale.

---

2. Algorithm / Approach

General pattern to compute the angle between vectors:

1. Compute the dot product of the two vectors.
2. Compute their magnitudes (Euclidean norms).
3. Compute the cosine of the angle as

$$\cos\theta = \frac{\mathbf{a} \cdot \mathbf{b}}{\|\mathbf{a}\| \,\|\mathbf{b}\|}.$$

4. Apply inverse cosine (arccos) to get the angle in radians.
5. Convert radians to degrees if required:

$$\theta_{\text{deg}} = \theta_{\text{rad}} \cdot \frac{180}{\pi}.$$

This same pattern appears in similarity measures, e.g. cosine similarity is just the value $\cos$\theta$$ without the final arccos.

---

3. Step-by-Step Strategy

Assume vectors are given as arrays/lists of numbers of equal length $n$.

1. Check dimensions

• Ensure both vectors have the same length.
• Handle or report error if not.

2. Compute dot product

dot = 0.0
for i in range(n):
dot += a[i] * b[i]

3. Compute magnitudes

import math

norm_a_sq = 0.0
norm_b_sq = 0.0
for i in range(n):
norm_a_sq += a[i] * a[i]
norm_b_sq += b[i] * b[i]

norm_a = math.sqrt(norm_a_sq)
norm_b = math.sqrt(norm_b_sq)

4. Guard against zero vectors

• If norm_a == 0 or norm_b == 0, the angle is undefined (directionless vector). Decide how your problem wants this handled (e.g., raise error, return 0, etc.).

5. Compute cosine of angle

cos_theta = dot / (norm_a * norm_b)

6. Clamp for numerical stability

cos_theta = max(-1.0, min(1.0, cos_theta))

7. Compute angle in radians and convert to degrees

theta_rad = math.acos(cos_theta)
theta_deg = theta_rad * 180.0 / math.pi

8. Return θ in degrees as the final result.

---

4. Common Pitfalls

• Zero-length vectors Division by zero occurs if $\|$\mathbf{a}$\| = 0$ or $\|$\mathbf{b}$\| = 0$. The angle is not defined, so you must explicitly handle this case.

• Floating-point precision issues Due to rounding, cos_theta might become slightly > 1 or < -1 (e.g. 1.0000000002), causing acos to return NaN. Clamping cos_theta to $[-1, 1]$ avoids this.

• Radians vs degrees confusion Most math libraries return angles in radians. Don’t forget to convert to degrees if the problem specifically asks for degrees.

• Mismatched dimensions Failing to ensure both vectors have the same length leads to incorrect results or runtime errors.

---

5. Time & Space Complexity

Let $n$ be the dimension of the vectors.

• Time Complexity

• Dot product: $O(n)$

• Norm computations: $O(n)$

• Remaining operations (divisions, sqrt, acos, conversion): $O(1)$ Overall: $O(n)$.

• Space Complexity

• Only a constant number of scalar variables used (dot, norms, etc.).

• No extra data structures proportional to $n$. Overall: $O(1)$ additional space (beyond the input vectors).