main.py

import math
import sys
import matplotlib.pyplot as plt
import memory_profiler
import numpy as np
import pandas as pd
import random
import seaborn as sns
from time import perf_counter

# Constants
COUNT = 1_000_000
NUM_RUNS = 10
RANDOM_SEED = 42

random.seed(RANDOM_SEED)
np.random.seed(RANDOM_SEED)

# Time generation
def compare_generation_times() -> tuple[float, float]:
    complex_gen_times = []
    vector_gen_times = []

    for _ in range(NUM_RUNS):
        start = perf_counter()
        complex_numbers = [
            complex(random.uniform(-1, 1), random.uniform(-1, 1)) for _ in range(COUNT)
        ]
        end = perf_counter()
        complex_gen_times.append(end - start)

        start = perf_counter()
        vectors = np.random.uniform(-1, 1, (COUNT, 2))
        end = perf_counter()
        vector_gen_times.append(end - start)

    return (sum(complex_gen_times) / NUM_RUNS, sum(vector_gen_times) / NUM_RUNS)

def compare_access_times() -> tuple[float, float]:
    complex_access_times = []
    vector_access_times = []

    for _ in range(NUM_RUNS):
        complex_numbers = [
            complex(random.uniform(-1, 1), random.uniform(-1, 1)) for _ in range(COUNT)
        ]

        vectors = np.random.uniform(-1, 1, (COUNT, 2))

        start = perf_counter()
        for z in complex_numbers:
            real = z.real
            imag = z.imag
        end = perf_counter()
        complex_access_times.append(end - start)

        start = perf_counter()
        for v in vectors:
            x = v[0]
            y = v[1]
        end = perf_counter()
        vector_access_times.append(end - start)

    return (sum(complex_access_times) / NUM_RUNS, sum(vector_access_times) / NUM_RUNS)

def compare_memory_usage() -> tuple[float, float]:
    # Generate 1 million complex numbers as a numpy array
    complex_array = np.array([complex(random.uniform(-1, 1), random.uniform(-1, 1)) for _ in range(1_000_000)])
    complex_size = complex_array.nbytes / (1024 ** 2)  # Convert bytes to megabytes

    # Generate 1 million 2D vectors as a numpy array
    vector_array = np.random.uniform(-1, 1, (1_000_000, 2))
    vector_size = vector_array.nbytes / (1024 ** 2)  # Convert bytes to megabytes

    return (complex_size, vector_size)

def compare_addition_times() -> tuple[float, float]:
    complex_addition_times = []
    vector_addition_times = []

    for _ in range(NUM_RUNS):
        c1, c2 = complex(random.uniform(-1, 1), random.uniform(-1, 1)), complex(
            random.uniform(-1, 1), random.uniform(-1, 1)
        )
        start = perf_counter()
        for _ in range(COUNT):
            z = c1 + c2
        end = perf_counter()
        complex_addition_times.append(end - start)

        v1 = np.random.uniform(-1, 1, 2)
        v2 = np.random.uniform(-1, 1, 2)
        start = perf_counter()
        for _ in range(COUNT):
            v = v1 + v2
        end = perf_counter()
        vector_addition_times.append(end - start)

    return (sum(complex_addition_times) / NUM_RUNS, sum(vector_addition_times) / NUM_RUNS)

def compare_dp_times() -> tuple[float, float]:
    complex_dot_times = []
    vector_dot_times = []

    for _ in range(NUM_RUNS):
        c1, c2 = complex(random.uniform(-1, 1), random.uniform(-1, 1)), complex(
            random.uniform(-1, 1), random.uniform(-1, 1)
        )
        start = perf_counter()
        for _ in range(COUNT):
            z = c1.real * c2.real + c1.imag * c2.imag
        end = perf_counter()
        complex_dot_times.append(end - start)

        v1 = np.random.uniform(-1, 1, 2)
        v2 = np.random.uniform(-1, 1, 2)
        start = perf_counter()
        for _ in range(COUNT):
            v = v1[0] * v2[0] + v1[1] * v2[1]
        end = perf_counter()
        vector_dot_times.append(end - start)

    return (sum(complex_dot_times) / NUM_RUNS, sum(vector_dot_times) / NUM_RUNS)

