@elaraai/east-py-datascience 0.0.2-beta.1

package/dist/mads/mads.d.ts

@@ -0,0 +1,413 @@
+/**
+ * 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 } from "@elaraai/east";
+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 */
+    lower: ArrayType<FloatType>;
+    /** Upper bounds for each dimension */
+    upper: ArrayType<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 */
+    eb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+    /** Progressive barrier constraint - temporary violations allowed */
+    pb: import("@elaraai/east").FunctionType<[ArrayType<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) */
+    ortho_2n: StructType<{}>;
+    /** ORTHO N+1: n+1 directions forming a simplex */
+    ortho_n_plus_1: StructType<{}>;
+    /** LT 2N: Lower triangular with 2n directions */
+    lt_2n: StructType<{}>;
+    /** Single direction */
+    single: StructType<{}>;
+}>;
+/**
+ * MADS optimization configuration.
+ *
+ * Configures the MADS algorithm parameters.
+ */
+export declare 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<VariantType<{
+        /** ORTHO 2N: 2n orthogonal directions (default) */
+        ortho_2n: StructType<{}>;
+        /** ORTHO N+1: n+1 directions forming a simplex */
+        ortho_n_plus_1: StructType<{}>;
+        /** LT 2N: Lower triangular with 2n directions */
+        lt_2n: StructType<{}>;
+        /** Single direction */
+        single: StructType<{}>;
+    }>>;
+    /** 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 declare const MADSResultType: StructType<{
+    /** Best solution vector found */
+    x_best: ArrayType<FloatType>;
+    /** Best objective value */
+    f_best: FloatType;
+    /** Number of blackbox evaluations performed */
+    bb_eval: IntegerType;
+    /** Whether optimization succeeded */
+    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, ($, 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<[ArrayType<FloatType>], FloatType>, ArrayType<FloatType>, StructType<{
+    /** Lower bounds for each dimension */
+    lower: ArrayType<FloatType>;
+    /** Upper bounds for each dimension */
+    upper: ArrayType<FloatType>;
+}>, OptionType<ArrayType<VariantType<{
+    /** Extreme barrier constraint - infeasible points rejected */
+    eb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+    /** Progressive barrier constraint - temporary violations allowed */
+    pb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+}>>>, 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<VariantType<{
+        /** ORTHO 2N: 2n orthogonal directions (default) */
+        ortho_2n: StructType<{}>;
+        /** ORTHO N+1: n+1 directions forming a simplex */
+        ortho_n_plus_1: StructType<{}>;
+        /** LT 2N: Lower triangular with 2n directions */
+        lt_2n: StructType<{}>;
+        /** Single direction */
+        single: StructType<{}>;
+    }>>;
+    /** 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>;
+}>], StructType<{
+    /** Best solution vector found */
+    x_best: ArrayType<FloatType>;
+    /** Best objective value */
+    f_best: FloatType;
+    /** Number of blackbox evaluations performed */
+    bb_eval: IntegerType;
+    /** Whether optimization succeeded */
+    success: BooleanType;
+}>>;
+/**
+ * Type definitions for MADS optimization.
+ */
+export declare const MADSTypes: {
+    /** Vector type (array of floats) */
+    readonly VectorType: ArrayType<FloatType>;
+    /** Scalar objective function type */
+    readonly ScalarObjectiveType: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+    /** Bounds type with lower and upper vectors */
+    readonly BoundsType: StructType<{
+        /** Lower bounds for each dimension */
+        lower: ArrayType<FloatType>;
+        /** Upper bounds for each dimension */
+        upper: ArrayType<FloatType>;
+    }>;
+    /** Constraint type (eb or pb variant) */
+    readonly ConstraintType: VariantType<{
+        /** Extreme barrier constraint - infeasible points rejected */
+        eb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+        /** Progressive barrier constraint - temporary violations allowed */
+        pb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+    }>;
+    /** Direction type for poll step */
+    readonly DirectionType: VariantType<{
+        /** ORTHO 2N: 2n orthogonal directions (default) */
+        ortho_2n: StructType<{}>;
+        /** ORTHO N+1: n+1 directions forming a simplex */
+        ortho_n_plus_1: StructType<{}>;
+        /** LT 2N: Lower triangular with 2n directions */
+        lt_2n: StructType<{}>;
+        /** Single direction */
+        single: StructType<{}>;
+    }>;
+    /** Configuration type */
+    readonly ConfigType: 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<VariantType<{
+            /** ORTHO 2N: 2n orthogonal directions (default) */
+            ortho_2n: StructType<{}>;
+            /** ORTHO N+1: n+1 directions forming a simplex */
+            ortho_n_plus_1: StructType<{}>;
+            /** LT 2N: Lower triangular with 2n directions */
+            lt_2n: StructType<{}>;
+            /** Single direction */
+            single: StructType<{}>;
+        }>>;
+        /** 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>;
+    }>;
+    /** Single-objective result type */
+    readonly ResultType: StructType<{
+        /** Best solution vector found */
+        x_best: ArrayType<FloatType>;
+        /** Best objective value */
+        f_best: FloatType;
+        /** Number of blackbox evaluations performed */
+        bb_eval: IntegerType;
+        /** Whether optimization succeeded */
+        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, ($, 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<[ArrayType<FloatType>], FloatType>, ArrayType<FloatType>, StructType<{
+        /** Lower bounds for each dimension */
+        lower: ArrayType<FloatType>;
+        /** Upper bounds for each dimension */
+        upper: ArrayType<FloatType>;
+    }>, OptionType<ArrayType<VariantType<{
+        /** Extreme barrier constraint - infeasible points rejected */
+        eb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+        /** Progressive barrier constraint - temporary violations allowed */
+        pb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+    }>>>, 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<VariantType<{
+            /** ORTHO 2N: 2n orthogonal directions (default) */
+            ortho_2n: StructType<{}>;
+            /** ORTHO N+1: n+1 directions forming a simplex */
+            ortho_n_plus_1: StructType<{}>;
+            /** LT 2N: Lower triangular with 2n directions */
+            lt_2n: StructType<{}>;
+            /** Single direction */
+            single: StructType<{}>;
+        }>>;
+        /** 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>;
+    }>], StructType<{
+        /** Best solution vector found */
+        x_best: ArrayType<FloatType>;
+        /** Best objective value */
+        f_best: FloatType;
+        /** Number of blackbox evaluations performed */
+        bb_eval: IntegerType;
+        /** Whether optimization succeeded */
+        success: BooleanType;
+    }>>;
+    /**
+     * Type definitions for MADS functions.
+     */
+    readonly Types: {
+        /** Vector type (array of floats) */
+        readonly VectorType: ArrayType<FloatType>;
+        /** Scalar objective function type */
+        readonly ScalarObjectiveType: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+        /** Bounds type with lower and upper vectors */
+        readonly BoundsType: StructType<{
+            /** Lower bounds for each dimension */
+            lower: ArrayType<FloatType>;
+            /** Upper bounds for each dimension */
+            upper: ArrayType<FloatType>;
+        }>;
+        /** Constraint type (eb or pb variant) */
+        readonly ConstraintType: VariantType<{
+            /** Extreme barrier constraint - infeasible points rejected */
+            eb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+            /** Progressive barrier constraint - temporary violations allowed */
+            pb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+        }>;
+        /** Direction type for poll step */
+        readonly DirectionType: VariantType<{
+            /** ORTHO 2N: 2n orthogonal directions (default) */
+            ortho_2n: StructType<{}>;
+            /** ORTHO N+1: n+1 directions forming a simplex */
+            ortho_n_plus_1: StructType<{}>;
+            /** LT 2N: Lower triangular with 2n directions */
+            lt_2n: StructType<{}>;
+            /** Single direction */
+            single: StructType<{}>;
+        }>;
+        /** Configuration type */
+        readonly ConfigType: 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<VariantType<{
+                /** ORTHO 2N: 2n orthogonal directions (default) */
+                ortho_2n: StructType<{}>;
+                /** ORTHO N+1: n+1 directions forming a simplex */
+                ortho_n_plus_1: StructType<{}>;
+                /** LT 2N: Lower triangular with 2n directions */
+                lt_2n: StructType<{}>;
+                /** Single direction */
+                single: StructType<{}>;
+            }>>;
+            /** 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>;
+        }>;
+        /** Single-objective result type */
+        readonly ResultType: StructType<{
+            /** Best solution vector found */
+            x_best: ArrayType<FloatType>;
+            /** Best objective value */
+            f_best: FloatType;
+            /** Number of blackbox evaluations performed */
+            bb_eval: IntegerType;
+            /** Whether optimization succeeded */
+            success: BooleanType;
+        }>;
+    };
+};
+//# sourceMappingURL=mads.d.ts.map

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

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

package/dist/mads/mads.js

@@ -0,0 +1,221 @@
+/**
+ * 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, } 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,
+    /** Upper bounds for each dimension */
+    upper: VectorType,
+});
+/**
+ * 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: StructType({}),
+    /** ORTHO N+1: n+1 directions forming a simplex */
+    ortho_n_plus_1: StructType({}),
+    /** LT 2N: Lower triangular with 2n directions */
+    lt_2n: StructType({}),
+    /** Single direction */
+    single: StructType({}),
+});
+/**
+ * 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,
+    /** 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, ($, 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,
+    MADSBoundsType,
+    OptionType(ArrayType(MADSConstraintType)),
+    MADSConfigType,
+], MADSResultType);
+// ============================================================================
+// Grouped Export
+// ============================================================================
+/**
+ * Type definitions for MADS optimization.
+ */
+export const MADSTypes = {
+    /** Vector type (array of floats) */
+    VectorType,
+    /** 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, ($, 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/mads/mads.js.map

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