{
  "skill": "alterlab-pymoo",
  "evals": [
    {
      "id": "biobjective-nsga2",
      "prompt": "I have a bridge design problem with two conflicting objectives — minimize material cost and minimize deflection. I want the full Pareto front of trade-off solutions and a plot of it.",
      "expected_output": "Invokes alterlab-pymoo: defines the bi-objective problem as an ElementwiseProblem (or selects a benchmark), runs NSGA-II via minimize() with a fixed seed and ('n_gen', N) termination, extracts result.F as the Pareto front, and visualizes the trade-off with a Scatter plot.",
      "assertions": [
        { "type": "should_trigger", "value": true },
        { "type": "output_contains", "value": "NSGA2" },
        { "type": "behavior", "value": "Uses NSGA-II via minimize() with a fixed seed, reads result.F as the Pareto front, and plots the two-objective trade-off with a Scatter plot." }
      ]
    },
    {
      "id": "many-objective-nsga3",
      "prompt": "I'm optimizing a 5-objective engineering design and NSGA-II gives me a poorly spread front. What algorithm and setup should I use, and how do I visualize five objectives?",
      "expected_output": "Invokes alterlab-pymoo: recommends NSGA-III for 4+ objectives, generates reference directions with get_reference_directions (das-dennis), configures NSGA3(ref_dirs=...), runs minimize(), and visualizes with a Parallel Coordinate Plot (PCP) since 5 objectives exceed scatter capability.",
      "assertions": [
        { "type": "should_trigger", "value": true },
        { "type": "behavior", "value": "Recommends NSGA-III with reference directions and a parallel-coordinate plot for the 5-objective case, not a 2D scatter." }
      ]
    },
    {
      "id": "constrained-optimization",
      "prompt": "My optimization problem has two inequality constraints and one equality constraint, and most candidate solutions come out infeasible. How do I formulate the constraints in pymoo and get feasible solutions?",
      "expected_output": "Invokes alterlab-pymoo: shows constraint formulation as g(x) <= 0 (out['G']) and h(x) = 0 (out['H']) inside _evaluate, explains the default feasibility-first handling and checking result.CV, and offers alternatives (ConstraintsAsPenalty, ConstraintsAsObjective, SRES/ISRES) when the feasible region is small.",
      "assertions": [
        { "type": "should_trigger", "value": true },
        { "type": "behavior", "value": "Formulates inequality constraints as g(x) <= 0 and explains feasibility-first handling or a specialized constrained algorithm." }
      ]
    },
    {
      "id": "mcdm-from-front",
      "prompt": "I already ran NSGA-II and have a Pareto front of 100 trade-off solutions, but I need to pick a single preferred design weighting objective two more heavily. How do I choose?",
      "expected_output": "Invokes alterlab-pymoo: normalizes the objectives to [0,1], applies a multi-criteria decision-making method such as PseudoWeights with the user's preference weights (or knee-point / compromise programming), and returns the selected solution's decision variables and objective values.",
      "assertions": [
        { "type": "should_trigger", "value": true },
        { "type": "output_contains", "value": "PseudoWeights" }
      ]
    },
    {
      "id": "near-miss-alterlab-simpy",
      "prompt": "I want to simulate a hospital emergency room where patients arrive randomly and compete for a limited number of doctors, and measure average waiting time and resource utilization over time.",
      "expected_output": "Does NOT invoke this skill; defers to alterlab-simpy. This is a discrete-event simulation of entities contending for shared resources over time, not a multi-objective optimization or Pareto-front computation.",
      "assertions": [
        { "type": "should_not_trigger", "value": true },
        { "type": "output_contains", "value": "alterlab-simpy" }
      ]
    },
    {
      "id": "near-miss-alterlab-scikit-learn",
      "prompt": "I have a labeled tabular dataset and want to tune the hyperparameters of a random forest classifier with cross-validated grid search to maximize accuracy.",
      "expected_output": "Does NOT invoke this skill; defers to alterlab-scikit-learn. Hyperparameter tuning of a supervised ML model via grid search is a machine-learning task, not evolutionary multi-objective optimization with pymoo.",
      "assertions": [
        { "type": "should_not_trigger", "value": true },
        { "type": "output_contains", "value": "alterlab-scikit-learn" }
      ]
    }
  ]
}

# Pymoo Algorithms Reference

Comprehensive reference for optimization algorithms available in pymoo.

## Single-Objective Optimization Algorithms

### Genetic Algorithm (GA)
**Purpose:** General-purpose single-objective evolutionary optimization
**Best for:** Continuous, discrete, or mixed-variable problems
**Algorithm type:** (μ+λ) genetic algorithm

**Key parameters:**
- `pop_size`: Population size (default: 100)
- `sampling`: Initial population generation strategy
- `selection`: Parent selection mechanism (default: Tournament)
- `crossover`: Recombination operator (default: SBX)
- `mutation`: Variation operator (default: Polynomial)
- `eliminate_duplicates`: Remove redundant solutions (default: True)
- `n_offsprings`: Offspring per generation

**Usage:**
```python
from pymoo.algorithms.soo.nonconvex.ga import GA
algorithm = GA(pop_size=100, eliminate_duplicates=True)
```

### Differential Evolution (DE)
**Purpose:** Single-objective continuous optimization
**Best for:** Continuous parameter optimization with good global search
**Algorithm type:** Population-based differential evolution

**Variants:** Multiple DE strategies available (rand/1/bin, best/1/bin, etc.)

### Particle Swarm Optimization (PSO)
**Purpose:** Single-objective optimization through swarm intelligence
**Best for:** Continuous problems, fast convergence on smooth landscapes

### CMA-ES
**Purpose:** Covariance Matrix Adaptation Evolution Strategy
**Best for:** Continuous optimization, particularly for noisy or ill-conditioned problems

### Pattern Search
**Purpose:** Direct search method
**Best for:** Problems where gradient information is unavailable

### Nelder-Mead
**Purpose:** Simplex-based optimization
**Best for:** Local optimization of continuous functions

## Multi-Objective Optimization Algorithms

### NSGA-II (Non-dominated Sorting Genetic Algorithm II)
**Purpose:** Multi-objective optimization with 2-3 objectives
**Best for:** Bi- and tri-objective problems requiring well-distributed Pareto fronts
**Selection strategy:** Non-dominated sorting + crowding distance

**Key features:**
- Fast non-dominated sorting
- Crowding distance for diversity
- Elitist approach
- Binary tournament mating selection

**Key parameters:**
- `pop_size`: Population size (default: 100)
- `sampling`: Initial population strategy
- `crossover`: Default SBX for continuous
- `mutation`: Default Polynomial Mutation
- `survival`: RankAndCrowding

**Usage:**
```python
from pymoo.algorithms.moo.nsga2 import NSGA2
algorithm = NSGA2(pop_size=100)
```

**When to use:**
- 2-3 objectives
- Need for distributed solutions across Pareto front
- Standard multi-objective benchmark

### NSGA-III
**Purpose:** Many-objective optimization (4+ objectives)
**Best for:** Problems with 4 or more objectives requiring uniform Pareto front coverage
**Selection strategy:** Reference direction-based diversity maintenance

**Key features:**
- Reference directions guide population
- Maintains diversity in high-dimensional objective spaces
- Niche preservation through reference points
- Underrepresented reference direction selection

**Key parameters:**
- `ref_dirs`: Reference directions (REQUIRED)
- `pop_size`: Defaults to number of reference directions
- `crossover`: Default SBX
- `mutation`: Default Polynomial Mutation

**Usage:**
```python
from pymoo.algorithms.moo.nsga3 import NSGA3
from pymoo.util.ref_dirs import get_reference_directions

ref_dirs = get_reference_directions("das-dennis", n_dim=4, n_partitions=12)
algorithm = NSGA3(ref_dirs=ref_dirs)
```

**NSGA-II vs NSGA-III:**
- Use NSGA-II for 2-3 objectives
- Use NSGA-III for 4+ objectives
- NSGA-III provides more uniform distribution
- NSGA-II has lower computational overhead

### R-NSGA-II (Reference Point Based NSGA-II)
**Purpose:** Multi-objective optimization with preference articulation
**Best for:** When decision maker has preferred regions of Pareto front

### U-NSGA-III (Unified NSGA-III)
**Purpose:** Improved version handling various scenarios
**Best for:** Many-objective problems with additional robustness

### MOEA/D (Multi-Objective Evolutionary Algorithm based on Decomposition)
**Purpose:** Decomposition-based multi-objective optimization
**Best for:** Problems where decomposition into scalar subproblems is effective

### AGE-MOEA
**Purpose:** Adaptive geometry estimation
**Best for:** Multi and many-objective problems with adaptive mechanisms

### RVEA (Reference Vector guided Evolutionary Algorithm)
**Purpose:** Reference vector-based many-objective optimization
**Best for:** Many-objective problems with adaptive reference vectors

### SMS-EMOA
**Purpose:** S-Metric Selection Evolutionary Multi-objective Algorithm
**Best for:** Problems where hypervolume indicator is critical
**Selection:** Uses dominated hypervolume contribution

## Dynamic Multi-Objective Algorithms

### D-NSGA-II
**Purpose:** Dynamic multi-objective problems
**Best for:** Time-varying objective functions or constraints

### KGB-DMOEA
**Purpose:** Knowledge-guided dynamic multi-objective optimization
**Best for:** Dynamic problems leveraging historical information

## Constrained Optimization

### SRES (Stochastic Ranking Evolution Strategy)
**Purpose:** Single-objective constrained optimization
**Best for:** Heavily constrained problems

### ISRES (Improved SRES)
**Purpose:** Enhanced constrained optimization
**Best for:** Complex constraint landscapes

## Algorithm Selection Guidelines

**For single-objective problems:**
- Start with GA for general problems
- Use DE for continuous optimization
- Try PSO for faster convergence on smooth problems
- Use CMA-ES for difficult/noisy landscapes