def compare_magnitude_times() -> tuple[float, float]:
    complex_magnitude_times = []
    vector_magnitude_times = []

    for _ in range(NUM_RUNS):
        c = complex(random.uniform(-1, 1), random.uniform(-1, 1))
        start = perf_counter()
        for _ in range(COUNT):
            z = abs(c)
        end = perf_counter()
        complex_magnitude_times.append(end - start)

        v = np.random.uniform(-1, 1, 2)
        start = perf_counter()
        for _ in range(COUNT):
            z = np.linalg.norm(v)
        end = perf_counter()
        vector_magnitude_times.append(end - start)

    return (sum(complex_magnitude_times) / NUM_RUNS, sum(vector_magnitude_times) / NUM_RUNS)

def get_rotation_times() -> tuple[float, float]:
    complex_rotation_times = []
    vector_rotation_times = []

    for _ in range(NUM_RUNS):
        angle = random.uniform(0, 2 * np.pi)
        rotation_complex = complex(np.cos(angle), np.sin(angle))
        rotation_matrix = np.array(
            [[np.cos(angle), -np.sin(angle)], [np.sin(angle), np.cos(angle)]]
        )

        c = complex(random.uniform(-1, 1), random.uniform(-1, 1))
        start = perf_counter()
        for _ in range(COUNT):
            z = c * rotation_complex
        end = perf_counter()
        complex_rotation_times.append(end - start)

        v = np.random.uniform(-1, 1, 2)
        start = perf_counter()
        for _ in range(COUNT):
            v = rotation_matrix @ v
        end = perf_counter()
        vector_rotation_times.append(end - start)

    return (sum(complex_rotation_times) / NUM_RUNS, sum(vector_rotation_times) / NUM_RUNS)



