refactor: reorganize optimizers into subfolders and migrate to uv

.github/workflows/python-publish.yaml

@@ -14,18 +14,14 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
-      - name: Set up Python
-        uses: actions/setup-python@v5
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
         with:
-          python-version: "3.x"
-      - name: Install pypa/build
-        run: >-
-          python3 -m
-          pip install
-          build
-          --user
+          version: "latest"
+      - name: Set up Python
+        run: uv python install 3.12
       - name: Build a binary wheel and a source tarball
-        run: python3 -m build
+        run: uv build
       - name: Store the distribution packages
         uses: actions/upload-artifact@v4
         with:

.github/workflows/tests.yaml

@@ -0,0 +1,59 @@
+name: Tests
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  test:
+    name: Test Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          version: "latest"
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Run tests
+        run: uv run pytest opt/test/ -v --tb=short
+
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          version: "latest"
+
+      - name: Set up Python
+        run: uv python install 3.12
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Run ruff check
+        run: uv run ruff check opt/
+
+      - name: Run ruff format check
+        run: uv run ruff format --check opt/

.pre-commit-config.yaml

@@ -2,17 +2,15 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: "v4.5.0"
+    rev: "v6.0.0"
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
       - id: check-yaml
       - id: check-added-large-files
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: "v0.3.4"
+    rev: "v0.14.10"
     hooks:
       - id: ruff
-        language_version: python3.12
-        types_or: [ python, pyi, jupyter ]
+        types_or: [python, pyi, jupyter]
       - id: ruff-format
-        language_version: python3.12

opt/__init__.py

@@ -1,6 +1,155 @@
-"""Useful optimizers, a set of optimization algorithms."""
+"""Useful optimizers, a set of optimization algorithms.
+
+This package provides 54 optimization algorithms organized into categories:
+- gradient_based: Gradient-based optimizers (AdaDelta, AdaGrad, Adam, etc.)
+- swarm_intelligence: Nature-inspired swarm algorithms (PSO, ACO, etc.)
+- evolutionary: Evolutionary algorithms (GA, DE, CMA-ES, etc.)
+- classical: Classical optimization methods (BFGS, Nelder-Mead, etc.)
+- metaheuristic: Metaheuristic algorithms (Harmony Search, etc.)
+- constrained: Constrained optimization methods
+- probabilistic: Probabilistic optimization methods
+
+All optimizers are re-exported at the package level for backward compatibility.
+"""
 
 from __future__ import annotations
 
+# Base class
+from opt.abstract_optimizer import AbstractOptimizer
+
+# Classical algorithms
+from opt.classical import BFGS
+from opt.classical import LBFGS
+from opt.classical import ConjugateGradient
+from opt.classical import HillClimbing
+from opt.classical import NelderMead
+from opt.classical import Powell
+from opt.classical import SimulatedAnnealing
+from opt.classical import TabuSearch
+from opt.classical import TrustRegion
+
+# Constrained optimization
+from opt.constrained import AugmentedLagrangian
+from opt.constrained import SuccessiveLinearProgramming
+
+# Evolutionary algorithms
+from opt.evolutionary import CMAESAlgorithm
+from opt.evolutionary import CulturalAlgorithm
+from opt.evolutionary import DifferentialEvolution
+from opt.evolutionary import EstimationOfDistributionAlgorithm
+from opt.evolutionary import GeneticAlgorithm
+from opt.evolutionary import ImperialistCompetitiveAlgorithm
+from opt.gradient_based import SGD
+
+# Gradient-based algorithms
+from opt.gradient_based import ADAGrad
+from opt.gradient_based import ADAMOptimization
+from opt.gradient_based import AMSGrad
+from opt.gradient_based import AdaDelta
+from opt.gradient_based import AdaMax
+from opt.gradient_based import AdamW
+from opt.gradient_based import Nadam
+from opt.gradient_based import NesterovAcceleratedGradient
+from opt.gradient_based import RMSprop
+from opt.gradient_based import SGDMomentum
+
+# Metaheuristic algorithms
+from opt.metaheuristic import CollidingBodiesOptimization
+from opt.metaheuristic import CrossEntropyMethod
+from opt.metaheuristic import EagleStrategy
+from opt.metaheuristic import HarmonySearch
+from opt.metaheuristic import ParticleFilter
+from opt.metaheuristic import ShuffledFrogLeapingAlgorithm
+from opt.metaheuristic import SineCosineAlgorithm
+from opt.metaheuristic import StochasticDiffusionSearch
+from opt.metaheuristic import StochasticFractalSearch
+from opt.metaheuristic import VariableDepthSearch
+from opt.metaheuristic import VariableNeighborhoodSearch
+from opt.metaheuristic import VeryLargeScaleNeighborhood
+
+# Probabilistic algorithms
+from opt.probabilistic import LDAnalysis
+from opt.probabilistic import ParzenTreeEstimator
+
+# Swarm intelligence algorithms
+from opt.swarm_intelligence import AntColony
+from opt.swarm_intelligence import ArtificialFishSwarm
+from opt.swarm_intelligence import BatAlgorithm
+from opt.swarm_intelligence import BeeAlgorithm
+from opt.swarm_intelligence import CatSwarmOptimization
+from opt.swarm_intelligence import CuckooSearch
+from opt.swarm_intelligence import FireflyAlgorithm
+from opt.swarm_intelligence import GlowwormSwarmOptimization
+from opt.swarm_intelligence import GreyWolfOptimizer
+from opt.swarm_intelligence import ParticleSwarm
+from opt.swarm_intelligence import SquirrelSearchAlgorithm
+from opt.swarm_intelligence import WhaleOptimizationAlgorithm
+
 
 __version__ = "0.1.2"
