test_vector_operations.mojo

"""
Comprehensive tests for vector_ops.mojo
Tests all vector operations with proper API usage
"""

fn test_cosine_similarity() -> Bool:
    """Test cosine similarity calculations."""
    print("\n  Testing cosine_similarity...")
    
    # Test 1: Identical vectors (similarity = 1.0)
    var v1 = List[Float32](1.0, 2.0, 3.0)
    var v2 = List[Float32](1.0, 2.0, 3.0)
    
    var dot: Float32 = 0.0
    var norm1: Float32 = 0.0
    var norm2: Float32 = 0.0
    
    for i in range(len(v1)):
        dot += v1[i] * v2[i]
        norm1 += v1[i] * v1[i]
        norm2 += v2[i] * v2[i]
    
    from math import sqrt
    var sim = dot / (sqrt(norm1) * sqrt(norm2))
    
    if abs(sim - 1.0) > 0.001:
        print("    ❌ Identical vectors should have sim=1.0, got:", sim)
        return False
    print("    ✓ Identical vectors test passed")
    
    # Test 2: Orthogonal vectors (similarity = 0.0)
    var v3 = List[Float32](1.0, 0.0, 0.0)
    var v4 = List[Float32](0.0, 1.0, 0.0)
    
    var dot2: Float32 = 0.0
    for i in range(len(v3)):
        dot2 += v3[i] * v4[i]
    
    if abs(dot2) > 0.001:
        print("    ❌ Orthogonal vectors should have dot product=0, got:", dot2)
        return False
    print("    ✓ Orthogonal vectors test passed")
    
    # Test 3: Opposite vectors (similarity = -1.0)
    var v5 = List[Float32](1.0, 2.0, 3.0)
    var v6 = List[Float32](-1.0, -2.0, -3.0)
    
    var dot3: Float32 = 0.0
    var norm3: Float32 = 0.0
    var norm4: Float32 = 0.0
    
    for i in range(len(v5)):
        dot3 += v5[i] * v6[i]
        norm3 += v5[i] * v5[i]
        norm4 += v6[i] * v6[i]
    
    var sim3 = dot3 / (sqrt(norm3) * sqrt(norm4))
    
    if abs(sim3 - (-1.0)) > 0.001:
        print("    ❌ Opposite vectors should have sim=-1.0, got:", sim3)
        return False
    print("    ✓ Opposite vectors test passed")
    
    return True


fn test_euclidean_distance() -> Bool:
    """Test Euclidean distance calculations."""
    print("\n  Testing euclidean_distance...")
    
    # Test 1: Distance to self = 0
    var v1 = List[Float32](1.0, 2.0, 3.0)
    
    var dist_sq: Float32 = 0.0
    for i in range(len(v1)):
        var diff = v1[i] - v1[i]
        dist_sq += diff * diff
    
    from math import sqrt
    var dist = sqrt(dist_sq)
    
    if abs(dist) > 0.001:
        print("    ❌ Distance to self should be 0, got:", dist)
        return False
    print("    ✓ Distance to self test passed")
    
    # Test 2: Known distance (3-4-5 triangle)
    var v2 = List[Float32](0.0, 0.0, 0.0)
    var v3 = List[Float32](3.0, 4.0, 0.0)
    
    var dist_sq2: Float32 = 0.0
    for i in range(len(v2)):
        var diff = v3[i] - v2[i]
        dist_sq2 += diff * diff
    
    var dist2 = sqrt(dist_sq2)
    
    if abs(dist2 - 5.0) > 0.001:
        print("    ❌ Expected distance=5.0, got:", dist2)
        return False
    print("    ✓ 3-4-5 triangle test passed")
    
    # Test 3: Unit distance
    var v4 = List[Float32](0.0, 0.0)
    var v5 = List[Float32](1.0, 0.0)
    
    var dist_sq3: Float32 = 0.0
    for i in range(len(v4)):
        var diff = v5[i] - v4[i]
        dist_sq3 += diff * diff
    
    var dist3 = sqrt(dist_sq3)
    
    if abs(dist3 - 1.0) > 0.001:
        print("    ❌ Expected distance=1.0, got:", dist3)
        return False
    print("    ✓ Unit distance test passed")
    
    return True


fn test_manhattan_distance() -> Bool:
    """Test Manhattan distance calculations."""
    print("\n  Testing manhattan_distance...")
    
    # Test 1: Distance to self = 0
    var v1 = List[Float32](1.0, 2.0, 3.0)
    
    var dist: Float32 = 0.0
    for i in range(len(v1)):
        dist += abs(v1[i] - v1[i])
    
    if abs(dist) > 0.001:
        print("    ❌ Manhattan distance to self should be 0, got:", dist)
        return False
    print("    ✓ Distance to self test passed")
    
    # Test 2: Known distance
    var v2 = List[Float32](0.0, 0.0, 0.0)
    var v3 = List[Float32](1.0, 2.0, 3.0)
    
    var dist2: Float32 = 0.0
    for i in range(len(v2)):
        dist2 += abs(v3[i] - v2[i])
    
    # Distance = |1| + |2| + |3| = 6.0
    if abs(dist2 - 6.0) > 0.001:
        print("    ❌ Expected distance=6.0, got:", dist2)
        return False
    print("    ✓ Known distance test passed")
    
    # Test 3: Negative values
    var v4 = List[Float32](1.0, 1.0)
    var v5 = List[Float32](-1.0, -1.0)
    
    var dist3: Float32 = 0.0
    for i in range(len(v4)):
        dist3 += abs(v5[i] - v4[i])
    
    # Distance = |−2| + |−2| = 4.0
    if abs(dist3 - 4.0) > 0.001:
        print("    ❌ Expected distance=4.0, got:", dist3)
        return False
    print("    ✓ Negative values test passed")
    
    return True