**For multi-objective problems:**
- 2-3 objectives: NSGA-II
- 4+ objectives: NSGA-III
- Preference articulation: R-NSGA-II
- Decomposition-friendly: MOEA/D
- Hypervolume focus: SMS-EMOA

**For constrained problems:**
- Feasibility-based survival selection (works with most algorithms)
- Heavy constraints: SRES/ISRES
- Penalty methods for algorithm compatibility

**For dynamic problems:**
- Time-varying: D-NSGA-II
- Historical knowledge useful: KGB-DMOEA

# Pymoo Constraints and Decision Making Reference

Reference for constraint handling and multi-criteria decision making in pymoo.

## Constraint Handling

### Defining Constraints

Constraints are specified in the Problem definition:

```python
from pymoo.core.problem import ElementwiseProblem
import numpy as np

class ConstrainedProblem(ElementwiseProblem):
    def __init__(self):
        super().__init__(
            n_var=2,
            n_obj=2,
            n_ieq_constr=2,    # Number of inequality constraints
            n_eq_constr=1,      # Number of equality constraints
            xl=np.array([0, 0]),
            xu=np.array([5, 5])
        )

    def _evaluate(self, x, out, *args, **kwargs):
        # Objectives
        f1 = x[0]**2 + x[1]**2
        f2 = (x[0]-1)**2 + (x[1]-1)**2

        out["F"] = [f1, f2]

        # Inequality constraints (formulated as g(x) <= 0)
        g1 = x[0] + x[1] - 5  # x[0] + x[1] >= 5 → -(x[0] + x[1] - 5) <= 0
        g2 = x[0]**2 + x[1]**2 - 25  # x[0]^2 + x[1]^2 <= 25

        out["G"] = [g1, g2]

        # Equality constraints (formulated as h(x) = 0)
        h1 = x[0] - 2*x[1]

        out["H"] = [h1]
```

**Constraint formulation rules:**
- Inequality: `g(x) <= 0` (feasible when negative or zero)
- Equality: `h(x) = 0` (feasible when zero)
- Convert `g(x) >= 0` to `-g(x) <= 0`

### Constraint Handling Techniques

#### 1. Feasibility First (Default)
**Mechanism:** Always prefer feasible over infeasible solutions
**Comparison:**
1. Both feasible → compare by objective values
2. One feasible, one infeasible → feasible wins
3. Both infeasible → compare by constraint violation

**Usage:**
```python
from pymoo.algorithms.moo.nsga2 import NSGA2

# Feasibility first is default for most algorithms
algorithm = NSGA2(pop_size=100)
```

**Advantages:**
- Works with any sorting-based algorithm
- Simple and effective
- No parameter tuning

**Disadvantages:**
- May struggle with small feasible regions
- Can ignore good infeasible solutions

#### 2. Penalty Methods
**Mechanism:** Add penalty to objective based on constraint violation
**Formula:** `F_penalized = F + penalty_factor * violation`

**Usage:**
```python
from pymoo.algorithms.soo.nonconvex.ga import GA
from pymoo.constraints.as_penalty import ConstraintsAsPenalty

# Wrap problem with penalty
problem_with_penalty = ConstraintsAsPenalty(problem, penalty=1e6)

algorithm = GA(pop_size=100)
```

**Parameters:**
- `penalty`: Penalty coefficient (tune based on problem scale)

**Advantages:**
- Converts constrained to unconstrained problem
- Works with any optimization algorithm

**Disadvantages:**
- Penalty parameter sensitive
- May need problem-specific tuning

#### 3. Constraint as Objective
**Mechanism:** Treat constraint violation as additional objective
**Result:** Multi-objective problem with M+1 objectives (M original + constraint)

**Usage:**
```python
from pymoo.algorithms.moo.nsga2 import NSGA2
from pymoo.constraints.as_obj import ConstraintsAsObjective

# Add constraint violation as objective
problem_with_cv_obj = ConstraintsAsObjective(problem)

algorithm = NSGA2(pop_size=100)
```

**Advantages:**
- No parameter tuning
- Maintains infeasible solutions that may be useful
- Works well when feasible region is small

**Disadvantages:**
- Increases problem dimensionality
- More complex Pareto front analysis

#### 4. Epsilon-Constraint Handling
**Mechanism:** Dynamic feasibility threshold
**Concept:** Gradually tighten constraint tolerance over generations

**Advantages:**
- Smooth transition to feasible region
- Helps with difficult constraint landscapes

**Disadvantages:**
- Algorithm-specific implementation
- Requires parameter tuning

#### 5. Repair Operators
**Mechanism:** Modify infeasible solutions to satisfy constraints
**Application:** After crossover/mutation, repair offspring

**Usage:**
```python
from pymoo.core.repair import Repair

class MyRepair(Repair):
    def _do(self, problem, X, **kwargs):
        # Project X onto feasible region
        # Example: clip to bounds
        X = np.clip(X, problem.xl, problem.xu)
        return X

from pymoo.algorithms.soo.nonconvex.ga import GA

algorithm = GA(pop_size=100, repair=MyRepair())
```

**Advantages:**
- Maintains feasibility throughout optimization
- Can encode domain knowledge

**Disadvantages:**
- Requires problem-specific implementation
- May restrict search

### Constraint-Handling Algorithms

Some algorithms have built-in constraint handling:

#### SRES (Stochastic Ranking Evolution Strategy)
**Purpose:** Single-objective constrained optimization
**Mechanism:** Stochastic ranking balances objectives and constraints

**Usage:**
```python
from pymoo.algorithms.soo.nonconvex.sres import SRES

algorithm = SRES()
```

#### ISRES (Improved SRES)
**Purpose:** Enhanced constrained optimization
**Improvements:** Better parameter adaptation

**Usage:**
```python
from pymoo.algorithms.soo.nonconvex.isres import ISRES

algorithm = ISRES()
```

### Constraint Handling Guidelines

**Choose technique based on:**

| Problem Characteristic | Recommended Technique |
|------------------------|----------------------|
| Large feasible region | Feasibility First |
| Small feasible region | Constraint as Objective, Repair |
| Heavily constrained | SRES/ISRES, Epsilon-constraint |
| Linear constraints | Repair (projection) |
| Nonlinear constraints | Feasibility First, Penalty |
| Known feasible solutions | Biased initialization |

## Multi-Criteria Decision Making (MCDM)

After obtaining a Pareto front, MCDM helps select preferred solution(s).

### Decision Making Context

**Pareto front characteristics:**
- Multiple non-dominated solutions
- Each represents different trade-off
- No objectively "best" solution
- Requires decision maker preferences

### MCDM Methods in Pymoo

#### 1. Pseudo-Weights
**Concept:** For each solution, pymoo computes a *pseudo-weight* vector — the
normalized distance from the nadir point per objective (a high value on objective
*i* means the solution is good on *i*). It then returns the solution whose
pseudo-weight vector is closest (L1) to your target `weights`. This is **not** a
weighted-sum scalarization; it picks the point that best matches the requested
trade-off proportions. The indicator normalizes internally with the front's
ideal/nadir, so you do not need to pre-normalize `F`.

**Usage:**
```python
from pymoo.mcdm.pseudo_weights import PseudoWeights

# Target trade-off proportions (should sum to 1)
weights = np.array([0.3, 0.7])  # want a solution ~30% biased to f1, 70% to f2

dm = PseudoWeights(weights)
best_idx = dm.do(result.F)        # returns a single integer index
best_solution = result.X[best_idx]
```

**When to use:**
- Clear preference articulation available
- Want a solution matching a target trade-off ratio

**Limitations:**
- Requires weight specification
- Reflects relative objective standing, not absolute values
- A target weight may have no exactly matching solution on the front

#### 2. Compromise Programming
**Concept:** Select solution closest to the ideal point under a distance metric.
**Metric:** Distance to ideal (`metric="euclidean"` by default; passed to the constructor, not to `do`).

```python
from pymoo.mcdm.compromise_programming import CompromiseProgramming

dm = CompromiseProgramming(metric="euclidean")
best_idx = dm.do(result.F)   # bounds are estimated from F automatically
```

> Caveat: in pymoo 0.6.1.x `CompromiseProgramming._do` is incomplete and may return
> `None` for the selected index. For a robust "closest-to-ideal" pick, do it directly:
> normalize `F`, then `best_idx = np.argmin(np.linalg.norm(F_norm, axis=1))`.
> For preference- or knee-based selection prefer `PseudoWeights` / `HighTradeoffPoints`.

**When to use:**
- Ideal objective values known or estimable
- Balanced consideration of all objectives
- No clear weight preferences

#### 3. Interactive Decision Making
**Concept:** Iterative preference refinement
**Process:**
1. Show representative solutions to decision maker
2. Gather feedback on preferences
3. Focus search on preferred regions
4. Repeat until satisfactory solution found

**Approaches:**
- Reference point methods
- Trade-off analysis
- Progressive preference articulation

### Decision Making Workflow

**Step 1: Normalize objectives**
```python
# Normalize to [0, 1] for fair comparison
F_norm = (result.F - result.F.min(axis=0)) / (result.F.max(axis=0) - result.F.min(axis=0))
```

**Step 2: Analyze trade-offs**
```python
from pymoo.visualization.scatter import Scatter

plot = Scatter()
plot.add(result.F)
plot.show()

# Identify knee points, extreme solutions
```

**Step 3: Apply MCDM method**
```python
from pymoo.mcdm.pseudo_weights import PseudoWeights

weights = np.array([0.4, 0.6])  # Based on preferences
dm = PseudoWeights(weights)
selected = dm.do(F_norm)
```

**Step 4: Validate selection**
```python
# Visualize selected solution
from pymoo.visualization.petal import Petal

plot = Petal()
plot.add(result.F[selected], label="Selected")
# Add other candidates for comparison
plot.show()
```

### Advanced MCDM Techniques

#### Knee / High-Tradeoff Point Detection
**Concept:** Solutions where a small improvement in one objective causes a large degradation in others — "knees" of the front.

