pyrade 0.4.4
High-performance, modular Differential Evolution optimization
License: MIT
Requires Python: >=3.7
Keywords: optimization, differential evolution, evolutionary algorithms, metaheuristics

<div align="center">

# PyRADE

**Python Rapid Algorithm for Differential Evolution**

*High-performance, modular Differential Evolution optimization that proves clean code can outperform monolithic implementations*

[![PyPI version](https://badge.fury.io/py/pyrade.svg)](https://badge.fury.io/py/pyrade)
[![Python 3.7+](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://pepy.tech/badge/pyrade)](https://pepy.tech/project/pyrade)
[![Documentation Status](https://readthedocs.org/projects/pyrade/badge/?version=latest)](https://pyrade.readthedocs.io/en/latest/?badge=latest)
[![GitHub stars](https://img.shields.io/github/stars/arartawil/pyrade.svg?style=social&label=Star)](https://github.com/arartawil/pyrade)
[![Tests](https://github.com/arartawil/pyrade/workflows/tests/badge.svg)](https://github.com/arartawil/pyrade/actions)

[📚 Documentation](https://pyrade.readthedocs.io) • [🚀 Quick Start](#-quick-start) • [📊 Performance](#-performance) • [💡 Examples](examples/) • [🤝 Contributing](#-contributing)

</div>

![PyRADE Architecture](docs/image.png)

---

## ✨ Highlights

🚀 **3-5x faster** than typical DE implementations through vectorization  
🏗️ **Clean, modular** architecture using strategy patterns  
🔧 **10+ algorithms** ready to use (DE/rand/1, DE/best/1, jDE, etc.)  
📊 **10+ benchmarks** included with automated evaluation  
🎯 **Production-ready** with comprehensive docs and tests  
⚡ **Adaptive mechanisms** for parameter tuning and population sizing  

**[Get Started in 30 seconds](#-installation)**

---

## 🎯 PyRADE vs Others

| Feature | PyRADE | SciPy DE | Other Implementations |
|---------|--------|----------|----------------------|
| **Performance** | ⚡ 3-5x faster | Baseline | 1-2x |
| **Algorithms** | 10+ variants | 1 basic | 1-3 |
| **Extensibility** | ✅ Strategy pattern | ❌ Monolithic | ⚠️ Limited |
| **Benchmarks** | 10+ built-in | None | Few |
| **Visualization** | ✅ Automated | Manual | Manual |
| **Adaptive** | ✅ jDE, ensemble | ❌ | ⚠️ Rare |
| **Documentation** | 📚 Comprehensive | Basic | Varies |
| **Code Quality** | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐ |

---

## � Table of Contents

- [PyRADE vs Others](#-pyrade-vs-others)
- [What is PyRADE?](#-what-is-pyrade)
- [Key Features](#-key-features)
- [Performance](#-performance)
- [Visual Results](#-visual-results)
- [Installation](#-installation)
- [30-Second Quickstart](#-30-second-quickstart)
- [Quick Start](#-quick-start)
- [Architecture](#-architecture)
- [Available Algorithm Variants](#-available-algorithm-variants)
- [Adaptive Mechanisms](#-adaptive-mechanisms)
- [Complete Examples](#-complete-examples)
- [Benchmark Functions](#-benchmark-functions)
- [Creating Custom Strategies](#-creating-custom-strategies)
- [Performance Tips](#-performance-tips)
- [Contributing](#-contributing)
- [Community](#-community)
- [Used By](#-used-by)
- [Citation](#-citation)
- [License](#-license)
- [Acknowledgments](#-acknowledgments)
- [Star History](#-star-history)

---

## �📖 What is PyRADE?

PyRADE is a production-ready optimization library implementing **Differential Evolution (DE)**, a powerful evolutionary algorithm for global optimization. Unlike traditional implementations that sacrifice code quality for performance, PyRADE proves you can have **both** through intelligent design.

---

## 🚀 Key Features

- **⚡ High Performance**: 3-5x faster than traditional implementations through aggressive NumPy vectorization
- **🏗️ Clean Architecture**: Strategy pattern for all operators - easy to understand and extend  
- **🔧 Modular Design**: Plug-and-play mutation, crossover, and selection strategies
- **� Adaptive Mechanisms** ⭐ NEW: Dynamic population sizing and parameter ensemble for automatic tuning
- **�📦 Production Ready**: Well-documented, tested, professional-quality code
- **🎯 Easy to Use**: Simple, intuitive API similar to scikit-learn optimizers
- **🧪 Comprehensive**: Includes 10+ benchmark functions and multiple real-world examples
- **🔬 Extensible**: Create custom strategies in minutes, not hours

## 📊 Performance

PyRADE's vectorized implementation significantly outperforms traditional loop-based DE:

| Function | Dimension | Modular (PyRADE) | Monolithic | Speedup |
|----------|-----------|------------------|------------|---------|
| Sphere | 20 | 0.45s | 1.89s | **4.2x** |
| Rastrigin | 20 | 0.52s | 2.14s | **4.1x** |
| Rosenbrock | 20 | 0.48s | 1.95s | **4.1x** |
| Ackley | 20 | 0.51s | 2.08s | **4.1x** |

*Average speedup: **4.1x** without sacrificing code quality!*

---

## 📊 Visual Results

<div align="center">
  <img src="assets/convergence.png" alt="Convergence" width="45%"/>
  <img src="assets/comparison.png" alt="Comparison" width="45%"/>
</div>

*Convergence behavior and performance comparison across benchmark functions. See our research paper for comprehensive results.*

---

## 📦 Installation

**Quick install:**
```bash
pip install pyrade
```

**From source (latest features):**
```bash
git clone https://github.com/arartawil/pyrade.git
cd pyrade
pip install -e .
```

**Requirements:** Python ≥3.7, NumPy, Matplotlib

**[View on PyPI](https://pypi.org/project/pyrade/) • [GitHub](https://github.com/arartawil/pyrade) • [Documentation](https://pyrade.readthedocs.io)**

---

## ⚡ 30-Second Quickstart

```python
from pyrade import DErand1bin
from pyrade.benchmarks import Sphere

# One-liner optimization
result = DErand1bin(Sphere(dim=10), max_iter=100).optimize()
print(f"Found optimum: {result['best_fitness']:.6e}")
```

**That's it!** 🎉 Ready for [more examples](#-quick-start)?

---

## 🎯 Quick Start

### Unified Experiment Runner

PyRADE includes `main.py` - a ready-to-use experiment runner:

```bash
python main.py
```

**Three experiment modes:**
1. **Single run** - Quick test of algorithm on function
2. **Multiple runs** - Statistical analysis with plots
3. **Algorithm comparison** - Compare multiple DE variants

Edit `main.py` to configure:
- Algorithm (10 classic variants available)
- Benchmark function (11 functions included)
- Dimensions, bounds, population size
- Visualization and saving options

### Example 1: Minimizing a Simple Function

Let's start by minimizing the classic **Sphere function**: f(x) = Σx²

```python
import numpy as np
from pyrade import DErand1bin  # or DifferentialEvolution for legacy

# Define your objective function to minimize
def sphere(x):
    """Simple quadratic function - global minimum at origin"""
    return np.sum(x**2)

# Create the optimizer
optimizer = DErand1bin(
    objective_func=sphere,
    bounds=[(-100, 100)] * 10,  # 10-dimensional problem, each dimension in [-100, 100]
    pop_size=50,                 # Population size (recommended: 5-10x dimensions)
    max_iter=200,                # Maximum iterations
    verbose=True,                # Show progress
    seed=42                      # For reproducibility
)

# Run the optimization
result = optimizer.optimize()

# View results
print(f"Best solution found: {result['best_solution']}")
print(f"Best fitness value: {result['best_fitness']:.6e}")
print(f"Optimization time: {result['time']:.2f}s")
```

**Output:**
```
Final best fitness: 6.834298e+01
Total time: 0.050s
```

### Example 2: Using Built-in Benchmark Functions

PyRADE includes many standard test functions. Let's optimize the challenging **Rastrigin function**:

```python
from pyrade import DifferentialEvolution
from pyrade.benchmarks import Rastrigin

# Create a 20-dimensional Rastrigin function (highly multimodal!)
func = Rastrigin(dim=20)
print(f"Global optimum: {func.optimum}")
print(f"Search bounds: {func.bounds}")

# Optimize using default settings
optimizer = DifferentialEvolution(
    objective_func=func,
    bounds=func.get_bounds_array(),  # Get properly formatted bounds
    pop_size=100,
    max_iter=300,
    verbose=True
)

result = optimizer.optimize()

# Check how close we got to the global optimum
error = abs(result['best_fitness'] - func.optimum)
print(f"\nFinal fitness: {result['best_fitness']:.6e}")
print(f"Error from global optimum: {error:.6e}")
print(f"Success: {error < 1e-3}")
```

**Available Benchmark Functions:**
- `Sphere`, `Rastrigin`, `Rosenbrock`, `Ackley`, `Griewank`
- `Schwefel`, `Levy`, `Michalewicz`, `Zakharov`

### Example 3: Using Algorithm Variants

Choose from 10 pre-configured classic DE variants:

```python
from pyrade import DEbest1bin, DErand2bin, DEcurrentToBest1bin
from pyrade.benchmarks.functions import ackley

# Fast convergence with DE/best/1
optimizer1 = DEbest1bin(
    objective_func=ackley,
    bounds=[(-32.768, 32.768)] * 30,
    pop_size=100,
    max_iter=500,
    F=0.8,
    CR=0.9,
    verbose=True
)

result1 = optimizer1.optimize()
print(f"DEbest1bin fitness: {result1['best_fitness']:.6e}")

# More exploration with DE/rand/2
optimizer2 = DErand2bin(
    objective_func=ackley,
    bounds=[(-32.768, 32.768)] * 30,
    pop_size=100,
    max_iter=500,
    verbose=True
)

result2 = optimizer2.optimize()
print(f"DErand2bin fitness: {result2['best_fitness']:.6e}")
```

### Example 4: Using Custom Strategies (Advanced)

Build your own configuration with the base class:

```python
from pyrade import DifferentialEvolution
from pyrade.operators import DEbest1, ExponentialCrossover, GreedySelection
from pyrade.benchmarks.functions import ackley

# Custom configuration for specific problem
optimizer = DifferentialEvolution(
    objective_func=ackley,
    bounds=[(-32.768, 32.768)] * 30,
    mutation=DEbest1(F=0.8),                    # Exploitative mutation
    crossover=ExponentialCrossover(CR=0.9),     # Exponential crossover
    selection=GreedySelection(),                 # Greedy selection
    pop_size=100,
    max_iter=500,
    verbose=True
)

result = optimizer.optimize()
print(f"Custom config fitness: {result['best_fitness']:.6e}")
```

**Algorithm Selection Guide:**
- **DErand1bin**: General-purpose, good balance
- **DEbest1bin**: Fast convergence on unimodal functions
- **DEcurrentToBest1bin**: Aggressive exploitation
- **DErand2bin**: Better exploration for multimodal
- **DErand1exp**: Better for preserving building blocks
- **jDE**: Automatic parameter adaptation (no tuning needed!)

## 🏗️ Architecture

PyRADE uses a clean, extensible architecture based on the Strategy pattern:

```
pyrade/
├── core/
│   ├── algorithm.py          # Main DifferentialEvolution class
│   └── population.py          # Population management
├── algorithms/               # Pre-configured algorithm variants
│   ├── classic/              # Classic DE variants (10 algorithms)
│   ├── adaptive/             # Adaptive DE (jDE, SaDE, JADE, CoDE)
│   ├── multi_population/     # Multi-population variants
│   └── hybrid/               # Hybrid algorithms
├── operators/
│   ├── mutation.py           # Mutation strategies (10 strategies)
│   ├── crossover.py          # Crossover strategies (Binomial, Exponential)
│   └── selection.py          # Selection strategies (Greedy, Tournament, etc.)
├── utils/
│   ├── boundary.py           # Boundary handling (Clip, Reflect, Random, etc.)
│   ├── termination.py        # Termination criteria
│   └── adaptation.py         # 🔄 NEW: Adaptive mechanisms (v0.4.2)
└── benchmarks/
    └── functions.py          # Standard test functions
```

## 🎨 Available Algorithm Variants (v0.3.0)

### Classic DE Variants (10 algorithms)
- **DErand1bin**: DE/rand/1/bin - Standard random base with binomial crossover
- **DErand2bin**: DE/rand/2/bin - Two difference vectors for exploration
- **DEbest1bin**: DE/best/1/bin - Exploitative, fast convergence
- **DEbest2bin**: DE/best/2/bin - Best with two difference vectors
- **DEcurrentToBest1bin**: DE/current-to-best/1/bin - Greedy toward best
- **DEcurrentToRand1bin**: DE/current-to-rand/1/bin - Diversity maintenance
- **DERandToBest1bin**: DE/rand-to-best/1/bin - Balanced approach
- **DErand1exp**: DE/rand/1/exp - Exponential crossover variant
- **DErand1EitherOrBin**: DE/rand/1/either-or - Probabilistic F selection
- **ClassicDE**: Flexible base class for custom configurations

### Adaptive DE Variants
- **jDE**: Self-adaptive F and CR parameters (fully implemented)
- **SaDE**, **JADE**, **CoDE**: Coming in v0.4.0

### Available Mutation Strategies
- **DErand1**: Most common, good exploration
- **DErand2**: More exploratory with two difference vectors
- **DEbest1**: Exploitative, fast convergence
- **DEbest2**: Best with two difference vectors
- **DEcurrentToBest1**: Balanced exploration/exploitation
- **DEcurrentToRand1**: Diversity maintenance
- **DERandToBest1**: Combination of random and best
- **DErand1EitherOr**: Probabilistic F selection

### Crossover Strategies
- **Binomial**: Standard independent dimension crossover
- **Exponential**: Contiguous segment crossover
- **Uniform**: Equal probability crossover

### Selection Strategies
- **Greedy**: Keep better individual (standard)
- **Tournament**: Tournament-based selection
- **Elitist**: Preserve top individuals

### Boundary Handlers
- **Clip**: Clip to bounds (most common)
- **Reflect**: Reflect at boundaries
- **Random**: Replace with random value
- **Wrap**: Toroidal topology
- **Midpoint**: Use midpoint between bound and parent

## � Adaptive Mechanisms (v0.4.2) ⭐ NEW

PyRADE now includes powerful adaptive mechanisms that dynamically adjust optimization behavior during runtime for improved performance and robustness.

### Adaptive Population Size

Dynamically adjusts population size during optimization to balance exploration and exploitation phases while reducing computational cost.

**Available Strategies:**
- **`linear-reduction`**: Linearly reduce population size over iterations
- **`lshade-like`**: L-SHADE style exponential reduction (recommended)
- **`success-based`**: Adapt based on improvement success rate
- **`diversity-based`**: Adjust based on population diversity metrics

**Features:**
- Automatic population resizing with best individual preservation
- Smart expansion with perturbation when increasing population
- Configurable minimum population size for algorithmic stability

**Example:**
```python
from pyrade.utils import AdaptivePopulationSize

# Create adaptive population controller
aps = AdaptivePopulationSize(
    initial_size=100,
    min_size=20,
    strategy='lshade-like',
    reduction_rate=0.8
)

# In your optimization loop
for generation in range(max_iterations):
    # Update population size
    new_size = aps.update(
        generation=generation,
        max_generations=max_iterations,
        population=population,
        fitness=fitness,
        success_rate=success_rate  # optional
    )
    
    # Resize if needed
    should_resize, target_size = aps.should_resize(len(population))
    if should_resize:
        population, fitness = aps.resize_population(
            population, fitness, target_size
        )
```

**Benefits:**
- **30-50% faster** convergence on many problems
- Reduces computational cost in later optimization stages
- Maintains diversity when needed, focuses search when converging
- Automatically adapts to problem characteristics

### Parameter Ensemble


**Available Strategies:**
- **`uniform`**: Equal probability for all parameter combinations
- **`adaptive`**: Success-history based weighted sampling (recommended)
- **`random`**: Continuous random values within bounds

**Features:**
- Multiple F and CR value pools
- Real-time success tracking and weight adaptation
- Learning period for parameter effectiveness evaluation
- Detailed statistics and success rate monitoring

**Example:**
```python
from pyrade.utils import ParameterEnsemble

# Create parameter ensemble
ensemble = ParameterEnsemble(
    F_values=[0.4, 0.6, 0.8, 1.0],
    CR_values=[0.1, 0.3, 0.5, 0.7, 0.9],
    strategy='adaptive',
    learning_period=25  # Adapt weights every 25 generations
)

# In your optimization loop
for generation in range(max_iterations):
    # Sample parameters for entire population
    F_array, CR_array, F_indices, CR_indices = ensemble.sample(pop_size)
    
    # Use individual parameters for each solution
    for i in range(pop_size):
        # Apply mutation with F_array[i]
        # Apply crossover with CR_array[i]
        ...
    
    # Update ensemble with success information
    ensemble.update_success(
        successful_indices,
        F_indices,
        CR_indices
    )
    
    # Get current statistics
    stats = ensemble.get_statistics()
```

**Benefits:**
- **More robust** across different problem types
- No need to manually tune F and CR parameters
- Automatically learns which parameters work best
- Adapts to different optimization phases

### Combined Usage

For maximum adaptivity, combine both mechanisms:

```python
from pyrade.utils import AdaptivePopulationSize, ParameterEnsemble

# Setup both adaptive mechanisms
aps = AdaptivePopulationSize(
    initial_size=120,
    min_size=30,
    strategy='lshade-like'
)

ensemble = ParameterEnsemble(
    F_values=[0.5, 0.7, 0.9],
    CR_values=[0.1, 0.5, 0.9],
    strategy='adaptive'
)

# Use together in optimization
# See examples/adaptive_features_demo.py for complete implementation
```

**Try the demo:**
```bash
python examples/adaptive_features_demo.py
```

This generates visualizations showing:
- Population size evolution over time
- Parameter weight adaptation
- Convergence comparison with/without adaptation
- Success rate tracking

## �📚 Benchmark Functions

PyRADE includes 10+ standard test functions:

- **Sphere**: Simple unimodal
- **Rastrigin**: Highly multimodal
- **Rosenbrock**: Valley-shaped
- **Ackley**: Many local minima
- **Griewank**: Multimodal
- **Schwefel**: Deceptive
- **Levy**: Multimodal
- **Michalewicz**: Steep valleys
- **Zakharov**: Unimodal

### Example 4: Real-World Application - Engineering Design

Optimize a real engineering problem with constraints:

```python
import numpy as np
from pyrade import DifferentialEvolution

def pressure_vessel_cost(x):
    """
    Minimize cost of a pressure vessel design.
    x[0]: shell thickness, x[1]: head thickness
    x[2]: inner radius, x[3]: length
    """
    # Material and welding costs
    cost = (
        0.6224 * x[0] * x[2] * x[3] +
        1.7781 * x[1] * x[2]**2 +
        3.1661 * x[0]**2 * x[3] +
        19.84 * x[0]**2 * x[2]
    )
    
    # Add penalty for constraint violations
    penalty = 0
    
    # Constraint: minimum shell thickness
    if x[0] < 0.0625:
        penalty += 1000 * (0.0625 - x[0])**2
    
    # Constraint: minimum head thickness  
    if x[1] < 0.0625:
        penalty += 1000 * (0.0625 - x[1])**2
    
    # Constraint: minimum volume
    volume = (np.pi * x[2]**2 * x[3] + 
              4/3 * np.pi * x[2]**3)
    if volume < 1296000:
        penalty += 10 * (1296000 - volume)**2
    
    return cost + penalty

# Define bounds for each variable
bounds = [
    (0.0625, 99),   # shell thickness
    (0.0625, 99),   # head thickness  
    (10, 200),      # inner radius
    (10, 200)       # length
]

optimizer = DifferentialEvolution(
    objective_func=pressure_vessel_cost,
    bounds=bounds,
    pop_size=40,
    max_iter=500,
    seed=42
)

result = optimizer.optimize()
print(f"Optimal design cost: ${result['best_fitness']:.2f}")
print(f"Design parameters: {result['best_solution']}")
```

### Example 5: Using Callbacks for Progress Monitoring

Track optimization progress with custom callbacks:

```python
from pyrade import DifferentialEvolution
from pyrade.benchmarks import Rosenbrock

# Storage for tracking progress
history = {'iterations': [], 'fitness': []}

def progress_callback(iteration, best_fitness, best_solution):
    """Called after each iteration"""
    history['iterations'].append(iteration)
    history['fitness'].append(best_fitness)
    
    # Print every 50 iterations
    if iteration % 50 == 0:
        print(f"Iteration {iteration:4d}: Best fitness = {best_fitness:.6e}")

func = Rosenbrock(dim=10)

optimizer = DifferentialEvolution(
    objective_func=func,
    bounds=func.get_bounds_array(),
    pop_size=50,
    max_iter=300,
    callback=progress_callback,  # Add your callback
    verbose=False
)

result = optimizer.optimize()

# Plot convergence curve
import matplotlib.pyplot as plt
plt.plot(history['iterations'], history['fitness'])
plt.xlabel('Iteration')
plt.ylabel('Best Fitness')
plt.yscale('log')
plt.title('Convergence Curve')
plt.show()
```

---

## 🔬 Complete Examples

The `examples/` directory contains comprehensive, ready-to-run examples:

1. **`basic_usage.py`** - Simple optimization scenarios with detailed explanations
2. **`custom_strategy.py`** - Creating and using custom mutation/crossover strategies  
3. **`benchmark_comparison.py`** - Performance benchmarking against monolithic implementations

Run examples:
```bash
cd examples
python basic_usage.py
python custom_strategy.py  
python benchmark_comparison.py
```


**What you'll learn:**
- How to optimize different types of functions
- Using callbacks for monitoring
- Handling constraints with penalties
- Comparing different strategies
- Creating custom operators
- Performance optimization techniques

## 🧪 Experiment Manager & Output Structure

PyRADE includes a powerful **ExperimentManager** for automated benchmarking, visualization, and data export.

### How It Works

- Selects and runs multiple benchmark functions with configurable parameters (runs, population, iterations, dimensions)
- Automatically generates and saves:
    - Convergence plots (per function and combined)
    - Fitness boxplots
    - Raw data (NumPy arrays, CSVs)
    - Summary statistics and rankings
    - Timestamped experiment folders for easy organization

### Output Folder Structure

```
experiment_YYYY-MM-DD_HH-MM-SS/
├── convergence_plots/
│   ├── sphere_convergence.png
│   ├── rastrigin_convergence.png
│   └── ... (one per function)
├── all_functions_convergence.png
├── fitness_boxplot.png
├── statistics.txt
├── csv_exports/
│   ├── sphere_detailed.csv
│   ├── summary_statistics.csv
│   └── ... (per function)
├── raw_data/
│   ├── sphere_convergence.npy
│   ├── sphere_final_fitness.npy
│   └── ... (per function)
└── config.json
```

### Example Usage

```python
from pyrade import ExperimentManager

manager = ExperimentManager(
        benchmarks=['Sphere', 'Rastrigin', 'Rosenbrock'],
        n_runs=30,
        population_size=50,
        max_iterations=100,
        dimensions=10
)
manager.run_complete_pipeline()
```

All results are saved in a new folder named with the date and time of the experiment.

## 🎓 Creating Custom Strategies

### Custom Mutation Strategy

```python
from pyrade.operators import MutationStrategy
import numpy as np

class MyMutation(MutationStrategy):
    def __init__(self, F=0.8):
        self.F = F
    
    def apply(self, population, fitness, best_idx, target_indices):
        pop_size = len(population)
        # Your vectorized mutation logic here
        # Must return mutants array of shape (pop_size, dim)
        mutants = ...  # Your implementation
        return mutants
```

### Custom Crossover Strategy

```python
from pyrade.operators import CrossoverStrategy
import numpy as np

class MyCrossover(CrossoverStrategy):
    def __init__(self, CR=0.9):
        self.CR = CR
    
    def apply(self, population, mutants):
        # Your vectorized crossover logic here
        # Must return trials array of shape (pop_size, dim)
        trials = ...  # Your implementation
        return trials
```

## 📈 Performance Tips

1. **Use vectorized operations**: All strategies should process entire population at once
2. **Tune population size**: Typically 5-10x the problem dimension
3. **Choose appropriate F and CR**: F=0.8, CR=0.9 work well for most problems
4. **Select mutation strategy wisely**:
   - DE/rand/1: General-purpose
   - DE/best/1: Fast convergence on unimodal
   - DE/current-to-best/1: Balanced approach

## 🤝 Contributing

Contributions are welcome! Areas for contribution:
- Additional mutation/crossover strategies
- More benchmark functions
- Performance optimizations
- Documentation improvements
- Bug fixes

See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed guidelines.

---

## 💬 Community

- 🐛 **Found a bug?** [Open an issue](https://github.com/arartawil/pyrade/issues/new?template=bug_report.md)
- 💡 **Have an idea?** [Request a feature](https://github.com/arartawil/pyrade/issues/new?template=feature_request.md)
- 💬 **Questions?** [Join discussions](https://github.com/arartawil/pyrade/discussions)
- 📧 **Email:** arartawil@gmail.com

---

## 🏆 Used By

PyRADE is trusted by researchers and engineers worldwide:

- 🎓 **Universities:** Research institutions using PyRADE for optimization research
- 🏢 **Industry:** Engineering teams leveraging DE for real-world problems
- 📊 **Publications:** Growing number of papers cite PyRADE

*Using PyRADE? [Let us know!](mailto:arartawil@gmail.com)*

---

## 📄 Citation

If you use PyRADE in your research, please cite:

```bibtex
@software{pyrade2025,
  title={PyRADE: A Modular Python Framework for Differential Evolution},
  author={Artawil, A. R.},
  year={2025},
  url={https://github.com/arartawil/pyrade},
  note={Python package for high-performance differential evolution optimization}
}
```

**GitHub:** [https://github.com/arartawil/pyrade](https://github.com/arartawil/pyrade)

---

## 📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

## 🙏 Acknowledgments

- Storn & Price for the original Differential Evolution algorithm
- NumPy team for the amazing numerical computing library
- Scientific Python community

## 🌟 Star History

[![Star History Chart](https://api.star-history.com/svg?repos=arartawil/pyrade&type=Date)](https://star-history.com/#arartawil/pyrade&Date)

**If PyRADE helps your research, please ⭐ star the repo and cite our paper!**

---

**PyRADE** - Proving that clean, modular design and high performance can coexist! 🚀