import numpy as np

# Broadcasting demonstration
matrix = np.array([[1, 2, 3],
                   [4, 5, 6]])      # Shape: (2, 3)
vector = np.array([10, 20, 30])     # Shape: (3,)
scalar = 5                          # Shape: ()

print(f"Matrix (2x3): \n{matrix}")
print(f"Vector (3,): {vector}")
print(f"Scalar: {scalar}")

# Broadcasting in action
matrix_plus_vector = matrix + vector  # Vector broadcasts to match matrix
matrix_plus_scalar = matrix + scalar  # Scalar broadcasts to match matrix

print(f"Matrix + Vector: \n{matrix_plus_vector}")
print(f"Matrix + Scalar: \n{matrix_plus_scalar}")

import numpy as np

# Broadcasting rules demonstration
print("📏 Broadcasting Rules Examples")
print("=" * 30)

# Rule 1: Same shape - always compatible
a = np.array([[1, 2], [3, 4]])     # (2, 2)
b = np.array([[5, 6], [7, 8]])     # (2, 2)
print(f"Same shape: {a.shape} + {b.shape} = {(a + b).shape}")

# Rule 2: One dimension is 1
c = np.array([[1, 2]])             # (1, 2)
d = np.array([[3], [4]])           # (2, 1)
print(f"One dim is 1: {c.shape} + {d.shape} = {(c + d).shape}")

# Rule 3: Missing dimensions
e = np.array([[1, 2, 3]])          # (1, 3)
f = np.array([10, 20, 30])         # (3,) → treated as (1, 3)
print(f"Missing dim: {e.shape} + {f.shape} = {(e + f).shape}")

# Rule 4: Scalar broadcasting
g = np.array([[1, 2], [3, 4]])     # (2, 2)
h = 10                             # () → broadcasts to (2, 2)
print(f"Scalar: {g.shape} + scalar = {(g + h).shape}")

import numpy as np

# 1D + 2D broadcasting
matrix = np.array([[1, 2, 3, 4],
                   [5, 6, 7, 8],
                   [9, 10, 11, 12]])  # Shape: (3, 4)

# Row vector (broadcasts across rows)
row_vector = np.array([1, 2, 3, 4])   # Shape: (4,) → (1, 4)
print(f"Matrix: \n{matrix}")
print(f"Row vector: {row_vector}")
print(f"Matrix + Row: \n{matrix + row_vector}")

# Column vector (broadcasts across columns)
col_vector = np.array([[10], [20], [30]])  # Shape: (3, 1)
print(f"Column vector: \n{col_vector}")
print(f"Matrix + Column: \n{matrix + col_vector}")

# Both directions
both_result = matrix + row_vector + col_vector
print(f"Matrix + Row + Column: \n{both_result}")

import numpy as np

# Scalar broadcasting (simplest case)
data = np.array([[10, 20, 30],
                 [40, 50, 60]])

print(f"Original data: \n{data}")

# Scalar operations
doubled = data * 2
shifted = data + 100
normalized = data / 10

print(f"Doubled (×2): \n{doubled}")
print(f"Shifted (+100): \n{shifted}")
print(f"Normalized (÷10): \n{normalized}")

# Real example: temperature conversion
celsius = np.array([[0, 25, 37], [15, 30, 45]])
fahrenheit = celsius * 9/5 + 32
print(f"Celsius: \n{celsius}")
print(f"Fahrenheit: \n{fahrenheit}")

import numpy as np

print("🧮 Practical Broadcasting Applications")
print("=" * 35)

# Example 1: Data normalization
data = np.array([[85, 92, 78, 96],
                 [79, 88, 95, 82],
                 [91, 85, 89, 94]])  # Students × Subjects

print(f"Test scores: \n{data}")

# Normalize each subject (column-wise)
subject_means = np.mean(data, axis=0)      # Shape: (4,)
subject_stds = np.std(data, axis=0)        # Shape: (4,)

