@elaraai/east-py-datascience 1.0.1 → 1.0.2

package/dist/src/mads/mads.d.ts

@@ -0,0 +1,410 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * MADS (Mesh Adaptive Direct Search) derivative-free optimization.
+ *
+ * Provides blackbox optimization using the NOMAD MADS algorithm via PyNomadBBO.
+ * MADS is designed for difficult optimization problems where:
+ * - Functions have no exploitable derivatives
+ * - Evaluations are computationally expensive
+ * - Functions may be contaminated by noise
+ * - Functions may fail for some feasible points
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, ArrayType, IntegerType, BooleanType, FloatType, NullType } from "@elaraai/east";
+import { VectorType } from "../types.js";
+export { VectorType, ScalarObjectiveType } from "../types.js";
+/**
+ * MADS optimization bounds.
+ *
+ * Defines the lower and upper bounds for each dimension of the search space.
+ */
+export declare const MADSBoundsType: StructType<{
+    /** Lower bounds for each dimension */
+    readonly lower: VectorType<FloatType>;
+    /** Upper bounds for each dimension */
+    readonly upper: VectorType<FloatType>;
+}>;
+/**
+ * MADS constraint type.
+ *
+ * A variant where the tag indicates the constraint handling method:
+ * - `eb` (Extreme Barrier): Infeasible points are rejected entirely
+ * - `pb` (Progressive Barrier): Allows temporary constraint violations during search
+ *
+ * The value is the constraint function: g(x) <= 0 is feasible.
+ */
+export declare const MADSConstraintType: VariantType<{
+    /** Extreme barrier constraint - infeasible points rejected */
+    readonly eb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
+    /** Progressive barrier constraint - temporary violations allowed */
+    readonly pb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
+}>;
+/**
+ * MADS direction type for poll step.
+ *
+ * Controls how search directions are generated during the poll step.
+ */
+export declare const MADSDirectionType: VariantType<{
+    /** ORTHO 2N: 2n orthogonal directions (default) */
+    readonly ortho_2n: NullType;
+    /** ORTHO N+1: n+1 directions forming a simplex */
+    readonly ortho_n_plus_1: NullType;
+    /** LT 2N: Lower triangular with 2n directions */
+    readonly lt_2n: NullType;
+    /** Single direction */
+    readonly single: NullType;
+}>;
+/**
+ * MADS optimization configuration.
+ *
+ * Configures the MADS algorithm parameters.
+ */
+export declare const MADSConfigType: StructType<{
+    /** Maximum number of blackbox evaluations */
+    readonly max_bb_eval: OptionType<IntegerType>;
+    /** Display verbosity level (0 = silent) */
+    readonly display_degree: OptionType<IntegerType>;
+    /** Direction type for poll step */
+    readonly direction_type: OptionType<VariantType<{
+        /** ORTHO 2N: 2n orthogonal directions (default) */
+        readonly ortho_2n: NullType;
+        /** ORTHO N+1: n+1 directions forming a simplex */
+        readonly ortho_n_plus_1: NullType;
+        /** LT 2N: Lower triangular with 2n directions */
+        readonly lt_2n: NullType;
+        /** Single direction */
+        readonly single: NullType;
+    }>>;
+    /** Initial mesh size */
+    readonly initial_mesh_size: OptionType<FloatType>;
+    /** Minimum mesh size (stopping criterion) */
+    readonly min_mesh_size: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    readonly seed: OptionType<IntegerType>;
+}>;
+/**
+ * MADS single-objective optimization result.
+ *
+ * Contains the best solution found and optimization statistics.
+ */
+export declare const MADSResultType: StructType<{
+    /** Best solution vector found */
+    readonly x_best: VectorType<FloatType>;
+    /** Best objective value */
+    readonly f_best: FloatType;
+    /** Number of blackbox evaluations performed */
+    readonly bb_eval: IntegerType;
+    /** Whether optimization succeeded */
+    readonly success: BooleanType;
+}>;
+/**
+ * Single-objective MADS optimization with optional constraints.
+ *
+ * Minimizes an objective function subject to bound constraints and optional
+ * nonlinear constraints using the MADS algorithm.
+ *
+ * @param objective - Objective function to minimize: x -> f(x)
+ * @param x0 - Initial starting point
+ * @param bounds - Lower and upper bounds for each dimension
+ * @param constraints - Optional array of constraint functions (g(x) <= 0 is feasible)
+ * @param config - Optimization configuration
+ * @returns Optimization result with best solution found
+ *
+ * @example
+ * ```ts
+ * import { East, FloatType, variant } from "@elaraai/east";
+ * import { MADS } from "@elaraai/east-py-datascience";
+ *
+ * // Minimize sum of squares
+ * const objective = East.function([MADS.Types.VectorType(FloatType)], FloatType, ($, x) => {
+ *     return x.reduce((acc, xi) => acc.add(xi.multiply(xi)), East.value(0.0));
+ * });
+ *
+ * const optimize = East.function([], MADS.Types.ResultType, $ => {
+ *     const x0 = $.let([0.71, 0.51, 0.51]);
+ *     const bounds = $.let({ lower: [-1.0, -1.0, -1.0], upper: [1.0, 1.0, 1.0] });
+ *     const config = $.let({
+ *         max_bb_eval: variant('some', 100n),
+ *         display_degree: variant('some', 0n),
+ *         direction_type: variant('none', null),
+ *         initial_mesh_size: variant('none', null),
+ *         min_mesh_size: variant('none', null),
+ *         seed: variant('some', 42n),
+ *     });
+ *     return $.return(MADS.optimize(objective, x0, bounds, variant('none', null), config));
+ * });
+ *
+ * const compiled = await East.compileAsync(optimize.toIR(), MADS.Implementation);
+ * const result = await compiled();
+ * console.log(`Best: ${result.f_best}`);
+ * ```
+ */
+export declare const mads_optimize: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>, VectorType<FloatType>, StructType<{
+    /** Lower bounds for each dimension */
+    readonly lower: VectorType<FloatType>;
+    /** Upper bounds for each dimension */
+    readonly upper: VectorType<FloatType>;
+}>, OptionType<ArrayType<VariantType<{
+    /** Extreme barrier constraint - infeasible points rejected */
+    readonly eb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
+    /** Progressive barrier constraint - temporary violations allowed */
+    readonly pb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
+}>>>, StructType<{
+    /** Maximum number of blackbox evaluations */
+    readonly max_bb_eval: OptionType<IntegerType>;
+    /** Display verbosity level (0 = silent) */
+    readonly display_degree: OptionType<IntegerType>;
+    /** Direction type for poll step */
+    readonly direction_type: OptionType<VariantType<{
+        /** ORTHO 2N: 2n orthogonal directions (default) */
+        readonly ortho_2n: NullType;
+        /** ORTHO N+1: n+1 directions forming a simplex */
+        readonly ortho_n_plus_1: NullType;
+        /** LT 2N: Lower triangular with 2n directions */
+        readonly lt_2n: NullType;
+        /** Single direction */
+        readonly single: NullType;
+    }>>;
+    /** Initial mesh size */
+    readonly initial_mesh_size: OptionType<FloatType>;
+    /** Minimum mesh size (stopping criterion) */
+    readonly min_mesh_size: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    readonly seed: OptionType<IntegerType>;
+}>], StructType<{
+    /** Best solution vector found */
+    readonly x_best: VectorType<FloatType>;
+    /** Best objective value */
+    readonly f_best: FloatType;
+    /** Number of blackbox evaluations performed */
+    readonly bb_eval: IntegerType;
+    /** Whether optimization succeeded */
+    readonly success: BooleanType;
+}>>;
+/**
+ * Type definitions for MADS optimization.
+ */
+export declare const MADSTypes: {
+    /** Scalar objective function type */
+    readonly ScalarObjectiveType: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
+    /** Bounds type with lower and upper vectors */
+    readonly BoundsType: StructType<{
+        /** Lower bounds for each dimension */
+        readonly lower: VectorType<FloatType>;
+        /** Upper bounds for each dimension */
+        readonly upper: VectorType<FloatType>;
+    }>;
+    /** Constraint type (eb or pb variant) */
+    readonly ConstraintType: VariantType<{
+        /** Extreme barrier constraint - infeasible points rejected */
+        readonly eb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
+        /** Progressive barrier constraint - temporary violations allowed */
+        readonly pb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
+    }>;
+    /** Direction type for poll step */
+    readonly DirectionType: VariantType<{
+        /** ORTHO 2N: 2n orthogonal directions (default) */
+        readonly ortho_2n: NullType;
+        /** ORTHO N+1: n+1 directions forming a simplex */
+        readonly ortho_n_plus_1: NullType;
+        /** LT 2N: Lower triangular with 2n directions */
+        readonly lt_2n: NullType;
+        /** Single direction */
+        readonly single: NullType;
+    }>;
+    /** Configuration type */
+    readonly ConfigType: StructType<{
+        /** Maximum number of blackbox evaluations */
+        readonly max_bb_eval: OptionType<IntegerType>;
+        /** Display verbosity level (0 = silent) */
+        readonly display_degree: OptionType<IntegerType>;
+        /** Direction type for poll step */
+        readonly direction_type: OptionType<VariantType<{
+            /** ORTHO 2N: 2n orthogonal directions (default) */
+            readonly ortho_2n: NullType;
+            /** ORTHO N+1: n+1 directions forming a simplex */
+            readonly ortho_n_plus_1: NullType;
+            /** LT 2N: Lower triangular with 2n directions */
+            readonly lt_2n: NullType;
+            /** Single direction */
+            readonly single: NullType;
+        }>>;
+        /** Initial mesh size */
+        readonly initial_mesh_size: OptionType<FloatType>;
+        /** Minimum mesh size (stopping criterion) */
+        readonly min_mesh_size: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        readonly seed: OptionType<IntegerType>;
+    }>;
+    /** Single-objective result type */
+    readonly ResultType: StructType<{
+        /** Best solution vector found */
+        readonly x_best: VectorType<FloatType>;
+        /** Best objective value */
+        readonly f_best: FloatType;
+        /** Number of blackbox evaluations performed */
+        readonly bb_eval: IntegerType;
+        /** Whether optimization succeeded */
+        readonly success: BooleanType;
+    }>;
+};
+/**
+ * MADS derivative-free blackbox optimization.
+ *
+ * Provides optimization algorithms for expensive blackbox functions
+ * where gradient information is unavailable using the NOMAD MADS algorithm.
+ *
+ * MADS is particularly effective for:
+ * - Expensive blackbox functions (simulations, experiments)
+ * - Functions with no exploitable derivatives
+ * - Noisy or stochastic functions
+ * - Functions that may fail for some inputs
+ *
+ * @example
+ * ```ts
+ * import { East, FloatType, variant } from "@elaraai/east";
+ * import { MADS } from "@elaraai/east-py-datascience";
+ *
+ * const objective = East.function([MADS.Types.VectorType(FloatType)], FloatType, ($, x) => {
+ *     return x.reduce((acc, xi) => acc.add(xi.multiply(xi)), East.value(0.0));
+ * });
+ *
+ * const optimize = East.function([], MADS.Types.ResultType, $ => {
+ *     const x0 = $.let([0.5, 0.5]);
+ *     const bounds = $.let({ lower: [-1.0, -1.0], upper: [1.0, 1.0] });
+ *     const config = $.let({
+ *         max_bb_eval: variant('some', 100n),
+ *         display_degree: variant('some', 0n),
+ *         direction_type: variant('none', null),
+ *         initial_mesh_size: variant('none', null),
+ *         min_mesh_size: variant('none', null),
+ *         seed: variant('some', 42n),
+ *     });
+ *     return $.return(MADS.optimize(objective, x0, bounds, variant('none', null), config));
+ * });
+ *
+ * const compiled = await East.compileAsync(optimize.toIR(), MADS.Implementation);
+ * const result = await compiled();
+ * ```
+ */
+export declare const MADS: {
+    /**
+     * Single-objective optimization with optional constraints.
+     *
+     * Minimizes an objective function subject to bound and nonlinear constraints.
+     */
+    readonly optimize: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>, VectorType<FloatType>, StructType<{
+        /** Lower bounds for each dimension */
+        readonly lower: VectorType<FloatType>;
+        /** Upper bounds for each dimension */
+        readonly upper: VectorType<FloatType>;
+    }>, OptionType<ArrayType<VariantType<{
+        /** Extreme barrier constraint - infeasible points rejected */
+        readonly eb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
+        /** Progressive barrier constraint - temporary violations allowed */
+        readonly pb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
+    }>>>, StructType<{
+        /** Maximum number of blackbox evaluations */
+        readonly max_bb_eval: OptionType<IntegerType>;
+        /** Display verbosity level (0 = silent) */
+        readonly display_degree: OptionType<IntegerType>;
+        /** Direction type for poll step */
+        readonly direction_type: OptionType<VariantType<{
+            /** ORTHO 2N: 2n orthogonal directions (default) */
+            readonly ortho_2n: NullType;
+            /** ORTHO N+1: n+1 directions forming a simplex */
+            readonly ortho_n_plus_1: NullType;
+            /** LT 2N: Lower triangular with 2n directions */
+            readonly lt_2n: NullType;
+            /** Single direction */
+            readonly single: NullType;
+        }>>;
+        /** Initial mesh size */
+        readonly initial_mesh_size: OptionType<FloatType>;
+        /** Minimum mesh size (stopping criterion) */
+        readonly min_mesh_size: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        readonly seed: OptionType<IntegerType>;
+    }>], StructType<{
+        /** Best solution vector found */
+        readonly x_best: VectorType<FloatType>;
+        /** Best objective value */
+        readonly f_best: FloatType;
+        /** Number of blackbox evaluations performed */
+        readonly bb_eval: IntegerType;
+        /** Whether optimization succeeded */
+        readonly success: BooleanType;
+    }>>;
+    /**
+     * Type definitions for MADS functions.
+     */
+    readonly Types: {
+        /** Scalar objective function type */
+        readonly ScalarObjectiveType: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
+        /** Bounds type with lower and upper vectors */
+        readonly BoundsType: StructType<{
+            /** Lower bounds for each dimension */
+            readonly lower: VectorType<FloatType>;
+            /** Upper bounds for each dimension */
+            readonly upper: VectorType<FloatType>;
+        }>;
+        /** Constraint type (eb or pb variant) */
+        readonly ConstraintType: VariantType<{
+            /** Extreme barrier constraint - infeasible points rejected */
+            readonly eb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
+            /** Progressive barrier constraint - temporary violations allowed */
+            readonly pb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
+        }>;
+        /** Direction type for poll step */
+        readonly DirectionType: VariantType<{
+            /** ORTHO 2N: 2n orthogonal directions (default) */
+            readonly ortho_2n: NullType;
+            /** ORTHO N+1: n+1 directions forming a simplex */
+            readonly ortho_n_plus_1: NullType;
+            /** LT 2N: Lower triangular with 2n directions */
+            readonly lt_2n: NullType;
+            /** Single direction */
+            readonly single: NullType;
+        }>;
+        /** Configuration type */
+        readonly ConfigType: StructType<{
+            /** Maximum number of blackbox evaluations */
+            readonly max_bb_eval: OptionType<IntegerType>;
+            /** Display verbosity level (0 = silent) */
+            readonly display_degree: OptionType<IntegerType>;
+            /** Direction type for poll step */
+            readonly direction_type: OptionType<VariantType<{
+                /** ORTHO 2N: 2n orthogonal directions (default) */
+                readonly ortho_2n: NullType;
+                /** ORTHO N+1: n+1 directions forming a simplex */
+                readonly ortho_n_plus_1: NullType;
+                /** LT 2N: Lower triangular with 2n directions */
+                readonly lt_2n: NullType;
+                /** Single direction */
+                readonly single: NullType;
+            }>>;
+            /** Initial mesh size */
+            readonly initial_mesh_size: OptionType<FloatType>;
+            /** Minimum mesh size (stopping criterion) */
+            readonly min_mesh_size: OptionType<FloatType>;
+            /** Random seed for reproducibility */
+            readonly seed: OptionType<IntegerType>;
+        }>;
+        /** Single-objective result type */
+        readonly ResultType: StructType<{
+            /** Best solution vector found */
+            readonly x_best: VectorType<FloatType>;
+            /** Best objective value */
+            readonly f_best: FloatType;
+            /** Number of blackbox evaluations performed */
+            readonly bb_eval: IntegerType;
+            /** Whether optimization succeeded */
+            readonly success: BooleanType;
+        }>;
+    };
+};
+//# sourceMappingURL=mads.d.ts.map

