Dot Product

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

1. 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).
2. Compute dot product: Use np.dot(vec1, vec2) for scalar result.
3. Compute element-wise: Multiply vec1 * vec2, convert to Python list with .tolist().
4. Matrix-vector product: mat @ vec1, convert to list.
5. Vector-matrix product: vec1 @ mat, convert to list.
6. Package results: Create dict with keys "dot", "elementwise", "mat_vec", "vec_mat".
7. 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.