**Usage:**
```python
from pymoo.mcdm.high_tradeoff import HighTradeoffPoints

dm = HighTradeoffPoints()       # epsilon controls sensitivity (default 0.125)
knee_idx = dm.do(result.F)      # returns array of indices (or None if none found)
knee_solutions = result.X[knee_idx]
```

**When to use:**
- No clear preferences
- Balanced trade-offs desired
- Convex Pareto fronts

> Note: in pymoo 0.6.x the knee-point selector lives in `pymoo.mcdm.high_tradeoff`
> as `HighTradeoffPoints` — there is no `pymoo.mcdm.knee` module.

#### Hypervolume Contribution
**Concept:** Select solutions contributing most to hypervolume
**Use case:** Maintain diverse subset of solutions

**Usage:** pymoo's `HV` indicator (0.6.x) exposes only `do(F)`, which returns the
hypervolume of a *set*. Per-point contribution is the leave-one-out drop in HV:

```python
import numpy as np
from pymoo.indicators.hv import HV

# ref_point must dominate (be worse than) every objective vector; e.g. nadir + margin
ref_point = result.F.max(axis=0) + 0.1
hv = HV(ref_point=ref_point)

total = hv.do(result.F)
contributions = np.array([
    total - hv.do(np.delete(result.F, i, axis=0))
    for i in range(len(result.F))
])

# Select top contributors
top_k = 5
top_indices = np.argsort(contributions)[-top_k:]
selected_solutions = result.X[top_indices]
```

### Decision Making Guidelines

**When decision maker has:**

| Preference Information | Recommended Method |
|------------------------|-------------------|
| Clear objective weights | Pseudo-Weights |
| Ideal target values | Compromise Programming |
| No prior preferences | Knee Point, Visual inspection |
| Conflicting criteria | Interactive methods |
| Need diverse subset | Hypervolume contribution |

**Best practices:**
1. **Normalize objectives** before MCDM
2. **Visualize Pareto front** to understand trade-offs
3. **Consider multiple methods** for robust selection
4. **Validate results** with domain experts
5. **Document assumptions** and preference sources
6. **Perform sensitivity analysis** on weights/parameters

### Integration Example

Complete workflow with constraint handling and decision making:

```python
from pymoo.algorithms.moo.nsga2 import NSGA2
from pymoo.optimize import minimize
from pymoo.mcdm.pseudo_weights import PseudoWeights
import numpy as np

# Define constrained problem
problem = MyConstrainedProblem()

# Setup algorithm with feasibility-first constraint handling
algorithm = NSGA2(
    pop_size=100,
    eliminate_duplicates=True
)

# Optimize
result = minimize(
    problem,
    algorithm,
    ('n_gen', 200),
    seed=1,
    verbose=True
)

# Filter feasible solutions only
feasible_mask = result.CV[:, 0] == 0  # Constraint violation = 0
F_feasible = result.F[feasible_mask]
X_feasible = result.X[feasible_mask]

# Normalize objectives
F_norm = (F_feasible - F_feasible.min(axis=0)) / (F_feasible.max(axis=0) - F_feasible.min(axis=0))

# Apply MCDM
weights = np.array([0.5, 0.5])
dm = PseudoWeights(weights)
best_idx = dm.do(F_norm)

# Get final solution
best_solution = X_feasible[best_idx]
best_objectives = F_feasible[best_idx]

print(f"Selected solution: {best_solution}")
print(f"Objective values: {best_objectives}")
```

# Pymoo Genetic Operators Reference

Comprehensive reference for genetic operators in pymoo.

## Sampling Operators

Sampling operators initialize populations at the start of optimization.

### Random Sampling
**Purpose:** Generate random initial solutions
**Types:**
- `FloatRandomSampling`: Continuous variables
- `BinaryRandomSampling`: Binary variables
- `IntegerRandomSampling`: Integer variables
- `PermutationRandomSampling`: Permutation-based problems

**Usage:**
```python
from pymoo.operators.sampling.rnd import FloatRandomSampling
sampling = FloatRandomSampling()
```

### Latin Hypercube Sampling (LHS)
**Purpose:** Space-filling initial population
**Benefit:** Better coverage of search space than random
**Types:**
- `LHS`: Standard Latin Hypercube

**Usage:**
```python
from pymoo.operators.sampling.lhs import LHS
sampling = LHS()
```

### Custom Sampling
Provide initial population through Population object or NumPy array

## Selection Operators

Selection operators choose parents for reproduction.

### Tournament Selection
**Purpose:** Select parents through tournament competition
**Mechanism:** Randomly select k individuals, choose best
**Parameters:**
- `pressure`: Tournament size (default: 2)
- `func_comp`: Comparison function

**Usage:**
```python
from pymoo.operators.selection.tournament import TournamentSelection
selection = TournamentSelection(pressure=2)
```

### Random Selection
**Purpose:** Uniform random parent selection
**Use case:** Baseline or exploration-focused algorithms

**Usage:**
```python
from pymoo.operators.selection.rnd import RandomSelection
selection = RandomSelection()
```

## Crossover Operators

Crossover operators recombine parent solutions to create offspring.

### For Continuous Variables

#### Simulated Binary Crossover (SBX)
**Purpose:** Primary crossover for continuous optimization
**Mechanism:** Simulates single-point crossover of binary-encoded variables
**Parameters:**
- `prob`: Crossover probability (default: 0.9)
- `eta`: Distribution index (default: 15)
  - Higher eta → offspring closer to parents
  - Lower eta → more exploration

**Usage:**
```python
from pymoo.operators.crossover.sbx import SBX
crossover = SBX(prob=0.9, eta=15)
```

**String shorthand:** `"real_sbx"`

#### Differential Evolution Crossover
**Purpose:** DE-specific recombination
**Variants:**
- `DE/rand/1/bin`
- `DE/best/1/bin`
- `DE/current-to-best/1/bin`

**Parameters:**
- `CR`: Crossover rate
- `F`: Scaling factor

### For Binary Variables

#### Single Point Crossover
**Purpose:** Cut and swap at one point
**Usage:**
```python
from pymoo.operators.crossover.pntx import SinglePointCrossover
crossover = SinglePointCrossover()
```

#### Two Point Crossover
**Purpose:** Cut and swap between two points
**Usage:**
```python
from pymoo.operators.crossover.pntx import TwoPointCrossover
crossover = TwoPointCrossover()
```

#### K-Point Crossover
**Purpose:** Multiple cut points
**Parameters:**
- `n_points`: Number of crossover points

#### Uniform Crossover
**Purpose:** Each gene independently from either parent
**Parameters:**
- `prob`: Per-gene swap probability (default: 0.5)

**Usage:**
```python
from pymoo.operators.crossover.ux import UniformCrossover
crossover = UniformCrossover(prob=0.5)
```

#### Half Uniform Crossover (HUX)
**Purpose:** Exchange exactly half of differing genes
**Benefit:** Maintains genetic diversity

### For Permutations

#### Order Crossover (OX)
**Purpose:** Preserve relative order from parents
**Use case:** Traveling salesman, scheduling problems

**Usage:**
```python
from pymoo.operators.crossover.ox import OrderCrossover
crossover = OrderCrossover()
```

#### Edge Recombination Crossover (ERX)
**Purpose:** Preserve edge information from parents
**Use case:** Routing problems where edge connectivity matters

#### Partially Mapped Crossover (PMX)
**Purpose:** Exchange segments while maintaining permutation validity

## Mutation Operators

Mutation operators introduce variation to maintain diversity.

### For Continuous Variables

#### Polynomial Mutation (PM)
**Purpose:** Primary mutation for continuous optimization
**Mechanism:** Polynomial probability distribution
**Parameters:**
- `prob`: Per-variable mutation probability
- `eta`: Distribution index (default: 20)
  - Higher eta → smaller perturbations
  - Lower eta → larger perturbations

**Usage:**
```python
from pymoo.operators.mutation.pm import PM
mutation = PM(prob=None, eta=20)  # prob=None means 1/n_var
```

**String shorthand:** `"real_pm"`

**Probability guidelines:**
- `None` or `1/n_var`: Standard recommendation
- Higher for more exploration
- Lower for more exploitation

### For Binary Variables

#### Bitflip Mutation
**Purpose:** Flip bits with specified probability
**Parameters:**
- `prob`: Per-bit flip probability

**Usage:**
```python
from pymoo.operators.mutation.bitflip import BitflipMutation
mutation = BitflipMutation(prob=0.05)
```

### For Integer Variables

#### Integer Polynomial Mutation
**Purpose:** PM adapted for integers
**Ensures:** Valid integer values after mutation

### For Permutations

#### Inversion Mutation
**Purpose:** Reverse a segment of the permutation
**Use case:** Maintains some order structure

**Usage:**
```python
from pymoo.operators.mutation.inversion import InversionMutation
mutation = InversionMutation()
```

#### Scramble Mutation
**Purpose:** Randomly shuffle a segment

### Custom Mutation
Define custom mutation by extending `Mutation` class

## Repair Operators

Repair operators fix constraint violations or ensure solution feasibility.

### Rounding Repair
**Purpose:** Round to nearest valid value
**Use case:** Integer/discrete variables with bound constraints

### Bounce Back Repair
**Purpose:** Reflect out-of-bounds values back into feasible region
**Use case:** Box-constrained continuous problems

### Projection Repair
**Purpose:** Project infeasible solutions onto feasible region
**Use case:** Linear constraints

### Custom Repair
**Purpose:** Domain-specific constraint handling
**Implementation:** Extend `Repair` class

**Example:**
```python
from pymoo.core.repair import Repair

class MyRepair(Repair):
    def _do(self, problem, X, **kwargs):
        # Modify X to satisfy constraints
        # Return repaired X
        return X
```

## Operator Configuration Guidelines

### Parameter Tuning

**Crossover probability:**
- High (0.8-0.95): Standard for most problems
- Lower: More emphasis on mutation