package/dist/src/mads/mads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mads.d.ts","sourceRoot":"","sources":["../../../src/mads/mads.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAEH,UAAU,EACV,WAAW,EACX,UAAU,EACV,SAAS,EACT,WAAW,EACX,WAAW,EACX,SAAS,EACT,QAAQ,EACX,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,UAAU,EAAuB,MAAM,aAAa,CAAC;AAG9D,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAE9D;;;;GAIG;AACH,eAAO,MAAM,cAAc;IACvB,sCAAsC;;IAEtC,sCAAsC;;EAExC,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB;IAC3B,8DAA8D;;IAE9D,oEAAoE;;EAEtE,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;IAC1B,mDAAmD;;IAEnD,kDAAkD;;IAElD,iDAAiD;;IAEjD,uBAAuB;;EAEzB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,cAAc;IACvB,6CAA6C;;IAE7C,2CAA2C;;IAE3C,mCAAmC;;QApBnC,mDAAmD;;QAEnD,kDAAkD;;QAElD,iDAAiD;;QAEjD,uBAAuB;;;IAgBvB,wBAAwB;;IAExB,6CAA6C;;IAE7C,sCAAsC;;EAExC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,cAAc;IACvB,iCAAiC;;IAEjC,2BAA2B;;IAE3B,+CAA+C;;IAE/C,qCAAqC;;EAEvC,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,aAAa;IAxHtB,sCAAsC;;IAEtC,sCAAsC;;;IActC,8DAA8D;;IAE9D,oEAAoE;;;IA0BpE,6CAA6C;;IAE7C,2CAA2C;;IAE3C,mCAAmC;;QApBnC,mDAAmD;;QAEnD,kDAAkD;;QAElD,iDAAiD;;QAEjD,uBAAuB;;;IAgBvB,wBAAwB;;IAExB,6CAA6C;;IAE7C,sCAAsC;;;IAUtC,iCAAiC;;IAEjC,2BAA2B;;IAE3B,+CAA+C;;IAE/C,qCAAqC;;GA4DxC,CAAC;AAMF;;GAEG;AACH,eAAO,MAAM,SAAS;IAClB,qCAAqC;;IAErC,+CAA+C;;QA9I/C,sCAAsC;;QAEtC,sCAAsC;;;IA8ItC,yCAAyC;;QAhIzC,8DAA8D;;QAE9D,oEAAoE;;;IAgIpE,mCAAmC;;QAtHnC,mDAAmD;;QAEnD,kDAAkD;;QAElD,iDAAiD;;QAEjD,uBAAuB;;;IAkHvB,yBAAyB;;QAxGzB,6CAA6C;;QAE7C,2CAA2C;;QAE3C,mCAAmC;;YApBnC,mDAAmD;;YAEnD,kDAAkD;;YAElD,iDAAiD;;YAEjD,uBAAuB;;;QAgBvB,wBAAwB;;QAExB,6CAA6C;;QAE7C,sCAAsC;;;IAgGtC,mCAAmC;;QAtFnC,iCAAiC;;QAEjC,2BAA2B;;QAE3B,+CAA+C;;QAE/C,qCAAqC;;;CAkF/B,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,IAAI;IACb;;;;OAIG;;QAtMH,sCAAsC;;QAEtC,sCAAsC;;;QActC,8DAA8D;;QAE9D,oEAAoE;;;QA0BpE,6CAA6C;;QAE7C,2CAA2C;;QAE3C,mCAAmC;;YApBnC,mDAAmD;;YAEnD,kDAAkD;;YAElD,iDAAiD;;YAEjD,uBAAuB;;;QAgBvB,wBAAwB;;QAExB,6CAA6C;;QAE7C,sCAAsC;;;QAUtC,iCAAiC;;QAEjC,2BAA2B;;QAE3B,+CAA+C;;QAE/C,qCAAqC;;;IAmIrC;;OAEG;;QA/DH,qCAAqC;;QAErC,+CAA+C;;YA9I/C,sCAAsC;;YAEtC,sCAAsC;;;QA8ItC,yCAAyC;;YAhIzC,8DAA8D;;YAE9D,oEAAoE;;;QAgIpE,mCAAmC;;YAtHnC,mDAAmD;;YAEnD,kDAAkD;;YAElD,iDAAiD;;YAEjD,uBAAuB;;;QAkHvB,yBAAyB;;YAxGzB,6CAA6C;;YAE7C,2CAA2C;;YAE3C,mCAAmC;;gBApBnC,mDAAmD;;gBAEnD,kDAAkD;;gBAElD,iDAAiD;;gBAEjD,uBAAuB;;;YAgBvB,wBAAwB;;YAExB,6CAA6C;;YAE7C,sCAAsC;;;QAgGtC,mCAAmC;;YAtFnC,iCAAiC;;YAEjC,2BAA2B;;YAE3B,+CAA+C;;YAE/C,qCAAqC;;;;CAwI/B,CAAC"}

