@elaraai/east-py-datascience 0.0.2-beta.7 → 0.0.2-beta.71

package/README.md

@@ -14,6 +14,45 @@
 npm install @elaraai/east-py-datascience @elaraai/east
 ```
 
+### Python Optional Dependencies
+
+Each module has its own optional Python dependencies to avoid installing unnecessary packages. Install only the extras you need:
+
+```bash
+# Single extra
+pip install "east-py-datascience[scipy]"
+
+# Multiple extras
+pip install "east-py-datascience[scipy,sklearn,xgboost]"
+
+# All extras
+pip install "east-py-datascience[all]"
+```
+
+When using a git dependency in `pyproject.toml`:
+```toml
+"east-py-datascience[scipy] @ git+https://github.com/elaraai/east-py@main#subdirectory=packages/east-py-datascience"
+```
+
+| Module | Extra | Python Packages |
+|--------|-------|-----------------|
+| **MADS** | `mads` | PyNomadBBO |
+| **Optuna** | `optuna` | optuna |
+| **SimAnneal** | `simanneal` | simanneal |
+| **Scipy** | `scipy` | scipy, cloudpickle |
+| **Optimization** | *(none)* | *(core only — numpy)* |
+| **GoogleOr** | `google-or` | ortools |
+| **Sklearn** | `sklearn` | scikit-learn, skl2onnx, onnxruntime, cloudpickle |
+| **XGBoost** | `xgboost` | xgboost, cloudpickle |
+| **LightGBM** | `lightgbm` | lightgbm, cloudpickle |
+| **NGBoost** | `ngboost` | ngboost, cloudpickle |
+| **Torch** | `torch` | torch, cloudpickle |
+| **GP** | `gp` | scikit-learn, cloudpickle |
+| **Lightning** | `lightning` | torch, pytorch-lightning, cloudpickle |
+| **Shap** | `shap` | shap, cloudpickle |
+| **MAPIE** | `mapie` | mapie, cloudpickle |
+| **ALNS** | `alns` | alns |
+
 ## Quick Start
 
 ```typescript
