evograd-diff 0.1.0__tar.gz → 0.1.1__tar.gz

{evograd_diff-0.1.0 → evograd_diff-0.1.1}/.claude/settings.local.json

@@ -6,7 +6,11 @@
       "Bash(git push *)",
       "Bash(uv build *)",
       "Bash(python -m zipfile -l dist/evograd-0.1.0-py3-none-any.whl)",
-      "WebFetch(domain:pypi.org)"
+      "WebFetch(domain:pypi.org)",
+      "Bash(uv run *)",
+      "Bash(git check-ignore *)",
+      "Bash(uv lock *)",
+      "Bash(git stash *)"
     ]
   }
 }

evograd_diff-0.1.1/.gitignore

@@ -0,0 +1,15 @@
+# Build artifacts
+dist/
+build/
+*.egg-info/
+
+# Python caches
+__pycache__/
+*.py[cod]
+
+# Virtual environments
+.venv/
+venv/
+
+# macOS
+.DS_Store

{evograd_diff-0.1.0 → evograd_diff-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evograd-diff
-Version: 0.1.0
+Version: 0.1.1
 Summary: PyTorch-based framework for differentiable evolutionary computation and swarm intelligence
 Project-URL: Homepage, https://github.com/andreatangherloni/EvoGrad
 Project-URL: Repository, https://github.com/andreatangherloni/EvoGrad
@@ -47,14 +47,21 @@ Description-Content-Type: text/markdown
 ## 📦 Installation
 
 ```bash
-# Clone the repository
-git clone https://github.com/YOUR_USERNAME/evograd.git
-cd evograd
+# From PyPI (the import name is `evograd`)
+pip install evograd-diff
+```
+
+Or install directly from the repository:
+
+```bash
+pip install "git+https://github.com/andreatangherloni/EvoGrad.git"
+```
 
-# Install dependencies
-pip install torch numpy
+For local development:
 
-# Install in development mode
+```bash
+git clone https://github.com/andreatangherloni/EvoGrad.git
+cd EvoGrad
 pip install -e .
 ```
 
@@ -62,7 +69,7 @@ pip install -e .
 
 ```python
 import torch
-from evograd.core import Problem, minimize
+from evograd.core import Problem, minimize, MaxEvaluations
 from evograd.algorithms import GA, DE, PSO, CMAES
 
 # Define an optimisation problem
@@ -75,22 +82,22 @@ problem = Problem(
 
 # Run with Genetic Algorithm
 ga = GA(pop_size=100, differentiable=True)
-result = minimize(problem, ga, max_evals=10000, seed=42)
+result = minimize(problem, ga, termination=MaxEvaluations(10000), seed=42)
 print(f"GA Best: {result.best_fitness:.6f}")
 
 # Run with Differential Evolution
 de = DE(pop_size=100, variant="DE/rand/1/bin", adaptive=True)
-result = minimize(problem, de, max_evals=10000, seed=42)
+result = minimize(problem, de, termination=MaxEvaluations(10000), seed=42)
 print(f"DE Best: {result.best_fitness:.6f}")
 
 # Run with Particle Swarm Optimisation
 pso = PSO(pop_size=100, adaptive=True, differentiable=True)
-result = minimize(problem, pso, max_evals=10000, seed=42)
+result = minimize(problem, pso, termination=MaxEvaluations(10000), seed=42)
 print(f"PSO Best: {result.best_fitness:.6f}")
 
 # Run with CMA-ES
 cmaes = CMAES(sigma=0.5, adaptive=True)
-result = minimize(problem, cmaes, max_evals=10000, seed=42)
+result = minimize(problem, cmaes, termination=MaxEvaluations(10000), seed=42)
 print(f"CMA-ES Best: {result.best_fitness:.6f}")
 ```
 

{evograd_diff-0.1.0 → evograd_diff-0.1.1}/README.md

@@ -20,14 +20,21 @@
 ## 📦 Installation
 
 ```bash
-# Clone the repository
-git clone https://github.com/YOUR_USERNAME/evograd.git
-cd evograd
+# From PyPI (the import name is `evograd`)
+pip install evograd-diff
+```
+
+Or install directly from the repository:
+
+```bash
+pip install "git+https://github.com/andreatangherloni/EvoGrad.git"
+```
 
-# Install dependencies
-pip install torch numpy
+For local development:
 
-# Install in development mode
+```bash
+git clone https://github.com/andreatangherloni/EvoGrad.git
+cd EvoGrad
 pip install -e .
 ```
 
@@ -35,7 +42,7 @@ pip install -e .
 
 ```python
 import torch
-from evograd.core import Problem, minimize
+from evograd.core import Problem, minimize, MaxEvaluations
 from evograd.algorithms import GA, DE, PSO, CMAES
 
 # Define an optimisation problem
@@ -48,22 +55,22 @@ problem = Problem(
 
 # Run with Genetic Algorithm
 ga = GA(pop_size=100, differentiable=True)
-result = minimize(problem, ga, max_evals=10000, seed=42)
+result = minimize(problem, ga, termination=MaxEvaluations(10000), seed=42)
 print(f"GA Best: {result.best_fitness:.6f}")
 
 # Run with Differential Evolution
 de = DE(pop_size=100, variant="DE/rand/1/bin", adaptive=True)
-result = minimize(problem, de, max_evals=10000, seed=42)
+result = minimize(problem, de, termination=MaxEvaluations(10000), seed=42)
 print(f"DE Best: {result.best_fitness:.6f}")
 
 # Run with Particle Swarm Optimisation
 pso = PSO(pop_size=100, adaptive=True, differentiable=True)
-result = minimize(problem, pso, max_evals=10000, seed=42)
+result = minimize(problem, pso, termination=MaxEvaluations(10000), seed=42)
 print(f"PSO Best: {result.best_fitness:.6f}")
 
 # Run with CMA-ES
 cmaes = CMAES(sigma=0.5, adaptive=True)
-result = minimize(problem, cmaes, max_evals=10000, seed=42)
+result = minimize(problem, cmaes, termination=MaxEvaluations(10000), seed=42)
 print(f"CMA-ES Best: {result.best_fitness:.6f}")
 ```
 

{evograd_diff-0.1.0 → evograd_diff-0.1.1}/evograd/algorithms/cmaes.py

@@ -281,15 +281,18 @@ class CMAES(Algorithm):
     # Setup
     # =========================================================================
     
-    def _setup(self) -> None:
-        """CMA-ES specific setup after initialization."""
-        n_var = self.problem.n_var
-        
+    def _setup_pop_size(self) -> None:
+        """Compute the default CMA-ES population size (lambda) before sampling."""
         # Compute default population size if not provided
         if self._requested_pop_size is None:
+            n_var = self.problem.n_var
             self.pop_size = 4 + int(3 * math.log(n_var))
             self.n_offsprings = self.pop_size
-        
+
+    def _setup(self) -> None:
+        """CMA-ES specific setup after initialization."""
+        n_var = self.problem.n_var
+
         # Initialize restart state
         self.restart_state.initial_pop_size = self.pop_size
         self.restart_state.current_pop_size = self.pop_size

{evograd_diff-0.1.0 → evograd_diff-0.1.1}/evograd/core/algorithm.py

@@ -322,10 +322,21 @@ class Algorithm(nn.Module, ABC):
     # Optional Hooks (can be overridden)
     # =========================================================================
     
+    def _setup_pop_size(self) -> None:
+        """
+        Resolve the population size before the initial population is sampled.
+
+        Override for algorithms that derive pop_size from the problem
+        (e.g. CMA-ES default lambda = 4 + floor(3*ln(n))). Called near the
+        start of initialize(), after the problem is attached but before
+        sampling, so the population is allocated at the final size.
+        """
+        pass
+
     def _setup(self) -> None:
         """
         One-time setup after initialisation.
-        
+
         Override to perform algorithm-specific setup that requires
         the problem and population to be initialized.
         Called at the end of initialize().
@@ -370,14 +381,17 @@ class Algorithm(nn.Module, ABC):
         
         # Move problem bounds to device
         self.register_buffer(
-            "xl", 
+            "xl",
             problem.xl.to(device=self.device, dtype=self.dtype)
         )
         self.register_buffer(
             "xu",
             problem.xu.to(device=self.device, dtype=self.dtype)
         )
-        
+
+        # Resolve final population size (e.g. CMA-ES auto lambda) before sampling
+        self._setup_pop_size()
+
         # Create initial population using sampling operator
         population = self.sampling(self.pop_size, problem)
         
@@ -686,13 +700,15 @@ class Algorithm(nn.Module, ABC):
         mode = "differentiable" if self.differentiable else "classical"
         status = "initialized" if self._is_initialized else "not initialized"
         n_var = self.n_var if self.problem else "?"
+        # device is only assigned in initialize(); fall back before then.
+        device = getattr(self, "device", "?")
         return (
             f"{self.__class__.__name__}("
             f"pop_size={self.pop_size}, "
             f"n_var={n_var}, "
             f"mode={mode}, "
             f"status={status}, "
-            f"device={self.device})"
+            f"device={device})"
         )
     
     def summary(self) -> str:

{evograd_diff-0.1.0 → evograd_diff-0.1.1}/evograd/tests/run_all.py

@@ -16,6 +16,9 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from tests.test_utils import run_all_tests as test_utils
 from tests.test_core import run_all_tests as test_core
 from tests.test_operators import run_all_tests as test_operators
+from tests.test_cmaes import run_all_tests as test_cmaes
+from tests.test_ga import run_all_tests as test_ga
+from tests.test_per_individual import main as test_per_individual
 
 
 def run_all():
@@ -45,7 +48,25 @@ def run_all():
     print("▶ RUNNING OPERATORS TESTS")
     print("▶"*60)
     results['operators'] = test_operators()
-    
+
+    # Run CMA-ES tests
+    print("\n\n" + "▶"*60)
+    print("▶ RUNNING CMA-ES TESTS")
+    print("▶"*60)
+    results['cmaes'] = test_cmaes()
+
+    # Run GA tests
+    print("\n\n" + "▶"*60)
+    print("▶ RUNNING GA TESTS")
+    print("▶"*60)
+    results['ga'] = test_ga()
+
+    # Run per-individual parameter tests
+    print("\n\n" + "▶"*60)
+    print("▶ RUNNING PER-INDIVIDUAL TESTS")
+    print("▶"*60)
+    results['per_individual'] = test_per_individual()
+
     # Summary
     print("\n\n" + "█"*60)
     print("█" + " "*58 + "█")

evograd_diff-0.1.1/evograd/tests/test_cmaes.py

@@ -0,0 +1,143 @@
+"""
+Test script for EvoGrad CMA-ES implementation.
+
+Tests:
+    - Default (auto) population size: lambda = 4 + floor(3*ln(n))
+    - Explicit population size
+    - Population tensor is allocated at the resolved pop_size
+    - End-to-end minimize() runs and converges
+
+Regression:
+    With no pop_size, CMA-ES used to allocate the population at a
+    placeholder size (10) and only recompute lambda afterwards, causing
+    a tensor-size mismatch on the first update for any n_var where
+    4 + floor(3*ln(n)) != 10. See _setup_pop_size().
+
+Usage:
+    cd evograd && python tests/test_cmaes.py
+"""
+
+import sys
+import os
+import math
+import torch
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from evograd.core.problem import Problem
+from evograd.core.minimize import minimize
+from evograd.core.termination import MaxEvaluations
+from evograd.algorithms.cmaes import CMAES
+
+
+def sphere(x):
+    """Sphere function: sum of squares. Global optimum at origin."""
+    return (x ** 2).sum(dim=-1)
+
+
+def _expected_lambda(n_var):
+    """CMA-ES default population size (lambda)."""
+    return 4 + int(3 * math.log(n_var))
+
+
+def make_problem(n_var):
+    return Problem(objective=sphere, n_var=n_var, xl=-5.0, xu=5.0)
+
+
+# =============================================================================
+# Tests
+# =============================================================================
+
+def test_auto_pop_size():
+    """Default pop_size must resolve to lambda and size the population."""
+    print("\n1. Testing auto pop_size (no pop_size given)...")
+
+    # Cover sizes where the auto value differs from the old placeholder (10).
+    for n_var in (2, 30, 50):
+        expected = _expected_lambda(n_var)
+
+        cmaes = CMAES(sigma=0.5)
+        cmaes.initialize(make_problem(n_var))
+
+        assert cmaes.pop_size == expected, (
+            f"n_var={n_var}: pop_size {cmaes.pop_size} != expected {expected}"
+        )
+        assert cmaes.n_offsprings == expected, (
+            f"n_var={n_var}: n_offsprings {cmaes.n_offsprings} != {expected}"
+        )
+        assert tuple(cmaes.population.shape) == (expected, n_var), (
+            f"n_var={n_var}: population shape {tuple(cmaes.population.shape)} "
+            f"!= {(expected, n_var)}"
+        )
+        print(f"   n_var={n_var:>3}: pop_size={cmaes.pop_size} "
+              f"population={tuple(cmaes.population.shape)} ✓")
+
+
+def test_explicit_pop_size():
+    """Explicit pop_size must be honoured exactly."""
+    print("\n2. Testing explicit pop_size...")
+
+    cmaes = CMAES(pop_size=50, sigma=0.5)
+    cmaes.initialize(make_problem(30))
+
+    assert cmaes.pop_size == 50, f"pop_size {cmaes.pop_size} != 50"
+    assert tuple(cmaes.population.shape) == (50, 30)
+    print(f"   pop_size={cmaes.pop_size} "
+          f"population={tuple(cmaes.population.shape)} ✓")
+
+
+def test_step_no_crash():
+    """The first update must not raise a size mismatch (the regression)."""
+    print("\n3. Testing step() with auto pop_size (regression)...")
+
+    cmaes = CMAES(sigma=0.5)
+    cmaes.initialize(make_problem(30))
+    for _ in range(3):
+        cmaes.step()
+    print(f"   3 steps ran; generation={cmaes.generation}, "
+          f"pop_size={cmaes.pop_size} ✓")
+
+
+def test_convergence():
+    """End-to-end minimize() should converge on the sphere function."""
+    print("\n4. Testing convergence via minimize()...")
+
+    problem = make_problem(10)
+    cmaes = CMAES(sigma=0.5)  # auto pop_size
+    result = minimize(
+        problem, cmaes, termination=MaxEvaluations(5000),
+        seed=42, verbose=False,
+    )
+    assert result.best_fitness < 1.0, (
+        f"did not converge: best_fitness={result.best_fitness}"
+    )
+    print(f"   best_fitness={result.best_fitness:.6f} (< 1.0) ✓")
+
+
+def run_all_tests():
+    """Run all CMA-ES tests."""
+    print("\n" + "#"*60)
+    print("# EvoGrad CMA-ES Tests")
+    print("#"*60)
+
+    try:
+        test_auto_pop_size()
+        test_explicit_pop_size()
+        test_step_no_crash()
+        test_convergence()
+
+        print("\n" + "="*60)
+        print("✓ ALL CMA-ES TESTS PASSED!")
+        print("="*60)
+        return True
+    except Exception as e:
+        print(f"\n✗ TEST FAILED: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    success = run_all_tests()
+    sys.exit(0 if success else 1)

{evograd_diff-0.1.0 → evograd_diff-0.1.1}/evograd/tests/test_ga.py

@@ -85,10 +85,10 @@ def test_ga_creation():
     print("\n2. Testing GA with custom operators...")
     ga = GA(
         pop_size=30,
-        selection=RouletteSelection(differentiable=True),
-        crossover=BlendCrossover(alpha=0.5, differentiable=True),
-        mutation=GaussianMutation(sigma=0.1, differentiable=True),
-        survival=MergeSurvival(elitism=True, n_elite=2, differentiable=True),
+        selection=RouletteSelection(adaptive=True),
+        crossover=BlendCrossover(alpha=0.5, adaptive=True),
+        mutation=GaussianMutation(sigma=0.1, adaptive=True),
+        survival=MergeSurvival(elitism=True, n_elite=2, adaptive=True),
     )
     print(f"   Created: {ga}")
     print(f"   Survival: {ga.survival}")
@@ -165,10 +165,10 @@ def test_ga_step():
     ga = GA(
         pop_size=30,
         sampling=UniformSampling(seed=42),
-        selection=TournamentSelection(tournament_size=3, differentiable=True),
-        crossover=SBXCrossover(eta=15, prob=0.9, differentiable=True),
-        mutation=PolynomialMutation(eta=20, differentiable=True),
-        survival=MergeSurvival(n_survive=30, elitism=True, n_elite=1, differentiable=True),
+        selection=TournamentSelection(tournament_size=3, adaptive=True),
+        crossover=SBXCrossover(eta=15, prob=0.9, adaptive=True),
+        mutation=PolynomialMutation(eta=20, adaptive=True),
+        survival=MergeSurvival(n_survive=30, elitism=True, n_elite=1, adaptive=True),
         differentiable=True,
     )
     ga.initialize(problem)
@@ -212,9 +212,7 @@ def test_survival_strategies():
     print("\n1. Testing MergeSurvival (mu+lambda)...")
     ga_plus = GA(
         pop_size=20,
-        survival=MergeSurvival(n_survive=20, elitism=True, n_elite=1),
-        seed=42,
-    )
+        survival=MergeSurvival(n_survive=20, elitism=True, n_elite=1),    )
     ga_plus.initialize(problem)
     for _ in range(5):
         ga_plus.step()
@@ -225,9 +223,7 @@ def test_survival_strategies():
     ga_comma_inst = GA(
         pop_size=20,
         n_offsprings=40,  # Must be >= pop_size
-        survival=CommaSurvival(n_survive=20, elitism=True, n_elite=1),
-        seed=42,
-    )
+        survival=CommaSurvival(n_survive=20, elitism=True, n_elite=1),    )
     ga_comma_inst.initialize(problem)
     for _ in range(5):
         ga_comma_inst.step()
@@ -238,9 +234,7 @@ def test_survival_strategies():
     ga_replace = GA(
         pop_size=20,
         n_offsprings=5,
-        survival=ReplaceWorstSurvival(n_survive=20, elitism=True, n_elite=1),
-        seed=42,
-    )
+        survival=ReplaceWorstSurvival(n_survive=20, elitism=True, n_elite=1),    )
     ga_replace.initialize(problem)
     for _ in range(20):  # More generations since fewer offspring per gen
         ga_replace.step()
@@ -250,9 +244,7 @@ def test_survival_strategies():
     print("\n4. Testing FitnessSurvival (pure truncation)...")
     ga_fitness = GA(
         pop_size=20,
-        survival=FitnessSurvival(n_survive=20),
-        seed=42,
-    )
+        survival=FitnessSurvival(n_survive=20),    )
     ga_fitness.initialize(problem)
     for _ in range(5):
         ga_fitness.step()
@@ -278,9 +270,7 @@ def test_elitism():
     print("\n1. Testing GA with elitism...")
     ga_elite = GA(
         pop_size=20,
-        survival=MergeSurvival(n_survive=20, elitism=True, n_elite=1),
-        seed=42,
-    )
+        survival=MergeSurvival(n_survive=20, elitism=True, n_elite=1),    )
     ga_elite.initialize(problem)
     
     best_values = [ga_elite.best_fitness]
@@ -299,7 +289,6 @@ def test_elitism():
     ga_no_elite = GA(
         pop_size=20,
         survival=FitnessSurvival(n_survive=20),  # No elitism
-        seed=42,
     )
     ga_no_elite.initialize(problem)
     
@@ -325,9 +314,7 @@ def test_differentiable_mode():
     
     ga = GA(
         pop_size=20,
-        differentiable=True,
-        seed=42,
-    )
+        differentiable=True,    )
     ga.initialize(problem)
     
     # Create optimizer for learnable parameters
@@ -386,9 +373,7 @@ def test_state_persistence():
         sampling=UniformSampling(seed=42),
         selection=TournamentSelection(tournament_size=3),
         crossover=SBXCrossover(eta=15, prob=0.9),
-        mutation=PolynomialMutation(eta=20),
-        seed=42,
-    )
+        mutation=PolynomialMutation(eta=20),    )
     ga1.initialize(problem)
     
     for _ in range(10):
@@ -408,9 +393,7 @@ def test_state_persistence():
         sampling=UniformSampling(seed=42),
         selection=TournamentSelection(tournament_size=3),
         crossover=SBXCrossover(eta=15, prob=0.9),
-        mutation=PolynomialMutation(eta=20),
-        seed=0,  # Different seed
-    )
+        mutation=PolynomialMutation(eta=20),    )
     ga2.initialize(problem)
     
     print(f"\n2. New GA before load:")
@@ -475,9 +458,7 @@ def test_convergence():
         selection=TournamentSelection(tournament_size=3),
         crossover=SBXCrossover(eta=15, prob=0.9),
         mutation=PolynomialMutation(eta=20),
-        survival=MergeSurvival(n_survive=50, elitism=True, n_elite=1),
-        seed=42,
-    )
+        survival=MergeSurvival(n_survive=50, elitism=True, n_elite=1),    )
     ga.initialize(problem)
     
     print(f"\n1. Running GA for 100 generations...")
@@ -513,10 +494,10 @@ def test_hyperparams():
     
     ga = GA(
         pop_size=20,
-        selection=TournamentSelection(tournament_size=3, differentiable=True),
-        crossover=SBXCrossover(eta=15, prob=0.9, differentiable=True),
-        mutation=PolynomialMutation(eta=20, differentiable=True),
-        survival=MergeSurvival(n_survive=20, elitism=True, n_elite=2, differentiable=True),
+        selection=TournamentSelection(tournament_size=3, adaptive=True),
+        crossover=SBXCrossover(eta=15, prob=0.9, adaptive=True),
+        mutation=PolynomialMutation(eta=20, adaptive=True),
+        survival=MergeSurvival(n_survive=20, elitism=True, n_elite=2, adaptive=True),
     )
     ga.initialize(problem)
     ga.step()

{evograd_diff-0.1.0 → evograd_diff-0.1.1}/evograd/tests/test_operators.py

@@ -170,7 +170,7 @@ def test_selection():
     print("\n2. Testing TournamentSelection (differentiable)...")
     tournament_diff = TournamentSelection(
         tournament_size=3,
-        differentiable=True,
+        adaptive=True,
         temperature=1.0,
         learn_temperature=True,
     )
@@ -247,7 +247,7 @@ def test_crossover():
     sbx_diff = SBXCrossover(
         eta=15,
         prob=0.9,
-        differentiable=True,
+        adaptive=True,
         learn_eta=True,
         learn_prob=True,
     )
@@ -274,7 +274,7 @@ def test_crossover():
     print(f"   Offspring shape: {offspring_bin.shape}")
     
     # Test differentiable binomial
-    binomial_diff = BinomialCrossover(cr=0.9, differentiable=True, learn_cr=True)
+    binomial_diff = BinomialCrossover(cr=0.9, adaptive=True, learn_cr=True)
     p1 = torch.nn.Parameter(parent1.clone())
     offspring_bin_diff = binomial_diff(p1, parent2)
     loss = offspring_bin_diff.sum()
@@ -343,7 +343,7 @@ def test_mutation():
     poly_diff = PolynomialMutation(
         eta=20,
         prob=0.1,
-        differentiable=True,
+        adaptive=True,
         learn_eta=True,
         learn_prob=True,
     )
@@ -367,7 +367,7 @@ def test_mutation():
     print(f"   With sigma_frac: ✓")
     
     # Test differentiable Gaussian
-    gauss_diff = GaussianMutation(sigma=0.1, differentiable=True, learn_sigma=True)
+    gauss_diff = GaussianMutation(sigma=0.1, adaptive=True, learn_sigma=True)
     pop_param = torch.nn.Parameter(population.clone())
     mutated_gauss_diff = gauss_diff(pop_param, xl, xu)
     loss = mutated_gauss_diff.sum()
@@ -592,18 +592,18 @@ def test_operator_integration():
     # Create differentiable operators
     selection_diff = TournamentSelection(
         tournament_size=3,
-        differentiable=True,
+        adaptive=True,
         temperature=1.0,
     )
     crossover_diff = SBXCrossover(
         eta=15,
         prob=0.9,
-        differentiable=True,
+        adaptive=True,
         learn_eta=True,
     )
     mutation_diff = GaussianMutation(
         sigma=0.1,
-        differentiable=True,
+        adaptive=True,
         learn_sigma=True,
     )
     

{evograd_diff-0.1.0 → evograd_diff-0.1.1}/evograd/tests/test_per_individual.py

@@ -266,7 +266,7 @@ def test_differentiable_mode():
     
     # Differentiable operators
     print("\n1. SBXCrossover with gradient flow:")
-    sbx = SBXCrossover(eta=15, prob=0.9, differentiable=True, learn_eta=True)
+    sbx = SBXCrossover(eta=15, prob=0.9, adaptive=True, learn_eta=True)
     
     p1 = torch.nn.Parameter(torch.randn(N, D))
     p2 = torch.randn(N, D)
@@ -282,7 +282,7 @@ def test_differentiable_mode():
     
     # PolynomialMutation with gradient flow
     print("\n2. PolynomialMutation with gradient flow:")
-    mutation = PolynomialMutation(eta=20, prob=0.1, differentiable=True, learn_eta=True)
+    mutation = PolynomialMutation(eta=20, prob=0.1, adaptive=True, learn_eta=True)
     
     x = torch.nn.Parameter(torch.randn(N, D))
     xl = torch.zeros(D)
@@ -305,22 +305,30 @@ def main():
     print("\n" + "#" * 70)
     print("# Per-Individual/Per-Gene Parameter Support Tests")
     print("#" * 70)
-    
-    test_crossover_configurations()
-    test_mutation_configurations()
-    test_shade_style_usage()
-    test_differentiable_mode()
-    
-    print("\n" + "=" * 70)
-    print("ALL TESTS PASSED! ✓")
-    print("=" * 70)
-    
-    print("\nSummary of Four Configurations:")
-    print("  1. Fixed (scalar)     - Same value for all")
-    print("  2. Per-gene [D]       - Different per variable")
-    print("  3. Per-individual [N] - Different per individual (SHADE needs this!)")
-    print("  4. Full matrix [N, D] - Maximum flexibility")
+
+    try:
+        test_crossover_configurations()
+        test_mutation_configurations()
+        test_shade_style_usage()
+        test_differentiable_mode()
+
+        print("\n" + "=" * 70)
+        print("ALL TESTS PASSED! ✓")
+        print("=" * 70)
+
+        print("\nSummary of Four Configurations:")
+        print("  1. Fixed (scalar)     - Same value for all")
+        print("  2. Per-gene [D]       - Different per variable")
+        print("  3. Per-individual [N] - Different per individual (SHADE needs this!)")
+        print("  4. Full matrix [N, D] - Maximum flexibility")
+        return True
+    except Exception as e:
+        print(f"\n✗ TEST FAILED: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
 
 
 if __name__ == "__main__":
-    main()
+    success = main()
+    sys.exit(0 if success else 1)

{evograd_diff-0.1.0 → evograd_diff-0.1.1}/evograd/tests/test_utils.py

@@ -183,8 +183,10 @@ def test_callbacks():
     
     print(f"   Tracked generations: {len(history_cb.generations)}")
     print(f"   Best fitness history: {history_cb.best_fitness[:3]}...")
-    assert len(history_cb.generations) == 5
-    assert len(history_cb.best_fitness) == 5
+    # on_optimisation_start records the initial state, then each of the 5
+    # on_generation_end calls records one more -> 1 + 5 = 6 entries.
+    assert len(history_cb.generations) == 6
+    assert len(history_cb.best_fitness) == 6
     
     # Test PrintCallback
     print("\n2. Testing PrintCallback...")

{evograd_diff-0.1.0 → evograd_diff-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "evograd-diff"
-version = "0.1.0"
+version = "0.1.1"
 description = "PyTorch-based framework for differentiable evolutionary computation and swarm intelligence"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{evograd_diff-0.1.0 → evograd_diff-0.1.1}/uv.lock

@@ -155,8 +155,8 @@ wheels = [
 ]
 
 [[package]]
-name = "evograd"
-version = "0.1.0"
+name = "evograd-diff"
+version = "0.1.1"
 source = { editable = "." }
 dependencies = [
     { name = "matplotlib" },