**Mutation probability:**
- `1/n_var`: Standard recommendation
- Higher: More exploration, slower convergence
- Lower: Faster convergence, risk of premature convergence

**Distribution indices (eta):**
- Crossover eta (15-30): Higher for local search
- Mutation eta (20-50): Higher for exploitation

### Problem-Specific Selection

**Continuous problems:**
- Crossover: SBX
- Mutation: Polynomial Mutation
- Selection: Tournament

**Binary problems:**
- Crossover: Two-point or Uniform
- Mutation: Bitflip
- Selection: Tournament

**Permutation problems:**
- Crossover: Order Crossover (OX)
- Mutation: Inversion or Scramble
- Selection: Tournament

**Mixed-variable problems:**
- Use appropriate operators per variable type
- Ensure operator compatibility

### String-Based Configuration

Pymoo supports convenient string-based operator specification:

```python
from pymoo.algorithms.soo.nonconvex.ga import GA

algorithm = GA(
    pop_size=100,
    sampling="real_random",
    crossover="real_sbx",
    mutation="real_pm"
)
```

**Available strings:**
- Sampling: `"real_random"`, `"real_lhs"`, `"bin_random"`, `"perm_random"`
- Crossover: `"real_sbx"`, `"real_de"`, `"int_sbx"`, `"bin_ux"`, `"bin_hux"`
- Mutation: `"real_pm"`, `"int_pm"`, `"bin_bitflip"`, `"perm_inv"`

## Operator Combination Examples

### Standard Continuous GA:
```python
from pymoo.operators.sampling.rnd import FloatRandomSampling
from pymoo.operators.crossover.sbx import SBX
from pymoo.operators.mutation.pm import PM
from pymoo.operators.selection.tournament import TournamentSelection

sampling = FloatRandomSampling()
crossover = SBX(prob=0.9, eta=15)
mutation = PM(eta=20)
selection = TournamentSelection()
```

### Binary GA:
```python
from pymoo.operators.sampling.rnd import BinaryRandomSampling
from pymoo.operators.crossover.pntx import TwoPointCrossover
from pymoo.operators.mutation.bitflip import BitflipMutation

sampling = BinaryRandomSampling()
crossover = TwoPointCrossover()
mutation = BitflipMutation(prob=0.05)
```

### Permutation GA (TSP):
```python
from pymoo.operators.sampling.rnd import PermutationRandomSampling
from pymoo.operators.crossover.ox import OrderCrossover
from pymoo.operators.mutation.inversion import InversionMutation

sampling = PermutationRandomSampling()
crossover = OrderCrossover()
mutation = InversionMutation()
```

# Pymoo Test Problems Reference

Comprehensive reference for benchmark optimization problems in pymoo.

## Single-Objective Test Problems

### Ackley Function
**Characteristics:**
- Highly multimodal
- Many local optima
- Tests algorithm's ability to escape local minima
- Continuous variables

### Griewank Function
**Characteristics:**
- Multimodal with regularly distributed local minima
- Product term introduces interdependencies between variables
- Global minimum at origin

### Rastrigin Function
**Characteristics:**
- Highly multimodal with regularly spaced local minima
- Challenging for gradient-based methods
- Tests global search capability

### Rosenbrock Function
**Characteristics:**
- Unimodal but narrow valley to global optimum
- Tests algorithm's convergence in difficult landscape
- Classic benchmark for continuous optimization

### Zakharov Function
**Characteristics:**
- Unimodal
- Single global minimum
- Tests basic convergence capability

## Multi-Objective Test Problems (2-3 objectives)

### ZDT Test Suite
**Purpose:** Standard benchmark for bi-objective optimization
**Construction:** f₂(x) = g(x) · h(f₁(x), g(x)) where g(x) = 1 at Pareto-optimal solutions

#### ZDT1
- **Variables:** 30 continuous
- **Bounds:** [0, 1]
- **Pareto front:** Convex
- **Purpose:** Basic convergence and diversity test

#### ZDT2
- **Variables:** 30 continuous
- **Bounds:** [0, 1]
- **Pareto front:** Non-convex (concave)
- **Purpose:** Tests handling of non-convex fronts

#### ZDT3
- **Variables:** 30 continuous
- **Bounds:** [0, 1]
- **Pareto front:** Disconnected (5 separate regions)
- **Purpose:** Tests diversity maintenance across discontinuous front

#### ZDT4
- **Variables:** 10 continuous (x₁ ∈ [0,1], x₂₋₁₀ ∈ [-10,10])
- **Pareto front:** Convex
- **Difficulty:** 21⁹ local Pareto fronts
- **Purpose:** Tests global search with many local optima

#### ZDT5
- **Variables:** 11 discrete (bitstring)
- **Encoding:** x₁ uses 30 bits, x₂₋₁₁ use 5 bits each
- **Pareto front:** Convex
- **Purpose:** Tests discrete optimization and deceptive landscapes

#### ZDT6
- **Variables:** 10 continuous
- **Bounds:** [0, 1]
- **Pareto front:** Non-convex with non-uniform density
- **Purpose:** Tests handling of biased solution distributions

**Usage:**
```python
from pymoo.problems.multi import ZDT1, ZDT2, ZDT3, ZDT4, ZDT5, ZDT6
problem = ZDT1()  # or ZDT2(), ZDT3(), etc.
```

### BNH (Binh and Korn)
**Characteristics:**
- 2 objectives
- 2 variables
- Constrained problem
- Tests constraint handling in multi-objective context

### OSY (Osyczka and Kundu)
**Characteristics:**
- 6 objectives
- 6 variables
- Multiple constraints
- Real-world inspired

### TNK (Tanaka)
**Characteristics:**
- 2 objectives
- 2 variables
- Disconnected feasible region
- Tests handling of disjoint search spaces

### Truss2D
**Characteristics:**
- Structural engineering problem
- Bi-objective (weight vs displacement)
- Practical application test

### Welded Beam
**Characteristics:**
- Engineering design problem
- Multiple constraints
- Practical optimization scenario

### Omni-test
**Characteristics:**
- Configurable test problem
- Various difficulty levels
- Systematic testing

### SYM-PART
**Characteristics:**
- Symmetric problem structure
- Tests specific algorithmic behaviors

## Many-Objective Test Problems (4+ objectives)

### DTLZ Test Suite
**Purpose:** Scalable many-objective benchmarks
**Objectives:** Configurable (typically 3-15)
**Variables:** Scalable

#### DTLZ1
- **Pareto front:** Linear (hyperplane)
- **Difficulty:** 11^k local Pareto fronts
- **Purpose:** Tests convergence with many local optima

#### DTLZ2
- **Pareto front:** Spherical (concave)
- **Difficulty:** Straightforward convergence
- **Purpose:** Basic many-objective diversity test

#### DTLZ3
- **Pareto front:** Spherical
- **Difficulty:** 3^k local Pareto fronts
- **Purpose:** Combines DTLZ1's multimodality with DTLZ2's geometry

#### DTLZ4
- **Pareto front:** Spherical with biased density
- **Difficulty:** Non-uniform solution distribution
- **Purpose:** Tests diversity maintenance with bias

#### DTLZ5
- **Pareto front:** Degenerate (curve in M-dimensional space)
- **Purpose:** Tests handling of degenerate fronts

#### DTLZ6
- **Pareto front:** Degenerate curve
- **Difficulty:** Harder convergence than DTLZ5
- **Purpose:** Challenging degenerate front

#### DTLZ7
- **Pareto front:** Disconnected regions
- **Difficulty:** 2^(M-1) disconnected regions
- **Purpose:** Tests diversity across disconnected fronts

**Usage:**
```python
from pymoo.problems.many import DTLZ1, DTLZ2
problem = DTLZ1(n_var=7, n_obj=3)  # 7 variables, 3 objectives
```

### WFG Test Suite
**Purpose:** Walking Fish Group scalable benchmarks
**Features:** More complex than DTLZ, various front shapes and difficulties

**Variants:** WFG1-WFG9 with different characteristics
- Non-separable
- Deceptive
- Multimodal
- Biased
- Scaled fronts

## Constrained Multi-Objective Problems

### MW Test Suite
**Purpose:** Multi-objective problems with various constraint types
**Features:** Different constraint difficulty levels

### DAS-CMOP
**Purpose:** Difficulty-adjustable and scalable constrained multi-objective problems
**Features:** Tunable constraint difficulty

### MODAct
**Purpose:** Multi-objective optimization with active constraints
**Features:** Realistic constraint scenarios

## Dynamic Multi-Objective Problems

### DF Test Suite
**Purpose:** CEC2018 Competition dynamic multi-objective benchmarks
**Features:**
- Time-varying objectives
- Changing Pareto fronts
- Tests algorithm adaptability

**Variants:** DF1-DF14 with different dynamics

## Custom Problem Definition

Define custom problems by extending base classes:

```python
from pymoo.core.problem import ElementwiseProblem
import numpy as np

class MyProblem(ElementwiseProblem):
    def __init__(self):
        super().__init__(
            n_var=2,           # number of variables
            n_obj=2,           # number of objectives
            n_ieq_constr=0,    # inequality constraints
            n_eq_constr=0,     # equality constraints
            xl=np.array([0, 0]),   # lower bounds
            xu=np.array([1, 1])    # upper bounds
        )

    def _evaluate(self, x, out, *args, **kwargs):
        # Define objectives
        f1 = x[0]**2 + x[1]**2
        f2 = (x[0]-1)**2 + x[1]**2

        out["F"] = [f1, f2]

        # Optional: constraints
        # out["G"] = constraint_values  # <= 0
        # out["H"] = equality_constraints  # == 0
```

## Problem Selection Guidelines

**For algorithm development:**
- Simple convergence: DTLZ2, ZDT1
- Multimodal: ZDT4, DTLZ1, DTLZ3
- Non-convex: ZDT2
- Disconnected: ZDT3, DTLZ7

