step one

internal/numerics/ode_test.go

@@ -0,0 +1,61 @@
+package numerics
+
+import (
+	"math"
+	"testing"
+)
+
+// scalarAdd / scalarLerp let us drive RK4 on a plain float64.
+func scalarAdd(y float64, k float64, dy float64) float64 { return y + k*dy }
+func scalarLerpF(a, b float64, l float64) float64         { return Lerp(a, b, l) }
+
+func TestRK4ExponentialDecay(t *testing.T) {
+	// dy/dt = -y → exact: y(t) = y0 * exp(-t).
+	deriv := func(_ float64, y float64) float64 { return -y }
+
+	y := 1.0
+	tnow := 0.0
+	dt := 0.01
+	for range 100 {
+		y = RK4Step(tnow, y, dt, deriv, scalarAdd)
+		tnow += dt
+	}
+	want := math.Exp(-1.0)
+	if math.Abs(y-want) > 1e-8 {
+		t.Errorf("RK4 exp decay at t=1: got %v, want %v (diff %v)", y, want, y-want)
+	}
+}
+
+func TestRK4ReverseTime(t *testing.T) {
+	// dy/dt = y → exact: y(t) = y0 * exp(t).
+	// Integrating from t=1 backwards with dt=-0.01 over 100 steps should give y0.
+	deriv := func(_ float64, y float64) float64 { return y }
+
+	y := math.E
+	tnow := 1.0
+	dt := -0.01
+	for range 100 {
+		y = RK4Step(tnow, y, dt, deriv, scalarAdd)
+		tnow += dt
+	}
+	if math.Abs(y-1.0) > 1e-8 {
+		t.Errorf("RK4 reverse: got %v, want 1.0 (diff %v)", y, y-1.0)
+	}
+}
+
+func TestRefineTrigger(t *testing.T) {
+	// y crosses 0 at l=0.4 between y1=1 and y2=-1.5.
+	y1, y2 := 1.0, -1.5
+	t1, t2 := 0.0, 1.0
+	trig := func(_ float64, y float64) bool { return y <= 0 }
+
+	tr, yr := RefineTrigger(t1, y1, t2, y2, trig, scalarLerpF, 0.001)
+
+	// The exact crossing is at l = 1/(1+1.5) = 0.4 → t = 0.4, y = 0.
+	if math.Abs(tr-0.4) > 0.01 {
+		t.Errorf("Refined t = %v, want ~0.4", tr)
+	}
+	if math.Abs(yr) > 0.01 {
+		t.Errorf("Refined y = %v, want ~0", yr)
+	}
+}