Chapter 123 — Vectors in Programming

# --- Visualization: Python list vs NumPy array behavior ---
import numpy as np
import matplotlib.pyplot as plt
plt.style.use('seaborn-v0_8-whitegrid')

# Demonstrate the addition difference
list_a = [1, 2, 3]
list_b = [4, 5, 6]

arr_a = np.array([1.0, 2.0, 3.0])
arr_b = np.array([4.0, 5.0, 6.0])

print("Python list:")
print(f"  [1,2,3] + [4,5,6] = {list_a + list_b}  (concatenation!)")

print("\nNumPy array:")
print(f"  [1,2,3] + [4,5,6] = {arr_a + arr_b}  (vector addition!)")

print("\nScaling:")
print(f"  Python: 2 * [1,2,3] = {2 * list_a}  (repetition!)")
print(f"  NumPy:  2 * [1,2,3] = {2 * arr_a}  (scalar multiplication!)")

# --- Visualization: Memory layout and speed ---
import numpy as np
import time

N = 1_000_000

python_list = list(range(N))
numpy_array = np.arange(N, dtype=np.float64)

# Time summing with Python list
t0 = time.perf_counter()
result_list = sum(python_list)
t1 = time.perf_counter()

# Time summing with NumPy
t2 = time.perf_counter()
result_numpy = numpy_array.sum()
t3 = time.perf_counter()

print(f"Python list sum: {result_list:.0f}  Time: {(t1-t0)*1000:.2f} ms")
print(f"NumPy array sum: {result_numpy:.0f}  Time: {(t3-t2)*1000:.2f} ms")
print(f"Speedup: {(t1-t0)/(t3-t2):.0f}x")
print(f"\nMemory — list: ~{8*N + 56*N:,} bytes approx")
print(f"Memory — numpy: {numpy_array.nbytes:,} bytes")

# --- Mathematical Formulation: NumPy array anatomy ---
import numpy as np

v = np.array([1.0, -2.5, 0.0, 7.3])

print("Vector v:", v)
print("Shape:   ", v.shape)    # (4,)
print("Dtype:   ", v.dtype)    # float64
print("Ndim:    ", v.ndim)     # 1
print("Size:    ", v.size)     # 4  (number of elements)
print("Nbytes:  ", v.nbytes)   # 32 (4 * 8)

# Specifying dtypes explicitly
v_int   = np.array([1, 2, 3], dtype=np.int32)
v_float = np.array([1, 2, 3], dtype=np.float64)
print("\nint32 vector:",   v_int,   v_int.dtype)
print("float64 vector:", v_float, v_float.dtype)

# --- Implementation: Utility functions for vectors ---
import numpy as np

def make_vector(*components):
    """
    Construct a float64 vector from individual components.

    Args:
        *components: scalar values

    Returns:
        ndarray, shape (n,), dtype float64
    """
    return np.array(components, dtype=np.float64)


def assert_vector(v, expected_dim=None):
    """
    Assert that v is a valid 1D numpy vector, optionally check dimension.

    Args:
        v: input to check
        expected_dim: int or None — expected number of components

    Raises:
        TypeError if v is not a 1D ndarray
        ValueError if dimension mismatch
    """
    if not isinstance(v, np.ndarray) or v.ndim != 1:
        raise TypeError(f"Expected 1D ndarray, got {type(v)} with ndim={getattr(v, 'ndim', 'N/A')}")
    if expected_dim is not None and v.shape[0] != expected_dim:
        raise ValueError(f"Expected dimension {expected_dim}, got {v.shape[0]}")


def vectors_same_dim(u, v):
    """
    Return True if u and v have the same dimension.

    Args:
        u, v: ndarrays

    Returns:
        bool
    """
    return u.shape == v.shape


# Test
v = make_vector(1, -2, 3.5)
print("Made vector:", v, "dtype:", v.dtype)

assert_vector(v)           # passes
assert_vector(v, 3)        # passes

try:
    assert_vector([1, 2])  # should fail
except TypeError as e:
    print("TypeError:", e)

try:
    assert_vector(v, 5)    # should fail
except ValueError as e:
    print("ValueError:", e)

# --- Experiment 1: Integer vs float dtype behavior ---
# Hypothesis: integer vectors truncate decimal results, float64 vectors do not.
# Try changing: dtype between int32, float32, float64
import numpy as np

DTYPE = np.int32   # <-- modify: try np.float32, np.float64

v = np.array([1, 2, 3], dtype=DTYPE)
result = v / 2

print(f"dtype={DTYPE.__name__}")
print(f"v = {v}")
print(f"v / 2 = {result}  (dtype: {result.dtype})")

# --- Experiment 2: Mutation and copying ---
# Hypothesis: assigning v = w and then modifying w WILL affect v (they share memory).
# Try changing: use np.copy() to prevent this.
import numpy as np

w = np.array([1.0, 2.0, 3.0])

USE_COPY = False  # <-- modify: try True

if USE_COPY:
    v = w.copy()
else:
    v = w  # just another name for the same array!

w[0] = 999.0

print("After modifying w[0]:")
print("  w =", w)
print("  v =", v)
print("  Same object?", v is w)

# --- Mini Project: Safe Vector Library ---
# Problem: Build a thin wrapper around NumPy that enforces vector semantics:
#          consistent dtype, dimension checking, and informative errors.
# Task: Implement the class below.

import numpy as np

class Vec:
    """
    A safe, typed vector wrapping a NumPy float64 array.
    Enforces dimension consistency and provides informative errors.
    """

    def __init__(self, data):
        """
        Args:
            data: list, tuple, or ndarray of numbers
        """
        # TODO: convert to float64 ndarray
        # TODO: raise TypeError if any element is not numeric
        pass

    @property
    def dim(self):
        """Return the dimension of the vector."""
        # TODO
        pass

    def __repr__(self):
        pass  # TODO: return a nice string

    def same_dim_as(self, other):
        """Return True if other is a Vec of the same dimension."""
        pass  # TODO


# When complete, these should work:
# v = Vec([1, 2, 3])
# print(v)         # Vec([1.0, 2.0, 3.0])
# print(v.dim)     # 3
# w = Vec([4, 5, 6])
# print(v.same_dim_as(w))  # True