def main():
    # Generation
    print("== Generating ==")
    complex_gen_time, vector_gen_time = compare_generation_times()
    print(f"Time to generate complex numbers: {complex_gen_time:.4f} seconds")
    print(f"Time to generate vectors: {vector_gen_time:.4f} seconds")
    ratio = max(complex_gen_time, vector_gen_time) / min(complex_gen_time, vector_gen_time)
    print(f"{'Complex numbers' if complex_gen_time < vector_gen_time else 'Vectors'} are {ratio:.2f}x faster to generate")

    # Access
    print("\n== Accessing ==")
    complex_access_time, vector_access_time = compare_access_times()
    print(f"Time to access complex numbers: {complex_access_time:.4f} seconds")
    print(f"Time to access vectors: {vector_access_time:.4f} seconds")
    ratio = max(complex_access_time, vector_access_time) / min(complex_access_time, vector_access_time)
    print(f"{'Complex numbers' if complex_access_time < vector_access_time else 'Vectors'} are {ratio:.2f}x faster to access")

    # Memory
    print("\n== Memory Usage ==")
    complex_size, vector_size = compare_memory_usage()
    print(f"Memory usage for complex numbers: {complex_size:.1f} MB")
    print(f"Memory usage for vectors: {vector_size:.1f} MB")
    ratio = max(complex_size, vector_size) / min(complex_size, vector_size)
    print(f"{'Complex numbers' if complex_size < vector_size else 'Vectors'} are {ratio:.2f}x more memory efficient")

    # Addition
    print("\n== Addition ==")
    complex_addition_time, vector_addition_time = compare_addition_times()
    print(f"Time to add complex numbers: {complex_addition_time:.4f} seconds")
    print(f"Time to add vectors: {vector_addition_time:.4f} seconds")
    ratio = max(complex_addition_time, vector_addition_time) / min(complex_addition_time, vector_addition_time)
    print(f"{'Complex numbers' if complex_addition_time < vector_addition_time else 'Vectors'} are {ratio:.2f}x faster to add")

    # Dot Product
    print("\n== Dot Product ==")
    complex_dot_time, vector_dot_time = compare_dp_times()
    print(f"Time to dot product complex numbers: {complex_dot_time:.4f} seconds")
    print(f"Time to dot product vectors: {vector_dot_time:.4f} seconds")
    ratio = max(complex_dot_time, vector_dot_time) / min(complex_dot_time, vector_dot_time)
    print(f"{'Complex numbers' if complex_dot_time < vector_dot_time else 'Vectors'} are {ratio:.2f}x faster to dot product")

    # Magnitude
    print("\n== Magnitude ==")
    complex_magnitude_time, vector_magnitude_time = compare_magnitude_times()
    print(f"Time to magnitude complex numbers: {complex_magnitude_time:.4f} seconds")
    print(f"Time to magnitude vectors: {vector_magnitude_time:.4f} seconds")
    ratio = max(complex_magnitude_time, vector_magnitude_time) / min(complex_magnitude_time, vector_magnitude_time)
    print(f"{'Complex numbers' if complex_magnitude_time < vector_magnitude_time else 'Vectors'} are {ratio:.2f}x faster to magnitude")

    # Rotation
    print("\n== Rotation ==")
    complex_rotation_time, vector_rotation_time = get_rotation_times()
    print(f"Time to rotate complex numbers: {complex_rotation_time:.4f} seconds")
    print(f"Time to rotate vectors: {vector_rotation_time:.4f} seconds")
    ratio = max(complex_rotation_time, vector_rotation_time) / min(complex_rotation_time, vector_rotation_time)
    print(f"{'Complex numbers' if complex_rotation_time < vector_rotation_time else 'Vectors'} are {ratio:.2f}x faster to rotate")

    # Create visualization
    metrics = ["Generation", "Access", "Addition", "Dot Product", "Magnitude", "Rotation"]
    complex_times = [
        complex_gen_time,
        complex_access_time,
        complex_addition_time,
        complex_dot_time,
        complex_magnitude_time,
        complex_rotation_time,
    ]
    vector_times = [
        vector_gen_time,
        vector_access_time,
        vector_addition_time,
        vector_dot_time,
        vector_magnitude_time,
        vector_rotation_time,
    ]

    df = pd.DataFrame(
        {
            "Category": metrics * 2,
            "Time (seconds)": complex_times + vector_times,
            "Type": ["Complex Numbers"] * len(metrics) + ["Vectors"] * len(metrics),
        }
    )

    # Create the grouped bar graph excluding memory usage
    plt.figure(figsize=(12, 6))
    sns.barplot(
        data=df, x="Category", y="Time (seconds)", hue="Type", palette="Set2"
    )
    plt.title(
        "Performance Comparison: Complex Numbers vs Vectors (Excluding Memory Usage)",
        fontsize=16,
    )
    plt.ylabel("Time (seconds)", fontsize=12)
    plt.xlabel("Category", fontsize=12)
    plt.xticks(rotation=45, ha="right")
    plt.legend(title="Data Type", fontsize=10)
    plt.tight_layout()

    # Create memory profile visualization
    memory_metrics = ["Memory Usage"]
    
    memory_df = pd.DataFrame({
        "Category": memory_metrics * 2,
        "Memory (MB)": [complex_size, vector_size],
        "Type": ["Complex Numbers", "Vectors"]
    })

    plt.figure(figsize=(8, 6))
    sns.barplot(
        data=memory_df, x="Category", y="Memory (MB)", hue="Type", palette="Set2"
    )
    plt.title("Memory Usage: Complex Numbers vs Vectors", fontsize=16)
    plt.ylabel("Memory (MB)", fontsize=12)
    plt.xlabel("Category", fontsize=12)
    plt.legend(title="Data Type", fontsize=10)
    plt.tight_layout()

    # Show the plot
    plt.show()

if __name__ == "__main__":
    main()
    complex_memory, vector_memory = compare_memory_usage()
    print(complex_memory, vector_memory)
    # Compare memory usage of a single complex number vs a single vector
    single_complex = complex(1.0, 1.0)
    single_vector = np.array([1.0, 1.0])
    
    print("\nSingle element memory usage:")
    print(f"Complex number: {sys.getsizeof(single_complex)} bytes")
    print(f"NumPy vector: {single_vector.nbytes} bytes")