tensor/optim/devolution_test.go

// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
// SPDX-License-Identifier: MIT

package optim

import (
	"math"
	"testing"

	"sourcedock.dev/petrbalvin/tensor/internal/core"
)

// TestDESphere pins the global minimum of the sphere from a wide box.
func TestDESphere(t *testing.T) {
	lower, _ := core.FromFloats([]float64{-10, -10, -10}, 3)
	upper, _ := core.FromFloats([]float64{10, 10, 10}, 3)
	x, fv, err := MinimiseDifferentialEvolution(func(a *core.Array) (float64, error) {
		s := 0.0
		for i := range 3 {
			s += a.FloatAt(i) * a.FloatAt(i)
		}
		return s, nil
	}, lower, upper, DifferentialEvolutionOptions{Generations: 300})
	if err != nil {
		t.Fatalf("MinimiseDifferentialEvolution: %v", err)
	}
	if fv > 1e-10 {
		t.Fatalf("sphere minimum = %.3e, want 0", fv)
	}
	for i := range 3 {
		if math.Abs(x.FloatAt(i)) > 1e-5 {
			t.Fatalf("x[%d] = %g, want 0", i, x.FloatAt(i))
		}
	}
}

// TestDERosenbrockRastrigin pins two multimodal classics: Rosenbrock's
// valley and Rastrigin's minefield of local minima.
func TestDERosenbrockRastrigin(t *testing.T) {
	lower, _ := core.FromFloats([]float64{-2.5, -2.5}, 2)
	upper, _ := core.FromFloats([]float64{2.5, 2.5}, 2)
	_, fvR, err := MinimiseDifferentialEvolution(func(a *core.Array) (float64, error) {
		x, y := a.FloatAt(0), a.FloatAt(1)
		return (1-x)*(1-x) + 100*(y-x*x)*(y-x*x), nil
	}, lower, upper, DifferentialEvolutionOptions{Generations: 600})
	if err != nil {
		t.Fatalf("Rosenbrock: %v", err)
	}
	if fvR > 1e-6 {
		t.Fatalf("Rosenbrock minimum = %.3e, want 0", fvR)
	}

	lowerR, _ := core.FromFloats([]float64{-5.12, -5.12, -5.12}, 3)
	upperR, _ := core.FromFloats([]float64{5.12, 5.12, 5.12}, 3)
	x, fv, err := MinimiseDifferentialEvolution(func(a *core.Array) (float64, error) {
		s := 0.0
		for i := range 3 {
			z := a.FloatAt(i)
			s += z*z - 10*math.Cos(2*math.Pi*z) + 10
		}
		return s, nil
	}, lowerR, upperR, DifferentialEvolutionOptions{Generations: 800})
	if err != nil {
		t.Fatalf("Rastrigin: %v", err)
	}
	if fv > 1e-6 {
		t.Fatalf("Rastrigin minimum = %.3e, want 0 (global basin found at %v)", fv, x)
	}
}

// TestDEBoundClamping pins that the search stays inside the box.
func TestDEBoundClamping(t *testing.T) {
	lower, _ := core.FromFloats([]float64{-1, -1}, 2)
	upper, _ := core.FromFloats([]float64{1, 1}, 2)
	x, _, err := MinimiseDifferentialEvolution(func(a *core.Array) (float64, error) {
		// Push toward a corner outside the box.
		return -a.FloatAt(0) - 2*a.FloatAt(1), nil
	}, lower, upper, DifferentialEvolutionOptions{Generations: 200})
	if err != nil {
		t.Fatalf("MinimiseDifferentialEvolution: %v", err)
	}
	for i := range 2 {
		if x.FloatAt(i) < lower.FloatAt(i)-1e-12 || x.FloatAt(i) > upper.FloatAt(i)+1e-12 {
			t.Fatalf("x[%d] = %g left the box", i, x.FloatAt(i))
		}
	}
}

// mustBound builds one bound vector.
func mustBound(vs ...float64) *core.Array {
	a, _ := core.FromFloats(vs, len(vs))
	return a
}

// TestDEErrors pins the input gates.
func TestDEErrors(t *testing.T) {
	lower, _ := core.FromFloats([]float64{1, 1}, 2)
	upper, _ := core.FromFloats([]float64{0, 2}, 2)
	if _, _, err := MinimiseDifferentialEvolution(func(a *core.Array) (float64, error) { return 0, nil },
		lower, upper, DifferentialEvolutionOptions{}); err == nil {
		t.Error("degenerate bound accepted")
	}
	lo, _ := core.FromFloats([]float64{0, 0}, 2)
	hi, _ := core.FromFloats([]float64{1, 1, 1}, 3)
	if _, _, err := MinimiseDifferentialEvolution(func(a *core.Array) (float64, error) { return 0, nil },
		lo, hi, DifferentialEvolutionOptions{}); err == nil {
		t.Error("mismatched bounds accepted")
	}
	if _, _, err := MinimiseDifferentialEvolution(func(a *core.Array) (float64, error) {
		return math.NaN(), nil
	}, lo, mustBound(1, 1), DifferentialEvolutionOptions{}); err == nil {
		t.Error("NaN objective accepted")
	}
}