@elaraai/east-py-datascience 0.0.2-beta.68 → 0.0.2-beta.69

package/README.md

@@ -42,7 +42,7 @@ When using a git dependency in `pyproject.toml`:
 | **Scipy** | `scipy` | scipy, cloudpickle |
 | **Optimization** | *(none)* | *(core only — numpy)* |
 | **GoogleOr** | `google-or` | ortools |
-| **Sklearn** | `sklearn` | scikit-learn, skl2onnx, onnxruntime |
+| **Sklearn** | `sklearn` | scikit-learn, skl2onnx, onnxruntime, cloudpickle |
 | **XGBoost** | `xgboost` | xgboost, cloudpickle |
 | **LightGBM** | `lightgbm` | lightgbm, cloudpickle |
 | **NGBoost** | `ngboost` | ngboost, cloudpickle |
@@ -103,7 +103,7 @@ const optimize = East.function([], MADS.Types.ResultType, $ => {
 
 | 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/index.d.ts

@@ -15,7 +15,7 @@
 export { MADS, mads_optimize, MADSTypes, VectorType, ScalarObjectiveType, MADSBoundsType, MADSConstraintType, MADSDirectionType, MADSConfigType, MADSResultType, } from "./mads/mads.js";
 export { Optuna, optuna_optimize, OptunaTypes, ParamValueType, ParamSpaceKindType, ParamSpaceType, NamedParamType, OptimizationDirectionType, PrunerType, OptunaStudyConfigType, TrialResultType, StudyResultType, ObjectiveFunctionType, } from "./optuna/optuna.js";
 export { SimAnneal, simanneal_optimize, simanneal_optimize_permutation, simanneal_optimize_subset, SimAnnealTypes, DiscreteStateType, EnergyFunctionType, MoveFunctionType, PermutationEnergyType, SubsetEnergyType, AnnealConfigType, AnnealResultType, } from "./simanneal/simanneal.js";
-export { Sklearn, sklearn_split, sklearn_overlap, OverlapConfigType, OverlapResultType, sklearn_standard_scaler_fit, sklearn_standard_scaler_transform, sklearn_min_max_scaler_fit, sklearn_min_max_scaler_transform, sklearn_compute_metrics, sklearn_compute_metrics_multi, sklearn_compute_classification_metrics, sklearn_compute_classification_metrics_multi, sklearn_regressor_chain_train, sklearn_regressor_chain_predict, SklearnTypes, SplitConfigType, SplitResultType, SklearnModelBlobType, RegressorChainBaseConfigType, RegressorChainConfigType, RegressionMetricType, MetricResultType, MetricsResultType, MetricAggregationType, MultiMetricsConfigType, MultiMetricResultType, MultiMetricsResultType, ClassificationMetricType, ClassificationAverageType, ClassificationMetricsConfigType, ClassificationMetricResultType, ClassificationMetricResultsType, MultiClassificationConfigType, MultiClassificationMetricResultType, MultiClassificationMetricResultsType, } from "./sklearn/sklearn.js";
+export { Sklearn, sklearn_split, sklearn_overlap, OverlapConfigType, OverlapResultType, sklearn_standard_scaler_fit, sklearn_standard_scaler_transform, sklearn_min_max_scaler_fit, sklearn_min_max_scaler_transform, sklearn_compute_metrics, sklearn_compute_metrics_multi, sklearn_compute_classification_metrics, sklearn_compute_classification_metrics_multi, sklearn_regressor_chain_train, sklearn_regressor_chain_predict, sklearn_gmm_fit, sklearn_gmm_predict, sklearn_gmm_predict_proba, sklearn_gmm_score_samples, sklearn_gmm_sample, sklearn_gmm_bic, sklearn_gmm_aic, GMMCovarianceType, GMMConfigType, SklearnTypes, SplitConfigType, SplitResultType, SklearnModelBlobType, RegressorChainBaseConfigType, RegressorChainConfigType, RegressionMetricType, MetricResultType, MetricsResultType, MetricAggregationType, MultiMetricsConfigType, MultiMetricResultType, MultiMetricsResultType, ClassificationMetricType, ClassificationAverageType, ClassificationMetricsConfigType, ClassificationMetricResultType, ClassificationMetricResultsType, MultiClassificationConfigType, MultiClassificationMetricResultType, MultiClassificationMetricResultsType, } from "./sklearn/sklearn.js";
 export { Scipy, scipy_curve_fit, scipy_stats_describe, scipy_stats_pearsonr, scipy_stats_spearmanr, scipy_interpolate_1d_fit, scipy_interpolate_1d_predict, scipy_optimize_minimize, scipy_optimize_minimize_quadratic, ScipyTypes, OptimizeMethodType, InterpolationKindType, OptimizeConfigType, InterpolateConfigType, ParamBoundsType, CustomCurveFunctionType, CurveFunctionType, CurveFitConfigType, QuadraticConfigType, StatsDescribeResultType, CorrelationResultType, CurveFitResultType, OptimizeResultType, ScipyModelBlobType, } from "./scipy/scipy.js";
 export { XGBoost, xgboost_train_regressor, xgboost_train_classifier, xgboost_train_quantile, xgboost_predict, xgboost_predict_class, xgboost_predict_proba, xgboost_predict_quantile, XGBoostTypes, XGBoostConfigType, XGBoostQuantileConfigType, XGBoostQuantilePredictResultType, XGBoostModelBlobType, } from "./xgboost/xgboost.js";
 export { LightGBM, lightgbm_train_regressor, lightgbm_train_classifier, lightgbm_predict, lightgbm_predict_class, lightgbm_predict_proba, LightGBMTypes, LightGBMConfigType, LightGBMModelBlobType, } from "./lightgbm/lightgbm.js";

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -19,7 +19,9 @@ export { Optuna, optuna_optimize, OptunaTypes, ParamValueType, ParamSpaceKindTyp
 // SimAnneal - Discrete optimization
 export { SimAnneal, simanneal_optimize, simanneal_optimize_permutation, simanneal_optimize_subset, SimAnnealTypes, DiscreteStateType, EnergyFunctionType, MoveFunctionType, PermutationEnergyType, SubsetEnergyType, AnnealConfigType, AnnealResultType, } from "./simanneal/simanneal.js";
 // Sklearn - ML utilities
-export { Sklearn, sklearn_split, sklearn_overlap, OverlapConfigType, OverlapResultType, sklearn_standard_scaler_fit, sklearn_standard_scaler_transform, sklearn_min_max_scaler_fit, sklearn_min_max_scaler_transform, sklearn_compute_metrics, sklearn_compute_metrics_multi, sklearn_compute_classification_metrics, sklearn_compute_classification_metrics_multi, sklearn_regressor_chain_train, sklearn_regressor_chain_predict, SklearnTypes, SplitConfigType, SplitResultType, SklearnModelBlobType, RegressorChainBaseConfigType, RegressorChainConfigType, 
+export { Sklearn, sklearn_split, sklearn_overlap, OverlapConfigType, OverlapResultType, sklearn_standard_scaler_fit, sklearn_standard_scaler_transform, sklearn_min_max_scaler_fit, sklearn_min_max_scaler_transform, sklearn_compute_metrics, sklearn_compute_metrics_multi, sklearn_compute_classification_metrics, sklearn_compute_classification_metrics_multi, sklearn_regressor_chain_train, sklearn_regressor_chain_predict, 
+// GMM
+sklearn_gmm_fit, sklearn_gmm_predict, sklearn_gmm_predict_proba, sklearn_gmm_score_samples, sklearn_gmm_sample, sklearn_gmm_bic, sklearn_gmm_aic, GMMCovarianceType, GMMConfigType, SklearnTypes, SplitConfigType, SplitResultType, SklearnModelBlobType, RegressorChainBaseConfigType, RegressorChainConfigType, 
 // Flexible metrics types
 RegressionMetricType, MetricResultType, MetricsResultType, MetricAggregationType, MultiMetricsConfigType, MultiMetricResultType, MultiMetricsResultType, ClassificationMetricType, ClassificationAverageType, ClassificationMetricsConfigType, ClassificationMetricResultType, ClassificationMetricResultsType, MultiClassificationConfigType, MultiClassificationMetricResultType, MultiClassificationMetricResultsType, } from "./sklearn/sklearn.js";
 // Scipy - Scientific computing

package/dist/index.js.map

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

package/dist/optimization/optimization.d.ts

@@ -41,6 +41,16 @@ export declare const EvaluationOrderType: VariantType<{
     readonly sequential: NullType;
     readonly random: NullType;
 }>;
+/**
+ * Optimization mode.
+ *
+ * - `coordinate`: Standard coordinate descent — optimize each element independently (default)
+ * - `swap`: Swap-based moves — swap pairs of elements, preserving valid permutations
+ */
+export declare const ModeType: VariantType<{
+    readonly coordinate: NullType;
+    readonly swap: NullType;
+}>;
 /**
  * Configuration for iterative optimization.
  *
@@ -63,6 +73,11 @@ export declare const IterativeConfigType: StructType<{
     }>>;
     /** Random seed for reproducibility */
     readonly random_state: OptionType<IntegerType>;
+    /** Optimization mode: coordinate (default) or swap for permutations */
+    readonly mode: OptionType<VariantType<{
+        readonly coordinate: NullType;
+        readonly swap: NullType;
+    }>>;
 }>;
 /**
  * Result of iterative optimization.
@@ -80,42 +95,43 @@ export declare const IterativeResultType: StructType<{
     readonly success: BooleanType;
 }>;
 /**
- * Iterative coordinate descent optimization over integer parameter vectors.
+ * Iterative optimization over integer parameter vectors.
  *
  * Maximizes an objective function over a vector of discrete integer parameters.
  * Each parameter position has its own set of candidate values (vector).
- * The algorithm optimizes one element at a time (coordinate descent),
- * with multiple independent restarts (samples).
  *
- * @example
- * ```ts
- * import { East, VectorType, IntegerType, FloatType, variant } from "@elaraai/east";
- * import { Optimization } from "@elaraai/east-py-datascience";
+ * Two modes are available:
+ * - **coordinate** (default): Coordinate descent — optimizes each element independently
+ *   by trying all candidate values while holding others fixed. Best for assignment problems
+ *   where each position can take any value independently.
+ * - **swap**: Swap-based moves — swaps pairs of elements, preserving valid permutations.
+ *   Use this for permutation problems (scheduling, ordering) where each value must appear
+ *   exactly once.
  *
- * // Objective: maximize sum of parameter values
- * const objective = East.function([VectorType(IntegerType)], FloatType, ($, params) => {
- *     const total = $.let(0.0);
- *     $.for(East.Array.range(0n, params.length()), ($, i) => {
- *         $.assign(total, total.add(params.get(i).toFloat()));
- *     });
- *     return $.return(total);
- * });
- *
- * const spaces = $.let([
- *     new BigInt64Array([0n, 1n, 2n]),
- *     new BigInt64Array([0n, 1n, 2n]),
- *     new BigInt64Array([0n, 1n, 2n]),
- * ]);
+ * @example Coordinate mode (assignment)
+ * ```ts
  * const config = $.let({
  *     iterations: variant('some', 10n),
  *     samples: variant('some', 3n),
  *     initial: variant('some', variant('random', null)),
  *     order: variant('some', variant('sequential', null)),
  *     random_state: variant('some', 42n),
+ *     mode: variant('none', null), // coordinate is the default
  * });
+ * const result = $.let(Optimization.iterative(objective, spaces, config));
+ * ```
  *
+ * @example Swap mode (permutation)
+ * ```ts
+ * const config = $.let({
+ *     iterations: variant('some', 50n),
+ *     samples: variant('some', 10n),
+ *     initial: variant('some', variant('random', null)),
+ *     order: variant('some', variant('random', null)),
+ *     random_state: variant('some', 42n),
+ *     mode: variant('some', variant('swap', null)),
+ * });
  * const result = $.let(Optimization.iterative(objective, spaces, config));
- * // result.best_objective = 6.0
  * ```
  */
 export declare const optimization_iterative: import("@elaraai/east").PlatformDefinition<[FunctionType<[VectorType<IntegerType>], FloatType>, ArrayType<VectorType<IntegerType>>, StructType<{
@@ -135,6 +151,11 @@ export declare const optimization_iterative: import("@elaraai/east").PlatformDef
     }>>;
     /** Random seed for reproducibility */
     readonly random_state: OptionType<IntegerType>;
+    /** Optimization mode: coordinate (default) or swap for permutations */
+    readonly mode: OptionType<VariantType<{
+        readonly coordinate: NullType;
+        readonly swap: NullType;
+    }>>;
 }>], StructType<{
     /** Best parameter values found */
     readonly best_parameters: VectorType<IntegerType>;
@@ -167,6 +188,11 @@ export declare const OptimizationTypes: {
         readonly sequential: NullType;
         readonly random: NullType;
     }>;
+    /** Optimization mode variant */
+    readonly ModeType: VariantType<{
+        readonly coordinate: NullType;
+        readonly swap: NullType;
+    }>;
     /** Configuration type */
     readonly ConfigType: StructType<{
         /** Maximum coordinate descent iterations per sample (default: 100) */
@@ -185,6 +211,11 @@ export declare const OptimizationTypes: {
         }>>;
         /** Random seed for reproducibility */
         readonly random_state: OptionType<IntegerType>;
+        /** Optimization mode: coordinate (default) or swap for permutations */
+        readonly mode: OptionType<VariantType<{
+            readonly coordinate: NullType;
+            readonly swap: NullType;
+        }>>;
     }>;
     /** Result type */
     readonly ResultType: StructType<{
@@ -201,15 +232,17 @@ export declare const OptimizationTypes: {
     }>;
 };
 /**
- * Iterative coordinate descent optimization for discrete combinatorial problems.
+ * Iterative optimization for discrete combinatorial problems.
  *
- * Maximizes an objective by independently optimizing each element of a
- * parameter vector over its candidate values. Supports multi-start sampling
- * for better exploration.
+ * Supports two modes:
+ * - **coordinate** (default): Element-wise coordinate descent. Best for
+ *   assignment problems where positions are independent.
+ * - **swap**: Pair-wise swap moves preserving permutations. Best for
+ *   scheduling/ordering where each value must appear exactly once.
  *
  * Use cases:
- * - Task-worker assignment
- * - Scheduling and rostering
+ * - Task-worker assignment (coordinate mode)
+ * - Scheduling and ordering (swap mode)
  * - Combinatorial selection problems
  * - Any discrete optimization with per-element candidate sets
  */
@@ -218,6 +251,73 @@ export declare const Optimization: {
      * Iterative optimization over integer parameter vectors.
      *
      * `Optimization.iterative(objective, spaces, config)`
+     *
+     * @example Coordinate mode — task-worker assignment
+     * ```ts
+     * // 3 tasks, 2 workers. Maximize total skill match.
+     * const skill = $.let([[3.0, 1.0], [1.0, 3.0], [2.0, 2.0]]);
+     * const objective = East.function(
+     *     [VectorType(IntegerType)], FloatType,
+     *     ($, assignments) => {
+     *         const total = $.let(0.0);
+     *         $.for(East.Array.range(0n, East.value(3n)), ($, i) => {
+     *             $.assign(total, total.add(skill.get(i).get(assignments.get(i))));
+     *         });
+     *         return $.return(total);
+     *     }
+     * );
+     * const spaces = $.let([
+     *     new BigInt64Array([0n, 1n]),
+     *     new BigInt64Array([0n, 1n]),
+     *     new BigInt64Array([0n, 1n]),
+     * ]);
+     * const config = $.let({
+     *     iterations: variant('some', 10n),
+     *     samples: variant('some', 3n),
+     *     initial: variant('some', variant('random', null)),
+     *     order: variant('some', variant('sequential', null)),
+     *     random_state: variant('some', 42n),
+     *     mode: variant('none', null),
+     * });
+     * const result = $.let(Optimization.iterative(objective, spaces, config));
+     * // result.best_objective = 8.0 (task 0→worker 0, task 1→worker 1, task 2→either)
+     * ```
+     *
+     * @example Swap mode — scheduling permutation
+     * ```ts
+     * // 4 jobs: find execution order minimizing weighted completion time.
+     * const durations = $.let([10.0, 5.0, 20.0, 3.0]);
+     * const values = $.let([1.0, 8.0, 2.0, 10.0]);
+     * const objective = East.function(
+     *     [VectorType(IntegerType)], FloatType,
+     *     ($, perm) => {
+     *         const cum = $.let(0.0);
+     *         const total = $.let(0.0);
+     *         $.for(East.Array.range(0n, East.value(4n)), ($, i) => {
+     *             const idx = $.let(perm.get(i));
+     *             $.assign(cum, cum.add(durations.get(idx)));
+     *             $.assign(total, total.add(values.get(idx).multiply(cum)));
+     *         });
+     *         return $.return(total.negate());
+     *     }
+     * );
+     * const spaces = $.let([
+     *     new BigInt64Array([0n, 1n, 2n, 3n]),
+     *     new BigInt64Array([0n, 1n, 2n, 3n]),
+     *     new BigInt64Array([0n, 1n, 2n, 3n]),
+     *     new BigInt64Array([0n, 1n, 2n, 3n]),
+     * ]);
+     * const config = $.let({
+     *     iterations: variant('some', 50n),
+     *     samples: variant('some', 10n),
+     *     initial: variant('some', variant('random', null)),
+     *     order: variant('some', variant('random', null)),
+     *     random_state: variant('some', 42n),
+     *     mode: variant('some', variant('swap', null)),
+     * });
+     * const result = $.let(Optimization.iterative(objective, spaces, config));
+     * // result.best_objective = -188.0 (optimal WSPT order)
+     * ```
      */
     readonly iterative: import("@elaraai/east").PlatformDefinition<[FunctionType<[VectorType<IntegerType>], FloatType>, ArrayType<VectorType<IntegerType>>, StructType<{
         /** Maximum coordinate descent iterations per sample (default: 100) */
@@ -236,6 +336,11 @@ export declare const Optimization: {
         }>>;
         /** Random seed for reproducibility */
         readonly random_state: OptionType<IntegerType>;
+        /** Optimization mode: coordinate (default) or swap for permutations */
+        readonly mode: OptionType<VariantType<{
+            readonly coordinate: NullType;
+            readonly swap: NullType;
+        }>>;
     }>], StructType<{
         /** Best parameter values found */
         readonly best_parameters: VectorType<IntegerType>;
@@ -268,6 +373,11 @@ export declare const Optimization: {
             readonly sequential: NullType;
             readonly random: NullType;
         }>;
+        /** Optimization mode variant */
+        readonly ModeType: VariantType<{
+            readonly coordinate: NullType;
+            readonly swap: NullType;
+        }>;
         /** Configuration type */
         readonly ConfigType: StructType<{
             /** Maximum coordinate descent iterations per sample (default: 100) */
@@ -286,6 +396,11 @@ export declare const Optimization: {
             }>>;
             /** Random seed for reproducibility */
             readonly random_state: OptionType<IntegerType>;
+            /** Optimization mode: coordinate (default) or swap for permutations */
+            readonly mode: OptionType<VariantType<{
+                readonly coordinate: NullType;
+                readonly swap: NullType;
+            }>>;
         }>;
         /** Result type */
         readonly ResultType: StructType<{

package/dist/optimization/optimization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"optimization.d.ts","sourceRoot":"","sources":["../../src/optimization/optimization.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAEH,UAAU,EACV,WAAW,EACX,UAAU,EACV,SAAS,EACT,UAAU,EACV,WAAW,EACX,WAAW,EACX,SAAS,EACT,QAAQ,EACR,YAAY,EACf,MAAM,eAAe,CAAC;AAMvB,wCAAwC;AACxC,eAAO,MAAM,mBAAmB,yBAA0B,CAAC;AAE3D,mDAAmD;AACnD,eAAO,MAAM,sBAAsB,oDAAiD,CAAC;AAErF,2DAA2D;AAC3D,eAAO,MAAM,mBAAmB,oCAAiC,CAAC;AAElE;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;EAG9B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;EAG9B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;IAC5B,sEAAsE;;IAEtE,kDAAkD;;IAElD,0DAA0D;;;;;IAE1D,yDAAyD;;;;;IAEzD,sCAAsC;;EAExC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;IAC5B,kCAAkC;;IAElC,yCAAyC;;IAEzC,6DAA6D;;IAE7D,4CAA4C;;IAE5C,qCAAqC;;EAEvC,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,sBAAsB;IAvE/B,sEAAsE;;IAEtE,kDAAkD;;IAElD,0DAA0D;;;;;IAE1D,yDAAyD;;;;;IAEzD,sCAAsC;;;IAQtC,kCAAkC;;IAElC,yCAAyC;;IAEzC,6DAA6D;;IAE7D,4CAA4C;;IAE5C,qCAAqC;;GAuDxC,CAAC;AAMF;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAC1B,4BAA4B;;IAE5B,8BAA8B;;IAE9B,4BAA4B;;IAE5B,qCAAqC;;;;;IAErC,+BAA+B;;;;;IAE/B,yBAAyB;;QAnGzB,sEAAsE;;QAEtE,kDAAkD;;QAElD,0DAA0D;;;;;QAE1D,yDAAyD;;;;;QAEzD,sCAAsC;;;IA6FtC,kBAAkB;;QArFlB,kCAAkC;;QAElC,yCAAyC;;QAEzC,6DAA6D;;QAE7D,4CAA4C;;QAE5C,qCAAqC;;;CA+E/B,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY;IACrB;;;;OAIG;;QA3HH,sEAAsE;;QAEtE,kDAAkD;;QAElD,0DAA0D;;;;;QAE1D,yDAAyD;;;;;QAEzD,sCAAsC;;;QAQtC,kCAAkC;;QAElC,yCAAyC;;QAEzC,6DAA6D;;QAE7D,4CAA4C;;QAE5C,qCAAqC;;;IAsGrC;;OAEG;;QAvCH,4BAA4B;;QAE5B,8BAA8B;;QAE9B,4BAA4B;;QAE5B,qCAAqC;;;;;QAErC,+BAA+B;;;;;QAE/B,yBAAyB;;YAnGzB,sEAAsE;;YAEtE,kDAAkD;;YAElD,0DAA0D;;;;;YAE1D,yDAAyD;;;;;YAEzD,sCAAsC;;;QA6FtC,kBAAkB;;YArFlB,kCAAkC;;YAElC,yCAAyC;;YAEzC,6DAA6D;;YAE7D,4CAA4C;;YAE5C,qCAAqC;;;;CA0G/B,CAAC"}
+{"version":3,"file":"optimization.d.ts","sourceRoot":"","sources":["../../src/optimization/optimization.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAEH,UAAU,EACV,WAAW,EACX,UAAU,EACV,SAAS,EACT,UAAU,EACV,WAAW,EACX,WAAW,EACX,SAAS,EACT,QAAQ,EACR,YAAY,EACf,MAAM,eAAe,CAAC;AAMvB,wCAAwC;AACxC,eAAO,MAAM,mBAAmB,yBAA0B,CAAC;AAE3D,mDAAmD;AACnD,eAAO,MAAM,sBAAsB,oDAAiD,CAAC;AAErF,2DAA2D;AAC3D,eAAO,MAAM,mBAAmB,oCAAiC,CAAC;AAElE;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;EAG9B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;EAG9B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;;;EAGnB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;IAC5B,sEAAsE;;IAEtE,kDAAkD;;IAElD,0DAA0D;;;;;IAE1D,yDAAyD;;;;;IAEzD,sCAAsC;;IAEtC,uEAAuE;;;;;EAEzE,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;IAC5B,kCAAkC;;IAElC,yCAAyC;;IAEzC,6DAA6D;;IAE7D,4CAA4C;;IAE5C,qCAAqC;;EAEvC,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,sBAAsB;IA1E/B,sEAAsE;;IAEtE,kDAAkD;;IAElD,0DAA0D;;;;;IAE1D,yDAAyD;;;;;IAEzD,sCAAsC;;IAEtC,uEAAuE;;;;;;IAQvE,kCAAkC;;IAElC,yCAAyC;;IAEzC,6DAA6D;;IAE7D,4CAA4C;;IAE5C,qCAAqC;;GAwDxC,CAAC;AAMF;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAC1B,4BAA4B;;IAE5B,8BAA8B;;IAE9B,4BAA4B;;IAE5B,qCAAqC;;;;;IAErC,+BAA+B;;;;;IAE/B,gCAAgC;;;;;IAEhC,yBAAyB;;QAxGzB,sEAAsE;;QAEtE,kDAAkD;;QAElD,0DAA0D;;;;;QAE1D,yDAAyD;;;;;QAEzD,sCAAsC;;QAEtC,uEAAuE;;;;;;IAgGvE,kBAAkB;;QAxFlB,kCAAkC;;QAElC,yCAAyC;;QAEzC,6DAA6D;;QAE7D,4CAA4C;;QAE5C,qCAAqC;;;CAkF/B,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY;IACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuEG;;QArMH,sEAAsE;;QAEtE,kDAAkD;;QAElD,0DAA0D;;;;;QAE1D,yDAAyD;;;;;QAEzD,sCAAsC;;QAEtC,uEAAuE;;;;;;QAQvE,kCAAkC;;QAElC,yCAAyC;;QAEzC,6DAA6D;;QAE7D,4CAA4C;;QAE5C,qCAAqC;;;IA8KrC;;OAEG;;QA9GH,4BAA4B;;QAE5B,8BAA8B;;QAE9B,4BAA4B;;QAE5B,qCAAqC;;;;;QAErC,+BAA+B;;;;;QAE/B,gCAAgC;;;;;QAEhC,yBAAyB;;YAxGzB,sEAAsE;;YAEtE,kDAAkD;;YAElD,0DAA0D;;;;;YAE1D,yDAAyD;;;;;YAEzD,sCAAsC;;YAEtC,uEAAuE;;;;;;QAgGvE,kBAAkB;;YAxFlB,kCAAkC;;YAElC,yCAAyC;;YAEzC,6DAA6D;;YAE7D,4CAA4C;;YAE5C,qCAAqC;;;;CAkL/B,CAAC"}

package/dist/optimization/optimization.js

@@ -44,6 +44,16 @@ export const EvaluationOrderType = VariantType({
     sequential: NullType,
     random: NullType,
 });
+/**
+ * Optimization mode.
+ *
+ * - `coordinate`: Standard coordinate descent — optimize each element independently (default)
+ * - `swap`: Swap-based moves — swap pairs of elements, preserving valid permutations
+ */
+export const ModeType = VariantType({
+    coordinate: NullType,
+    swap: NullType,
+});
 /**
  * Configuration for iterative optimization.
  *
@@ -60,6 +70,8 @@ export const IterativeConfigType = StructType({
     order: OptionType(EvaluationOrderType),
     /** Random seed for reproducibility */
     random_state: OptionType(IntegerType),
+    /** Optimization mode: coordinate (default) or swap for permutations */
+    mode: OptionType(ModeType),
 });
 /**
  * Result of iterative optimization.
@@ -80,42 +92,43 @@ export const IterativeResultType = StructType({
 // Platform Functions
 // ============================================================================
 /**
- * Iterative coordinate descent optimization over integer parameter vectors.
+ * Iterative optimization over integer parameter vectors.
  *
  * Maximizes an objective function over a vector of discrete integer parameters.
  * Each parameter position has its own set of candidate values (vector).
- * The algorithm optimizes one element at a time (coordinate descent),
- * with multiple independent restarts (samples).
  *
- * @example
- * ```ts
- * import { East, VectorType, IntegerType, FloatType, variant } from "@elaraai/east";
- * import { Optimization } from "@elaraai/east-py-datascience";
+ * Two modes are available:
+ * - **coordinate** (default): Coordinate descent — optimizes each element independently
+ *   by trying all candidate values while holding others fixed. Best for assignment problems
+ *   where each position can take any value independently.
+ * - **swap**: Swap-based moves — swaps pairs of elements, preserving valid permutations.
+ *   Use this for permutation problems (scheduling, ordering) where each value must appear
+ *   exactly once.
  *
- * // Objective: maximize sum of parameter values
- * const objective = East.function([VectorType(IntegerType)], FloatType, ($, params) => {
- *     const total = $.let(0.0);
- *     $.for(East.Array.range(0n, params.length()), ($, i) => {
- *         $.assign(total, total.add(params.get(i).toFloat()));
- *     });
- *     return $.return(total);
- * });
- *
- * const spaces = $.let([
- *     new BigInt64Array([0n, 1n, 2n]),
- *     new BigInt64Array([0n, 1n, 2n]),
- *     new BigInt64Array([0n, 1n, 2n]),
- * ]);
+ * @example Coordinate mode (assignment)
+ * ```ts
  * const config = $.let({
  *     iterations: variant('some', 10n),
  *     samples: variant('some', 3n),
  *     initial: variant('some', variant('random', null)),
  *     order: variant('some', variant('sequential', null)),
  *     random_state: variant('some', 42n),
+ *     mode: variant('none', null), // coordinate is the default
  * });
+ * const result = $.let(Optimization.iterative(objective, spaces, config));
+ * ```
  *
+ * @example Swap mode (permutation)
+ * ```ts
+ * const config = $.let({
+ *     iterations: variant('some', 50n),
+ *     samples: variant('some', 10n),
+ *     initial: variant('some', variant('random', null)),
+ *     order: variant('some', variant('random', null)),
+ *     random_state: variant('some', 42n),
+ *     mode: variant('some', variant('swap', null)),
+ * });
  * const result = $.let(Optimization.iterative(objective, spaces, config));
- * // result.best_objective = 6.0
  * ```
  */
 export const optimization_iterative = East.platform("optimization_iterative", [
@@ -140,21 +153,25 @@ export const OptimizationTypes = {
     InitialStrategyType,
     /** Evaluation order variant */
     EvaluationOrderType,
+    /** Optimization mode variant */
+    ModeType,
     /** Configuration type */
     ConfigType: IterativeConfigType,
     /** Result type */
     ResultType: IterativeResultType,
 };
 /**
- * Iterative coordinate descent optimization for discrete combinatorial problems.
+ * Iterative optimization for discrete combinatorial problems.
  *
- * Maximizes an objective by independently optimizing each element of a
- * parameter vector over its candidate values. Supports multi-start sampling
- * for better exploration.
+ * Supports two modes:
+ * - **coordinate** (default): Element-wise coordinate descent. Best for
+ *   assignment problems where positions are independent.
+ * - **swap**: Pair-wise swap moves preserving permutations. Best for
+ *   scheduling/ordering where each value must appear exactly once.
  *
  * Use cases:
- * - Task-worker assignment
- * - Scheduling and rostering
+ * - Task-worker assignment (coordinate mode)
+ * - Scheduling and ordering (swap mode)
  * - Combinatorial selection problems
  * - Any discrete optimization with per-element candidate sets
  */
@@ -163,6 +180,73 @@ export const Optimization = {
      * Iterative optimization over integer parameter vectors.
      *
      * `Optimization.iterative(objective, spaces, config)`
+     *
+     * @example Coordinate mode — task-worker assignment
+     * ```ts
+     * // 3 tasks, 2 workers. Maximize total skill match.
+     * const skill = $.let([[3.0, 1.0], [1.0, 3.0], [2.0, 2.0]]);
+     * const objective = East.function(
+     *     [VectorType(IntegerType)], FloatType,
+     *     ($, assignments) => {
+     *         const total = $.let(0.0);
+     *         $.for(East.Array.range(0n, East.value(3n)), ($, i) => {
+     *             $.assign(total, total.add(skill.get(i).get(assignments.get(i))));
+     *         });
+     *         return $.return(total);
+     *     }
+     * );
+     * const spaces = $.let([
+     *     new BigInt64Array([0n, 1n]),
+     *     new BigInt64Array([0n, 1n]),
+     *     new BigInt64Array([0n, 1n]),
+     * ]);
+     * const config = $.let({
+     *     iterations: variant('some', 10n),
+     *     samples: variant('some', 3n),
+     *     initial: variant('some', variant('random', null)),
+     *     order: variant('some', variant('sequential', null)),
+     *     random_state: variant('some', 42n),
+     *     mode: variant('none', null),
+     * });
+     * const result = $.let(Optimization.iterative(objective, spaces, config));
+     * // result.best_objective = 8.0 (task 0→worker 0, task 1→worker 1, task 2→either)
+     * ```
+     *
+     * @example Swap mode — scheduling permutation
+     * ```ts
+     * // 4 jobs: find execution order minimizing weighted completion time.
+     * const durations = $.let([10.0, 5.0, 20.0, 3.0]);
+     * const values = $.let([1.0, 8.0, 2.0, 10.0]);
+     * const objective = East.function(
+     *     [VectorType(IntegerType)], FloatType,
+     *     ($, perm) => {
+     *         const cum = $.let(0.0);
+     *         const total = $.let(0.0);
+     *         $.for(East.Array.range(0n, East.value(4n)), ($, i) => {
+     *             const idx = $.let(perm.get(i));
+     *             $.assign(cum, cum.add(durations.get(idx)));
+     *             $.assign(total, total.add(values.get(idx).multiply(cum)));
+     *         });
+     *         return $.return(total.negate());
+     *     }
+     * );
+     * const spaces = $.let([
+     *     new BigInt64Array([0n, 1n, 2n, 3n]),
+     *     new BigInt64Array([0n, 1n, 2n, 3n]),
+     *     new BigInt64Array([0n, 1n, 2n, 3n]),
+     *     new BigInt64Array([0n, 1n, 2n, 3n]),
+     * ]);
+     * const config = $.let({
+     *     iterations: variant('some', 50n),
+     *     samples: variant('some', 10n),
+     *     initial: variant('some', variant('random', null)),
+     *     order: variant('some', variant('random', null)),
+     *     random_state: variant('some', 42n),
+     *     mode: variant('some', variant('swap', null)),
+     * });
+     * const result = $.let(Optimization.iterative(objective, spaces, config));
+     * // result.best_objective = -188.0 (optimal WSPT order)
+     * ```
      */
     iterative: optimization_iterative,
     /**

package/dist/optimization/optimization.js.map

@@ -1 +1 @@
-{"version":3,"file":"optimization.js","sourceRoot":"","sources":["../../src/optimization/optimization.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EACH,IAAI,EACJ,UAAU,EACV,WAAW,EACX,UAAU,EACV,SAAS,EACT,UAAU,EACV,WAAW,EACX,WAAW,EACX,SAAS,EACT,QAAQ,EACR,YAAY,GACf,MAAM,eAAe,CAAC;AAEvB,+EAA+E;AAC/E,mBAAmB;AACnB,+EAA+E;AAE/E,wCAAwC;AACxC,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC,WAAW,CAAC,CAAC;AAE3D,mDAAmD;AACnD,MAAM,CAAC,MAAM,sBAAsB,GAAG,YAAY,CAAC,CAAC,mBAAmB,CAAC,EAAE,SAAS,CAAC,CAAC;AAErF,2DAA2D;AAC3D,MAAM,CAAC,MAAM,mBAAmB,GAAG,SAAS,CAAC,mBAAmB,CAAC,CAAC;AAElE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,WAAW,CAAC;IAC3C,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;CACnB,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,WAAW,CAAC;IAC3C,UAAU,EAAE,QAAQ;IACpB,MAAM,EAAE,QAAQ;CACnB,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;IAC1C,sEAAsE;IACtE,UAAU,EAAE,UAAU,CAAC,WAAW,CAAC;IACnC,kDAAkD;IAClD,OAAO,EAAE,UAAU,CAAC,WAAW,CAAC;IAChC,0DAA0D;IAC1D,OAAO,EAAE,UAAU,CAAC,mBAAmB,CAAC;IACxC,yDAAyD;IACzD,KAAK,EAAE,UAAU,CAAC,mBAAmB,CAAC;IACtC,sCAAsC;IACtC,YAAY,EAAE,UAAU,CAAC,WAAW,CAAC;CACxC,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;IAC1C,kCAAkC;IAClC,eAAe,EAAE,mBAAmB;IACpC,yCAAyC;IACzC,cAAc,EAAE,SAAS;IACzB,6DAA6D;IAC7D,UAAU,EAAE,WAAW;IACvB,4CAA4C;IAC5C,WAAW,EAAE,WAAW;IACxB,qCAAqC;IACrC,OAAO,EAAE,WAAW;CACvB,CAAC,CAAC;AAEH,+EAA+E;AAC/E,qBAAqB;AACrB,+EAA+E;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,CAAC,QAAQ,CAC/C,wBAAwB,EACxB;IACI,sBAAsB,EAAI,sCAAsC;IAChE,mBAAmB,EAAO,2CAA2C;IACrE,mBAAmB,EAAO,SAAS;CACtC,EACD,mBAAmB,CACtB,CAAC;AAEF,+EAA+E;AAC/E,iBAAiB;AACjB,+EAA+E;AAE/E;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC7B,4BAA4B;IAC5B,mBAAmB;IACnB,8BAA8B;IAC9B,aAAa,EAAE,sBAAsB;IACrC,4BAA4B;IAC5B,UAAU,EAAE,mBAAmB;IAC/B,qCAAqC;IACrC,mBAAmB;IACnB,+BAA+B;IAC/B,mBAAmB;IACnB,yBAAyB;IACzB,UAAU,EAAE,mBAAmB;IAC/B,kBAAkB;IAClB,UAAU,EAAE,mBAAmB;CACzB,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IACxB;;;;OAIG;IACH,SAAS,EAAE,sBAAsB;IAEjC;;OAEG;IACH,KAAK,EAAE,iBAAiB;CAClB,CAAC"}
+{"version":3,"file":"optimization.js","sourceRoot":"","sources":["../../src/optimization/optimization.ts"],"names":[],"mappings":"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"}