samyama-optimization 0.2.0

High-performance metaheuristic optimization algorithms (Jaya, Rao, TLBO, BMR, BWR, QOJaya, ITLBO) in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

# Samyama Optimization Engine (Rust)

A high-performance library implementing metaphor-less metaheuristic optimization algorithms.

## Algorithms
- **Jaya**: Parameter-less optimization (Toward best, away from worst).
- **Rao (1, 2, 3)**: Metaphor-less algorithms using best, worst, and mean solutions.
- **TLBO**: Teaching-Learning-Based Optimization.
- **BMR**: Best-Mean-Random.
- **BWR**: Best-Worst-Random.

## Features
- **Parallel Evaluation**: Automatic multi-threaded fitness calculation via `rayon`.
- **Zero-Copy**: Minimal overhead when operating on large vectors.
- **Python Bindings**: Easy integration with Python data science stacks.

## Usage (Rust)
```rust
use samyama_optimization::algorithms::*;
use samyama_optimization::common::*;
use ndarray::array;

let problem = SimpleProblem {
    objective_func: |x| x.iter().map(|&v| v * v).sum(),
    dim: 2,
    lower: array![-10.0, -10.0],
    upper: array![10.0, 10.0],
};

let solver = JayaSolver::new(SolverConfig::default());
let result = solver.solve(&problem);
println!("Best: {:?}", result.best_variables);
```

## Usage (Python)
```python
import samyama_optimization as so
import numpy as np

def sphere(x):
    return np.sum(x**2)

res = so.solve_jaya(sphere, np.array([-10, -10]), np.array([10, 10]))
print(f"Best fitness: {res.best_fitness}")
```