print(f"Subject means: {subject_means}")
print(f"Subject stds: {subject_stds}")

# Broadcasting for normalization
normalized = (data - subject_means) / subject_stds
print(f"Normalized scores: \n{normalized}")

# Example 2: Sales analysis
monthly_sales = np.array([[1500, 2200, 1800],  # Q1
                          [1800, 2400, 2100],  # Q2  
                          [1600, 2100, 1900],  # Q3
                          [2000, 2600, 2300]]) # Q4

print(f"\nMonthly sales (Quarters × Products): \n{monthly_sales}")

# Calculate percentage growth from Q1
q1_baseline = monthly_sales[0]  # Shape: (3,)
growth_rates = ((monthly_sales - q1_baseline) / q1_baseline) * 100

print(f"Q1 baseline: {q1_baseline}")
print(f"Growth rates (%): \n{growth_rates}")

import numpy as np

print("⚠️ Broadcasting Errors and Solutions")
print("=" * 35)

# Error example: Incompatible shapes
matrix1 = np.array([[1, 2, 3], [4, 5, 6]])    # (2, 3)
matrix2 = np.array([[1, 2], [3, 4]])          # (2, 2)

print(f"Matrix1 shape: {matrix1.shape}")
print(f"Matrix2 shape: {matrix2.shape}")

# This would cause an error:
# result = matrix1 + matrix2  # ValueError!

print("❌ Cannot broadcast (2,3) with (2,2)")

# Solution 1: Reshape or pad
matrix2_padded = np.column_stack([matrix2, np.zeros(2)])
print(f"Padded matrix2: \n{matrix2_padded}")
print(f"Now compatible: {matrix1 + matrix2_padded}")

# Solution 2: Use compatible operations
vector = np.array([1, 2, 3])  # (3,) - compatible with (2, 3)
print(f"Compatible addition: \n{matrix1 + vector}")

# Common error: Wrong axis
grades = np.array([[85, 90, 78], [92, 88, 95]])  # (2, 3)
weights = np.array([0.3, 0.7])  # (2,) - for students, not subjects

# Wrong: This won't work as expected
# weighted = grades * weights  # Broadcasting along wrong axis

# Correct: Reshape for proper broadcasting
weights_reshaped = weights.reshape(-1, 1)  # (2, 1)
weighted = grades * weights_reshaped
print(f"Correct weighting: \n{weighted}")

import numpy as np

print("🎯 Broadcasting Best Practices")
print("=" * 30)

# Practice 1: Check shapes before operations
def safe_broadcast_add(a, b):
    print(f"Shape A: {a.shape}, Shape B: {b.shape}")
    try:
        result = a + b
        print(f"Result shape: {result.shape}")
        return result
    except ValueError as e:
        print(f"Broadcasting error: {e}")
        return None

# Test safe broadcasting
a = np.array([[1, 2, 3]])         # (1, 3)
b = np.array([[4], [5], [6]])     # (3, 1)
c = np.array([7, 8])              # (2,) - incompatible

safe_broadcast_add(a, b)  # Should work
safe_broadcast_add(a, c)  # Should fail

# Practice 2: Use newaxis for explicit control
data = np.array([1, 2, 3, 4, 5])  # (5,)

# Make it a column vector
column = data[:, np.newaxis]       # (5, 1)
# Make it a row vector  
row = data[np.newaxis, :]          # (1, 5)

print(f"Original: {data.shape}")
print(f"Column: {column.shape}")
print(f"Row: {row.shape}")

# Practice 3: Understand the pattern
matrix = np.random.randn(4, 6)     # (4, 6)
row_operation = np.array([1, 2, 3, 4, 5, 6])      # (6,) - affects columns
col_operation = np.array([10, 20, 30, 40])[:, np.newaxis]  # (4, 1) - affects rows

print(f"Matrix shape: {matrix.shape}")
print(f"Row operation affects columns: {row_operation.shape}")
print(f"Column operation affects rows: {col_operation.shape}")