+
+__all__: list[str] = [
+    # Classical
+    "BFGS",
+    "LBFGS",
+    "SGD",
+    "ADAGrad",
+    "ADAMOptimization",
+    "AMSGrad",
+    # Base class
+    "AbstractOptimizer",
+    # Gradient-based
+    "AdaDelta",
+    "AdaMax",
+    "AdamW",
+    # Swarm intelligence
+    "AntColony",
+    "ArtificialFishSwarm",
+    # Constrained
+    "AugmentedLagrangian",
+    "BatAlgorithm",
+    "BeeAlgorithm",
+    # Evolutionary
+    "CMAESAlgorithm",
+    "CatSwarmOptimization",
+    # Metaheuristic
+    "CollidingBodiesOptimization",
+    "ConjugateGradient",
+    "CrossEntropyMethod",
+    "CuckooSearch",
+    "CulturalAlgorithm",
+    "DifferentialEvolution",
+    "EagleStrategy",
+    "EstimationOfDistributionAlgorithm",
+    "FireflyAlgorithm",
+    "GeneticAlgorithm",
+    "GlowwormSwarmOptimization",
+    "GreyWolfOptimizer",
+    "HarmonySearch",
+    "HillClimbing",
+    "ImperialistCompetitiveAlgorithm",
+    # Probabilistic
+    "LDAnalysis",
+    "Nadam",
+    "NelderMead",
+    "NesterovAcceleratedGradient",
+    "ParticleFilter",
+    "ParticleSwarm",
+    "ParzenTreeEstimator",
+    "Powell",
+    "RMSprop",
+    "SGDMomentum",
+    "ShuffledFrogLeapingAlgorithm",
+    "SimulatedAnnealing",
+    "SineCosineAlgorithm",
+    "SquirrelSearchAlgorithm",
+    "StochasticDiffusionSearch",
+    "StochasticFractalSearch",
+    "SuccessiveLinearProgramming",
+    "TabuSearch",
+    "TrustRegion",
+    "VariableDepthSearch",
+    "VariableNeighborhoodSearch",
+    "VeryLargeScaleNeighborhood",
+    "WhaleOptimizationAlgorithm",
+]

opt/classical/__init__.py

