bioalgo 0.1.0__tar.gz

bioalgo-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Developer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bioalgo-0.1.0/PKG-INFO

@@ -0,0 +1,194 @@
+Metadata-Version: 2.4
+Name: bioalgo
+Version: 0.1.0
+Summary: A lightweight, modular Python toolkit for bio-inspired and nature-inspired metaheuristic optimization algorithms.
+Author-email: Developer <developer@example.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/example/bioalgo
+Project-URL: Repository, https://github.com/example/bioalgo
+Project-URL: Documentation, https://github.com/example/bioalgo#readme
+Keywords: optimization,metaheuristics,bio-inspired,nature-inspired,particle-swarm-optimization,differential-evolution,simulated-annealing,firefly-algorithm,biogeography-based-optimization,hill-climbing,n-queens,traveling-salesman-problem
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# bioalgo
+
+[![PyPI version](https://img.shields.io/pypi/v/bioalgo.svg)](https://pypi.org/project/bioalgo/)
+[![Python versions](https://img.shields.io/pypi/pyversions/bioalgo.svg)](https://pypi.org/project/bioalgo/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**bioalgo** is a lightweight, pure-Python library for nature-inspired, bio-inspired, and metaheuristic optimization algorithms. It includes both discrete combinatorial solvers (N-Queens, Traveling Salesman Problem) and continuous multimodal function optimizers.
+
+---
+
+## Algorithms Included
+
+| Algorithm | Type | Description / Operators | Typical Applications |
+| :--- | :--- | :--- | :--- |
+| **Hill Climbing** | Discrete Local Search | Steepest ascent, conflict evaluation, random-restart heuristics | N-Queens, constraint satisfaction |
+| **Simulated Annealing (SA)** | Metaheuristic | Metropolis acceptance criterion ($P = e^{-\Delta E / T}$), 2-opt swaps, geometric cooling | Traveling Salesman Problem (TSP), combinatorial routing |
+| **Particle Swarm Optimization (PSO)** | Swarm Intelligence | Velocity/position updates, cognitive ($\text{pBest}$) and social ($\text{gBest}$) components, inertia damping | Continuous multimodal minimization |
+| **Differential Evolution (DE)** | Evolutionary | Mutation (`DE/rand/1`, `DE/best/1`), binomial crossover ($CR$), one-to-one selection | Non-linear parameter estimation, benchmark optimization |
+| **Biogeography-Based Optimization (BBO)** | Ecological | Species migration ($\lambda, \mu$), Habitat Suitability Index (HSI), elitism, mutation | Continuous global optimization |
+| **Firefly Algorithm (FA)** | Swarm Intelligence | Light intensity, distance attractiveness ($\beta(r) = \beta_0 e^{-\gamma r^2}$), randomized step damping | Multimodal landscapes with multiple local optima |
+
+---
+
+## Installation
+
+Install via `pip`:
+
+```bash
+pip install bioalgo
+```
+
+Or install in development/editable mode:
+
+```bash
+git clone https://github.com/example/bioalgo.git
+cd bioalgo
+pip install -e .
+```
+
+---
+
+## Quickstart
+
+### 1. Particle Swarm Optimization (PSO)
+```python
+from bioalgo import ParticleSwarmOptimization
+from bioalgo.benchmarks import rastrigin
+
+# Optimize the multimodal Rastrigin function in 5 dimensions
+pso = ParticleSwarmOptimization(
+    cost_func=rastrigin,
+    dim=5,
+    bounds=(-5.12, 5.12),
+    num_particles=40
+)
+
+best_vector, best_cost, history = pso.optimize(max_iter=100)
+print(f"Optimal Cost: {best_cost:.6e}")
+print(f"Optimal Solution: {best_vector}")
+```
+
+### 2. Differential Evolution (DE)
+```python
+from bioalgo import DifferentialEvolution
+from bioalgo.benchmarks import ackley
+
+de = DifferentialEvolution(
+    cost_func=ackley,
+    dim=5,
+    bounds=(-32.768, 32.768),
+    pop_size=40,
+    strategy="best/1/bin"
+)
+
+best_vector, best_cost, history = de.optimize(max_generations=100)
+print(f"Ackley Minimum: {best_cost:.6e}")
+```
+
+### 3. Solve N-Queens with Hill Climbing
+```python
+from bioalgo import NQueensProblem, HillClimbing
+
+problem = NQueensProblem(n=8)
+solver = HillClimbing(problem)
+solution, restarts, steps = solver.search_with_restarts(max_restarts=50)
+
+print(f"Solved in {restarts} restart(s) and {steps} steps:")
+print(problem.render_board(solution))
+```
+
+### 4. Traveling Salesman Problem (TSP) with Simulated Annealing
+```python
+from bioalgo import TravelingSalesmanProblem, SimulatedAnnealing
+
+problem = TravelingSalesmanProblem()
+sa = SimulatedAnnealing(problem, initial_temp=1000.0, cooling_rate=0.995)
+
+best_tour, best_distance, history = sa.optimize(seed=42)
+print(f"Best Tour Length: {best_distance:.2f}")
+print("Tour Sequence:", " -> ".join(best_tour))
+```
+
+---
+
+## Built-in Benchmark Functions
+
+`bioalgo.benchmarks` includes standard continuous functions:
+- `sphere(x)`
+- `rastrigin(x)`
+- `ackley(x)`
+- `rosenbrock(x)`
+- `griewank(x)`
+
+---
+
+## Command Line Interface (CLI)
+
+`bioalgo` comes with a command-line interface:
+
+```bash
+# Solve 8-Queens and render the board
+bioalgo nqueens -n 8 --render
+
+# Solve Traveling Salesman Problem
+bioalgo tsp --temp 1000 --cooling 0.995
+
+# Optimize a continuous benchmark using PSO, DE, BBO, or FA
+bioalgo optimize pso --func rastrigin --dim 5 --iters 100
+bioalgo optimize de --func ackley --dim 5 --iters 100
+bioalgo optimize bbo --func sphere --dim 5 --iters 100
+bioalgo optimize fa --func rastrigin --dim 5 --iters 100
+```
+
+---
+
+## Building and Publishing to PyPI
+
+### 1. Build the Distribution Archives
+```bash
+python -m build
+```
+This produces `.tar.gz` (source distribution) and `.whl` (built wheel) in `dist/`.
+
+### 2. Check Package Metadata
+```bash
+twine check dist/*
+```
+
+### 3. Test on TestPyPI (Recommended first)
+```bash
+twine upload --repository testpypi dist/*
+```
+
+### 4. Upload to Production PyPI
+```bash
+twine upload dist/*
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

bioalgo-0.1.0/README.md

@@ -0,0 +1,163 @@
+# bioalgo
+
+[![PyPI version](https://img.shields.io/pypi/v/bioalgo.svg)](https://pypi.org/project/bioalgo/)
+[![Python versions](https://img.shields.io/pypi/pyversions/bioalgo.svg)](https://pypi.org/project/bioalgo/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**bioalgo** is a lightweight, pure-Python library for nature-inspired, bio-inspired, and metaheuristic optimization algorithms. It includes both discrete combinatorial solvers (N-Queens, Traveling Salesman Problem) and continuous multimodal function optimizers.
+
+---
+
+## Algorithms Included
+
+| Algorithm | Type | Description / Operators | Typical Applications |
+| :--- | :--- | :--- | :--- |
+| **Hill Climbing** | Discrete Local Search | Steepest ascent, conflict evaluation, random-restart heuristics | N-Queens, constraint satisfaction |
+| **Simulated Annealing (SA)** | Metaheuristic | Metropolis acceptance criterion ($P = e^{-\Delta E / T}$), 2-opt swaps, geometric cooling | Traveling Salesman Problem (TSP), combinatorial routing |
+| **Particle Swarm Optimization (PSO)** | Swarm Intelligence | Velocity/position updates, cognitive ($\text{pBest}$) and social ($\text{gBest}$) components, inertia damping | Continuous multimodal minimization |
+| **Differential Evolution (DE)** | Evolutionary | Mutation (`DE/rand/1`, `DE/best/1`), binomial crossover ($CR$), one-to-one selection | Non-linear parameter estimation, benchmark optimization |
+| **Biogeography-Based Optimization (BBO)** | Ecological | Species migration ($\lambda, \mu$), Habitat Suitability Index (HSI), elitism, mutation | Continuous global optimization |
+| **Firefly Algorithm (FA)** | Swarm Intelligence | Light intensity, distance attractiveness ($\beta(r) = \beta_0 e^{-\gamma r^2}$), randomized step damping | Multimodal landscapes with multiple local optima |
+
+---
+
+## Installation
+
+Install via `pip`:
+
+```bash
+pip install bioalgo
+```
+
+Or install in development/editable mode:
+
+```bash
+git clone https://github.com/example/bioalgo.git
+cd bioalgo
+pip install -e .
+```
+
+---
+
+## Quickstart
+
+### 1. Particle Swarm Optimization (PSO)
+```python
+from bioalgo import ParticleSwarmOptimization
+from bioalgo.benchmarks import rastrigin
+
+# Optimize the multimodal Rastrigin function in 5 dimensions
+pso = ParticleSwarmOptimization(
+    cost_func=rastrigin,
+    dim=5,
+    bounds=(-5.12, 5.12),
+    num_particles=40
+)
+
+best_vector, best_cost, history = pso.optimize(max_iter=100)
+print(f"Optimal Cost: {best_cost:.6e}")
+print(f"Optimal Solution: {best_vector}")
+```
+
+### 2. Differential Evolution (DE)
+```python
+from bioalgo import DifferentialEvolution
+from bioalgo.benchmarks import ackley
+
+de = DifferentialEvolution(
+    cost_func=ackley,
+    dim=5,
+    bounds=(-32.768, 32.768),
+    pop_size=40,
+    strategy="best/1/bin"
+)
+
+best_vector, best_cost, history = de.optimize(max_generations=100)
+print(f"Ackley Minimum: {best_cost:.6e}")
+```
+
+### 3. Solve N-Queens with Hill Climbing
+```python
+from bioalgo import NQueensProblem, HillClimbing
+
+problem = NQueensProblem(n=8)
+solver = HillClimbing(problem)
+solution, restarts, steps = solver.search_with_restarts(max_restarts=50)
+
+print(f"Solved in {restarts} restart(s) and {steps} steps:")
+print(problem.render_board(solution))
+```
+
+### 4. Traveling Salesman Problem (TSP) with Simulated Annealing
+```python
+from bioalgo import TravelingSalesmanProblem, SimulatedAnnealing
+
+problem = TravelingSalesmanProblem()
+sa = SimulatedAnnealing(problem, initial_temp=1000.0, cooling_rate=0.995)
+
+best_tour, best_distance, history = sa.optimize(seed=42)
+print(f"Best Tour Length: {best_distance:.2f}")
+print("Tour Sequence:", " -> ".join(best_tour))
+```
+
+---
+
+## Built-in Benchmark Functions
+
+`bioalgo.benchmarks` includes standard continuous functions:
+- `sphere(x)`
+- `rastrigin(x)`
+- `ackley(x)`
+- `rosenbrock(x)`
+- `griewank(x)`
+
+---
+
+## Command Line Interface (CLI)
+
+`bioalgo` comes with a command-line interface:
+
+```bash
+# Solve 8-Queens and render the board
+bioalgo nqueens -n 8 --render
+
+# Solve Traveling Salesman Problem
+bioalgo tsp --temp 1000 --cooling 0.995
+
+# Optimize a continuous benchmark using PSO, DE, BBO, or FA
+bioalgo optimize pso --func rastrigin --dim 5 --iters 100
+bioalgo optimize de --func ackley --dim 5 --iters 100
+bioalgo optimize bbo --func sphere --dim 5 --iters 100
+bioalgo optimize fa --func rastrigin --dim 5 --iters 100
+```
+
+---
+
+## Building and Publishing to PyPI
+
+### 1. Build the Distribution Archives
+```bash
+python -m build
+```
+This produces `.tar.gz` (source distribution) and `.whl` (built wheel) in `dist/`.
+
+### 2. Check Package Metadata
+```bash
+twine check dist/*
+```
+
+### 3. Test on TestPyPI (Recommended first)
+```bash
+twine upload --repository testpypi dist/*
+```
+
+### 4. Upload to Production PyPI
+```bash
+twine upload dist/*
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

bioalgo-0.1.0/pyproject.toml

@@ -0,0 +1,65 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "bioalgo"
+version = "0.1.0"
+description = "A lightweight, modular Python toolkit for bio-inspired and nature-inspired metaheuristic optimization algorithms."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+authors = [
+    { name = "Developer", email = "developer@example.com" }
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Education",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+keywords = [
+    "optimization",
+    "metaheuristics",
+    "bio-inspired",
+    "nature-inspired",
+    "particle-swarm-optimization",
+    "differential-evolution",
+    "simulated-annealing",
+    "firefly-algorithm",
+    "biogeography-based-optimization",
+    "hill-climbing",
+    "n-queens",
+    "traveling-salesman-problem",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "build",
+    "twine",
+]
+
+[project.scripts]
+bioalgo = "bioalgo.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/example/bioalgo"
+Repository = "https://github.com/example/bioalgo"
+Documentation = "https://github.com/example/bioalgo#readme"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]

bioalgo-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

bioalgo-0.1.0/src/bioalgo/__init__.py

@@ -0,0 +1,70 @@
+"""
+bioalgo: Bio-Inspired & Nature-Inspired Metaheuristic Optimization Library.
+
+Algorithms included:
+  - Hill Climbing (N-Queens, local search)
+  - Simulated Annealing (TSP, Metropolis criterion)
+  - Particle Swarm Optimization (PSO, continuous global optimization)
+  - Differential Evolution (DE, continuous multimodal optimization)
+  - Biogeography-Based Optimization (BBO, migration & mutation)
+  - Firefly Algorithm (FA, multimodal attraction & brightness)
+
+Utility functions:
+  - bioalgo.menu(): Launches interactive code viewer and runner.
+  - bioalgo.run_all(): Runs all 6 algorithms sequentially.
+  - bioalgo.print_code(): Prints code of a program.
+  - bioalgo.print_all_codes(): Prints code of all programs.
+"""
+
+from bioalgo import benchmarks
+from bioalgo.bbo import BiogeographyBasedOptimization, Habitat
+from bioalgo.differential_evolution import DifferentialEvolution
+from bioalgo.firefly import FireflyAlgorithm
+from bioalgo.hill_climbing import HillClimbing, NQueensProblem, solve_n_queens
+from bioalgo.pso import Particle, ParticleSwarmOptimization
+from bioalgo.runner import (
+    menu,
+    print_all_codes,
+    print_code,
+    print_menu,
+    run_all,
+    run_bbo,
+    run_differential_evolution,
+    run_firefly,
+    run_hill_climbing,
+    run_pso,
+    run_simulated_annealing,
+)
+from bioalgo.simulated_annealing import (
+    SimulatedAnnealing,
+    TravelingSalesmanProblem,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "benchmarks",
+    "HillClimbing",
+    "NQueensProblem",
+    "solve_n_queens",
+    "SimulatedAnnealing",
+    "TravelingSalesmanProblem",
+    "Particle",
+    "ParticleSwarmOptimization",
+    "DifferentialEvolution",
+    "Habitat",
+    "BiogeographyBasedOptimization",
+    "FireflyAlgorithm",
+    "run_all",
+    "menu",
+    "print_menu",
+    "print_code",
+    "print_all_codes",
+    "run_hill_climbing",
+    "run_simulated_annealing",
+    "run_pso",
+    "run_differential_evolution",
+    "run_bbo",
+    "run_firefly",
+    "__version__",
+]

bioalgo-0.1.0/src/bioalgo/bbo.py

@@ -0,0 +1,103 @@
+"""
+Biogeography-Based Optimization (BBO) Algorithm.
+"""
+
+import random
+from typing import Callable, List, Optional, Sequence, Tuple
+
+
+class Habitat:
+    """Represents an island/habitat with SIVs and HSI."""
+
+    def __init__(self, siv: List[float], cost: float):
+        self.siv = list(siv)
+        self.cost = cost
+        self.lambda_rate = 0.0
+        self.mu_rate = 0.0
+
+
+class BiogeographyBasedOptimization:
+    """Dan Simon's Biogeography-Based Optimization (BBO) solver."""
+
+    def __init__(
+        self,
+        cost_func: Callable[[Sequence[float]], float],
+        dim: int,
+        bounds: Tuple[float, float] = (-5.0, 5.0),
+        num_habitats: int = 50,
+        p_mutation: float = 0.05,
+        i_max: float = 1.0,
+        e_max: float = 1.0,
+        elite_count: int = 2,
+    ):
+        self.cost_func = cost_func
+        self.dim = dim
+        self.bounds = bounds
+        self.num_habitats = num_habitats
+        self.p_mutation = p_mutation
+        self.i_max = i_max
+        self.e_max = e_max
+        self.elite_count = elite_count
+
+    def optimize(
+        self, max_generations: int = 100, seed: Optional[int] = None
+    ) -> Tuple[List[float], float, List[float]]:
+        """
+        Executes BBO optimization.
+        Returns: (best_siv, best_cost, history)
+        """
+        if seed is not None:
+            random.seed(seed)
+
+        low, high = self.bounds
+        habitats: List[Habitat] = []
+
+        for _ in range(self.num_habitats):
+            siv = [random.uniform(low, high) for _ in range(self.dim)]
+            habitats.append(Habitat(siv, self.cost_func(siv)))
+
+        history = []
+
+        for _ in range(max_generations):
+            habitats.sort(key=lambda h: h.cost)
+            history.append(habitats[0].cost)
+
+            # Assign migration rates
+            for rank_idx, hab in enumerate(habitats):
+                rank = self.num_habitats - rank_idx
+                hab.lambda_rate = self.i_max * (1.0 - (rank / self.num_habitats))
+                hab.mu_rate = self.e_max * (rank / self.num_habitats)
+
+            total_mu = sum(h.mu_rate for h in habitats)
+            new_habitats: List[Habitat] = []
+
+            # Retain elites
+            for e in range(self.elite_count):
+                new_habitats.append(Habitat(habitats[e].siv, habitats[e].cost))
+
+            # Non-elite migration & mutation
+            for i in range(self.elite_count, self.num_habitats):
+                new_siv = list(habitats[i].siv)
+                for j in range(self.dim):
+                    if random.random() < habitats[i].lambda_rate:
+                        rand_pick = random.uniform(0, total_mu)
+                        running = 0.0
+                        selected_k = 0
+                        for k_idx, h in enumerate(habitats):
+                            running += h.mu_rate
+                            if running >= rand_pick:
+                                selected_k = k_idx
+                                break
+                        new_siv[j] = habitats[selected_k].siv[j]
+
+                    # Mutation
+                    if random.random() < self.p_mutation:
+                        pert = random.gauss(0, 0.1 * (high - low))
+                        new_siv[j] = max(low, min(high, new_siv[j] + pert))
+
+                new_habitats.append(Habitat(new_siv, self.cost_func(new_siv)))
+
+            habitats = new_habitats
+
+        habitats.sort(key=lambda h: h.cost)
+        return habitats[0].siv, habitats[0].cost, history

bioalgo-0.1.0/src/bioalgo/benchmarks.py

@@ -0,0 +1,66 @@
+"""
+Standard mathematical benchmark functions for continuous optimization.
+"""
+
+import math
+from typing import List, Sequence
+
+
+def sphere(x: Sequence[float]) -> float:
+    """
+    Sphere benchmark function (Unimodal).
+    Global minimum: f(0, ..., 0) = 0.0
+    Domain: [-5.12, 5.12]^D
+    """
+    return sum(xi ** 2 for xi in x)
+
+
+def rastrigin(x: Sequence[float]) -> float:
+    """
+    Rastrigin benchmark function (Highly Multimodal).
+    Global minimum: f(0, ..., 0) = 0.0
+    Domain: [-5.12, 5.12]^D
+    """
+    d = len(x)
+    return 10.0 * d + sum(xi ** 2 - 10.0 * math.cos(2.0 * math.pi * xi) for xi in x)
+
+
+def ackley(x: Sequence[float]) -> float:
+    """
+    Ackley benchmark function (Multimodal with many local minima).
+    Global minimum: f(0, ..., 0) = 0.0
+    Domain: [-32.768, 32.768]^D
+    """
+    d = len(x)
+    if d == 0:
+        return 0.0
+    sum_sq = sum(xi ** 2 for xi in x)
+    sum_cos = sum(math.cos(2.0 * math.pi * xi) for xi in x)
+    term1 = -20.0 * math.exp(-0.2 * math.sqrt(sum_sq / d))
+    term2 = -math.exp(sum_cos / d)
+    return term1 + term2 + 20.0 + math.e
+
+
+def rosenbrock(x: Sequence[float]) -> float:
+    """
+    Rosenbrock banana valley function.
+    Global minimum: f(1, ..., 1) = 0.0
+    Domain: [-5.0, 10.0]^D
+    """
+    return sum(
+        100.0 * (x[i + 1] - x[i] ** 2) ** 2 + (1.0 - x[i]) ** 2
+        for i in range(len(x) - 1)
+    )
+
+
+def griewank(x: Sequence[float]) -> float:
+    """
+    Griewank benchmark function.
+    Global minimum: f(0, ..., 0) = 0.0
+    Domain: [-600.0, 600.0]^D
+    """
+    sum_term = sum(xi ** 2 for xi in x) / 4000.0
+    prod_term = 1.0
+    for i, xi in enumerate(x, start=1):
+        prod_term *= math.cos(xi / math.sqrt(i))
+    return sum_term - prod_term + 1.0