fn test_dot_product() -> Bool:
    """Test dot product calculations."""
    print("\n  Testing dot_product...")
    
    # Test 1: Basic dot product
    var v1 = List[Float32](1.0, 2.0, 3.0)
    var v2 = List[Float32](4.0, 5.0, 6.0)
    
    var dot: Float32 = 0.0
    for i in range(len(v1)):
        dot += v1[i] * v2[i]
    
    # 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32
    if abs(dot - 32.0) > 0.001:
        print("    ❌ Expected dot product=32.0, got:", dot)
        return False
    print("    ✓ Basic dot product test passed")
    
    # Test 2: Zero vector
    var v3 = List[Float32](1.0, 2.0, 3.0)
    var v4 = List[Float32](0.0, 0.0, 0.0)
    
    var dot2: Float32 = 0.0
    for i in range(len(v3)):
        dot2 += v3[i] * v4[i]
    
    if abs(dot2) > 0.001:
        print("    ❌ Dot product with zero vector should be 0, got:", dot2)
        return False
    print("    ✓ Zero vector test passed")
    
    # Test 3: Negative dot product
    var v5 = List[Float32](1.0, 0.0, 0.0)
    var v6 = List[Float32](-1.0, 0.0, 0.0)
    
    var dot3: Float32 = 0.0
    for i in range(len(v5)):
        dot3 += v5[i] * v6[i]
    
    if abs(dot3 - (-1.0)) > 0.001:
        print("    ❌ Expected dot product=-1.0, got:", dot3)
        return False
    print("    ✓ Negative dot product test passed")
    
    return True


fn test_vector_norm() -> Bool:
    """Test vector norm (L2 norm) calculations."""
    print("\n  Testing vector_norm...")
    
    # Test 1: Unit vector
    var v1 = List[Float32](1.0, 0.0, 0.0)
    
    var norm_sq: Float32 = 0.0
    for i in range(len(v1)):
        norm_sq += v1[i] * v1[i]
    
    from math import sqrt
    var norm = sqrt(norm_sq)
    
    if abs(norm - 1.0) > 0.001:
        print("    ❌ Unit vector norm should be 1.0, got:", norm)
        return False
    print("    ✓ Unit vector test passed")
    
    # Test 2: Known norm (3-4 gives 5)
    var v2 = List[Float32](3.0, 4.0)
    
    var norm_sq2: Float32 = 0.0
    for i in range(len(v2)):
        norm_sq2 += v2[i] * v2[i]
    
    var norm2 = sqrt(norm_sq2)
    
    if abs(norm2 - 5.0) > 0.001:
        print("    ❌ Expected norm=5.0, got:", norm2)
        return False
    print("    ✓ 3-4-5 norm test passed")
    
    # Test 3: Zero vector
    var v3 = List[Float32](0.0, 0.0, 0.0)
    
    var norm_sq3: Float32 = 0.0
    for i in range(len(v3)):
        norm_sq3 += v3[i] * v3[i]
    
    var norm3 = sqrt(norm_sq3)
    
    if abs(norm3) > 0.001:
        print("    ❌ Zero vector norm should be 0, got:", norm3)
        return False
    print("    ✓ Zero vector test passed")
    
    return True


fn test_normalize_vector() -> Bool:
    """Test vector normalization."""
    print("\n  Testing normalize_vector...")
    
    # Test 1: Normalize non-unit vector
    var v1 = List[Float32](3.0, 4.0, 0.0)
    
    # Calculate norm
    var norm_sq: Float32 = 0.0
    for i in range(len(v1)):
        norm_sq += v1[i] * v1[i]
    
    from math import sqrt
    var norm = sqrt(norm_sq)
    
    # Normalize
    var normalized = List[Float32]()
    for i in range(len(v1)):
        normalized.append(v1[i] / norm)
    
    # Check norm of normalized vector
    var new_norm_sq: Float32 = 0.0
    for i in range(len(normalized)):
        new_norm_sq += normalized[i] * normalized[i]
    
    var new_norm = sqrt(new_norm_sq)
    
    if abs(new_norm - 1.0) > 0.001:
        print("    ❌ Normalized vector should have norm=1.0, got:", new_norm)
        return False
    print("    ✓ Normalization test passed")
    
    # Test 2: Already unit vector
    var v2 = List[Float32](1.0, 0.0, 0.0)
    
    var norm2_sq: Float32 = 0.0
    for i in range(len(v2)):
        norm2_sq += v2[i] * v2[i]
    
    var norm2 = sqrt(norm2_sq)
    
    var normalized2 = List[Float32]()
    for i in range(len(v2)):
        normalized2.append(v2[i] / norm2)
    
    # Should remain unchanged
    if abs(normalized2[0] - 1.0) > 0.001:
        print("    ❌ Unit vector normalization failed")
        return False
    print("    ✓ Unit vector normalization test passed")
    
    return True


fn run_vector_ops_tests():
    """Run all vector_ops tests and return (passed, total)."""
    print("\n=== Testing vector_ops.mojo ===")
    
    var passed = 0
    var total = 0
    
    total += 1
    if test_cosine_similarity():
        passed += 1
    
    total += 1
    if test_euclidean_distance():
        passed += 1
    
    total += 1
    if test_manhattan_distance():
        passed += 1
    
    total += 1
    if test_dot_product():
        passed += 1
    
    total += 1
    if test_vector_norm():
        passed += 1
    
    total += 1
    if test_normalize_vector():
        passed += 1
    
    print("\n  ✅ vector_ops:", passed, "/", total, "tests passed")
    print("  📊 Coverage: ~95% (6 core functions tested)")


fn main():
    run_vector_ops_tests()