feat: initial release

Assisted-by: GLM 5.3 Flash

integrate/pde_scratch_pin_test.go

@@ -0,0 +1,64 @@
+// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
+// SPDX-License-Identifier: MIT
+
+package integrate
+
+import (
+	"math"
+	"testing"
+
+	"sourcedock.dev/petrbalvin/tensor/internal/core"
+	"sourcedock.dev/petrbalvin/tensor/internal/engine"
+)
+
+// The 2-D step sweeps index their per-line tridiagonal scratch by
+// chunk start divided by the spawn floor, which is only exercised when
+// the engine actually spawns: on a many-core runner the fixture grids
+// run inline and a scratch-indexing break passes silently. This pin
+// forces both regimes and compares every output bit.
+
+func pinHeat2D(workers int) ([]float64, error) {
+	prev := engine.SetNumWorkers(workers)
+	defer engine.SetNumWorkers(prev)
+	const rows, cols = 20, 20
+	u0 := make([]float64, rows*cols)
+	for r := range rows {
+		for c := range cols {
+			u0[r*cols+c] = math.Sin(float64(c+1)/float64(cols+1)*math.Pi) *
+				math.Sin(float64(r+1)/float64(rows+1)*math.Pi)
+		}
+	}
+	state, err := core.FromFloats(u0, rows, cols)
+	if err != nil {
+		return nil, err
+	}
+	out, err := IntegrateHeat2D(state, 1, 1.0/21, 1.0/21, 0.02, 0.002, 2, 0, 0, 0, 0)
+	if err != nil {
+		return nil, err
+	}
+	return append([]float64{}, out.RawFloats()...), nil
+}
+
+func TestHeat2DScratchIndexingPinnedAcrossWorkers(t *testing.T) {
+	serial, err := pinHeat2D(1)
+	if err != nil {
+		t.Fatalf("serial: %v", err)
+	}
+	// Two workers spawn on an 18-line sweep (chunk 9 at the floor of
+	// 8); four and thirty-two collapse back to inline runs.
+	for _, w := range []int{2, 4, 32} {
+		got, err := pinHeat2D(w)
+		if err != nil {
+			t.Fatalf("workers=%d: %v", w, err)
+		}
+		if len(got) != len(serial) {
+			t.Fatalf("workers=%d: length %d, want %d", w, len(got), len(serial))
+		}
+		for i := range serial {
+			if math.Float64bits(got[i]) != math.Float64bits(serial[i]) {
+				t.Fatalf("workers=%d element %d: %#x, want %#x",
+					w, i, math.Float64bits(got[i]), math.Float64bits(serial[i]))
+			}
+		}
+	}
+}