package/dist/src/mads/mads.js

@@ -0,0 +1,219 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * MADS (Mesh Adaptive Direct Search) derivative-free optimization.
+ *
+ * Provides blackbox optimization using the NOMAD MADS algorithm via PyNomadBBO.
+ * MADS is designed for difficult optimization problems where:
+ * - Functions have no exploitable derivatives
+ * - Evaluations are computationally expensive
+ * - Functions may be contaminated by noise
+ * - Functions may fail for some feasible points
+ *
+ * @packageDocumentation
+ */
+import { East, StructType, VariantType, OptionType, ArrayType, IntegerType, BooleanType, FloatType, NullType, } from "@elaraai/east";
+import { VectorType, ScalarObjectiveType } from "../types.js";
+// Re-export shared types for convenience
+export { VectorType, ScalarObjectiveType } from "../types.js";
+/**
+ * MADS optimization bounds.
+ *
+ * Defines the lower and upper bounds for each dimension of the search space.
+ */
+export const MADSBoundsType = StructType({
+    /** Lower bounds for each dimension */
+    lower: VectorType(FloatType),
+    /** Upper bounds for each dimension */
+    upper: VectorType(FloatType),
+});
+/**
+ * MADS constraint type.
+ *
+ * A variant where the tag indicates the constraint handling method:
+ * - `eb` (Extreme Barrier): Infeasible points are rejected entirely
+ * - `pb` (Progressive Barrier): Allows temporary constraint violations during search
+ *
+ * The value is the constraint function: g(x) <= 0 is feasible.
+ */
+export const MADSConstraintType = VariantType({
+    /** Extreme barrier constraint - infeasible points rejected */
+    eb: ScalarObjectiveType,
+    /** Progressive barrier constraint - temporary violations allowed */
+    pb: ScalarObjectiveType,
+});
+/**
+ * MADS direction type for poll step.
+ *
+ * Controls how search directions are generated during the poll step.
+ */
+export const MADSDirectionType = VariantType({
+    /** ORTHO 2N: 2n orthogonal directions (default) */
+    ortho_2n: NullType,
+    /** ORTHO N+1: n+1 directions forming a simplex */
+    ortho_n_plus_1: NullType,
+    /** LT 2N: Lower triangular with 2n directions */
+    lt_2n: NullType,
+    /** Single direction */
+    single: NullType,
+});
+/**
+ * MADS optimization configuration.
+ *
+ * Configures the MADS algorithm parameters.
+ */
+export const MADSConfigType = StructType({
+    /** Maximum number of blackbox evaluations */
+    max_bb_eval: OptionType(IntegerType),
+    /** Display verbosity level (0 = silent) */
+    display_degree: OptionType(IntegerType),
+    /** Direction type for poll step */
+    direction_type: OptionType(MADSDirectionType),
+    /** Initial mesh size */
+    initial_mesh_size: OptionType(FloatType),
+    /** Minimum mesh size (stopping criterion) */
+    min_mesh_size: OptionType(FloatType),
+    /** Random seed for reproducibility */
+    seed: OptionType(IntegerType),
+});
+/**
+ * MADS single-objective optimization result.
+ *
+ * Contains the best solution found and optimization statistics.
+ */
+export const MADSResultType = StructType({
+    /** Best solution vector found */
+    x_best: VectorType(FloatType),
+    /** Best objective value */
+    f_best: FloatType,
+    /** Number of blackbox evaluations performed */
+    bb_eval: IntegerType,
+    /** Whether optimization succeeded */
+    success: BooleanType,
+});
+// ============================================================================
+// Platform Functions
+// ============================================================================
+/**
+ * Single-objective MADS optimization with optional constraints.
+ *
+ * Minimizes an objective function subject to bound constraints and optional
+ * nonlinear constraints using the MADS algorithm.
+ *
+ * @param objective - Objective function to minimize: x -> f(x)
+ * @param x0 - Initial starting point
+ * @param bounds - Lower and upper bounds for each dimension
+ * @param constraints - Optional array of constraint functions (g(x) <= 0 is feasible)
+ * @param config - Optimization configuration
+ * @returns Optimization result with best solution found
+ *
+ * @example
+ * ```ts
+ * import { East, FloatType, variant } from "@elaraai/east";
+ * import { MADS } from "@elaraai/east-py-datascience";
+ *
+ * // Minimize sum of squares
+ * const objective = East.function([MADS.Types.VectorType(FloatType)], FloatType, ($, x) => {
+ *     return x.reduce((acc, xi) => acc.add(xi.multiply(xi)), East.value(0.0));
+ * });
+ *
+ * const optimize = East.function([], MADS.Types.ResultType, $ => {
+ *     const x0 = $.let([0.71, 0.51, 0.51]);
+ *     const bounds = $.let({ lower: [-1.0, -1.0, -1.0], upper: [1.0, 1.0, 1.0] });
+ *     const config = $.let({
+ *         max_bb_eval: variant('some', 100n),
+ *         display_degree: variant('some', 0n),
+ *         direction_type: variant('none', null),
+ *         initial_mesh_size: variant('none', null),
+ *         min_mesh_size: variant('none', null),
+ *         seed: variant('some', 42n),
+ *     });
+ *     return $.return(MADS.optimize(objective, x0, bounds, variant('none', null), config));
+ * });
+ *
+ * const compiled = await East.compileAsync(optimize.toIR(), MADS.Implementation);
+ * const result = await compiled();
+ * console.log(`Best: ${result.f_best}`);
+ * ```
+ */
+export const mads_optimize = East.platform("mads_optimize", [
+    ScalarObjectiveType,
+    VectorType(FloatType),
+    MADSBoundsType,
+    OptionType(ArrayType(MADSConstraintType)),
+    MADSConfigType,
+], MADSResultType);
+// ============================================================================
+// Grouped Export
+// ============================================================================
+/**
+ * Type definitions for MADS optimization.
+ */
+export const MADSTypes = {
+    /** Scalar objective function type */
+    ScalarObjectiveType,
+    /** Bounds type with lower and upper vectors */
+    BoundsType: MADSBoundsType,
+    /** Constraint type (eb or pb variant) */
+    ConstraintType: MADSConstraintType,
+    /** Direction type for poll step */
+    DirectionType: MADSDirectionType,
+    /** Configuration type */
+    ConfigType: MADSConfigType,
+    /** Single-objective result type */
+    ResultType: MADSResultType,
+};
+/**
+ * MADS derivative-free blackbox optimization.
+ *
+ * Provides optimization algorithms for expensive blackbox functions
+ * where gradient information is unavailable using the NOMAD MADS algorithm.
+ *
+ * MADS is particularly effective for:
+ * - Expensive blackbox functions (simulations, experiments)
+ * - Functions with no exploitable derivatives
+ * - Noisy or stochastic functions
+ * - Functions that may fail for some inputs
+ *
+ * @example
+ * ```ts
+ * import { East, FloatType, variant } from "@elaraai/east";
+ * import { MADS } from "@elaraai/east-py-datascience";
+ *
+ * const objective = East.function([MADS.Types.VectorType(FloatType)], FloatType, ($, x) => {
+ *     return x.reduce((acc, xi) => acc.add(xi.multiply(xi)), East.value(0.0));
+ * });
+ *
+ * const optimize = East.function([], MADS.Types.ResultType, $ => {
+ *     const x0 = $.let([0.5, 0.5]);
+ *     const bounds = $.let({ lower: [-1.0, -1.0], upper: [1.0, 1.0] });
+ *     const config = $.let({
+ *         max_bb_eval: variant('some', 100n),
+ *         display_degree: variant('some', 0n),
+ *         direction_type: variant('none', null),
+ *         initial_mesh_size: variant('none', null),
+ *         min_mesh_size: variant('none', null),
+ *         seed: variant('some', 42n),
+ *     });
+ *     return $.return(MADS.optimize(objective, x0, bounds, variant('none', null), config));
+ * });
+ *
+ * const compiled = await East.compileAsync(optimize.toIR(), MADS.Implementation);
+ * const result = await compiled();
+ * ```
+ */
+export const MADS = {
+    /**
+     * Single-objective optimization with optional constraints.
+     *
+     * Minimizes an objective function subject to bound and nonlinear constraints.
+     */
+    optimize: mads_optimize,
+    /**
+     * Type definitions for MADS functions.
+     */
+    Types: MADSTypes,
+};
+//# sourceMappingURL=mads.js.map

package/dist/src/mads/mads.js.map

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