@@ -57,12 +96,14 @@ const optimize = East.function([], MADS.Types.ResultType, $ => {
 | **Optuna** | Bayesian optimization with TPE sampler | Hyperparameter tuning, mixed-type parameters, efficient search with few evaluations |
 | **SimAnneal** | Simulated annealing for discrete optimization | TSP, scheduling, subset selection, knapsack, assignment problems |
 | **Scipy** | Scientific optimization and curve fitting | Gradient-based minimization, curve fitting, interpolation, statistics |
+| **Optimization** | Iterative coordinate descent optimization | Parameter tuning, sequential optimization across parameter groups |
+| **GoogleOr** | Google OR-Tools constraint programming, routing, LP, and graph algorithms | CP-SAT, vehicle routing (TSP/VRP), linear/mixed-integer programming, min-cost flow, max flow, assignment |
 
 ### Machine Learning
 
 | Module | Description | Use Cases |
 |--------|-------------|-----------|
-| **Sklearn** | Core ML utilities from scikit-learn | Train/test split, preprocessing (StandardScaler, MinMaxScaler), metrics, multi-target regression |
+| **Sklearn** | Core ML utilities from scikit-learn | Train/test split, preprocessing (StandardScaler, MinMaxScaler), metrics, multi-target regression, Gaussian Mixture Models |
 | **XGBoost** | Gradient boosting with XGBoost | Regression, classification, feature importance, fast training |
 | **LightGBM** | Fast gradient boosting with leaf-wise growth | Large datasets, high cardinality features, faster than XGBoost on big data |
 | **NGBoost** | Natural gradient boosting with uncertainty | Probabilistic predictions, confidence intervals, uncertainty quantification |

package/dist/alns/alns.d.ts

@@ -0,0 +1,528 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * ALNS (Adaptive Large Neighborhood Search) metaheuristic optimization.
+ *
+ * Provides combinatorial optimization using destroy-repair operators.
+ * ALNS is designed for discrete optimization problems where:
+ * - Solutions are combinatorial (assignments, schedules, routes)
+ * - Domain-specific destroy/repair operators can be defined
+ * - The objective function may be complex or black-box
+ * - Local search alone gets stuck in local minima
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, ArrayType, IntegerType, BooleanType, FloatType, NullType, FunctionType } from "@elaraai/east";
+/**
+ * Simulated annealing acceptance configuration.
+ */
+export declare const SimulatedAnnealingConfigType: StructType<{
+    /** Starting temperature (default: 100.0) */
+    readonly start_temperature: OptionType<FloatType>;
+    /** Ending temperature (default: 0.01) */
+    readonly end_temperature: OptionType<FloatType>;
+    /** Cooling step multiplier (default: 0.99) */
+    readonly step: OptionType<FloatType>;
+}>;
+/**
+ * Record-to-record travel acceptance configuration.
+ */
+export declare const RecordToRecordConfigType: StructType<{
+    /** Threshold as fraction of best objective (default: 0.05) */
+    readonly threshold: OptionType<FloatType>;
+}>;
+/**
+ * Acceptance criterion variant.
+ *
+ * Controls whether to accept or reject new solutions:
+ * - `simulated_annealing`: Probabilistic acceptance based on temperature
+ * - `hill_climbing`: Only accept improving solutions
+ * - `record_to_record`: Accept if within threshold of best
+ */
+export declare const AcceptanceCriterionType: VariantType<{
+    readonly simulated_annealing: StructType<{
+        /** Starting temperature (default: 100.0) */
+        readonly start_temperature: OptionType<FloatType>;
+        /** Ending temperature (default: 0.01) */
+        readonly end_temperature: OptionType<FloatType>;
+        /** Cooling step multiplier (default: 0.99) */
+        readonly step: OptionType<FloatType>;
+    }>;
+    readonly hill_climbing: NullType;
+    readonly record_to_record: StructType<{
+        /** Threshold as fraction of best objective (default: 0.05) */
+        readonly threshold: OptionType<FloatType>;
+    }>;
+}>;
+/**
+ * Roulette wheel selection configuration.
+ *
+ * Scores are applied when an operator finds: [new_best, better, accepted, rejected]
+ */
+export declare const RouletteWheelConfigType: StructType<{
+    /** Scores for [new_best, better, accepted, rejected] (default: [33, 9, 3, 0]) */
+    readonly scores: OptionType<ArrayType<IntegerType>>;
+    /** Weight decay factor (default: 0.8) */
+    readonly decay: OptionType<FloatType>;
+}>;
+/**
+ * Operator selection strategy variant.
+ */
+export declare const OperatorSelectionType: VariantType<{
+    readonly roulette_wheel: StructType<{
+        /** Scores for [new_best, better, accepted, rejected] (default: [33, 9, 3, 0]) */
+        readonly scores: OptionType<ArrayType<IntegerType>>;
+        /** Weight decay factor (default: 0.8) */
+        readonly decay: OptionType<FloatType>;
+    }>;
+}>;
+/**
+ * Stopping criterion variant.
+ *
+ * Controls when to stop the optimization:
+ * - `max_iterations`: Stop after N iterations
+ * - `max_runtime`: Stop after N seconds
+ * - `no_improvement`: Stop after N iterations without improvement
+ */
+export declare const StopCriterionType: VariantType<{
+    readonly max_iterations: IntegerType;
+    readonly max_runtime: FloatType;
+    readonly no_improvement: IntegerType;
+}>;
+/**
+ * ALNS optimization configuration.
+ */
+export declare const ALNSConfigType: StructType<{
+    /** Stopping criterion (default: max_iterations 1000) */
+    readonly stop: OptionType<VariantType<{
+        readonly max_iterations: IntegerType;
+        readonly max_runtime: FloatType;
+        readonly no_improvement: IntegerType;
+    }>>;
+    /** Acceptance criterion (default: simulated_annealing) */
+    readonly acceptance: OptionType<VariantType<{
+        readonly simulated_annealing: StructType<{
+            /** Starting temperature (default: 100.0) */
+            readonly start_temperature: OptionType<FloatType>;
+            /** Ending temperature (default: 0.01) */
+            readonly end_temperature: OptionType<FloatType>;
+            /** Cooling step multiplier (default: 0.99) */
+            readonly step: OptionType<FloatType>;
+        }>;
+        readonly hill_climbing: NullType;
+        readonly record_to_record: StructType<{
+            /** Threshold as fraction of best objective (default: 0.05) */
+            readonly threshold: OptionType<FloatType>;
+        }>;
+    }>>;
+    /** Operator selection strategy (default: roulette_wheel) */
+    readonly operator_selection: OptionType<VariantType<{
+        readonly roulette_wheel: StructType<{
+            /** Scores for [new_best, better, accepted, rejected] (default: [33, 9, 3, 0]) */
+            readonly scores: OptionType<ArrayType<IntegerType>>;
+            /** Weight decay factor (default: 0.8) */
+            readonly decay: OptionType<FloatType>;
+        }>;
+    }>>;
+    /** Random seed for reproducibility */
+    readonly seed: OptionType<IntegerType>;
+}>;
+/**
+ * ALNS optimization result type.
+ * Note: For generic platform usage, the result type is defined inline
+ * with "S" placeholder. This function is kept for backwards compatibility.
+ */
+export declare const ALNSResultType: StructType<{
+    /** Best solution found */
+    readonly best_solution: "S";
+    /** Best objective value */
+    readonly best_objective: FloatType;
+    /** Number of iterations performed */
+    readonly iterations: IntegerType;
+    /** Total runtime in seconds */
+    readonly runtime: FloatType;
+    /** Whether optimization succeeded */
+    readonly success: BooleanType;
+}>;
+/**
+ * ALNS optimization platform function (generic over solution type S).
+ *
+ * Minimizes an objective function using destroy-repair operators.
+ * Operators are defined as S -> S functions that modify the solution.
+ *
+ * @example
+ * ```ts
+ * import { East, StructType, ArrayType, StringType, FloatType, variant } from "@elaraai/east";
+ * import { ALNS } from "@elaraai/east-py-datascience";
+ *
+ * const SolutionType = StructType({
+ *     assignments: ArrayType(StringType),
+ *     cost: FloatType,
+ * });
+ *
+ * const optimize = East.function([SolutionType], ALNS.Types.ResultType, ($, initial) => {
+ *     // Define operators inline (they can access outer scope variables)
+ *     const objective = East.function([SolutionType], FloatType, ($, s) => $.return(s.cost));
+ *     const destroy = East.function([SolutionType], SolutionType, ($, s) => $.return(s));
+ *     const repair = East.function([SolutionType], SolutionType, ($, s) => $.return(s));
+ *
+ *     const config = $.let({
+ *         stop: variant('some', variant('max_iterations', 1000n)),
+ *         acceptance: variant('none', null),
+ *         operator_selection: variant('none', null),
+ *         seed: variant('some', 42n),
+ *     });
+ *
+ *     const result = $.let(ALNS.optimize([SolutionType], initial, objective, [destroy], [repair], config));
+ *     $.return(result);
+ * });
+ * ```
+ */
+export declare const alns_optimize: import("@elaraai/east").GenericPlatformDefinition<readonly ["S"], readonly ["S", FunctionType<["S"], FloatType>, ArrayType<FunctionType<["S"], "S">>, ArrayType<FunctionType<["S"], "S">>, StructType<{
+    /** Stopping criterion (default: max_iterations 1000) */
+    readonly stop: OptionType<VariantType<{
+        readonly max_iterations: IntegerType;
+        readonly max_runtime: FloatType;
+        readonly no_improvement: IntegerType;
+    }>>;
+    /** Acceptance criterion (default: simulated_annealing) */
+    readonly acceptance: OptionType<VariantType<{
+        readonly simulated_annealing: StructType<{
+            /** Starting temperature (default: 100.0) */
+            readonly start_temperature: OptionType<FloatType>;
+            /** Ending temperature (default: 0.01) */
+            readonly end_temperature: OptionType<FloatType>;
+            /** Cooling step multiplier (default: 0.99) */
+            readonly step: OptionType<FloatType>;
+        }>;
+        readonly hill_climbing: NullType;
+        readonly record_to_record: StructType<{
+            /** Threshold as fraction of best objective (default: 0.05) */
+            readonly threshold: OptionType<FloatType>;
+        }>;
+    }>>;
+    /** Operator selection strategy (default: roulette_wheel) */
+    readonly operator_selection: OptionType<VariantType<{
+        readonly roulette_wheel: StructType<{
+            /** Scores for [new_best, better, accepted, rejected] (default: [33, 9, 3, 0]) */
+            readonly scores: OptionType<ArrayType<IntegerType>>;
+            /** Weight decay factor (default: 0.8) */
+            readonly decay: OptionType<FloatType>;
+        }>;
+    }>>;
+    /** Random seed for reproducibility */
+    readonly seed: OptionType<IntegerType>;
+}>], StructType<{
+    /** Best solution found */
+    readonly best_solution: "S";
+    /** Best objective value */
+    readonly best_objective: FloatType;
+    /** Number of iterations performed */
+    readonly iterations: IntegerType;
+    /** Total runtime in seconds */
+    readonly runtime: FloatType;
+    /** Whether optimization succeeded */
+    readonly success: BooleanType;
+}>>;
+/**
+ * Type definitions for ALNS optimization.
+ */
+export declare const ALNSTypes: {
+    /** Simulated annealing config */
+    readonly SimulatedAnnealingConfigType: StructType<{
+        /** Starting temperature (default: 100.0) */
+        readonly start_temperature: OptionType<FloatType>;
+        /** Ending temperature (default: 0.01) */
+        readonly end_temperature: OptionType<FloatType>;
+        /** Cooling step multiplier (default: 0.99) */
+        readonly step: OptionType<FloatType>;
+    }>;
+    /** Record-to-record config */
+    readonly RecordToRecordConfigType: StructType<{
+        /** Threshold as fraction of best objective (default: 0.05) */
+        readonly threshold: OptionType<FloatType>;
+    }>;
+    /** Acceptance criterion variant */
+    readonly AcceptanceCriterionType: VariantType<{
+        readonly simulated_annealing: StructType<{
+            /** Starting temperature (default: 100.0) */
+            readonly start_temperature: OptionType<FloatType>;
+            /** Ending temperature (default: 0.01) */
+            readonly end_temperature: OptionType<FloatType>;
+            /** Cooling step multiplier (default: 0.99) */
+            readonly step: OptionType<FloatType>;
+        }>;
+        readonly hill_climbing: NullType;
+        readonly record_to_record: StructType<{
+            /** Threshold as fraction of best objective (default: 0.05) */
+            readonly threshold: OptionType<FloatType>;
+        }>;
+    }>;
+    /** Roulette wheel selection config */
+    readonly RouletteWheelConfigType: StructType<{
+        /** Scores for [new_best, better, accepted, rejected] (default: [33, 9, 3, 0]) */
+        readonly scores: OptionType<ArrayType<IntegerType>>;
+        /** Weight decay factor (default: 0.8) */
+        readonly decay: OptionType<FloatType>;
+    }>;
+    /** Operator selection variant */
+    readonly OperatorSelectionType: VariantType<{
+        readonly roulette_wheel: StructType<{
+            /** Scores for [new_best, better, accepted, rejected] (default: [33, 9, 3, 0]) */
+            readonly scores: OptionType<ArrayType<IntegerType>>;
+            /** Weight decay factor (default: 0.8) */
+            readonly decay: OptionType<FloatType>;
+        }>;
+    }>;
+    /** Stop criterion variant */
+    readonly StopCriterionType: VariantType<{
+        readonly max_iterations: IntegerType;
+        readonly max_runtime: FloatType;
+        readonly no_improvement: IntegerType;
+    }>;
+    /** Main configuration type */
+    readonly ConfigType: StructType<{
+        /** Stopping criterion (default: max_iterations 1000) */
+        readonly stop: OptionType<VariantType<{
+            readonly max_iterations: IntegerType;
+            readonly max_runtime: FloatType;
+            readonly no_improvement: IntegerType;
+        }>>;
+        /** Acceptance criterion (default: simulated_annealing) */
+        readonly acceptance: OptionType<VariantType<{
+            readonly simulated_annealing: StructType<{
+                /** Starting temperature (default: 100.0) */
+                readonly start_temperature: OptionType<FloatType>;
+                /** Ending temperature (default: 0.01) */
+                readonly end_temperature: OptionType<FloatType>;
+                /** Cooling step multiplier (default: 0.99) */
+                readonly step: OptionType<FloatType>;
+            }>;
+            readonly hill_climbing: NullType;
+            readonly record_to_record: StructType<{
+                /** Threshold as fraction of best objective (default: 0.05) */
+                readonly threshold: OptionType<FloatType>;
+            }>;
+        }>>;
+        /** Operator selection strategy (default: roulette_wheel) */
+        readonly operator_selection: OptionType<VariantType<{
+            readonly roulette_wheel: StructType<{
+                /** Scores for [new_best, better, accepted, rejected] (default: [33, 9, 3, 0]) */
+                readonly scores: OptionType<ArrayType<IntegerType>>;
+                /** Weight decay factor (default: 0.8) */
+                readonly decay: OptionType<FloatType>;
+            }>;
+        }>>;
+        /** Random seed for reproducibility */
+        readonly seed: OptionType<IntegerType>;
+    }>;
+    /** Result type (with "S" placeholder for solution type) */
+    readonly ResultType: StructType<{
+        /** Best solution found */
+        readonly best_solution: "S";
+        /** Best objective value */
+        readonly best_objective: FloatType;
+        /** Number of iterations performed */
+        readonly iterations: IntegerType;
+        /** Total runtime in seconds */
+        readonly runtime: FloatType;
+        /** Whether optimization succeeded */
+        readonly success: BooleanType;
+    }>;
+};
+/**
+ * ALNS (Adaptive Large Neighborhood Search) optimization.
+ *
+ * Provides combinatorial optimization using destroy-repair operators.
+ * ALNS is particularly effective for:
+ * - Scheduling and rostering problems
+ * - Vehicle routing problems
+ * - Resource allocation problems
+ * - Any problem where domain-specific operators can be designed
+ *
+ * @example
+ * ```ts
+ * import { East, StructType, FloatType, variant } from "@elaraai/east";
+ * import { ALNS } from "@elaraai/east-py-datascience";
+ *
+ * const SolutionType = StructType({ value: FloatType });
+ *
+ * const optimize = East.function([SolutionType], ALNS.Types.ResultType, ($, initial) => {
+ *     const objective = East.function([SolutionType], FloatType, ($, s) => $.return(s.value));
+ *     const destroy = East.function([SolutionType], SolutionType, ($, s) => $.return(s));
+ *     const repair = East.function([SolutionType], SolutionType, ($, s) => $.return(s));
+ *
+ *     const config = $.let({
+ *         stop: variant('some', variant('max_iterations', 100n)),
+ *         acceptance: variant('none', null),
+ *         operator_selection: variant('none', null),
+ *         seed: variant('some', 42n),
+ *     });
+ *
+ *     return $.return(ALNS.optimize([SolutionType], initial, objective, [destroy], [repair], config));
+ * });
+ * ```
+ */
+export declare const ALNS: {
+    /**
+     * ALNS optimization (generic over solution type).
+     *
+     * Call with type parameter array first, then arguments:
+     * `ALNS.optimize([MySolutionType], initial, objective, destroys, repairs, config)`
+     */
+    readonly optimize: import("@elaraai/east").GenericPlatformDefinition<readonly ["S"], readonly ["S", FunctionType<["S"], FloatType>, ArrayType<FunctionType<["S"], "S">>, ArrayType<FunctionType<["S"], "S">>, StructType<{
+        /** Stopping criterion (default: max_iterations 1000) */
+        readonly stop: OptionType<VariantType<{
+            readonly max_iterations: IntegerType;
+            readonly max_runtime: FloatType;
+            readonly no_improvement: IntegerType;
+        }>>;
+        /** Acceptance criterion (default: simulated_annealing) */
+        readonly acceptance: OptionType<VariantType<{
+            readonly simulated_annealing: StructType<{
+                /** Starting temperature (default: 100.0) */
+                readonly start_temperature: OptionType<FloatType>;
+                /** Ending temperature (default: 0.01) */
+                readonly end_temperature: OptionType<FloatType>;
+                /** Cooling step multiplier (default: 0.99) */
+                readonly step: OptionType<FloatType>;
+            }>;
+            readonly hill_climbing: NullType;
+            readonly record_to_record: StructType<{
+                /** Threshold as fraction of best objective (default: 0.05) */
+                readonly threshold: OptionType<FloatType>;
+            }>;
+        }>>;
+        /** Operator selection strategy (default: roulette_wheel) */
+        readonly operator_selection: OptionType<VariantType<{
+            readonly roulette_wheel: StructType<{
+                /** Scores for [new_best, better, accepted, rejected] (default: [33, 9, 3, 0]) */
+                readonly scores: OptionType<ArrayType<IntegerType>>;
+                /** Weight decay factor (default: 0.8) */
+                readonly decay: OptionType<FloatType>;
+            }>;
+        }>>;
+        /** Random seed for reproducibility */
+        readonly seed: OptionType<IntegerType>;
+    }>], StructType<{
+        /** Best solution found */
+        readonly best_solution: "S";
+        /** Best objective value */
+        readonly best_objective: FloatType;
+        /** Number of iterations performed */
+        readonly iterations: IntegerType;
+        /** Total runtime in seconds */
+        readonly runtime: FloatType;
+        /** Whether optimization succeeded */
+        readonly success: BooleanType;
+    }>>;
+    /**
+     * Type definitions for ALNS functions.
+     */
+    readonly Types: {
+        /** Simulated annealing config */
+        readonly SimulatedAnnealingConfigType: StructType<{
+            /** Starting temperature (default: 100.0) */
+            readonly start_temperature: OptionType<FloatType>;
+            /** Ending temperature (default: 0.01) */
+            readonly end_temperature: OptionType<FloatType>;
+            /** Cooling step multiplier (default: 0.99) */
+            readonly step: OptionType<FloatType>;
+        }>;
+        /** Record-to-record config */
+        readonly RecordToRecordConfigType: StructType<{
+            /** Threshold as fraction of best objective (default: 0.05) */
+            readonly threshold: OptionType<FloatType>;
+        }>;
+        /** Acceptance criterion variant */
+        readonly AcceptanceCriterionType: VariantType<{
+            readonly simulated_annealing: StructType<{
+                /** Starting temperature (default: 100.0) */
+                readonly start_temperature: OptionType<FloatType>;
+                /** Ending temperature (default: 0.01) */
+                readonly end_temperature: OptionType<FloatType>;
+                /** Cooling step multiplier (default: 0.99) */
+                readonly step: OptionType<FloatType>;
+            }>;
+            readonly hill_climbing: NullType;
+            readonly record_to_record: StructType<{
+                /** Threshold as fraction of best objective (default: 0.05) */
+                readonly threshold: OptionType<FloatType>;
+            }>;
+        }>;
+        /** Roulette wheel selection config */
+        readonly RouletteWheelConfigType: StructType<{
+            /** Scores for [new_best, better, accepted, rejected] (default: [33, 9, 3, 0]) */
+            readonly scores: OptionType<ArrayType<IntegerType>>;
+            /** Weight decay factor (default: 0.8) */
+            readonly decay: OptionType<FloatType>;
+        }>;
+        /** Operator selection variant */
+        readonly OperatorSelectionType: VariantType<{
+            readonly roulette_wheel: StructType<{
+                /** Scores for [new_best, better, accepted, rejected] (default: [33, 9, 3, 0]) */
+                readonly scores: OptionType<ArrayType<IntegerType>>;
+                /** Weight decay factor (default: 0.8) */
+                readonly decay: OptionType<FloatType>;
+            }>;
+        }>;
+        /** Stop criterion variant */
+        readonly StopCriterionType: VariantType<{
+            readonly max_iterations: IntegerType;
+            readonly max_runtime: FloatType;
+            readonly no_improvement: IntegerType;
+        }>;
+        /** Main configuration type */
+        readonly ConfigType: StructType<{
+            /** Stopping criterion (default: max_iterations 1000) */
+            readonly stop: OptionType<VariantType<{
+                readonly max_iterations: IntegerType;
+                readonly max_runtime: FloatType;
+                readonly no_improvement: IntegerType;
+            }>>;
+            /** Acceptance criterion (default: simulated_annealing) */
+            readonly acceptance: OptionType<VariantType<{
+                readonly simulated_annealing: StructType<{
+                    /** Starting temperature (default: 100.0) */
+                    readonly start_temperature: OptionType<FloatType>;
+                    /** Ending temperature (default: 0.01) */
+                    readonly end_temperature: OptionType<FloatType>;
+                    /** Cooling step multiplier (default: 0.99) */
+                    readonly step: OptionType<FloatType>;
+                }>;
+                readonly hill_climbing: NullType;
+                readonly record_to_record: StructType<{
+                    /** Threshold as fraction of best objective (default: 0.05) */
+                    readonly threshold: OptionType<FloatType>;
+                }>;
+            }>>;
+            /** Operator selection strategy (default: roulette_wheel) */
+            readonly operator_selection: OptionType<VariantType<{
+                readonly roulette_wheel: StructType<{
+                    /** Scores for [new_best, better, accepted, rejected] (default: [33, 9, 3, 0]) */
+                    readonly scores: OptionType<ArrayType<IntegerType>>;
+                    /** Weight decay factor (default: 0.8) */
+                    readonly decay: OptionType<FloatType>;
+                }>;
+            }>>;
+            /** Random seed for reproducibility */
+            readonly seed: OptionType<IntegerType>;
+        }>;
+        /** Result type (with "S" placeholder for solution type) */
+        readonly ResultType: StructType<{
+            /** Best solution found */
+            readonly best_solution: "S";
+            /** Best objective value */
+            readonly best_objective: FloatType;
+            /** Number of iterations performed */
+            readonly iterations: IntegerType;
+            /** Total runtime in seconds */
+            readonly runtime: FloatType;
+            /** Whether optimization succeeded */
+            readonly success: BooleanType;
+        }>;
+    };
+};
+//# sourceMappingURL=alns.d.ts.map

package/dist/alns/alns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alns.d.ts","sourceRoot":"","sources":["../../src/alns/alns.ts"],"names":[],"mappings":"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"}