Chapter 121 — What is a Vector?

# --- Visualization: Vectors as arrows in 2D ---
import numpy as np
import matplotlib.pyplot as plt
plt.style.use('seaborn-v0_8-whitegrid')

# Define three vectors
vectors = {
    'v₁ = [3, 1]':  (3,  1,  'steelblue'),
    'v₂ = [-1, 2]': (-1, 2,  'coral'),
    'v₃ = [2, -2]': (2,  -2, 'mediumseagreen'),
}

fig, ax = plt.subplots(figsize=(7, 7))

ORIGIN = np.array([0, 0])
for label, (x, y, color) in vectors.items():
    ax.annotate(
        '', xy=(x, y), xytext=ORIGIN,
        arrowprops=dict(arrowstyle='->', color=color, lw=2)
    )
    ax.text(x + 0.1, y + 0.1, label, color=color, fontsize=11)

ax.set_xlim(-3, 5)
ax.set_ylim(-3, 4)
ax.axhline(0, color='black', linewidth=0.8)
ax.axvline(0, color='black', linewidth=0.8)
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_title('Three 2D Vectors — Arrows Anchored at the Origin')
ax.set_aspect('equal')
plt.tight_layout()
plt.show()

# --- Mathematical Formulation: Vectors in NumPy ---
import numpy as np

# A 2D vector
v1 = np.array([3.0, 1.0])   # shape: (2,)

# A 3D vector
v2 = np.array([1.0, -2.0, 4.0])  # shape: (3,)

# A 5D vector (same math, just can't draw it)
v3 = np.array([0.1, 0.5, 0.2, 0.8, 0.4])  # shape: (5,)

print("v1:", v1, "  shape:", v1.shape, "  dtype:", v1.dtype)
print("v2:", v2, "  shape:", v2.shape)
print("v3:", v3, "  shape:", v3.shape)

# Accessing components
print("\nFirst component of v2:", v2[0])
print("All components of v3:", [v3[i] for i in range(len(v3))])

# The zero vector
zero_3d = np.zeros(3)
print("\nZero vector (3D):", zero_3d)

# --- Implementation: Vector class from scratch ---
# We build a minimal vector type to make the operations explicit.
# In practice we use NumPy, but this clarifies what a vector *is*.

class Vector:
    """
    A simple n-dimensional vector.

    Args:
        components: list or tuple of real numbers
    """

    def __init__(self, components):
        self.data = list(float(c) for c in components)
        self.dim = len(self.data)

    def __repr__(self):
        formatted = ', '.join(f'{c:.3g}' for c in self.data)
        return f'Vector([{formatted}])'

    def __len__(self):
        return self.dim

    def __getitem__(self, i):
        return self.data[i]

    def __eq__(self, other):
        """Two vectors are equal iff all components are equal."""
        if self.dim != other.dim:
            return False
        return all(abs(a - b) < 1e-10 for a, b in zip(self.data, other.data))


# Test it
v = Vector([3, 1, -2])
w = Vector([3, 1, -2])
u = Vector([1, 0,  2])

print("v:", v)
print("w:", w)
print("u:", u)
print("v == w:", v == w)   # True
print("v == u:", v == u)   # False
print("dim of v:", len(v))
print("Second component:", v[1])

# --- Experiment 1: What changes a vector? ---
# Hypothesis: changing any single component produces a different vector.
# Try changing: which component you modify, and by how much.
import numpy as np
import matplotlib.pyplot as plt
plt.style.use('seaborn-v0_8-whitegrid')

original = np.array([2.0, 1.0])
DELTA = 1.5   # <-- modify this

variant_x = original + np.array([DELTA, 0])   # shift x component
variant_y = original + np.array([0, DELTA])   # shift y component

fig, ax = plt.subplots(figsize=(6, 6))
for vec, label, color in [
    (original,  'original', 'steelblue'),
    (variant_x, 'shift x',  'coral'),
    (variant_y, 'shift y',  'mediumseagreen'),
]:
    ax.annotate('', xy=vec, xytext=[0,0],
                arrowprops=dict(arrowstyle='->', color=color, lw=2))
    ax.text(vec[0]+0.05, vec[1]+0.05, label, color=color)

ax.set_xlim(-1, 5); ax.set_ylim(-1, 5)
ax.axhline(0, color='black', lw=0.8); ax.axvline(0, color='black', lw=0.8)
ax.set_aspect('equal')
ax.set_title(f'Component Perturbation (DELTA={DELTA})')
ax.set_xlabel('x'); ax.set_ylabel('y')
plt.tight_layout()
plt.show()

# --- Experiment 2: High-dimensional vectors ---
# Hypothesis: NumPy handles 1000-dimensional vectors as easily as 2D.
# Try changing: N to 1, 10, 100, 10000
import numpy as np

N = 1000   # <-- modify this

v = np.random.randn(N)
print(f"Vector dimension: {N}")
print(f"First 5 components: {v[:5]}")
print(f"Shape: {v.shape}")
print(f"Memory usage: {v.nbytes} bytes")

# --- Mini Project: Wind Vector Display ---
# Problem: A weather station records wind readings as (speed_kmh, direction_degrees)
#          Convert each reading to a Cartesian vector and display on a map grid.
# Dataset: generated sensor readings
# Task: implement polar_to_cartesian(), display arrows on a grid

import numpy as np
import matplotlib.pyplot as plt
plt.style.use('seaborn-v0_8-whitegrid')

# Sensor grid positions (x, y in km)
grid_x = np.array([0, 1, 2, 0, 1, 2, 0, 1, 2], dtype=float)
grid_y = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2], dtype=float)

# Wind readings: (speed km/h, direction degrees clockwise from North)
readings = np.array([
    [15, 45], [20, 90], [18, 135],
    [12, 30], [25, 60], [22, 90],
    [10, 0],  [16, 80], [19, 110],
])

def polar_to_cartesian(speed, direction_deg):
    """
    Convert polar wind reading to Cartesian vector.

    Args:
        speed: wind speed (km/h)
        direction_deg: direction in degrees, clockwise from North

    Returns:
        (vx, vy): Cartesian components
    """
    # TODO: implement this
    # Hint: North is +y. East is +x.
    # A 0-degree wind blows North (positive y).
    # A 90-degree wind blows East (positive x).
    # Use np.deg2rad(), np.cos(), np.sin()
    pass

# --- When complete, this should display a wind field ---
# vx = np.array([polar_to_cartesian(s, d)[0] for s, d in readings])
# vy = np.array([polar_to_cartesian(s, d)[1] for s, d in readings])
#
# fig, ax = plt.subplots(figsize=(7, 7))
# ax.quiver(grid_x, grid_y, vx, vy, scale=200, color='steelblue')
# ax.set_title('Wind Field — Vector Representation')
# ax.set_xlabel('km East'); ax.set_ylabel('km North')
# plt.tight_layout(); plt.show()