@elaraai/east-py-datascience 0.0.2-beta.8 → 0.0.2-beta.80

package/dist/{mads → src/mads}/mads.d.ts

@@ -15,6 +15,7 @@
  * @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.
@@ -23,9 +24,9 @@ export { VectorType, ScalarObjectiveType } from "../types.js";
  */
 export declare const MADSBoundsType: StructType<{
     /** Lower bounds for each dimension */
-    lower: ArrayType<FloatType>;
+    readonly lower: VectorType<FloatType>;
     /** Upper bounds for each dimension */
-    upper: ArrayType<FloatType>;
+    readonly upper: VectorType<FloatType>;
 }>;
 /**
  * MADS constraint type.
@@ -38,9 +39,9 @@ export declare const MADSBoundsType: StructType<{
  */
 export declare const MADSConstraintType: VariantType<{
     /** Extreme barrier constraint - infeasible points rejected */
-    eb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+    readonly eb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
     /** Progressive barrier constraint - temporary violations allowed */
-    pb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+    readonly pb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
 }>;
 /**
  * MADS direction type for poll step.
@@ -49,13 +50,13 @@ export declare const MADSConstraintType: VariantType<{
  */
 export declare const MADSDirectionType: VariantType<{
     /** ORTHO 2N: 2n orthogonal directions (default) */
-    ortho_2n: NullType;
+    readonly ortho_2n: NullType;
     /** ORTHO N+1: n+1 directions forming a simplex */
-    ortho_n_plus_1: NullType;
+    readonly ortho_n_plus_1: NullType;
     /** LT 2N: Lower triangular with 2n directions */
-    lt_2n: NullType;
+    readonly lt_2n: NullType;
     /** Single direction */
-    single: NullType;
+    readonly single: NullType;
 }>;
 /**
  * MADS optimization configuration.
@@ -64,26 +65,26 @@ export declare const MADSDirectionType: VariantType<{
  */
 export declare const MADSConfigType: StructType<{
     /** Maximum number of blackbox evaluations */
-    max_bb_eval: OptionType<IntegerType>;
+    readonly max_bb_eval: OptionType<IntegerType>;
     /** Display verbosity level (0 = silent) */
-    display_degree: OptionType<IntegerType>;
+    readonly display_degree: OptionType<IntegerType>;
     /** Direction type for poll step */
-    direction_type: OptionType<VariantType<{
+    readonly direction_type: OptionType<VariantType<{
         /** ORTHO 2N: 2n orthogonal directions (default) */
-        ortho_2n: NullType;
+        readonly ortho_2n: NullType;
         /** ORTHO N+1: n+1 directions forming a simplex */
-        ortho_n_plus_1: NullType;
+        readonly ortho_n_plus_1: NullType;
         /** LT 2N: Lower triangular with 2n directions */
-        lt_2n: NullType;
+        readonly lt_2n: NullType;
         /** Single direction */
-        single: NullType;
+        readonly single: NullType;
     }>>;
     /** Initial mesh size */
-    initial_mesh_size: OptionType<FloatType>;
+    readonly initial_mesh_size: OptionType<FloatType>;
     /** Minimum mesh size (stopping criterion) */
-    min_mesh_size: OptionType<FloatType>;
+    readonly min_mesh_size: OptionType<FloatType>;
     /** Random seed for reproducibility */
-    seed: OptionType<IntegerType>;
+    readonly seed: OptionType<IntegerType>;
 }>;
 /**
  * MADS single-objective optimization result.
@@ -92,13 +93,13 @@ export declare const MADSConfigType: StructType<{
  */
 export declare const MADSResultType: StructType<{
     /** Best solution vector found */
-    x_best: ArrayType<FloatType>;
+    readonly x_best: VectorType<FloatType>;
     /** Best objective value */
-    f_best: FloatType;
+    readonly f_best: FloatType;
     /** Number of blackbox evaluations performed */
-    bb_eval: IntegerType;
+    readonly bb_eval: IntegerType;
     /** Whether optimization succeeded */
-    success: BooleanType;
+    readonly success: BooleanType;
 }>;
 /**
  * Single-objective MADS optimization with optional constraints.
@@ -119,7 +120,7 @@ export declare const MADSResultType: StructType<{
  * import { MADS } from "@elaraai/east-py-datascience";
  *
  * // Minimize sum of squares
- * const objective = East.function([MADS.Types.VectorType], FloatType, ($, x) => {
+ * const objective = East.function([MADS.Types.VectorType(FloatType)], FloatType, ($, x) => {
  *     return x.reduce((acc, xi) => acc.add(xi.multiply(xi)), East.value(0.0));
  * });
  *
@@ -142,115 +143,113 @@ export declare const MADSResultType: StructType<{
  * 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<{
+export declare const mads_optimize: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>, VectorType<FloatType>, StructType<{
     /** Lower bounds for each dimension */
-    lower: ArrayType<FloatType>;
+    readonly lower: VectorType<FloatType>;
     /** Upper bounds for each dimension */
-    upper: ArrayType<FloatType>;
+    readonly upper: VectorType<FloatType>;
 }>, OptionType<ArrayType<VariantType<{
     /** Extreme barrier constraint - infeasible points rejected */
-    eb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+    readonly eb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
     /** Progressive barrier constraint - temporary violations allowed */
-    pb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+    readonly pb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
 }>>>, StructType<{
     /** Maximum number of blackbox evaluations */
-    max_bb_eval: OptionType<IntegerType>;
+    readonly max_bb_eval: OptionType<IntegerType>;
     /** Display verbosity level (0 = silent) */
-    display_degree: OptionType<IntegerType>;
+    readonly display_degree: OptionType<IntegerType>;
     /** Direction type for poll step */
-    direction_type: OptionType<VariantType<{
+    readonly direction_type: OptionType<VariantType<{
         /** ORTHO 2N: 2n orthogonal directions (default) */
-        ortho_2n: NullType;
+        readonly ortho_2n: NullType;
         /** ORTHO N+1: n+1 directions forming a simplex */
-        ortho_n_plus_1: NullType;
+        readonly ortho_n_plus_1: NullType;
         /** LT 2N: Lower triangular with 2n directions */
-        lt_2n: NullType;
+        readonly lt_2n: NullType;
         /** Single direction */
-        single: NullType;
+        readonly single: NullType;
     }>>;
     /** Initial mesh size */
-    initial_mesh_size: OptionType<FloatType>;
+    readonly initial_mesh_size: OptionType<FloatType>;
     /** Minimum mesh size (stopping criterion) */
-    min_mesh_size: OptionType<FloatType>;
+    readonly min_mesh_size: OptionType<FloatType>;
     /** Random seed for reproducibility */
-    seed: OptionType<IntegerType>;
+    readonly seed: OptionType<IntegerType>;
 }>], StructType<{
     /** Best solution vector found */
-    x_best: ArrayType<FloatType>;
+    readonly x_best: VectorType<FloatType>;
     /** Best objective value */
-    f_best: FloatType;
+    readonly f_best: FloatType;
     /** Number of blackbox evaluations performed */
-    bb_eval: IntegerType;
+    readonly bb_eval: IntegerType;
     /** Whether optimization succeeded */
-    success: BooleanType;
+    readonly 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>;
+    readonly ScalarObjectiveType: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
     /** Bounds type with lower and upper vectors */
     readonly BoundsType: StructType<{
         /** Lower bounds for each dimension */
-        lower: ArrayType<FloatType>;
+        readonly lower: VectorType<FloatType>;
         /** Upper bounds for each dimension */
-        upper: ArrayType<FloatType>;
+        readonly upper: VectorType<FloatType>;
     }>;
     /** Constraint type (eb or pb variant) */
     readonly ConstraintType: VariantType<{
         /** Extreme barrier constraint - infeasible points rejected */
-        eb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+        readonly eb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
         /** Progressive barrier constraint - temporary violations allowed */
-        pb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+        readonly pb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
     }>;
     /** Direction type for poll step */
     readonly DirectionType: VariantType<{
         /** ORTHO 2N: 2n orthogonal directions (default) */
-        ortho_2n: NullType;
+        readonly ortho_2n: NullType;
         /** ORTHO N+1: n+1 directions forming a simplex */
-        ortho_n_plus_1: NullType;
+        readonly ortho_n_plus_1: NullType;
         /** LT 2N: Lower triangular with 2n directions */
-        lt_2n: NullType;
+        readonly lt_2n: NullType;
         /** Single direction */
-        single: NullType;
+        readonly single: NullType;
     }>;
     /** Configuration type */
     readonly ConfigType: StructType<{
         /** Maximum number of blackbox evaluations */
-        max_bb_eval: OptionType<IntegerType>;
+        readonly max_bb_eval: OptionType<IntegerType>;
         /** Display verbosity level (0 = silent) */
-        display_degree: OptionType<IntegerType>;
+        readonly display_degree: OptionType<IntegerType>;
         /** Direction type for poll step */
-        direction_type: OptionType<VariantType<{
+        readonly direction_type: OptionType<VariantType<{
             /** ORTHO 2N: 2n orthogonal directions (default) */
-            ortho_2n: NullType;
+            readonly ortho_2n: NullType;
             /** ORTHO N+1: n+1 directions forming a simplex */
-            ortho_n_plus_1: NullType;
+            readonly ortho_n_plus_1: NullType;
             /** LT 2N: Lower triangular with 2n directions */
-            lt_2n: NullType;
+            readonly lt_2n: NullType;
             /** Single direction */
-            single: NullType;
+            readonly single: NullType;
         }>>;
         /** Initial mesh size */
-        initial_mesh_size: OptionType<FloatType>;
+        readonly initial_mesh_size: OptionType<FloatType>;
         /** Minimum mesh size (stopping criterion) */
-        min_mesh_size: OptionType<FloatType>;
+        readonly min_mesh_size: OptionType<FloatType>;
         /** Random seed for reproducibility */
-        seed: OptionType<IntegerType>;
+        readonly seed: OptionType<IntegerType>;
     }>;
     /** Single-objective result type */
     readonly ResultType: StructType<{
         /** Best solution vector found */
-        x_best: ArrayType<FloatType>;
+        readonly x_best: VectorType<FloatType>;
         /** Best objective value */
-        f_best: FloatType;
+        readonly f_best: FloatType;
         /** Number of blackbox evaluations performed */
-        bb_eval: IntegerType;
+        readonly bb_eval: IntegerType;
         /** Whether optimization succeeded */
-        success: BooleanType;
+        readonly success: BooleanType;
     }>;
 };
 /**
@@ -270,7 +269,7 @@ export declare const MADSTypes: {
  * import { East, FloatType, variant } from "@elaraai/east";
  * import { MADS } from "@elaraai/east-py-datascience";
  *
- * const objective = East.function([MADS.Types.VectorType], FloatType, ($, x) => {
+ * const objective = East.function([MADS.Types.VectorType(FloatType)], FloatType, ($, x) => {
  *     return x.reduce((acc, xi) => acc.add(xi.multiply(xi)), East.value(0.0));
  * });
  *
@@ -298,115 +297,113 @@ export declare const MADS: {
      *
      * 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<{
+    readonly optimize: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>, VectorType<FloatType>, StructType<{
         /** Lower bounds for each dimension */
-        lower: ArrayType<FloatType>;
+        readonly lower: VectorType<FloatType>;
         /** Upper bounds for each dimension */
-        upper: ArrayType<FloatType>;
+        readonly upper: VectorType<FloatType>;
     }>, OptionType<ArrayType<VariantType<{
         /** Extreme barrier constraint - infeasible points rejected */
-        eb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+        readonly eb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
         /** Progressive barrier constraint - temporary violations allowed */
-        pb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+        readonly pb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
     }>>>, StructType<{
         /** Maximum number of blackbox evaluations */
-        max_bb_eval: OptionType<IntegerType>;
+        readonly max_bb_eval: OptionType<IntegerType>;
         /** Display verbosity level (0 = silent) */
-        display_degree: OptionType<IntegerType>;
+        readonly display_degree: OptionType<IntegerType>;
         /** Direction type for poll step */
-        direction_type: OptionType<VariantType<{
+        readonly direction_type: OptionType<VariantType<{
             /** ORTHO 2N: 2n orthogonal directions (default) */
-            ortho_2n: NullType;
+            readonly ortho_2n: NullType;
             /** ORTHO N+1: n+1 directions forming a simplex */
-            ortho_n_plus_1: NullType;
+            readonly ortho_n_plus_1: NullType;
             /** LT 2N: Lower triangular with 2n directions */
-            lt_2n: NullType;
+            readonly lt_2n: NullType;
             /** Single direction */
-            single: NullType;
+            readonly single: NullType;
         }>>;
         /** Initial mesh size */
-        initial_mesh_size: OptionType<FloatType>;
+        readonly initial_mesh_size: OptionType<FloatType>;
         /** Minimum mesh size (stopping criterion) */
-        min_mesh_size: OptionType<FloatType>;
+        readonly min_mesh_size: OptionType<FloatType>;
         /** Random seed for reproducibility */
-        seed: OptionType<IntegerType>;
+        readonly seed: OptionType<IntegerType>;
     }>], StructType<{
         /** Best solution vector found */
-        x_best: ArrayType<FloatType>;
+        readonly x_best: VectorType<FloatType>;
         /** Best objective value */
-        f_best: FloatType;
+        readonly f_best: FloatType;
         /** Number of blackbox evaluations performed */
-        bb_eval: IntegerType;
+        readonly bb_eval: IntegerType;
         /** Whether optimization succeeded */
-        success: BooleanType;
+        readonly 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>;
+        readonly ScalarObjectiveType: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
         /** Bounds type with lower and upper vectors */
         readonly BoundsType: StructType<{
             /** Lower bounds for each dimension */
-            lower: ArrayType<FloatType>;
+            readonly lower: VectorType<FloatType>;
             /** Upper bounds for each dimension */
-            upper: ArrayType<FloatType>;
+            readonly upper: VectorType<FloatType>;
         }>;
         /** Constraint type (eb or pb variant) */
         readonly ConstraintType: VariantType<{
             /** Extreme barrier constraint - infeasible points rejected */
-            eb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+            readonly eb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
             /** Progressive barrier constraint - temporary violations allowed */
-            pb: import("@elaraai/east").FunctionType<[ArrayType<FloatType>], FloatType>;
+            readonly pb: import("@elaraai/east").FunctionType<[VectorType<FloatType>], FloatType>;
         }>;
         /** Direction type for poll step */
         readonly DirectionType: VariantType<{
             /** ORTHO 2N: 2n orthogonal directions (default) */
-            ortho_2n: NullType;
+            readonly ortho_2n: NullType;
             /** ORTHO N+1: n+1 directions forming a simplex */
-            ortho_n_plus_1: NullType;
+            readonly ortho_n_plus_1: NullType;
             /** LT 2N: Lower triangular with 2n directions */
-            lt_2n: NullType;
+            readonly lt_2n: NullType;
             /** Single direction */
-            single: NullType;
+            readonly single: NullType;
         }>;
         /** Configuration type */
         readonly ConfigType: StructType<{
             /** Maximum number of blackbox evaluations */
-            max_bb_eval: OptionType<IntegerType>;
+            readonly max_bb_eval: OptionType<IntegerType>;
             /** Display verbosity level (0 = silent) */
-            display_degree: OptionType<IntegerType>;
+            readonly display_degree: OptionType<IntegerType>;
             /** Direction type for poll step */
-            direction_type: OptionType<VariantType<{
+            readonly direction_type: OptionType<VariantType<{
                 /** ORTHO 2N: 2n orthogonal directions (default) */
-                ortho_2n: NullType;
+                readonly ortho_2n: NullType;
                 /** ORTHO N+1: n+1 directions forming a simplex */
-                ortho_n_plus_1: NullType;
+                readonly ortho_n_plus_1: NullType;
                 /** LT 2N: Lower triangular with 2n directions */
-                lt_2n: NullType;
+                readonly lt_2n: NullType;
                 /** Single direction */
-                single: NullType;
+                readonly single: NullType;
             }>>;
             /** Initial mesh size */
-            initial_mesh_size: OptionType<FloatType>;
+            readonly initial_mesh_size: OptionType<FloatType>;
             /** Minimum mesh size (stopping criterion) */
-            min_mesh_size: OptionType<FloatType>;
+            readonly min_mesh_size: OptionType<FloatType>;
             /** Random seed for reproducibility */
-            seed: OptionType<IntegerType>;
+            readonly seed: OptionType<IntegerType>;
         }>;
         /** Single-objective result type */
         readonly ResultType: StructType<{
             /** Best solution vector found */
-            x_best: ArrayType<FloatType>;
+            readonly x_best: VectorType<FloatType>;
             /** Best objective value */
-            f_best: FloatType;
+            readonly f_best: FloatType;
             /** Number of blackbox evaluations performed */
-            bb_eval: IntegerType;
+            readonly bb_eval: IntegerType;
             /** Whether optimization succeeded */
-            success: BooleanType;
+            readonly success: BooleanType;
         }>;
     };
 };

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":"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"}