**For comprehensive testing:**
- ZDT suite for bi-objective
- DTLZ suite for many-objective
- WFG for complex landscapes
- MW/DAS-CMOP for constraints

**For real-world validation:**
- Engineering problems (Truss2D, Welded Beam)
- Match problem characteristics to application domain

**Variable types:**
- Continuous: Most problems
- Discrete: ZDT5
- Mixed: Define custom problem

# Pymoo Quick Reference — Algorithms, Benchmarks, Operators, Troubleshooting

Selection tables and short snippets. For deep detail see the topic-specific references
(`algorithms.md`, `problems.md`, `operators.md`, `visualization.md`, `constraints_mcdm.md`).

## Algorithm Selection Guide

### Single-Objective Problems

| Algorithm | Best For | Key Features |
|-----------|----------|--------------|
| **GA** | General-purpose | Flexible, customizable operators |
| **DE** | Continuous optimization | Good global search |
| **PSO** | Smooth landscapes | Fast convergence |
| **CMA-ES** | Difficult/noisy problems | Self-adapting |

### Multi-Objective Problems (2-3 objectives)

| Algorithm | Best For | Key Features |
|-----------|----------|--------------|
| **NSGA-II** | Standard benchmark | Fast, reliable, well-tested |
| **R-NSGA-II** | Preference regions | Reference point guidance |
| **MOEA/D** | Decomposable problems | Scalarization approach |

### Many-Objective Problems (4+ objectives)

| Algorithm | Best For | Key Features |
|-----------|----------|--------------|
| **NSGA-III** | 4-15 objectives | Reference direction-based |
| **RVEA** | Adaptive search | Reference vector evolution |
| **AGE-MOEA** | Complex landscapes | Adaptive geometry |

### Constrained Problems

| Approach | Algorithm | When to Use |
|----------|-----------|-------------|
| Feasibility-first | Any algorithm | Large feasible region |
| Specialized | SRES, ISRES | Heavy constraints |
| Penalty | GA + penalty | Algorithm compatibility |

See `references/algorithms.md` for the comprehensive algorithm reference.

## Benchmark Problems

```python
from pymoo.problems import get_problem

# Single-objective
problem = get_problem("rastrigin", n_var=10)
problem = get_problem("rosenbrock", n_var=10)

# Multi-objective
problem = get_problem("zdt1")        # Convex front
problem = get_problem("zdt2")        # Non-convex front
problem = get_problem("zdt3")        # Disconnected front

# Many-objective
problem = get_problem("dtlz2", n_obj=5, n_var=12)
problem = get_problem("dtlz7", n_obj=4)
```

See `references/problems.md` for the complete test problem reference.

## Genetic Operator Customization

### Standard operator configuration
```python
from pymoo.algorithms.soo.nonconvex.ga import GA
from pymoo.operators.crossover.sbx import SBX
from pymoo.operators.mutation.pm import PM

algorithm = GA(
    pop_size=100,
    crossover=SBX(prob=0.9, eta=15),
    mutation=PM(eta=20),
    eliminate_duplicates=True
)
```

### Operator selection by variable type

**Continuous variables:**
- Crossover: SBX (Simulated Binary Crossover)
- Mutation: PM (Polynomial Mutation)

**Binary variables:**
- Crossover: TwoPointCrossover, UniformCrossover
- Mutation: BitflipMutation

**Permutations (TSP, scheduling):**
- Crossover: OrderCrossover (OX)
- Mutation: InversionMutation

See `references/operators.md` for the comprehensive operator reference.

## Performance and Troubleshooting

**Problem: Algorithm not converging**
- Increase population size
- Increase number of generations
- Check if problem is multimodal (try different algorithms)
- Verify constraints are correctly formulated

**Problem: Poor Pareto front distribution**
- For NSGA-III: Adjust reference directions
- Increase population size
- Check for duplicate elimination
- Verify problem scaling

**Problem: Few feasible solutions**
- Use constraint-as-objective approach
- Apply repair operators
- Try SRES/ISRES for constrained problems
- Check constraint formulation (should be g <= 0)

**Problem: High computational cost**
- Reduce population size
- Decrease number of generations
- Use simpler operators
- Enable parallelization (if problem supports)

### Best practices

1. **Normalize objectives** when scales differ significantly
2. **Set random seed** for reproducibility
3. **Save history** to analyze convergence: `save_history=True`
4. **Visualize results** to understand solution quality
5. **Compare with true Pareto front** when available
6. **Use appropriate termination criteria** (generations, evaluations, tolerance)
7. **Tune operator parameters** for problem characteristics

## Common patterns

- Subclass `ElementwiseProblem` to evaluate one solution at a time, or `Problem` to evaluate the whole population as a vectorized batch (faster when NumPy can vectorize)
- Constraints formulated as `g(x) <= 0` and `h(x) = 0`
- Reference directions required for NSGA-III
- Normalize objectives before MCDM
- Use appropriate termination: `('n_gen', N)`, `('n_evals', N)`, or tolerance-based `get_termination("moo", ftol=1e-3, n_max_gen=500)` (`"soo"` for single-objective). There is no `"f_tol"` key; `get_termination` raises `Termination not found`

## Installation and environment

```bash
uv pip install pymoo
```

**Dependencies:** NumPy, SciPy, matplotlib, autograd, cma (≥ 3.4, needed for CMA-ES under NumPy 2), and moocore, installed automatically.
**Documentation:** https://pymoo.org/ — this skill is based on pymoo 0.6.x (current 0.6.2 as of 2026-09).

# Pymoo Visualization Reference

Comprehensive reference for visualization capabilities in pymoo.

## Overview

Pymoo provides eight visualization types for analyzing multi-objective optimization results. All plots wrap matplotlib and accept standard matplotlib keyword arguments for customization.

## Core Visualization Types

### 1. Scatter Plots
**Purpose:** Visualize objective space for 2D, 3D, or higher dimensions
**Best for:** Pareto fronts, solution distributions, algorithm comparisons

**Usage:**
```python
from pymoo.visualization.scatter import Scatter

# 2D scatter plot
plot = Scatter()
plot.add(result.F, color="red", label="Algorithm A")
plot.add(ref_pareto_front, color="black", alpha=0.3, label="True PF")
plot.show()

# 3D scatter plot
plot = Scatter(title="3D Pareto Front")
plot.add(result.F)
plot.show()
```

**Parameters:**
- `title`: Plot title
- `figsize`: Figure size tuple (width, height)
- `legend`: Show legend (default: True)
- `labels`: Axis labels list

**Add method parameters:**
- `color`: Color specification
- `alpha`: Transparency (0-1)
- `s`: Marker size
- `marker`: Marker style
- `label`: Legend label

**N-dimensional projection:**
For >3 objectives, automatically creates scatter plot matrix

### 2. Parallel Coordinate Plots (PCP)
**Purpose:** Compare multiple solutions across many objectives
**Best for:** Many-objective problems, comparing algorithm performance

**Mechanism:** Each vertical axis represents one objective, lines connect objective values for each solution

**Usage:**
```python
from pymoo.visualization.pcp import PCP

plot = PCP()
plot.add(result.F, color="blue", alpha=0.5)
plot.add(reference_set, color="red", alpha=0.8)
plot.show()
```

**Parameters:**
- `title`: Plot title
- `figsize`: Figure size
- `labels`: Objective labels
- `bounds`: Normalization bounds (min, max) per objective
- `normalize_each_axis`: Normalize to [0,1] per axis (default: True)

**Best practices:**
- Normalize for different objective scales
- Use transparency for overlapping lines
- Limit number of solutions for clarity (<1000)

### 3. Heatmap
**Purpose:** Show solution density and distribution patterns
**Best for:** Understanding solution clustering, identifying gaps

**Usage:**
```python
from pymoo.visualization.heatmap import Heatmap

plot = Heatmap(title="Solution Density")
plot.add(result.F)
plot.show()
```

**Parameters:**
- `bins`: Number of bins per dimension (default: 20)
- `cmap`: Colormap name (e.g., "viridis", "plasma", "hot")
- `norm`: Normalization method

**Interpretation:**
- Bright regions: High solution density
- Dark regions: Few or no solutions
- Reveals distribution uniformity

### 4. Petal Diagram
**Purpose:** Radial representation of multiple objectives
**Best for:** Comparing individual solutions across objectives

**Structure:** Each "petal" represents one objective, length indicates objective value

**Usage:**
```python
from pymoo.visualization.petal import Petal

plot = Petal(title="Solution Comparison", bounds=[min_vals, max_vals])
plot.add(result.F[0], color="blue", label="Solution 1")
plot.add(result.F[1], color="red", label="Solution 2")
plot.show()
```

**Parameters:**
- `bounds`: [min, max] per objective for normalization
- `labels`: Objective names
- `reverse`: Reverse specific objectives (for minimization display)

**Use cases:**
- Decision making between few solutions
- Presenting trade-offs to stakeholders

### 5. Radar Charts
**Purpose:** Multi-criteria performance profiles
**Best for:** Comparing solution characteristics

**Similar to:** Petal diagram but with connected vertices

**Usage:**
```python
from pymoo.visualization.radar import Radar

plot = Radar(bounds=[min_vals, max_vals])
plot.add(solution_A, label="Design A")
plot.add(solution_B, label="Design B")
plot.show()
```

### 6. Radviz
**Purpose:** Dimensional reduction for visualization
**Best for:** High-dimensional data exploration, pattern recognition

**Mechanism:** Projects high-dimensional points onto 2D circle, dimension anchors on perimeter

**Usage:**
```python
from pymoo.visualization.radviz import Radviz

plot = Radviz(title="High-dimensional Solution Space")
plot.add(result.F, color="blue", s=30)
plot.show()
```

**Parameters:**
- `endpoint_style`: Anchor point visualization
- `labels`: Dimension labels

**Interpretation:**
- Points near anchor: High value in that dimension
- Central points: Balanced across dimensions
- Clusters: Similar solutions

