Dot Product

easyFREELinear Algebra BasicsNumPy Linear AlgebraNumPy Foundations

Problem Statement

Compute dot products and matrix multiplications.

Background

NumPy provides several multiplication operations:

np.dot(a, b) - dot product
a @ b - matrix multiplication (Python 3.5+)
a * b - element-wise multiplication

For vectors: dot product = sum of element-wise products For matrices: standard matrix multiplication

Your Task

Write a function compute_products(vec1, vec2, mat) that computes various products.

Output Format

Return a dictionary with:

"dot": Dot product of vec1 and vec2 (a plain Python int)
"elementwise": Element-wise product of vec1 and vec2 (a plain Python list)
"mat_vec": Matrix times vec1 (a plain Python list)
"vec_mat": vec1 times matrix (a plain Python list)

The dictionary is printed, so values must be built-in Python types, not NumPy scalars or arrays.

Example

Input

vec1 = [1,2,3], vec2 = [4,5,6], mat = identity

Output

{'dot': 32, 'elementwise': [4, 10, 18], 'mat_vec': [1, 2, 3], 'vec_mat': [1, 2, 3]}

Reasoning

Inputs: vec1 $= (1, 2, 3)$ and vec2 $= (4, 5, 6)$ are length-3 vectors; mat is the $3 \times 3$ identity matrix $I$ (ones on the diagonal, zeros elsewhere).
dot: multiply matching entries and add them up: $1 \cdot 4 + 2 \cdot 5 + 3 \cdot 6 = 4 + 10 + 18 = 32$ .
elementwise: keep the matching products separately instead of adding them: $(4, 10, 18)$ . Notice that its entries sum to the dot product, $32$ .
mat_vec: entry $i$ is $\sum_j m_{ij} v_j$ , the dot product of row $i$ of the matrix with vec1. With $I$ , row $i$ picks out $v_i$ alone, giving $(1, 2, 3)$ .
vec_mat: entry $j$ is $\sum_i v_i m_{ij}$ , the dot product of vec1 with column $j$ . $I$ again gives $(1, 2, 3)$ .
Notice: the last two only agree here because $I$ is symmetric. For $M = \begin{pmatrix}1 & 2\\3 & 4\end{pmatrix}$ and $v = (1, 1)$ , $Mv = (3, 7)$ but $vM = (4, 6)$ .

Constraints

vec1 and vec2 have same length
mat is square with size matching vector length

Learn this in

NumPy & Data WranglingFoundations

More from NumPy Foundations

Solve Linear Systemmedium Matrix Operationseasy Image-like Reshapingmedium Array Stackingeasy Array Reshapingeasy

Concept primer

Background Knowledge

The dot product of two vectors $\vec{a} = [a_1, a_2, \dots, a_n]$ and $\vec{b} = [b_1, b_2, \dots, b_n]$ is a scalar computed as $\vec{a} \cdot$ \vec{b} $=$ \sum_{i=1}^n a_i b_i $. Geometrically, it equals$ |\vec{a} $| |$ \vec{b} $| \cos\theta$ , measuring projection and similarity. In NumPy, np.dot(vec1, vec2) computes this efficiently for 1D arrays as a sum of element-wise products.

Element-wise multiplication (Hadamard product) multiplies corresponding elements: $\vec{a} \odot$ \vec{b} $= [a_1 b_1, a_2 b_2, \dots, a_n b_n]$ , using vec1 * vec2. Matrix-vector multiplication $\mathbf{M} \vec{v}$ produces a vector where each entry is a dot product of a matrix row with $\vec{v}$ . Vector-matrix multiplication $\vec{v} \mathbf{M}$ uses the matrix column with $\vec{v}$ . NumPy's @ operator (or np.dot) handles these, with broadcasting aligning shapes automatically.

These operations underpin linear algebra: dot products enable projections, while matrix products model transformations like rotations.

Algorithm/Approach

Use NumPy's built-in functions for efficiency:

Scalar dot product: np.dot(vec1, vec2) or vec1 @ vec2.
Element-wise: vec1 * vec2, convert to list.
Matrix-vector: mat @ vec1.
Vector-matrix: vec1 @ mat.

Return a dictionary mapping keys to results, ensuring outputs match types (scalar for dot, lists for vectors).

Step-by-Step Strategy

Validate inputs: Assume vec1, vec2 are 1D NumPy arrays of equal length; mat is 2D with compatible shape (e.g., $n \times n$ for identity-like sample).
Compute dot product: Use np.dot(vec1, vec2) for scalar result.
Compute element-wise: Multiply vec1 * vec2, convert to Python list with .tolist().
Matrix-vector product: mat @ vec1, convert to list.
Vector-matrix product: vec1 @ mat, convert to list.
Package results: Create dict with keys "dot", "elementwise", "mat_vec", "vec_mat".
Test shapes: Verify vec1.shape == mat.shape for compatibility.

Common Pitfalls

Output types: Dot must be scalar (float/int), others lists—not NumPy arrays.
Shape mismatches: vec1 @ mat fails if vec1 length ≠ mat rows; check dimensions.
Operator precedence: @ for matmul vs * for element-wise—mixing causes errors.
1D array behavior: NumPy treats 1D as vectors; np.dot auto-handles, but explicit shapes prevent issues.
No imports in function: Assume numpy as np is imported outside; don't re-import.

Time & Space Complexity

Time: $O(n)$ per operation (dot/element-wise: $n$ multiplies + sum; mat-vec: $O(n^2)$ for $n \times n$ matrix). Total: $O(n^2)$ .
Space: $O(n)$ for output vectors/lists; dictionary overhead negligible. NumPy operations are in-place efficient.

solution.py

Python 3.13

Test results