evograd-diff 0.2.0__tar.gz → 0.2.1__tar.gz

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evograd-diff
-Version: 0.2.0
+Version: 0.2.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

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/evograd/__init__.py

@@ -57,7 +57,7 @@ Authors
 Andrea Tangherloni <andrea.tangherloni@unibocconi.it>
 """
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 __author__ = "Andrea Tangherloni"
 
 __all__ = [

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/evograd/algorithms/cmaes.py

@@ -83,6 +83,7 @@ import torch.nn as nn
 from torch import Tensor
 
 from evograd.core.algorithm import Algorithm
+from evograd.operators.relaxations import standard_normal, log_param
 
 if TYPE_CHECKING:
     from evograd.core.problem import Problem
@@ -386,9 +387,7 @@ class CMAES(Algorithm):
                 with torch.no_grad():
                     self._log_sigma.fill_(math.log(sigma_val))
             else:
-                self._log_sigma = nn.Parameter(
-                    torch.tensor(sigma_val, device=self.device, dtype=self.dtype).log()
-                )
+                self._log_sigma = log_param(sigma_val, device=self.device, dtype=self.dtype)
         else:
             if hasattr(self, '_sigma_buffer'):
                 self._sigma_buffer.fill_(sigma_val)
@@ -467,9 +466,7 @@ class CMAES(Algorithm):
                     self._to_logit(cmu).to(device=self.device, dtype=self.dtype)
                 )
                 # damps is positive, store as log
-                self._log_damps = nn.Parameter(
-                    torch.tensor(damps, device=self.device, dtype=self.dtype).log()
-                )
+                self._log_damps = log_param(damps, device=self.device, dtype=self.dtype)
         else:
             if not hasattr(self, '_cc'):
                 self.register_buffer("_cc", torch.tensor(cc, device=self.device, dtype=self.dtype))
@@ -587,7 +584,7 @@ class CMAES(Algorithm):
         N, D = self.pop_size, self.n_var
         
         # Sample standard normal
-        z = torch.randn(N, D, device=self.device, dtype=self.dtype)
+        z = standard_normal(N, D, device=self.device, dtype=self.dtype)
         
         # Transform: y = L @ z
         L = self.L

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/evograd/algorithms/de.py

@@ -63,6 +63,8 @@ import torch.nn as nn
 from torch import Tensor
 
 from evograd.core.algorithm import Algorithm
+from evograd.operators.repair import clamp_to_bounds
+from evograd.operators.relaxations import log_param
 
 if TYPE_CHECKING:
     from evograd.core.problem import Problem
@@ -308,9 +310,7 @@ class DE(Algorithm):
         # Setup F parameter
         if self.adaptive:
             # Learnable F stored as log(F) for positivity
-            self._log_F = nn.Parameter(
-                torch.tensor(self._init_F, device=self.device, dtype=self.dtype).log()
-            )
+            self._log_F = log_param(self._init_F, device=self.device, dtype=self.dtype)
         else:
             self.register_buffer(
                 "_F_buffer",
@@ -627,7 +627,7 @@ class DE(Algorithm):
             trial = self.repair(trial, self.xl, self.xu)
         else:
             # Default: clamp to bounds
-            trial = torch.clamp(trial, self.xl, self.xu)
+            trial = clamp_to_bounds(trial, self.xl, self.xu)
         
         return trial
     

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/evograd/algorithms/pso.py

@@ -52,6 +52,7 @@ import torch.nn as nn
 from torch import Tensor
 
 from evograd.core.algorithm import Algorithm
+from evograd.operators.repair import clamp_to_bounds
 
 if TYPE_CHECKING:
     from evograd.core.problem import Problem
@@ -357,7 +358,7 @@ class PSO(Algorithm):
         pos_repaired = torch.where(above, 2 * self.xu - position, pos_repaired)
         
         # Clamp to ensure within bounds (in case of large violations)
-        pos_repaired = torch.clamp(pos_repaired, self.xl, self.xu)
+        pos_repaired = clamp_to_bounds(pos_repaired, self.xl, self.xu)
         
         # Reverse velocity at boundaries
         vel_repaired = velocity.clone()
@@ -473,7 +474,7 @@ class PSO(Algorithm):
                 old_pos = new_pos - new_velocity          # P₀
                 grad_delta = self._population.data - old_pos  # −lr·∇
                 combined = new_pos + grad_delta           # P₀ + v − lr·∇
-                combined = torch.clamp(combined, self.xl, self.xu)
+                combined = clamp_to_bounds(combined, self.xl, self.xu)
                 self._population.copy_(combined)
             else:
                 self._population.copy_(new_pos)

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/evograd/algorithms/shade.py

@@ -65,6 +65,7 @@ import torch.nn as nn
 from torch import Tensor
 
 from evograd.core.algorithm import Algorithm
+from evograd.operators.relaxations import standard_normal
 
 if TYPE_CHECKING:
     from evograd.core.problem import Problem
@@ -197,7 +198,7 @@ class SHADEMemory:
         
         # Sample from Normal distribution
         sigma = 0.1  # Standard SHADE scale parameter
-        CR = mu_CR + sigma * torch.randn(n, device=device, dtype=dtype)
+        CR = mu_CR + sigma * standard_normal(n, device=device, dtype=dtype)
         
         # Truncate to [0, 1]
         CR = torch.clamp(CR, min=0.0, max=1.0)
@@ -520,7 +521,7 @@ class SHADE(Algorithm):
             
             # Reparameterized Normal for CR
             sigma = 0.1
-            eps = torch.randn(N, device=self.device, dtype=self.dtype)
+            eps = standard_normal(N, device=self.device, dtype=self.dtype)
             CR = mu_CR + sigma * eps
             CR = torch.clamp(CR, min=0.0, max=1.0)
         else:
@@ -886,8 +887,6 @@ class LSHADE(SHADE):
         adaptive: bool = False,
         differentiable: bool = False,
         selection_temperature: float = 1.0,
-        seed: Optional[int] = None,
-        device: Optional[Union[str, torch.device]] = None,
         dtype: torch.dtype = torch.float32,
     ) -> None:
         self.pop_size_init = pop_size_init  # Will be set in _setup if None
@@ -909,8 +908,6 @@ class LSHADE(SHADE):
             differentiable=differentiable,
             adaptive=adaptive,
             selection_temperature=selection_temperature,
-            seed=seed,
-            device=device,
             dtype=dtype,
         )
     
@@ -919,8 +916,10 @@ class LSHADE(SHADE):
         # Set default pop_size_init based on problem dimension
         if self.pop_size_init is None:
             self.pop_size_init = 18 * self.problem.n_var
-            self._pop_size = self.pop_size_init
-        
+        # Always initialise the working population size (fixes target_pop_size
+        # AttributeError when pop_size_init was provided explicitly).
+        self._pop_size = self.pop_size_init
+
         # Create success-history memory with L-SHADE archive size
         self.memory = SHADEMemory.create(
             H=self.memory_size,

evograd_diff-0.2.1/evograd/benchmarks/functions/cec2017/_base.py

@@ -0,0 +1,51 @@
+"""
+Shared base for CEC 2017 functions.
+
+Single source of truth for the bias, shift/rotation loading, default bounds, and
+the shift+rotate transform used by the simple and hybrid CEC 2017 families
+(previously copy-pasted in simple.py and hybrid.py).
+"""
+from __future__ import annotations
+
+from typing import Optional, Tuple
+
+from torch import Tensor
+
+from ..base import BenchmarkFunction
+from . import data as cec_data
+
+
+class CEC2017Base(BenchmarkFunction):
+    """Base for shifted+rotated CEC 2017 functions (search space [-100, 100]^D)."""
+
+    def __init__(
+        self,
+        func_num: int,
+        n_var: int = 10,
+        rotation: Optional[Tensor] = None,
+        shift: Optional[Tensor] = None,
+        seed: Optional[int] = None,
+    ):
+        super().__init__(n_var=n_var, xl=-100.0, xu=100.0)
+
+        self.func_num = func_num
+        self.bias = func_num * 100.0  # F_i* = i * 100
+
+        if rotation is not None:
+            self.rotation = rotation
+        else:
+            self.rotation = cec_data.get_rotation(func_num, n_var, seed=seed)
+
+        if shift is not None:
+            self.shift = shift
+        else:
+            self.shift = cec_data.get_shift(func_num, n_var, seed=seed)
+
+    def default_bounds(self) -> Tuple[float, float]:
+        return (-100.0, 100.0)
+
+    def _shift_rotate(self, x: Tensor) -> Tensor:
+        """Apply the shift + rotation transform (single source of truth)."""
+        shift = self.shift.to(x.device, x.dtype)
+        rotation = self.rotation.to(x.device, x.dtype)
+        return cec_data.shift_rotate(x, shift, rotation)

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/evograd/benchmarks/functions/cec2017/hybrid.py

@@ -26,11 +26,15 @@ from torch import Tensor
 from ..base import BenchmarkFunction
 from . import basic
 from . import data as cec_data
+from ._base import CEC2017Base
 
 
-class CEC2017HybridFunction(BenchmarkFunction):
-    """Base class for CEC 2017 hybrid functions."""
-    
+class CEC2017HybridFunction(CEC2017Base):
+    """Base class for CEC 2017 hybrid functions (adds a shuffle permutation).
+
+    Shared shift/rotation handling is inherited from CEC2017Base (see _base.py).
+    """
+
     def __init__(
         self,
         func_num: int,
@@ -40,47 +44,13 @@ class CEC2017HybridFunction(BenchmarkFunction):
         shuffle: Optional[Tensor] = None,
         seed: Optional[int] = None,
     ):
-        """
-        Initialize CEC 2017 hybrid function.
-        
-        Args:
-            func_num: Function number (11-20).
-            n_var: Number of variables.
-            rotation: Optional rotation matrix.
-            shift: Optional shift vector.
-            shuffle: Optional shuffle permutation.
-            seed: Random seed for generating transforms if not provided.
-        """
-        super().__init__(n_var=n_var, xl=-100.0, xu=100.0)
-        
-        self.func_num = func_num
-        self.bias = func_num * 100.0
-        
-        # Load or generate transforms
-        if rotation is not None:
-            self.rotation = rotation
-        else:
-            self.rotation = cec_data.get_rotation(func_num, n_var, seed=seed)
-        
-        if shift is not None:
-            self.shift = shift
-        else:
-            self.shift = cec_data.get_shift(func_num, n_var, seed=seed)
-        
+        super().__init__(func_num=func_num, n_var=n_var,
+                         rotation=rotation, shift=shift, seed=seed)
         if shuffle is not None:
             self.shuffle = shuffle
         else:
             self.shuffle = cec_data.get_shuffle(func_num, n_var, seed=seed)
-    
-    def default_bounds(self) -> Tuple[float, float]:
-        return (-100.0, 100.0)
-    
-    def _shift_rotate(self, x: Tensor) -> Tensor:
-        """Apply shift and rotation transformation."""
-        shift = self.shift.to(x.device, x.dtype)
-        rotation = self.rotation.to(x.device, x.dtype)
-        return cec_data.shift_rotate(x, shift, rotation)
-    
+
     def _shuffle_and_partition(self, x: Tensor, partitions: List[float]) -> List[Tensor]:
         """Apply shuffle and partition."""
         shuffle = self.shuffle.to(x.device)

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/evograd/benchmarks/functions/cec2017/simple.py

@@ -26,54 +26,17 @@ from torch import Tensor
 from ..base import BenchmarkFunction
 from . import basic
 from . import data as cec_data
+from ._base import CEC2017Base
 
 
-class CEC2017Function(BenchmarkFunction):
-    """Base class for CEC 2017 functions with shift and rotation support."""
-    
-    def __init__(
-        self,
-        func_num: int,
-        n_var: int = 10,
-        rotation: Optional[Tensor] = None,
-        shift: Optional[Tensor] = None,
-        seed: Optional[int] = None,
-    ):
-        """
-        Initialize CEC 2017 function.
-        
-        Args:
-            func_num: Function number (1-30).
-            n_var: Number of variables (2, 10, 20, 30, 50, or 100 for official data).
-            rotation: Optional rotation matrix. If None, loads from data or generates.
-            shift: Optional shift vector. If None, loads from data or generates.
-            seed: Random seed for generating transforms if not provided.
-        """
-        super().__init__(n_var=n_var, xl=-100.0, xu=100.0)
-        
-        self.func_num = func_num
-        self.bias = func_num * 100.0  # F_i* = i * 100
-        
-        # Load or generate rotation matrix
-        if rotation is not None:
-            self.rotation = rotation
-        else:
-            self.rotation = cec_data.get_rotation(func_num, n_var, seed=seed)
-        
-        # Load or generate shift vector
-        if shift is not None:
-            self.shift = shift
-        else:
-            self.shift = cec_data.get_shift(func_num, n_var, seed=seed)
-    
-    def default_bounds(self) -> Tuple[float, float]:
-        return (-100.0, 100.0)
-    
-    def _shift_rotate(self, x: Tensor) -> Tensor:
-        """Apply shift and rotation transformation."""
-        shift = self.shift.to(x.device, x.dtype)
-        rotation = self.rotation.to(x.device, x.dtype)
-        return cec_data.shift_rotate(x, shift, rotation)
+class CEC2017Function(CEC2017Base):
+    """Base class for CEC 2017 simple functions (shift + rotation).
+
+    The shared __init__, default_bounds, and _shift_rotate live in
+    CEC2017Base (see _base.py).
+    """
+
+    pass
 
 
 class CEC2017_F1(CEC2017Function):

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/evograd/operators/crossover.py

@@ -71,7 +71,7 @@ import torch
 import torch.nn as nn
 from torch import Tensor
 
-from evograd.operators.relaxations import binary_concrete, expand_param
+from evograd.operators.relaxations import binary_concrete, expand_param, log_param
 
 __all__ = [
     "Crossover",
@@ -136,9 +136,7 @@ class Crossover(nn.Module, ABC):
         
         # Temperature parameter (log for positivity)
         if learn_temperature and adaptive:
-            self._log_temperature = nn.Parameter(
-                torch.tensor(temperature).log()
-            )
+            self._log_temperature = log_param(temperature)
         else:
             self.register_buffer(
                 "_log_temperature",
@@ -328,7 +326,7 @@ class SBXCrossover(Crossover):
         
         # Eta parameter (log for positivity)
         if learn_eta and adaptive:
-            self._log_eta = nn.Parameter(torch.tensor(eta).log())
+            self._log_eta = log_param(eta)
         else:
             self.register_buffer("_log_eta", torch.tensor(eta).log())
     

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/evograd/operators/mutation.py

@@ -67,7 +67,7 @@ import torch
 import torch.nn as nn
 from torch import Tensor
 
-from evograd.operators.relaxations import binary_concrete, expand_param
+from evograd.operators.relaxations import binary_concrete, expand_param, standard_normal, log_param
 
 if TYPE_CHECKING:
     from evograd.core.problem import Problem
@@ -136,9 +136,7 @@ class Mutation(nn.Module, ABC):
         
         # Temperature parameter (log for positivity)
         if learn_temperature and adaptive:
-            self._log_temperature = nn.Parameter(
-                torch.tensor(temperature).log()
-            )
+            self._log_temperature = log_param(temperature)
         else:
             self.register_buffer(
                 "_log_temperature",
@@ -366,7 +364,7 @@ class PolynomialMutation(Mutation):
         
         # Eta parameter (log for positivity)
         if learn_eta and adaptive:
-            self._log_eta = nn.Parameter(torch.tensor(eta).log())
+            self._log_eta = log_param(eta)
         else:
             self.register_buffer("_log_eta", torch.tensor(eta).log())
     
@@ -523,7 +521,7 @@ class GaussianMutation(Mutation):
         # Sigma parameter (log for positivity)
         sigma_val = sigma if sigma is not None else sigma_frac
         if learn_sigma and adaptive:
-            self._log_sigma = nn.Parameter(torch.tensor(sigma_val).log())
+            self._log_sigma = log_param(sigma_val)
         else:
             self.register_buffer("_log_sigma", torch.tensor(sigma_val).log())
     
@@ -593,7 +591,7 @@ class GaussianMutation(Mutation):
                 sigma_expanded = expand_param(None, self.sigma, n_pop, n_var, device, dtype)
         
         # Gaussian noise (reparameterised)
-        noise = torch.randn(n_pop, n_var, device=device, dtype=dtype) * sigma_expanded
+        noise = standard_normal(n_pop, n_var, device=device, dtype=dtype) * sigma_expanded
         
         # Apply mutation with mask
         y = x + mask * noise
@@ -779,7 +777,7 @@ class NonUniformMutation(Mutation):
         
         # B parameter (log for positivity)
         if learn_b and adaptive:
-            self._log_b = nn.Parameter(torch.tensor(b).log())
+            self._log_b = log_param(b)
         else:
             self.register_buffer("_log_b", torch.tensor(b).log())
     

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/evograd/operators/relaxations.py

@@ -13,12 +13,14 @@ Functions:
 
 import torch
 from torch import Tensor
-from typing import Union
+from typing import Optional, Union
 
 __all__ = [
     "gumbel_softmax",
     "binary_concrete", 
     "expand_param",
+    "standard_normal",
+    "log_param",
 ]
 
 
@@ -173,3 +175,30 @@ def expand_param(
             )
     else:
         raise ValueError(f"param must be 0D, 1D, or 2D, got {val.dim()}D")
+
+
+def standard_normal(
+    *shape: int,
+    device: Optional[torch.device] = None,
+    dtype: Optional[torch.dtype] = None,
+    generator: Optional[torch.Generator] = None,
+) -> Tensor:
+    """Draw standard-normal (pathwise / reparameterization) noise.
+
+    Single source for the ``torch.randn(..., device=, dtype=)`` reparameterization
+    draw, reused by CMA-ES sampling, Gaussian mutation, and the samplers.
+    """
+    return torch.randn(*shape, device=device, dtype=dtype, generator=generator)
+
+
+def log_param(
+    value: Union[float, Tensor],
+    device: Optional[torch.device] = None,
+    dtype: Optional[torch.dtype] = None,
+) -> "torch.nn.Parameter":
+    """Learnable positive hyperparameter stored on the log scale.
+
+    Single source for the repeated ``nn.Parameter(torch.tensor(v).log())`` idiom
+    used for sigma, F, eta, temperature, etc. Recover the value via ``.exp()``.
+    """
+    return torch.nn.Parameter(torch.tensor(value, device=device, dtype=dtype).log())

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/evograd/operators/repair.py

@@ -50,9 +50,19 @@ __all__ = [
     "BoundsRepair",
     "RepairMethod",
     "NoRepair",
+    "clamp_to_bounds",
 ]
 
 
+def clamp_to_bounds(x: Tensor, xl: Tensor, xu: Tensor) -> Tensor:
+    """Clamp ``x`` element-wise to the box ``[xl, xu]``.
+
+    Single source of truth for box-bounds clamping: reused by ClipRepair and by
+    the algorithms (PSO/DE) instead of repeating ``torch.clamp`` inline.
+    """
+    return torch.clamp(x, min=xl, max=xu)
+
+
 class RepairMethod(Enum):
     """Available repair methods."""
     CLIP = "clip"
@@ -189,7 +199,7 @@ class ClipRepair(Repair):
         xl: Tensor,
         xu: Tensor,
     ) -> Tensor:
-        return torch.clamp(x, min=xl, max=xu)
+        return clamp_to_bounds(x, xl, xu)
     
     def __repr__(self) -> str:
         return "ClipRepair()"

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/evograd/operators/sampling.py

@@ -32,6 +32,8 @@ import torch
 import torch.nn as nn
 from torch import Tensor
 
+from evograd.operators.relaxations import standard_normal
+
 if TYPE_CHECKING:
     from evograd.core.problem import Problem
 
@@ -335,16 +337,12 @@ class NormalSampling(Sampling):
         if generator is not None:
             # Generator may be on CPU for MPS devices
             gen_device = generator.device
-            z = torch.randn(
-                n_samples, n_var,
-                device=gen_device,
-                dtype=dtype,
-                generator=generator,
-            )
+            z = standard_normal(n_samples, n_var, device=gen_device, dtype=dtype,
+                                generator=generator)
             if gen_device != device:
                 z = z.to(device)
         else:
-            z = torch.randn(n_samples, n_var, device=device, dtype=dtype)
+            z = standard_normal(n_samples, n_var, device=device, dtype=dtype)
         
         # Transform to [0, 1] centered at 0.5 with scaled std
         # mean=0.5, std=sigma_factor * 0.5

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/evograd/operators/selection.py

@@ -44,7 +44,7 @@ import torch
 import torch.nn as nn
 from torch import Tensor
 
-from evograd.operators.relaxations import gumbel_softmax
+from evograd.operators.relaxations import gumbel_softmax, log_param
 
 __all__ = [
     "Selection",
@@ -94,9 +94,7 @@ class Selection(nn.Module, ABC):
         # Temperature parameter
         if learn_temperature and adaptive:
             # Store as log for positivity
-            self._log_temperature = nn.Parameter(
-                torch.tensor(temperature).log()
-            )
+            self._log_temperature = log_param(temperature)
         else:
             self.register_buffer(
                 "_log_temperature",

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/evograd/tests/run_all.py

@@ -18,6 +18,9 @@ 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_de import run_all_tests as test_de
+from tests.test_pso import run_all_tests as test_pso
+from tests.test_shade import run_all_tests as test_shade
 from tests.test_per_individual import main as test_per_individual
 
 
@@ -61,6 +64,24 @@ def run_all():
     print("▶"*60)
     results['ga'] = test_ga()
 
+    # Run DE tests
+    print("\n\n" + "▶"*60)
+    print("▶ RUNNING DE TESTS")
+    print("▶"*60)
+    results['de'] = test_de()
+
+    # Run PSO tests
+    print("\n\n" + "▶"*60)
+    print("▶ RUNNING PSO TESTS")
+    print("▶"*60)
+    results['pso'] = test_pso()
+
+    # Run SHADE tests
+    print("\n\n" + "▶"*60)
+    print("▶ RUNNING SHADE TESTS")
+    print("▶"*60)
+    results['shade'] = test_shade()
+
     # Run per-individual parameter tests
     print("\n\n" + "▶"*60)
     print("▶ RUNNING PER-INDIVIDUAL TESTS")

evograd_diff-0.2.1/evograd/tests/test_de.py

@@ -0,0 +1,62 @@
+"""Behavioural tests for Differential Evolution — coverage added before the refactor."""
+import math
+import sys
+
+import torch
+
+from evograd.core.problem import Problem
+from evograd.core.minimize import minimize
+from evograd.core.termination import MaxEvaluations
+from evograd.algorithms.de import DE
+
+
+def sphere(x):
+    return (x ** 2).sum(dim=-1)
+
+
+def P(n=10, lo=-5.0, hi=5.0):
+    return Problem(objective=sphere, n_var=n, xl=lo, xu=hi)
+
+
+def test_de_converges():
+    print("\n1. DE converges on sphere...")
+    r = minimize(P(10), DE(pop_size=30), termination=MaxEvaluations(8000), seed=0, verbose=False)
+    assert r.best_fitness < 1.0, f"DE best {r.best_fitness} !< 1.0"
+
+
+def test_de_variants():
+    print("2. DE variants run, finite fitness...")
+    for v in ("DE/rand/1/bin", "DE/best/1/bin", "DE/current-to-best/1/bin", "DE/rand/2/bin"):
+        r = minimize(P(8), DE(pop_size=20, variant=v), termination=MaxEvaluations(1500), seed=1, verbose=False)
+        assert math.isfinite(r.best_fitness), f"DE {v} non-finite fitness"
+
+
+def test_de_four_modes():
+    print("3. DE four modes run, finite fitness...")
+    for kw in ({}, dict(adaptive=True), dict(differentiable=True), dict(adaptive=True, differentiable=True)):
+        r = minimize(P(8), DE(pop_size=20, **kw), termination=MaxEvaluations(800), seed=2, verbose=False)
+        assert math.isfinite(r.best_fitness), f"DE {kw} non-finite fitness"
+
+
+def test_de_respects_bounds():
+    print("4. DE respects bounds...")
+    r = minimize(P(6, -2.0, 2.0), DE(pop_size=20), termination=MaxEvaluations(1500), seed=3, verbose=False)
+    x = r.best_solution
+    assert (x >= -2.0 - 1e-3).all() and (x <= 2.0 + 1e-3).all(), "DE violated bounds"
+
+
+def run_all_tests():
+    ok = True
+    for t in (test_de_converges, test_de_variants, test_de_four_modes, test_de_respects_bounds):
+        try:
+            t()
+            print("   PASS")
+        except Exception:
+            ok = False
+            import traceback
+            traceback.print_exc()
+    return ok
+
+
+if __name__ == "__main__":
+    sys.exit(0 if run_all_tests() else 1)

evograd_diff-0.2.1/evograd/tests/test_pso.py

@@ -0,0 +1,62 @@
+"""Behavioural tests for Particle Swarm Optimisation — coverage added before the refactor."""
+import math
+import sys
+
+import torch
+
+from evograd.core.problem import Problem
+from evograd.core.minimize import minimize
+from evograd.core.termination import MaxEvaluations
+from evograd.algorithms.pso import PSO
+
+
+def sphere(x):
+    return (x ** 2).sum(dim=-1)
+
+
+def P(n=10, lo=-5.0, hi=5.0):
+    return Problem(objective=sphere, n_var=n, xl=lo, xu=hi)
+
+
+def test_pso_converges():
+    print("\n1. PSO converges on sphere...")
+    r = minimize(P(10), PSO(pop_size=30), termination=MaxEvaluations(8000), seed=0, verbose=False)
+    assert r.best_fitness < 1.0, f"PSO best {r.best_fitness} !< 1.0"
+
+
+def test_pso_four_modes():
+    print("2. PSO four modes run, finite fitness...")
+    for kw in ({}, dict(adaptive=True), dict(differentiable=True), dict(adaptive=True, differentiable=True)):
+        r = minimize(P(8), PSO(pop_size=20, **kw), termination=MaxEvaluations(800), seed=1, verbose=False)
+        assert math.isfinite(r.best_fitness), f"PSO {kw} non-finite fitness"
+
+
+def test_pso_per_particle_coeffs():
+    print("3. PSO per-particle adaptive coeffs run...")
+    r = minimize(P(8), PSO(pop_size=20, adaptive=True, per_particle_coeffs=True),
+                 termination=MaxEvaluations(800), seed=2, verbose=False)
+    assert math.isfinite(r.best_fitness), "PSO per-particle non-finite fitness"
+
+
+def test_pso_respects_bounds():
+    print("4. PSO respects bounds...")
+    r = minimize(P(6, -2.0, 2.0), PSO(pop_size=20), termination=MaxEvaluations(1500), seed=3, verbose=False)
+    x = r.best_solution
+    assert (x >= -2.0 - 1e-3).all() and (x <= 2.0 + 1e-3).all(), "PSO violated bounds"
+
+
+def run_all_tests():
+    ok = True
+    for t in (test_pso_converges, test_pso_four_modes, test_pso_per_particle_coeffs, test_pso_respects_bounds):
+        try:
+            t()
+            print("   PASS")
+        except Exception:
+            ok = False
+            import traceback
+            traceback.print_exc()
+    return ok
+
+
+if __name__ == "__main__":
+    sys.exit(0 if run_all_tests() else 1)

evograd_diff-0.2.1/evograd/tests/test_shade.py

@@ -0,0 +1,64 @@
+"""Behavioural tests for SHADE (and LSHADE) — coverage added before the refactor."""
+import math
+import sys
+
+import torch
+
+from evograd.core.problem import Problem
+from evograd.core.minimize import minimize
+from evograd.core.termination import MaxEvaluations
+from evograd.algorithms.shade import SHADE, LSHADE
+
+
+def sphere(x):
+    return (x ** 2).sum(dim=-1)
+
+
+def P(n=10, lo=-5.0, hi=5.0):
+    return Problem(objective=sphere, n_var=n, xl=lo, xu=hi)
+
+
+def test_shade_converges():
+    print("\n1. SHADE converges on sphere...")
+    r = minimize(P(10), SHADE(pop_size=30), termination=MaxEvaluations(3000), seed=0, verbose=False)
+    assert r.best_fitness < 1.0, f"SHADE best {r.best_fitness} !< 1.0"
+
+
+def test_shade_four_modes():
+    print("2. SHADE four modes run, finite fitness...")
+    for kw in ({}, dict(adaptive=True), dict(differentiable=True), dict(adaptive=True, differentiable=True)):
+        r = minimize(P(8), SHADE(pop_size=20, **kw), termination=MaxEvaluations(800), seed=1, verbose=False)
+        assert math.isfinite(r.best_fitness), f"SHADE {kw} non-finite fitness"
+
+
+def test_shade_respects_bounds():
+    print("3. SHADE respects bounds...")
+    r = minimize(P(6, -2.0, 2.0), SHADE(pop_size=20), termination=MaxEvaluations(1200), seed=2, verbose=False)
+    x = r.best_solution
+    assert (x >= -2.0 - 1e-3).all() and (x <= 2.0 + 1e-3).all(), "SHADE violated bounds"
+
+
+def test_lshade_runs():
+    print("4. LSHADE runs, finite fitness, respects bounds (fixed)...")
+    r = minimize(P(10), LSHADE(pop_size_init=40, pop_size_min=4),
+                 termination=MaxEvaluations(2000), seed=3, verbose=False)
+    assert math.isfinite(r.best_fitness), "LSHADE non-finite fitness"
+    x = r.best_solution
+    assert (x >= -5.0 - 1e-3).all() and (x <= 5.0 + 1e-3).all(), "LSHADE violated bounds"
+
+
+def run_all_tests():
+    ok = True
+    for t in (test_shade_converges, test_shade_four_modes, test_shade_respects_bounds, test_lshade_runs):
+        try:
+            t()
+            print("   PASS")
+        except Exception:
+            ok = False
+            import traceback
+            traceback.print_exc()
+    return ok
+
+
+if __name__ == "__main__":
+    sys.exit(0 if run_all_tests() else 1)

{evograd_diff-0.2.0 → evograd_diff-0.2.1}/pyproject.toml

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