feat: initial release

Assisted-by: GLM 5.3 Flash

integrate/filon_bounds_regression_test.go

@@ -0,0 +1,68 @@
+// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
+// SPDX-License-Identifier: MIT
+
+package integrate
+
+import (
+	"math"
+	"testing"
+)
+
+// TestIntegrateFilonRejectsInfiniteBounds pins the refusal: an infinite
+// bound used to fall into an unrepresentable panel count (the conversion
+// of the ceiling of infinity) and come back as a quiet NaN pair with a
+// nil error, and with k = 0 it sampled the amplitude at infinity. The
+// error contract refuses NaN bounds and an infinite frequency; an
+// infinite bound is the same breach and answers the same way.
+func TestIntegrateFilonRejectsInfiniteBounds(t *testing.T) {
+	f := func(x float64) (float64, error) { return math.Exp(-x), nil }
+	cases := []struct {
+		label   string
+		a, b, k float64
+	}{
+		{"upper tail", 0, math.Inf(1), 1},
+		{"lower tail", math.Inf(-1), 0, 1},
+		{"whole line", math.Inf(-1), math.Inf(1), 1},
+		{"zero frequency upper tail", 0, math.Inf(1), 0},
+		{"span product overflow", 0, 1e100, 1e300},
+	}
+	for _, c := range cases {
+		cos, sin, err := IntegrateFilon(f, c.a, c.b, c.k, FilonOptions{})
+		if err == nil {
+			t.Fatalf("%s: [%g, %g] at k=%g integrated to (%g, %g) with no error, want a refusal",
+				c.label, c.a, c.b, c.k, cos, sin)
+		}
+	}
+}
+
+// TestIntegrateFilonRejectsUnrepresentablePanels pins the two refusals
+// the infinite-bound guard alone does not reach. A panel estimate that
+// stays finite but sits beyond the int range converted to garbage: a
+// wrapped negative count iterated zero times and answered a quiet zero,
+// and a saturated count would iterate forever. And two finite bounds
+// far enough apart that their span overflows leave an infinite panel
+// width, where a constant amplitude stays finite and the carrier phase
+// 0·Inf comes back as a quiet NaN pair. Both answer with the error
+// contract instead.
+func TestIntegrateFilonRejectsUnrepresentablePanels(t *testing.T) {
+	constant := func(float64) (float64, error) { return 1, nil }
+	cases := []struct {
+		label   string
+		a, b, k float64
+		opts    FilonOptions
+		f       func(x float64) (float64, error)
+	}{
+		{"finite estimate beyond the int range", 0, 1e8, 1e300, FilonOptions{}, constant},
+		{"finite estimate just above the int range", 0, 1e18, 6e2, FilonOptions{}, constant},
+		{"overflowing span at zero frequency", -math.MaxFloat64, math.MaxFloat64, 0, FilonOptions{}, constant},
+		{"overflowing span with forced panels", -math.MaxFloat64, math.MaxFloat64, 0, FilonOptions{Panels: 2}, constant},
+		{"overflowing span with a frequency", -math.MaxFloat64, math.MaxFloat64, 1, FilonOptions{}, constant},
+	}
+	for _, c := range cases {
+		cos, sin, err := IntegrateFilon(c.f, c.a, c.b, c.k, c.opts)
+		if err == nil {
+			t.Fatalf("%s: [%g, %g] at k=%g integrated to (%g, %g) with no error, want a refusal",
+				c.label, c.a, c.b, c.k, cos, sin)
+		}
+	}
+}