### 7. Star Coordinates
**Purpose:** Alternative high-dimensional visualization
**Best for:** Comparing multi-dimensional datasets

**Mechanism:** Each dimension as axis from origin, points plotted based on values

**Usage:**
```python
from pymoo.visualization.star_coordinate import StarCoordinate

plot = StarCoordinate()
plot.add(result.F)
plot.show()
```

**Parameters:**
- `axis_style`: Axis appearance
- `axis_extension`: Axis length beyond max value
- `labels`: Dimension labels

### 8. Video/Animation
**Purpose:** Show optimization progress over time
**Best for:** Understanding convergence behavior, presentations

Animation is **not** built into `pymoo.visualization`. In pymoo 0.6.x it is driven by
the separate `pyrecorder` package (`uv pip install pyrecorder`, pulls in opencv). Run
with `save_history=True`, then record one frame per stored generation:

```python
from pyrecorder.recorder import Recorder
from pyrecorder.writers.video import Video
from pymoo.visualization.scatter import Scatter

# result = minimize(problem, algorithm, ('n_gen', N), seed=1, save_history=True)
with Recorder(Video("optimization_progress.mp4")) as rec:
    for entry in result.history:
        plot = Scatter(title=f"gen {entry.n_gen}")
        plot.add(entry.opt.get("F"))
        plot.do()
        rec.record()
```

**Requirements:**
- `save_history=True` in `minimize`
- `pyrecorder` installed (writes MP4 via opencv; ffmpeg optional for re-encode)

## Advanced Features

### Multiple Dataset Overlay

All plot types support adding multiple datasets:

```python
plot = Scatter(title="Algorithm Comparison")
plot.add(nsga2_result.F, color="red", alpha=0.5, label="NSGA-II")
plot.add(nsga3_result.F, color="blue", alpha=0.5, label="NSGA-III")
plot.add(true_pareto_front, color="black", linewidth=2, label="True PF")
plot.show()
```

### Custom Styling

Pass matplotlib kwargs directly:

```python
plot = Scatter(
    title="My Results",
    figsize=(10, 8),
    tight_layout=True
)
plot.add(
    result.F,
    color="red",
    marker="o",
    s=50,
    alpha=0.7,
    edgecolors="black",
    linewidth=0.5
)
```

### Normalization

Normalize objectives to [0,1] for fair comparison:

```python
plot = PCP(normalize_each_axis=True, bounds=[min_bounds, max_bounds])
```

### Save to File

Save plots instead of displaying:

```python
plot = Scatter()
plot.add(result.F)
plot.save("my_plot.png", dpi=300)
```

## Visualization Selection Guide

**Choose visualization based on:**

| Problem Type | Primary Plot | Secondary Plot |
|--------------|--------------|----------------|
| 2-objective | Scatter | Heatmap |
| 3-objective | 3D Scatter | Parallel Coordinates |
| Many-objective (4-10) | Parallel Coordinates | Radviz |
| Many-objective (>10) | Radviz | Star Coordinates |
| Solution comparison | Petal/Radar | Parallel Coordinates |
| Algorithm convergence | Video | Scatter (final) |
| Distribution analysis | Heatmap | Scatter |

**Combinations:**
- Scatter + Heatmap: Overall distribution + density
- PCP + Petal: Population overview + individual solutions
- Scatter + Video: Final result + convergence process

## Common Visualization Workflows

### 1. Algorithm Comparison
```python
from pymoo.visualization.scatter import Scatter

plot = Scatter(title="Algorithm Comparison on ZDT1")
plot.add(ga_result.F, color="blue", label="GA", alpha=0.6)
plot.add(nsga2_result.F, color="red", label="NSGA-II", alpha=0.6)
plot.add(zdt1.pareto_front(), color="black", label="True PF")
plot.show()
```

### 2. Many-objective Analysis
```python
from pymoo.visualization.pcp import PCP

plot = PCP(
    title="5-objective DTLZ2 Results",
    labels=["f1", "f2", "f3", "f4", "f5"],
    normalize_each_axis=True
)
plot.add(result.F, alpha=0.3)
plot.show()
```

### 3. Decision Making
```python
from pymoo.visualization.petal import Petal

# Compare top 3 solutions
candidates = result.F[:3]

plot = Petal(
    title="Top 3 Solutions",
    bounds=[result.F.min(axis=0), result.F.max(axis=0)],
    labels=["Cost", "Weight", "Efficiency", "Safety"]
)
for i, sol in enumerate(candidates):
    plot.add(sol, label=f"Solution {i+1}")
plot.show()
```

### 4. Convergence Visualization
```python
from pymoo.optimize import minimize

# Enable history
result = minimize(
    problem,
    algorithm,
    ('n_gen', 200),
    seed=1,
    save_history=True,
    verbose=False
)

# Create convergence plot
from pymoo.visualization.scatter import Scatter

plot = Scatter(title="Convergence Over Generations")
# history has one entry per generation; for n_gen=200 valid indices are 0..199
for gen in [0, 50, 100, 150, 199]:
    F = result.history[gen].opt.get("F")
    plot.add(F, alpha=0.5, label=f"Gen {gen + 1}")
plot.show()
```

## Tips and Best Practices

1. **Use appropriate alpha:** For overlapping points, use `alpha=0.3-0.7`
2. **Normalize objectives:** Different scales? Normalize for fair visualization
3. **Label clearly:** Always provide meaningful labels and legends
4. **Limit data points:** >10000 points? Sample or use heatmap
5. **Color schemes:** Use colorblind-friendly palettes
6. **Save high-res:** Use `dpi=300` for publications
7. **Interactive exploration:** Consider plotly for interactive plots
8. **Combine views:** Show multiple perspectives for comprehensive analysis

# Pymoo Workflows — Worked Examples

Complete, copy-pasteable examples for each common optimization task. Each maps to a runnable script in `scripts/`.

## Workflow 1: Single-Objective Optimization

**When:** Optimizing one objective function.

**Steps:** Define/select problem → choose single-objective algorithm (GA, DE, PSO, CMA-ES) → configure termination → run → extract best solution.

```python
from pymoo.algorithms.soo.nonconvex.ga import GA
from pymoo.problems import get_problem
from pymoo.optimize import minimize

# Built-in problem
problem = get_problem("rastrigin", n_var=10)

# Configure Genetic Algorithm
algorithm = GA(
    pop_size=100,
    eliminate_duplicates=True
)

# Optimize
result = minimize(
    problem,
    algorithm,
    ('n_gen', 200),
    seed=1,
    verbose=True
)

print(f"Best solution: {result.X}")
print(f"Best objective: {result.F[0]}")
```

See `scripts/single_objective_example.py` for the complete example.

## Workflow 2: Multi-Objective Optimization (2-3 objectives)

**When:** Optimizing 2-3 conflicting objectives, need Pareto front.

**Algorithm choice:** NSGA-II (standard for bi/tri-objective).

**Steps:** Define multi-objective problem → configure NSGA-II → run to obtain Pareto front → visualize trade-offs → apply decision making (optional).

```python
from pymoo.algorithms.moo.nsga2 import NSGA2
from pymoo.problems import get_problem
from pymoo.optimize import minimize
from pymoo.visualization.scatter import Scatter

# Bi-objective benchmark problem
problem = get_problem("zdt1")

# NSGA-II algorithm
algorithm = NSGA2(pop_size=100)

# Optimize
result = minimize(problem, algorithm, ('n_gen', 200), seed=1)

# Visualize Pareto front
plot = Scatter()
plot.add(result.F, label="Obtained Front")
plot.add(problem.pareto_front(), label="True Front", alpha=0.3)
plot.show()

print(f"Found {len(result.F)} Pareto-optimal solutions")
```

See `scripts/multi_objective_example.py` for the complete example.

## Workflow 3: Many-Objective Optimization (4+ objectives)

**When:** Optimizing 4 or more objectives.

**Algorithm choice:** NSGA-III (designed for many objectives).

**Key difference:** Must provide reference directions for population guidance.

**Steps:** Define many-objective problem → generate reference directions → configure NSGA-III with reference directions → run → visualize using Parallel Coordinate Plot.

```python
from pymoo.algorithms.moo.nsga3 import NSGA3
from pymoo.problems import get_problem
from pymoo.optimize import minimize
from pymoo.util.ref_dirs import get_reference_directions
from pymoo.visualization.pcp import PCP

# Many-objective problem (5 objectives)
problem = get_problem("dtlz2", n_obj=5)

# Generate reference directions (required for NSGA-III)
ref_dirs = get_reference_directions("das-dennis", n_dim=5, n_partitions=12)

# Configure NSGA-III
algorithm = NSGA3(ref_dirs=ref_dirs)

# Optimize
result = minimize(problem, algorithm, ('n_gen', 300), seed=1)

# Visualize with Parallel Coordinates
plot = PCP(labels=[f"f{i+1}" for i in range(5)])
plot.add(result.F, alpha=0.3)
plot.show()
```

See `scripts/many_objective_example.py` for the complete example.

## Workflow 4: Custom Problem Definition

**When:** Solving a domain-specific optimization problem.

**Steps:** Extend `ElementwiseProblem` → define `__init__` with dimensions and bounds → implement `_evaluate` for objectives (and constraints) → use with any algorithm.

**Unconstrained example:**
```python
from pymoo.core.problem import ElementwiseProblem
import numpy as np

class MyProblem(ElementwiseProblem):
    def __init__(self):
        super().__init__(
            n_var=2,              # Number of variables
            n_obj=2,              # Number of objectives
            xl=np.array([0, 0]),  # Lower bounds
            xu=np.array([5, 5])   # Upper bounds
        )

    def _evaluate(self, x, out, *args, **kwargs):
        # Define objectives
        f1 = x[0]**2 + x[1]**2
        f2 = (x[0]-1)**2 + (x[1]-1)**2

        out["F"] = [f1, f2]
```

