"""Chapter 4: constructed change, energy and projection investigations.

Run with Python 3.11+. Standard library only; no data or network access.
"""

from fractions import Fraction
from math import log, sqrt


def interval_report(times: list[float], values: list[float]) -> list[tuple[float, float, float]]:
    if len(times) != len(values) or len(times) < 2:
        raise ValueError("aligned time and value arrays need at least two points")
    if any(b <= a for a, b in zip(times, times[1:])):
        raise ValueError("times must strictly increase")
    if any(v <= 0 for v in values):
        raise ValueError("log changes require positive readings")
    return [((b-a)/(tb-ta), b/a, log(b/a)/(tb-ta))
            for ta, tb, a, b in zip(times, times[1:], values, values[1:])]


def energy(power_kw: list[float], duration_h: list[float]) -> tuple[float, float]:
    if not power_kw or len(power_kw) != len(duration_h):
        raise ValueError("power and duration arrays must align")
    if any(p < 0 for p in power_kw) or any(h < 0 for h in duration_h):
        raise ValueError("negative power/duration outside this case")
    hours = sum(duration_h)
    if not hours:
        raise ValueError("no operating duration")
    total = sum(p*h for p, h in zip(power_kw, duration_h))
    return total, total/hours


def project(x: tuple[float, float], v: tuple[float, float]) -> tuple[float, float]:
    denominator = sum(z*z for z in v)
    if not denominator:
        raise ValueError("cannot project onto a zero vector")
    scalar = sum(a*b for a, b in zip(x, v))/denominator
    return scalar*v[0], scalar*v[1]


def small_least_squares() -> tuple[Fraction, Fraction, list[Fraction], list[Fraction]]:
    """Exact intercept and slope for (0,1), (1,2), (2,2)."""
    xs = [Fraction(0), Fraction(1), Fraction(2)]
    ys = [Fraction(1), Fraction(2), Fraction(2)]
    xbar = sum(xs)/len(xs)
    ybar = sum(ys)/len(ys)
    numerator = sum((x-xbar)*(y-ybar) for x,y in zip(xs,ys))
    denominator = sum((x-xbar)**2 for x in xs)
    if not denominator:
        raise ValueError("input has no variation")
    slope = numerator/denominator
    intercept = ybar-slope*xbar
    fitted = [intercept+slope*x for x in xs]
    residuals = [y-p for y,p in zip(ys,fitted)]
    return intercept, slope, fitted, residuals


def main() -> None:
    changes = interval_report([0,2,4,6],[.10,.20,.40,.62])
    print("Constructed culture: interval, absolute rate per hour, ratio, log rate per hour")
    for i,(rate,ratio,log_rate) in enumerate(changes,1):
        print(f"  {i}: {rate:.3f}, {ratio:.2f}, {log_rate:.3f}")
    assert [round(x[1],2) for x in changes] == [2.0,2.0,1.55]
    total,mean = energy([2,5],[3,2])
    assert (total,mean)==(16,3.2)
    print(f"Aligned pump energy: {total:.1f} kWh; duration-weighted power: {mean:.1f} kW")
    print(f"Equal-time shortcut: {sum([2,5])/2*5:.1f} kWh (incorrect for these durations)")
    projection=project((3,4),(2,0))
    assert projection==(3,0) and project((3,4),(10,0))==(3,0)
    print(f"Projection onto east: {projection}")
    intercept,slope,fitted,residuals=small_least_squares()
    assert (intercept,slope)==(Fraction(7,6),Fraction(1,2))
    assert sum(residuals)==0 and sum(x*r for x,r in enumerate(residuals))==0
    assert sum(r*r for r in residuals)==Fraction(1,6)
    print(f"Least-squares intercept/slope: {intercept}, {slope}")
    print(f"Fitted values: {', '.join(map(str,fitted))}")
    print(f"Residuals: {', '.join(map(str,residuals))}; squared sum: {sum(r*r for r in residuals)}")
    pooled_speed=Fraction(7*60,22)
    assert 19 < float(pooled_speed) < 19.1
    print(f"Pooled journey speed: {float(pooled_speed):.2f} km/h")


if __name__ == "__main__":
    main()
