Constraint Theory

# 156 lines of error-prone floating-point math
import numpy as np
from math import sqrt, acos, cos, sin, pi

class TriangleSolver:
    def __init__(self, tolerance=1e-10):
        self.tol = tolerance
        self.max_iter = 1000
    
    def solve_right_triangle(self, a, b):
        # Floating point accumulation errors
        c_sq = a*a + b*b
        c = sqrt(c_sq)
        
        # Drift accumulates here
        angle_a = acos(a / c)
        angle_b = acos(b / c)
        
        # Precision loss in repeated ops
        hyp = sqrt(a**2 + b**2)
        
        # Need epsilon comparison
        if abs(angle_a + angle_b - pi/2) > self.tol:
            raise ValueError("Angles don't sum to 90°")
        
        return {
            'hypotenuse': hyp,
            'angles': (angle_a, angle_b),
            # Stored as floats - precision loss
            'precise': False
        }
    
    def snap_to_pythagorean(self, x, y):
        # Iterative approximation needed
        for _ in range(self.max_iter):
            ratio = x / y if y != 0 else float('inf')
            # Check against known triples...
            for a, b, c in PYTHAGOREAN_TRIPLES:
                if abs(ratio - a/b) < self.tol:
                    return (a, b, c)
        return None  # May not find exact

// 187 lines with error handling
use std::f64::consts::PI;

struct TriangleSolver {
    tolerance: f64,
    max_iter: usize,
}

impl TriangleSolver {
    pub fn new() -> Self {
        Self {
            tolerance: 1e-10,
            max_iter: 1000,
        }
    }
    
    pub fn solve_right_triangle(&self, a: f64, b: f64) 
        -> Result {
        // Floating-point accumulation
        let c_sq = a * a + b * b;
        let c = c_sq.sqrt();
        
        // Precision loss in trig
        let angle_a = (a / c).acos();
        let angle_b = (b / c).acos();
        
        // Epsilon comparisons needed
        if (angle_a + angle_b - PI / 2.0).abs() > self.tolerance {
            return Err(Error::InvalidAngles);
        }
        
        Ok(TriangleResult {
            hypotenuse: c,
            angles: [angle_a, angle_b],
            precise: false,  // Never truly precise
        })
    }
}

// 143 lines with precision issues
class TriangleSolver {
    constructor(tolerance = 1e-10) {
        this.tolerance = tolerance;
        this.maxIter = 1000;
    }
    
    solveRightTriangle(a, b) {
        // Floating-point drift
        const cSq = a * a + b * b;
        const c = Math.sqrt(cSq);
        
        // Precision loss in trig
        const angleA = Math.acos(a / c);
        const angleB = Math.acos(b / c);
        
        // JavaScript number issues
        const sum = angleA + angleB;
        const expected = Math.PI / 2;
        
        if (Math.abs(sum - expected) > this.tolerance) {
            throw new Error("Angles don't sum to 90°");
        }
        
        return {
            hypotenuse: c,
            angles: [angleA, angleB],
            // IEEE 754 double - never exact
            precise: false
        };
    }
    
    // Need extensive testing for edge cases
    snapToPythagorean(x, y) {
        const ratio = y !== 0 ? x / y : Infinity;
        // Iterative search... lots of code
    }
}

// 203 lines with templates and error handling
#include <cmath>
#include <stdexcept>
#include <vector>

template<typename T = double>
class TriangleSolver {
private:
    T tolerance_;
    int max_iter_;
    
public:
    TriangleSolver(T tol = 1e-10, int max = 1000)
        : tolerance_(tol), max_iter_(max) {}
    
    struct Result {
        T hypotenuse;
        T angles[2];
        bool precise;
    };
    
    Result solve_right_triangle(T a, T b) {
        // Template for float/double - both have issues
        T c_sq = a * a + b * b;
        T c = std::sqrt(c_sq);
        
        // Precision loss in repeated operations
        T angle_a = std::acos(a / c);
        T angle_b = std::acos(b / c);
        
        // Epsilon comparison needed
        T sum = angle_a + angle_b;
        T expected = M_PI / 2.0;
        
        if (std::abs(sum - expected) > tolerance_) {
            throw std::runtime_error("Invalid angles");
        }
        
        return {c, {angle_a, angle_b}, false};
    }
};