**Constrained example:**
```python
class ConstrainedProblem(ElementwiseProblem):
    def __init__(self):
        super().__init__(
            n_var=2,
            n_obj=2,
            n_ieq_constr=2,        # Inequality constraints
            n_eq_constr=1,         # Equality constraints
            xl=np.array([0, 0]),
            xu=np.array([5, 5])
        )

    def _evaluate(self, x, out, *args, **kwargs):
        # Objectives
        out["F"] = [f1, f2]

        # Inequality constraints (g <= 0)
        out["G"] = [g1, g2]

        # Equality constraints (h = 0)
        out["H"] = [h1]
```

**Constraint formulation rules:**
- Inequality: Express as `g(x) <= 0` (feasible when ≤ 0)
- Equality: Express as `h(x) = 0` (feasible when = 0)
- Convert `g(x) >= b` to `-(g(x) - b) <= 0`

See `scripts/custom_problem_example.py` for complete examples.

## Workflow 5: Constraint Handling

**When:** Problem has feasibility constraints.

**1. Feasibility First (Default — Recommended)**
```python
from pymoo.algorithms.moo.nsga2 import NSGA2

# Works automatically with constrained problems
algorithm = NSGA2(pop_size=100)
result = minimize(problem, algorithm, termination)

# Check feasibility
feasible = result.CV[:, 0] == 0  # CV = constraint violation
print(f"Feasible solutions: {np.sum(feasible)}")
```

**2. Penalty Method**
```python
from pymoo.constraints.as_penalty import ConstraintsAsPenalty

# Wrap problem to convert constraints to penalties
problem_penalized = ConstraintsAsPenalty(problem, penalty=1e6)
```

**3. Constraint as Objective**
```python
from pymoo.constraints.as_obj import ConstraintsAsObjective

# Treat constraint violation as additional objective
problem_with_cv = ConstraintsAsObjective(problem)
```

**4. Specialized Algorithms**
```python
from pymoo.algorithms.soo.nonconvex.sres import SRES

# SRES has built-in constraint handling
algorithm = SRES()
```

See `references/constraints_mcdm.md` for the comprehensive constraint handling guide.

## Workflow 6: Decision Making from Pareto Front

**When:** Have Pareto front, need to select preferred solution(s).

**Steps:** Run multi-objective optimization → normalize objectives to [0, 1] → define preference weights → apply MCDM method → visualize selected solution.

**Example using Pseudo-Weights:**
```python
from pymoo.mcdm.pseudo_weights import PseudoWeights
import numpy as np

# After obtaining result from multi-objective optimization
# Normalize objectives
F_norm = (result.F - result.F.min(axis=0)) / (result.F.max(axis=0) - result.F.min(axis=0))

# Define preferences (must sum to 1)
weights = np.array([0.3, 0.7])  # 30% f1, 70% f2

# Apply decision making
dm = PseudoWeights(weights)
selected_idx = dm.do(F_norm)

# Get selected solution
best_solution = result.X[selected_idx]
best_objectives = result.F[selected_idx]

print(f"Selected solution: {best_solution}")
print(f"Objective values: {best_objectives}")
```

**Other MCDM methods:**
- Compromise Programming: Select closest to ideal point
- Knee Point: Find balanced trade-off solutions
- Hypervolume Contribution: Select most diverse subset

See `scripts/decision_making_example.py` and `references/constraints_mcdm.md` for detailed MCDM methods.

## Workflow 7: Visualization

**Choose visualization based on number of objectives.**

**2 objectives: Scatter Plot**
```python
from pymoo.visualization.scatter import Scatter

plot = Scatter(title="Bi-objective Results")
plot.add(result.F, color="blue", alpha=0.7)
plot.show()
```

**3 objectives: 3D Scatter**
```python
plot = Scatter(title="Tri-objective Results")
plot.add(result.F)  # Automatically renders in 3D
plot.show()
```

**4+ objectives: Parallel Coordinate Plot**
```python
from pymoo.visualization.pcp import PCP

plot = PCP(
    labels=[f"f{i+1}" for i in range(n_obj)],
    normalize_each_axis=True
)
plot.add(result.F, alpha=0.3)
plot.show()
```

**Solution comparison: Petal Diagram**
```python
from pymoo.visualization.petal import Petal

plot = Petal(
    bounds=[result.F.min(axis=0), result.F.max(axis=0)],
    labels=["Cost", "Weight", "Efficiency"]
)
plot.add(solution_A, label="Design A")
plot.add(solution_B, label="Design B")
plot.show()
```

See `references/visualization.md` for all visualization types and usage.

"""
Custom problem definition example using pymoo.

This script demonstrates how to define a custom optimization problem
and solve it using pymoo.
"""

from pymoo.core.problem import ElementwiseProblem
from pymoo.algorithms.moo.nsga2 import NSGA2
from pymoo.optimize import minimize
from pymoo.visualization.scatter import Scatter
import numpy as np


class MyBiObjectiveProblem(ElementwiseProblem):
    """
    Custom bi-objective optimization problem.

    Minimize:
        f1(x) = x1^2 + x2^2
        f2(x) = (x1-1)^2 + (x2-1)^2

    Subject to:
        0 <= x1 <= 5
        0 <= x2 <= 5
    """

    def __init__(self):
        super().__init__(
            n_var=2,                    # Number of decision variables
            n_obj=2,                    # Number of objectives
            n_ieq_constr=0,            # Number of inequality constraints
            n_eq_constr=0,             # Number of equality constraints
            xl=np.array([0, 0]),       # Lower bounds
            xu=np.array([5, 5])        # Upper bounds
        )

    def _evaluate(self, x, out, *args, **kwargs):
        """Evaluate objectives for a single solution."""
        # Objective 1: Distance from origin
        f1 = x[0]**2 + x[1]**2

        # Objective 2: Distance from (1, 1)
        f2 = (x[0] - 1)**2 + (x[1] - 1)**2

        # Return objectives
        out["F"] = [f1, f2]


class ConstrainedProblem(ElementwiseProblem):
    """
    Custom constrained bi-objective problem.

    Minimize:
        f1(x) = x1
        f2(x) = (1 + x2) / x1

    Subject to:
        x2 + 9*x1 >= 6          (g1 <= 0)
        -x2 + 9*x1 >= 1         (g2 <= 0)
        0.1 <= x1 <= 1
        0 <= x2 <= 5
    """

    def __init__(self):
        super().__init__(
            n_var=2,
            n_obj=2,
            n_ieq_constr=2,            # Two inequality constraints
            xl=np.array([0.1, 0.0]),
            xu=np.array([1.0, 5.0])
        )

    def _evaluate(self, x, out, *args, **kwargs):
        """Evaluate objectives and constraints."""
        # Objectives
        f1 = x[0]
        f2 = (1 + x[1]) / x[0]

        out["F"] = [f1, f2]

        # Inequality constraints (g <= 0)
        # Convert g1: x2 + 9*x1 >= 6  →  -(x2 + 9*x1 - 6) <= 0
        g1 = -(x[1] + 9 * x[0] - 6)

        # Convert g2: -x2 + 9*x1 >= 1  →  -(-x2 + 9*x1 - 1) <= 0
        g2 = -(-x[1] + 9 * x[0] - 1)

        out["G"] = [g1, g2]


def solve_custom_problem():
    """Solve custom bi-objective problem."""

    print("="*60)
    print("CUSTOM PROBLEM - UNCONSTRAINED")
    print("="*60)

    # Define custom problem
    problem = MyBiObjectiveProblem()

    # Configure algorithm
    algorithm = NSGA2(pop_size=100)

    # Solve
    result = minimize(
        problem,
        algorithm,
        ('n_gen', 200),
        seed=1,
        verbose=False
    )

    print(f"Number of solutions: {len(result.F)}")
    print(f"Objective space range:")
    print(f"  f1: [{result.F[:, 0].min():.3f}, {result.F[:, 0].max():.3f}]")
    print(f"  f2: [{result.F[:, 1].min():.3f}, {result.F[:, 1].max():.3f}]")

    # Visualize
    plot = Scatter(title="Custom Bi-Objective Problem")
    plot.add(result.F, color="blue", alpha=0.7)
    plot.show()

    return result


def solve_constrained_problem():
    """Solve custom constrained problem."""

    print("\n" + "="*60)
    print("CUSTOM PROBLEM - CONSTRAINED")
    print("="*60)

    # Define constrained problem
    problem = ConstrainedProblem()

    # Configure algorithm
    algorithm = NSGA2(pop_size=100)

    # Solve
    result = minimize(
        problem,
        algorithm,
        ('n_gen', 200),
        seed=1,
        verbose=False
    )

    # Check feasibility
    feasible = result.CV[:, 0] == 0  # Constraint violation = 0

    print(f"Total solutions: {len(result.F)}")
    print(f"Feasible solutions: {np.sum(feasible)}")
    print(f"Infeasible solutions: {np.sum(~feasible)}")

    if np.any(feasible):
        F_feasible = result.F[feasible]
        print(f"\nFeasible objective space range:")
        print(f"  f1: [{F_feasible[:, 0].min():.3f}, {F_feasible[:, 0].max():.3f}]")
        print(f"  f2: [{F_feasible[:, 1].min():.3f}, {F_feasible[:, 1].max():.3f}]")

        # Visualize feasible solutions
        plot = Scatter(title="Constrained Problem - Feasible Solutions")
        plot.add(F_feasible, color="green", alpha=0.7, label="Feasible")

        if np.any(~feasible):
            plot.add(result.F[~feasible], color="red", alpha=0.3, s=10, label="Infeasible")

        plot.show()

    return result


if __name__ == "__main__":
    # Run both examples
    result1 = solve_custom_problem()
    result2 = solve_constrained_problem()

    print("\n" + "="*60)
    print("EXAMPLES COMPLETED")
    print("="*60)

"""
Multi-criteria decision making example using pymoo.

This script demonstrates how to select preferred solutions from
a Pareto front using various MCDM methods.
"""