package/dist/{mads → src/mads}/mads.js

@@ -25,9 +25,9 @@ export { VectorType, ScalarObjectiveType } from "../types.js";
  */
 export const MADSBoundsType = StructType({
     /** Lower bounds for each dimension */
-    lower: VectorType,
+    lower: VectorType(FloatType),
     /** Upper bounds for each dimension */
-    upper: VectorType,
+    upper: VectorType(FloatType),
 });
 /**
  * MADS constraint type.
@@ -85,7 +85,7 @@ export const MADSConfigType = StructType({
  */
 export const MADSResultType = StructType({
     /** Best solution vector found */
-    x_best: VectorType,
+    x_best: VectorType(FloatType),
     /** Best objective value */
     f_best: FloatType,
     /** Number of blackbox evaluations performed */
@@ -115,7 +115,7 @@ export const MADSResultType = StructType({
  * import { MADS } from "@elaraai/east-py-datascience";
  *
  * // Minimize sum of squares
- * const objective = East.function([MADS.Types.VectorType], FloatType, ($, x) => {
+ * const objective = East.function([MADS.Types.VectorType(FloatType)], FloatType, ($, x) => {
  *     return x.reduce((acc, xi) => acc.add(xi.multiply(xi)), East.value(0.0));
  * });
  *
@@ -140,7 +140,7 @@ export const MADSResultType = StructType({
  */
 export const mads_optimize = East.platform("mads_optimize", [
     ScalarObjectiveType,
-    VectorType,
+    VectorType(FloatType),
     MADSBoundsType,
     OptionType(ArrayType(MADSConstraintType)),
     MADSConfigType,
@@ -152,8 +152,6 @@ export const mads_optimize = East.platform("mads_optimize", [
  * 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 */
@@ -184,7 +182,7 @@ export const MADSTypes = {
  * import { East, FloatType, variant } from "@elaraai/east";
  * import { MADS } from "@elaraai/east-py-datascience";
  *
- * const objective = East.function([MADS.Types.VectorType], FloatType, ($, x) => {
+ * const objective = East.function([MADS.Types.VectorType(FloatType)], FloatType, ($, x) => {
  *     return x.reduce((acc, xi) => acc.add(xi.multiply(xi)), East.value(0.0));
  * });
  *

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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"}