Vector Dot Product

easyFREEVectorsLinear AlgebraCV: Mathematical Foundations

Implement a function to compute the dot product of two vectors a and b. The dot product, a fundamental concept in linear algebra, is used to measure the similarity between two vectors, which is crucial in various computer vision applications.

The dot product of two vectors $\mathbf{a} = [a_1, a_2,..., a_n]$ and $\mathbf{b} = [b_1, b_2,..., b_n]$ can be calculated by multiplying corresponding elements and summing them up. Return the result rounded to 4 decimal places.

\mathbf{a} \cdot \mathbf{b} = \sum_{i=1}^{n} a_i b_i = a_1 b_1 + a_2 b_2 +... + a_n b_n

This technique is widely used in image processing.

Example

Input

dot_product([1, 2, 3], [4, 5, 6])

Output

Reasoning

Inputs: $\mathbf{a} = [1, 2, 3]$ and $\mathbf{b} = [4, 5, 6]$ are two vectors of the same length $n = 3$ ; entry $a_i$ is paired with the entry $b_i$ in the same position.
Pairwise products: $a_1 b_1 = 1 \times 4 = 4$ , $a_2 b_2 = 2 \times 5 = 10$ , $a_3 b_3 = 3 \times 6 = 18$ .
Sum: $\mathbf{a} \cdot \mathbf{b} = 4 + 10 + 18 = 32$ .
Output: a single scalar, 32. Rounding to 4 decimal places leaves it unchanged because every input is a whole number, so no decimals appear.
Notice that the result collapses two vectors into one number. Large positive values mean the vectors point in similar directions; perpendicular vectors such as $[1, 0]$ and $[0, 1]$ give exactly $0$ , and a vector dotted with itself, e.g. $[3, 4] \cdot [3, 4] = 9 + 16 = 25$ , gives its squared length.

Constraints

Both vectors have the same 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

Vector Dot Product: Background & Solution Strategy

Background Knowledge

The dot product (also called scalar product or inner product) is a fundamental operation that combines two vectors to produce a single scalar value. Geometrically, it measures how much two vectors "point in the same direction"—when vectors are parallel, the dot product is maximized; when perpendicular, it equals zero. Mathematically, the dot product of vectors a and b is computed by multiplying corresponding components and summing the results.

In computer vision and machine learning, the dot product is ubiquitous. It appears in similarity computations (measuring how alike two feature vectors are), in neural network operations (where weights and activations are combined via dot products), and in geometric calculations (projecting one vector onto another). Understanding this operation deeply will help you grasp more complex concepts like attention mechanisms, which rely heavily on dot product computations for comparing sequences of data.

The dot product also has an important relationship with the cosine of the angle between two vectors: $\mathbf{a} \cdot$ \mathbf{b} $= |$ \mathbf{a} $| |$ \mathbf{b} $| \cos($ \theta $)$ , where $\theta$ is the angle between them. This connection makes the dot product a natural choice for measuring vector similarity in computer vision tasks.

Algorithm/Approach

The solution follows a straightforward iterative accumulation pattern:

Initialize an accumulator variable to zero
Iterate through corresponding pairs of elements from both vectors
Multiply each pair and add the result to the accumulator
Return the final accumulated value

This is a linear scan with a single pass through the data—no nested loops or complex data structures needed.

Step-by-Step Strategy

Step 1: Validate Input

Ensure both vectors have the same length (they must for a valid dot product)
Handle edge cases like empty vectors (dot product should be 0)

Step 2: Initialize Accumulator

Create a variable to store the running sum, initialized to 0

Step 3: Iterate and Accumulate

Loop through indices from 0 to n-1 (where n is the vector length)
For each index i, multiply a[i] * b[i]
Add this product to your accumulator

Step 4: Return Result

After the loop completes, return the accumulated sum

Common Pitfalls

Length mismatch: Always verify both vectors have equal length before computing. Attempting to access out-of-bounds indices will cause errors.
Integer vs. floating-point arithmetic: If your vectors contain floats, ensure your accumulator is also a float type to avoid precision loss.
Off-by-one errors: Double-check loop bounds—you should iterate from index 0 to n-1 inclusive.
Not initializing the accumulator: Forgetting to set the sum to 0 before looping will produce incorrect results.
Confusing dot product with element-wise multiplication: The dot product produces a scalar, not a vector. Don't return an array of products.

Time & Space Complexity

Time Complexity: $O(n)$ where n is the length of the vectors. You must examine every element exactly once to compute the sum.

Space Complexity: $O(1)$ (constant space). You only need a single accumulator variable regardless of vector size. If the input vectors are provided as arrays/lists, they occupy $O(n)$ space, but your algorithm itself uses only constant additional memory.

solution.py

Python 3.13

Test results