@@ -0,0 +1,31 @@
+"""Classical optimization algorithms.
+
+This module contains traditional mathematical optimization methods including derivative-based
+and derivative-free approaches. Includes: BFGS, Conjugate Gradient, Hill Climbing, L-BFGS,
+Nelder-Mead, Powell, Simulated Annealing, Tabu Search, and Trust Region methods.
+"""
+
+from __future__ import annotations
+
+from opt.classical.bfgs import BFGS
+from opt.classical.conjugate_gradient import ConjugateGradient
+from opt.classical.hill_climbing import HillClimbing
+from opt.classical.lbfgs import LBFGS
+from opt.classical.nelder_mead import NelderMead
+from opt.classical.powell import Powell
+from opt.classical.simulated_annealing import SimulatedAnnealing
+from opt.classical.tabu_search import TabuSearch
+from opt.classical.trust_region import TrustRegion
+
+
+__all__: list[str] = [
+    "BFGS",
+    "LBFGS",
+    "ConjugateGradient",
+    "HillClimbing",
+    "NelderMead",
+    "Powell",
+    "SimulatedAnnealing",
+    "TabuSearch",
+    "TrustRegion",
+]

opt/constrained/__init__.py

@@ -0,0 +1,14 @@
+"""Constrained optimization algorithms.
+
+This module contains optimizers specifically designed for handling optimization problems
+with equality and/or inequality constraints. Includes: Augmented Lagrangian Method
+and Successive Linear Programming.
+"""
+
+from __future__ import annotations
+
+from opt.constrained.augmented_lagrangian_method import AugmentedLagrangian
+from opt.constrained.successive_linear_programming import SuccessiveLinearProgramming
+
+
+__all__: list[str] = ["AugmentedLagrangian", "SuccessiveLinearProgramming"]

opt/evolutionary/__init__.py

@@ -0,0 +1,29 @@
+"""Evolutionary optimization algorithms.
+
+This module contains population-based metaheuristic optimizers inspired by biological
+evolution. Includes: CMA-ES, Cultural Algorithm, Differential Evolution, Estimation of
+Distribution Algorithm, Genetic Algorithm, and Imperialist Competitive Algorithm.
+"""
+
+from __future__ import annotations
+
+from opt.evolutionary.cma_es import CMAESAlgorithm
+from opt.evolutionary.cultural_algorithm import CulturalAlgorithm
+from opt.evolutionary.differential_evolution import DifferentialEvolution
+from opt.evolutionary.estimation_of_distribution_algorithm import (
+    EstimationOfDistributionAlgorithm,
+)
+from opt.evolutionary.genetic_algorithm import GeneticAlgorithm
+from opt.evolutionary.imperialist_competitive_algorithm import (
+    ImperialistCompetitiveAlgorithm,
+)
+
+
+__all__: list[str] = [
+    "CMAESAlgorithm",
+    "CulturalAlgorithm",
+    "DifferentialEvolution",
+    "EstimationOfDistributionAlgorithm",
+    "GeneticAlgorithm",
+    "ImperialistCompetitiveAlgorithm",
+]

opt/gradient_based/__init__.py

@@ -0,0 +1,34 @@
+"""Gradient-based optimization algorithms.
+
+This module contains optimizers that use gradient information to find optimal solutions.
+Includes: AdaDelta, AdaGrad, AdaMax, AdamW, Adam, AMSGrad, NAdam, Nesterov, RMSprop, SGD.
+"""
+
+from __future__ import annotations
+
+from opt.gradient_based.adadelta import AdaDelta
+from opt.gradient_based.adagrad import ADAGrad
+from opt.gradient_based.adamax import AdaMax
+from opt.gradient_based.adamw import AdamW
+from opt.gradient_based.adaptive_moment_estimation import ADAMOptimization
+from opt.gradient_based.amsgrad import AMSGrad
+from opt.gradient_based.nadam import Nadam
+from opt.gradient_based.nesterov_accelerated_gradient import NesterovAcceleratedGradient
+from opt.gradient_based.rmsprop import RMSprop
+from opt.gradient_based.sgd_momentum import SGDMomentum
+from opt.gradient_based.stochastic_gradient_descent import SGD
+
+
+__all__: list[str] = [
+    "SGD",
+    "ADAGrad",
+    "ADAMOptimization",
+    "AMSGrad",
+    "AdaDelta",
+    "AdaMax",
+    "AdamW",
+    "Nadam",
+    "NesterovAcceleratedGradient",
+    "RMSprop",
+    "SGDMomentum",
+]