from pymoo.algorithms.moo.nsga2 import NSGA2
from pymoo.problems import get_problem
from pymoo.optimize import minimize
from pymoo.mcdm.pseudo_weights import PseudoWeights
from pymoo.visualization.scatter import Scatter
from pymoo.visualization.petal import Petal
import numpy as np


def run_optimization_for_decision_making():
    """Run optimization to obtain Pareto front."""

    print("Running optimization to obtain Pareto front...")

    # Solve ZDT1 problem
    problem = get_problem("zdt1")
    algorithm = NSGA2(pop_size=100)

    result = minimize(
        problem,
        algorithm,
        ('n_gen', 200),
        seed=1,
        verbose=False
    )

    print(f"Obtained {len(result.F)} solutions in Pareto front\n")

    return problem, result


def apply_pseudo_weights(result, weights):
    """Apply pseudo-weights MCDM method."""

    print(f"Applying Pseudo-Weights with weights: {weights}")

    # Normalize objectives to [0, 1]
    F_norm = (result.F - result.F.min(axis=0)) / (result.F.max(axis=0) - result.F.min(axis=0))

    # Apply MCDM
    dm = PseudoWeights(weights)
    selected_idx = dm.do(F_norm)

    selected_x = result.X[selected_idx]
    selected_f = result.F[selected_idx]

    print(f"Selected solution (decision variables): {selected_x}")
    print(f"Selected solution (objectives): {selected_f}")
    print()

    return selected_idx, selected_x, selected_f


def compare_different_preferences(result):
    """Compare selections with different preference weights."""

    print("="*60)
    print("COMPARING DIFFERENT PREFERENCE WEIGHTS")
    print("="*60 + "\n")

    # Define different preference scenarios
    scenarios = [
        ("Equal preference", np.array([0.5, 0.5])),
        ("Prefer f1", np.array([0.8, 0.2])),
        ("Prefer f2", np.array([0.2, 0.8])),
    ]

    selections = {}

    for name, weights in scenarios:
        print(f"Scenario: {name}")
        idx, x, f = apply_pseudo_weights(result, weights)
        selections[name] = (idx, f)

    # Visualize all selections
    plot = Scatter(title="Decision Making - Different Preferences")
    plot.add(result.F, color="lightgray", alpha=0.5, s=20, label="Pareto Front")

    colors = ["red", "blue", "green"]
    for (name, (idx, f)), color in zip(selections.items(), colors):
        plot.add(f, color=color, s=100, marker="*", label=name)

    plot.show()

    return selections


def visualize_selected_solutions(result, selections):
    """Visualize selected solutions using petal diagram."""

    # Get objective bounds for normalization
    f_min = result.F.min(axis=0)
    f_max = result.F.max(axis=0)

    plot = Petal(
        title="Selected Solutions Comparison",
        bounds=[f_min, f_max],
        labels=["f1", "f2"]
    )

    colors = ["red", "blue", "green"]
    for (name, (idx, f)), color in zip(selections.items(), colors):
        plot.add(f, color=color, label=name)

    plot.show()


def find_extreme_solutions(result):
    """Find extreme solutions (best in each objective)."""

    print("\n" + "="*60)
    print("EXTREME SOLUTIONS")
    print("="*60 + "\n")

    # Best f1 (minimize f1)
    best_f1_idx = np.argmin(result.F[:, 0])
    print(f"Best f1 solution: {result.F[best_f1_idx]}")
    print(f"  Decision variables: {result.X[best_f1_idx]}\n")

    # Best f2 (minimize f2)
    best_f2_idx = np.argmin(result.F[:, 1])
    print(f"Best f2 solution: {result.F[best_f2_idx]}")
    print(f"  Decision variables: {result.X[best_f2_idx]}\n")

    return best_f1_idx, best_f2_idx


def main():
    """Main execution function."""

    # Step 1: Run optimization
    problem, result = run_optimization_for_decision_making()

    # Step 2: Find extreme solutions
    best_f1_idx, best_f2_idx = find_extreme_solutions(result)

    # Step 3: Compare different preference weights
    selections = compare_different_preferences(result)

    # Step 4: Visualize selections with petal diagram
    visualize_selected_solutions(result, selections)

    print("="*60)
    print("DECISION MAKING EXAMPLE COMPLETED")
    print("="*60)
    print("\nKey Takeaways:")
    print("1. Different weights lead to different selected solutions")
    print("2. Higher weight on an objective selects solutions better in that objective")
    print("3. Visualization helps understand trade-offs")
    print("4. MCDM methods help formalize decision maker preferences")


if __name__ == "__main__":
    main()

"""
Many-objective optimization example using pymoo.

This script demonstrates many-objective optimization (4+ objectives)
using NSGA-III on the DTLZ2 benchmark problem.
"""

from pymoo.algorithms.moo.nsga3 import NSGA3
from pymoo.problems import get_problem
from pymoo.optimize import minimize
from pymoo.util.ref_dirs import get_reference_directions
from pymoo.visualization.pcp import PCP


def run_many_objective_optimization():
    """Run many-objective optimization example."""

    # Define the problem - DTLZ2 with 5 objectives
    n_obj = 5
    problem = get_problem("dtlz2", n_obj=n_obj)

    # Generate reference directions for NSGA-III
    # Das-Dennis method for uniform distribution
    ref_dirs = get_reference_directions("das-dennis", n_obj, n_partitions=12)

    print(f"Number of reference directions: {len(ref_dirs)}")

    # Configure NSGA-III algorithm
    algorithm = NSGA3(
        ref_dirs=ref_dirs,
        eliminate_duplicates=True
    )

    # Run optimization
    result = minimize(
        problem,
        algorithm,
        ('n_gen', 300),
        seed=1,
        verbose=True
    )

    # Print results summary
    print("\n" + "="*60)
    print("MANY-OBJECTIVE OPTIMIZATION RESULTS")
    print("="*60)
    print(f"Number of objectives: {n_obj}")
    print(f"Number of solutions: {len(result.F)}")
    print(f"Number of generations: {result.algorithm.n_gen}")
    print(f"Number of function evaluations: {result.algorithm.evaluator.n_eval}")

    # Show objective space statistics
    print("\nObjective space statistics:")
    print(f"Minimum values per objective: {result.F.min(axis=0)}")
    print(f"Maximum values per objective: {result.F.max(axis=0)}")
    print("="*60)

    # Visualize using Parallel Coordinate Plot
    plot = PCP(
        title=f"DTLZ2 ({n_obj} objectives) - NSGA-III Results",
        labels=[f"f{i+1}" for i in range(n_obj)],
        normalize_each_axis=True
    )
    plot.add(result.F, alpha=0.3, color="blue")
    plot.show()

    return result


if __name__ == "__main__":
    result = run_many_objective_optimization()

"""
Multi-objective optimization example using pymoo.

This script demonstrates multi-objective optimization using
NSGA-II on the ZDT1 benchmark problem.
"""

from pymoo.algorithms.moo.nsga2 import NSGA2
from pymoo.problems import get_problem
from pymoo.optimize import minimize
from pymoo.visualization.scatter import Scatter


def run_multi_objective_optimization():
    """Run multi-objective optimization example."""

    # Define the problem - ZDT1 (bi-objective)
    problem = get_problem("zdt1")

    # Configure NSGA-II algorithm
    algorithm = NSGA2(
        pop_size=100,
        eliminate_duplicates=True
    )

    # Run optimization
    result = minimize(
        problem,
        algorithm,
        ('n_gen', 200),
        seed=1,
        verbose=True
    )

    # Print results summary
    print("\n" + "="*60)
    print("MULTI-OBJECTIVE OPTIMIZATION RESULTS")
    print("="*60)
    print(f"Number of solutions in Pareto front: {len(result.F)}")
    print(f"Number of generations: {result.algorithm.n_gen}")
    print(f"Number of function evaluations: {result.algorithm.evaluator.n_eval}")
    print("\nFirst 5 solutions (decision variables):")
    print(result.X[:5])
    print("\nFirst 5 solutions (objective values):")
    print(result.F[:5])
    print("="*60)

    # Visualize results
    plot = Scatter(title="ZDT1 - NSGA-II Results")
    plot.add(result.F, color="red", alpha=0.7, s=30, label="Obtained Pareto Front")

    # Add true Pareto front for comparison
    pf = problem.pareto_front()
    plot.add(pf, color="black", alpha=0.3, label="True Pareto Front")

    plot.show()

    return result


if __name__ == "__main__":
    result = run_multi_objective_optimization()

"""
Single-objective optimization example using pymoo.

This script demonstrates basic single-objective optimization
using the Genetic Algorithm on the Sphere function.
"""

from pymoo.algorithms.soo.nonconvex.ga import GA
from pymoo.problems import get_problem
from pymoo.optimize import minimize
from pymoo.operators.crossover.sbx import SBX
from pymoo.operators.mutation.pm import PM
from pymoo.operators.sampling.rnd import FloatRandomSampling
from pymoo.termination import get_termination


def run_single_objective_optimization():
    """Run single-objective optimization example."""

    # Define the problem - Sphere function (sum of squares)
    problem = get_problem("sphere", n_var=10)

    # Configure the algorithm
    algorithm = GA(
        pop_size=100,
        sampling=FloatRandomSampling(),
        crossover=SBX(prob=0.9, eta=15),
        mutation=PM(eta=20),
        eliminate_duplicates=True
    )

    # Define termination criteria
    termination = get_termination("n_gen", 100)

    # Run optimization
    result = minimize(
        problem,
        algorithm,
        termination,
        seed=1,
        verbose=True
    )

    # Print results
    print("\n" + "="*60)
    print("OPTIMIZATION RESULTS")
    print("="*60)
    print(f"Best solution: {result.X}")
    print(f"Best objective value: {result.F[0]:.6f}")
    print(f"Number of generations: {result.algorithm.n_gen}")
    print(f"Number of function evaluations: {result.algorithm.evaluator.n_eval}")
    print("="*60)

    return result


if __name__ == "__main__":
    result = run_single_objective_optimization()