Vector Magnitude

easyFREEVectorsLinear AlgebraCV: Mathematical Foundations

Implement a function to compute the magnitude (also known as the Euclidean norm) of a given vector. The magnitude of a vector is a fundamental concept in linear algebra and vector calculus, as it represents the "length" or "size" of the vector.

The magnitude of a vector $\mathbf{v} = [v_1, v_2,..., v_n]$ can be calculated using the formula $||\mathbf{v}|| = \sqrt{v_1^2 + v_2^2 +... + v_n^2}$ . To calculate this, follow these steps:

Square each component of the vector.
Sum the squared components.
Take the square root of the sum.

||\mathbf{v}|| = \sqrt{\sum_{i=1}^{n} v_i^2}

This technique is widely used in computer vision for image and signal processing.

Example

Input

magnitude([3, 4])

Output

5.0000

Reasoning

Input: v is the vector $[3, 4]$ , a point in 2-D space: 3 units along the first axis, 4 along the second. Its magnitude is the straight-line distance from the origin to that point.
Why squares: the two components are the legs of a right triangle and the vector is its hypotenuse, so Pythagoras gives $\|\mathbf{v}\|^2 = 3^2 + 4^2 = 9 + 16 = 25$ .
Length: $\|\mathbf{v}\| = \sqrt{25} = 5$ , reported to 4 decimal places as 5.0000.
Notice: squaring makes every term non-negative, so signs never cancel. The vector $[-3, 4]$ also has length 5, and the result is only $0$ for the all-zero vector.
More dimensions: the same rule extends to any length. For example $[1, 1, 1, 1]$ gives $\sqrt{1+1+1+1} = \sqrt{4} = 2$ , which is longer than any single component of 1.

Constraints

Vector length n where 1 ≤ n ≤ 1000
Vector elements are floating-point numbers
Return the result rounded to 4 decimal places

Learn this in

Mathematical FoundationsFoundations

More from CV: Mathematical Foundations

Adam Optimizer Stephard Power Iteration for Dominant Eigenvectorhard SVD Image Compressionhard Batch Affine Transform with PyTorchmedium Covariance Matrix from Image Patcheshard

Concept primer

The magnitude (Euclidean norm) of a vector is computed by squaring each component, summing those squares, and taking the square root of the sum.

1. Background Knowledge

A vector in this context is an ordered list of numbers, often written as $\mathbf{v} = [v_1, v_2, \dots, v_n]$ . You can think of it as a point in $n$ ‑dimensional space, or as an arrow from the origin to that point.

The Euclidean norm (or magnitude or length) of a vector generalizes the Pythagorean theorem to higher dimensions. For 2D, the length of $(x, y)$ is $\sqrt{x^2 + y^2}$ ; for 3D, the length of $(x, y, z)$ is $\sqrt{x^2 + y^2 + z^2}$ . In $n$ dimensions, this becomes:

\|\mathbf{v}\| = \sqrt{v_1^2 + v_2^2 + \dots + v_n^2}

This quantity is heavily used in normalization (scaling a vector to have length 1) and in distance computations (the distance between two points is the norm of their difference).

2. Algorithm / General Approach

The algorithm pattern is:

Iterate over all vector components.
Accumulate the sum of their squares.
Take the square root of the final sum to get the magnitude.

This is a simple single-pass reduction (fold) over the elements of the vector.

3. Step-by-Step Strategy

Assuming the input is a list/array v of length n:

Initialize an accumulator:

sum_sq = 0.0

For each component x in v:

Square it and add to the accumulator:

sum_sq += x * x

After the loop, compute the square root:

magnitude = math.sqrt(sum_sq)

Return or print magnitude.

In pseudocode:

function vector_magnitude(v):
 sum_sq = 0
 for each x in v:
 sum_sq = sum_sq + x * x
 return sqrt(sum_sq)

4. Common Pitfalls

Forgetting the square root: Summing squares alone gives you the squared norm, not the magnitude.
Integer vs float:
If components or the accumulator are integers, you might lose precision.
Use floating-point (e.g., double / float) for sum_sq and the result.
Empty vector:
If the problem allows it, the norm of an empty vector is usually defined as 0; otherwise, the input will typically guarantee at least one element.
Overflow for large values (less of a concern in Easy problems, but worth noting):
Squaring large integers can exceed integer range; using floating-point can help in practice.

5. Time & Space Complexity

Time complexity: You process each of the $n$ components once, so time complexity is $O(n)$
Space complexity: Aside from the input, you only keep a few scalar variables (sum_sq, magnitude), so space complexity is $O(1)$

solution.py

Python 3.13

Test results