Operations and Transformations

class Constraint:
    """
    Operator for applying constraints on Parameters during optimization.
    
    The constraint function should return positive values when constraints 
    are violated, and zero or negative values when constraints are satisfied.
    
    Parameters:
    - func: Constraint function that returns positive values for violations
    - optimizer: Optimizer name for constraint solving (str, default="NGOpt")
    - budget: Budget for constraint application (int, default=100)
    """
    
    def __init__(self, func: Callable, optimizer: str = "NGOpt", budget: int = 100):
        """Initialize constraint with function and solver parameters."""
    
    def __call__(self, parameter: Parameter) -> Parameter:
        """Apply constraint to parameter, returning constrained version."""
    
    def apply_constraint(self, parameter: Parameter) -> Parameter:
        """Find parameter that better satisfies the constraint."""
    
    def function(self, parameter: Parameter) -> float:
        """Wrapper ensuring constraint returns non-negative values."""
    
    def stopping_criterion(self, parameter: Parameter) -> bool:
        """Check if acceptable solution was found."""

class Mutation:
    """
    Base class for custom mutation and recombination operations.
    
    All mutations follow the pattern: mutation(parameter) or mutation()(parameter)
    """
    
    def __call__(self, parameter: Parameter, inplace: bool = False) -> Parameter:
        """Apply mutation to parameter."""
    
    def root(self) -> Parameter:
        """Get root parameter being mutated."""

class DataMutation(Mutation):
    """Base class for mutations that operate on Data parameters."""

class Crossover(DataMutation):
    """
    Array crossover operation that merges parts of arrays.
    
    Parameters:
    - axis: Axis along which to perform crossover (int, optional)
    - max_size: Maximum size for crossover segments (int, optional)
    - fft: Use FFT-based crossover (bool, default=False)
    """
    
    def __init__(self, axis: int = None, max_size: int = None, fft: bool = False):
        """Initialize crossover with parameters."""

class RavelCrossover(Crossover):
    """
    Crossover operation after flattening arrays.
    
    Parameters:
    - max_size: Maximum size for crossover segments (int, optional)
    """

class Translation(DataMutation):
    """
    Array translation that shifts elements along specified axes.
    
    Parameters:
    - axis: Axis or axes for translation (None, int, or iterable of ints)
    """
    
    def __init__(self, axis = None):
        """Initialize translation with axis specification."""

class Jumping(DataMutation):
    """
    Array jumping that moves chunks between positions.
    
    Parameters:
    - axis: Axis for jumping operation (int, optional)
    - size: Size of chunks to move (int, optional)
    """

class LocalGaussian(DataMutation):
    """
    Local Gaussian noise applied to specific regions.
    
    Parameters:
    - size: Size of local region (int, optional)
    - axes: Axes for local application (optional)
    """

class Cauchy(Mutation):
    """Cauchy mutation applied to entire parameter."""

class MutationChoice(DataMutation):
    """
    Selection between multiple mutations based on Choice parameter.
    
    Parameters:
    - mutations: List of mutation operations
    - with_default: Include default mutation (bool, default=True)
    """

def Int(deterministic: bool = True):
    """
    Cast Data parameters as integers or integer arrays.
    
    Parameters:
    - deterministic: Rounding strategy (bool, default=True)
        - True: Round to nearest integer
        - False: Probabilistic sampling of surrounding integers
    
    Returns:
        Function that applies integer casting to parameters
    
    Examples:
        Deterministic: 0.2 → 0, 0.8 → 1
        Probabilistic: 0.2 → 0 (80% chance) or 1 (20% chance)
    """

import nevergrad as ng

# Define constraint function (returns positive when violated)
def constraint_func(x):
    # Constraint: sum of squares should be <= 1
    return max(0, sum(x.value**2) - 1)

# Create constrained parameter
param = ng.p.Array(shape=(3,))
constrained_param = ng.ops.constraints.Constraint(constraint_func)(param)

# Use in optimization
optimizer = ng.optimizers.CMA(parametrization=constrained_param, budget=100)

# Apply crossover mutation
param = ng.p.Array(shape=(10,))
mutated = ng.ops.mutations.Crossover(axis=0)(param)

# Apply translation along specific axis
translated = ng.ops.mutations.Translation(axis=1)(param)

# Apply local Gaussian noise
local_noise = ng.ops.mutations.LocalGaussian(size=3)(param)

# Chain multiple mutations
mutation_combo = ng.ops.mutations.MutationChoice([
    ng.ops.mutations.Crossover(),
    ng.ops.mutations.Translation(),
    ng.ops.mutations.Cauchy()
])
result = mutation_combo(param)

# Deterministic integer casting
continuous_param = ng.p.Array(shape=(5,)).set_bounds(-10, 10)
integer_param = ng.ops.Int(deterministic=True)(continuous_param)

# Probabilistic integer casting
prob_integer = ng.ops.Int(deterministic=False)(continuous_param)

# Use in optimization
optimizer = ng.optimizers.DE(parametrization=integer_param, budget=50)

def discrete_function(x):
    # Function that works with integer inputs
    return sum(int(val)**2 for val in x.value)

recommendation = optimizer.minimize(discrete_function)
print(f"Best integer solution: {[int(x) for x in recommendation.value]}")

# Multi-constraint optimization
def volume_constraint(x):
    # Volume must be positive
    return max(0, -x.value[0] * x.value[1] * x.value[2])

def surface_constraint(x):
    # Surface area must be <= 100
    a, b, c = x.value
    surface = 2 * (a*b + b*c + a*c)
    return max(0, surface - 100)

# Apply multiple constraints
param = ng.p.Array(shape=(3,)).set_bounds(0.1, 10)
constrained = ng.ops.constraints.Constraint(volume_constraint)(param)
constrained = ng.ops.constraints.Constraint(surface_constraint)(constrained)

# Optimize with constraints
optimizer = ng.optimizers.CMA(parametrization=constrained, budget=200)