@elaraai/east-py-datascience 0.0.2-beta.6 → 0.0.2-beta.61

package/dist/scipy/scipy.d.ts

@@ -17,61 +17,61 @@ export { VectorType, MatrixType, ScalarObjectiveType } from "../types.js";
  */
 export declare const OptimizeMethodType: VariantType<{
     /** BFGS algorithm */
-    bfgs: NullType;
+    readonly bfgs: NullType;
     /** L-BFGS-B algorithm (default) */
-    l_bfgs_b: NullType;
+    readonly l_bfgs_b: NullType;
     /** Nelder-Mead simplex */
-    nelder_mead: NullType;
+    readonly nelder_mead: NullType;
     /** Powell's method */
-    powell: NullType;
+    readonly powell: NullType;
     /** Conjugate gradient */
-    cg: NullType;
+    readonly cg: NullType;
 }>;
 /**
  * Interpolation method for scipy.interpolate.interp1d.
  */
 export declare const InterpolationKindType: VariantType<{
     /** Linear interpolation (default) */
-    linear: NullType;
+    readonly linear: NullType;
     /** Cubic interpolation */
-    cubic: NullType;
+    readonly cubic: NullType;
     /** Quadratic interpolation */
-    quadratic: NullType;
+    readonly quadratic: NullType;
 }>;
 /**
  * Configuration for scipy.optimize.minimize.
  */
 export declare const OptimizeConfigType: StructType<{
     /** Optimization method */
-    method: OptionType<VariantType<{
+    readonly method: OptionType<VariantType<{
         /** BFGS algorithm */
-        bfgs: NullType;
+        readonly bfgs: NullType;
         /** L-BFGS-B algorithm (default) */
-        l_bfgs_b: NullType;
+        readonly l_bfgs_b: NullType;
         /** Nelder-Mead simplex */
-        nelder_mead: NullType;
+        readonly nelder_mead: NullType;
         /** Powell's method */
-        powell: NullType;
+        readonly powell: NullType;
         /** Conjugate gradient */
-        cg: NullType;
+        readonly cg: NullType;
     }>>;
     /** Maximum number of iterations */
-    max_iter: OptionType<IntegerType>;
+    readonly max_iter: OptionType<IntegerType>;
     /** Tolerance for convergence */
-    tol: OptionType<FloatType>;
+    readonly tol: OptionType<FloatType>;
 }>;
 /**
  * Configuration for scipy.interpolate.interp1d.
  */
 export declare const InterpolateConfigType: StructType<{
     /** Interpolation method */
-    kind: OptionType<VariantType<{
+    readonly kind: OptionType<VariantType<{
         /** Linear interpolation (default) */
-        linear: NullType;
+        readonly linear: NullType;
         /** Cubic interpolation */
-        cubic: NullType;
+        readonly cubic: NullType;
         /** Quadratic interpolation */
-        quadratic: NullType;
+        readonly quadratic: NullType;
     }>>;
 }>;
 /**
@@ -79,14 +79,16 @@ export declare const InterpolateConfigType: StructType<{
  */
 export declare const ParamBoundsType: StructType<{
     /** Lower bounds for each parameter */
-    lower: import("@elaraai/east").ArrayType<FloatType>;
+    readonly lower: import("@elaraai/east").ArrayType<FloatType>;
     /** Upper bounds for each parameter */
-    upper: import("@elaraai/east").ArrayType<FloatType>;
+    readonly upper: import("@elaraai/east").ArrayType<FloatType>;
 }>;
 /**
- * Custom curve function type: (x: Float, params: Vector) -> Float
+ * Custom curve function type: (x: Float, params: Vector, fixed_params: Vector) -> Float
+ * The params are optimized, fixed_params are passed through unchanged.
+ * If no fixed_params provided in config, an empty vector is passed.
  */
-export declare const CustomCurveFunctionType: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
+export declare const CustomCurveFunctionType: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
 /**
  * Curve function type for scipy_curve_fit.
  *
@@ -95,36 +97,38 @@ export declare const CustomCurveFunctionType: FunctionType<[FloatType, import("@
  */
 export declare const CurveFunctionType: VariantType<{
     /** y = a * exp(-b * x), 2 params: [a, b] */
-    exponential_decay: NullType;
+    readonly exponential_decay: NullType;
     /** y = a + b * exp(-c * x), 3 params: [a, b, c] */
-    exponential_with_offset: NullType;
+    readonly exponential_with_offset: NullType;
     /** y = a * exp(b * x), 2 params: [a, b] */
-    exponential_growth: NullType;
+    readonly exponential_growth: NullType;
     /** y = L / (1 + exp(-k * (x - x0))), 3 params: [L, k, x0] */
-    logistic: NullType;
+    readonly logistic: NullType;
     /** y = a * exp(-b * exp(-c * x)), 3 params: [a, b, c] */
-    gompertz: NullType;
+    readonly gompertz: NullType;
     /** y = a * x^b, 2 params: [a, b] */
-    power_law: NullType;
+    readonly power_law: NullType;
     /** y = a + b * x, 2 params: [a, b] */
-    linear: NullType;
+    readonly linear: NullType;
     /** y = a + b*x + c*x^2, 3 params: [a, b, c] */
-    quadratic: NullType;
+    readonly quadratic: NullType;
     /** y = a + b*x + c*x^2 + d*x^3, 4 params: [a, b, c, d] */
-    cubic: NullType;
+    readonly cubic: NullType;
     /** Custom function provided by user */
-    custom: StructType<{
-        /** The curve function */
-        fn: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
+    readonly custom: StructType<{
+        /** The curve function: (x, params, fixed_params) -> y */
+        readonly fn: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
         /** Number of parameters to optimize */
-        n_params: IntegerType;
+        readonly n_params: IntegerType;
         /** Optional parameter bounds */
-        param_bounds: OptionType<StructType<{
+        readonly param_bounds: OptionType<StructType<{
             /** Lower bounds for each parameter */
-            lower: import("@elaraai/east").ArrayType<FloatType>;
+            readonly lower: import("@elaraai/east").ArrayType<FloatType>;
             /** Upper bounds for each parameter */
-            upper: import("@elaraai/east").ArrayType<FloatType>;
+            readonly upper: import("@elaraai/east").ArrayType<FloatType>;
         }>>;
+        /** Optional fixed parameters passed to fn but not optimized */
+        readonly fixed_params: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
     }>;
 }>;
 /**
@@ -132,89 +136,104 @@ export declare const CurveFunctionType: VariantType<{
  */
 export declare const CurveFitConfigType: StructType<{
     /** Maximum number of function evaluations */
-    max_iter: OptionType<IntegerType>;
+    readonly max_iter: OptionType<IntegerType>;
     /** Initial guess for parameters */
-    initial_guess: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
+    readonly initial_guess: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
 }>;
 /**
  * Configuration for quadratic optimization: f(x) = 0.5 * x'Ax + b'x + c
  */
 export declare const QuadraticConfigType: StructType<{
     /** Quadratic term (symmetric positive definite) */
-    A: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
+    readonly A: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
     /** Linear term */
-    b: import("@elaraai/east").ArrayType<FloatType>;
+    readonly b: import("@elaraai/east").ArrayType<FloatType>;
     /** Constant term */
-    c: FloatType;
+    readonly c: FloatType;
 }>;
 /**
  * Descriptive statistics result.
  */
 export declare const StatsDescribeResultType: StructType<{
     /** Number of observations */
-    count: IntegerType;
+    readonly count: IntegerType;
     /** Mean value */
-    mean: FloatType;
+    readonly mean: FloatType;
     /** Variance */
-    variance: FloatType;
+    readonly variance: FloatType;
     /** Skewness */
-    skewness: FloatType;
+    readonly skewness: FloatType;
     /** Kurtosis */
-    kurtosis: FloatType;
+    readonly kurtosis: FloatType;
     /** Minimum value */
-    min: FloatType;
+    readonly min: FloatType;
     /** Maximum value */
-    max: FloatType;
+    readonly max: FloatType;
+}>;
+/**
+ * Robust statistics result (median-based, outlier-resistant).
+ */
+export declare const RobustStatsResultType: StructType<{
+    /** Median value */
+    readonly median: FloatType;
+    /** Interquartile range (Q3 - Q1) */
+    readonly iqr: FloatType;
+    /** Median absolute deviation */
+    readonly mad: FloatType;
+    /** 25th percentile */
+    readonly q1: FloatType;
+    /** 75th percentile */
+    readonly q3: FloatType;
 }>;
 /**
  * Correlation result (Pearson or Spearman).
  */
 export declare const CorrelationResultType: StructType<{
     /** Correlation coefficient */
-    correlation: FloatType;
+    readonly correlation: FloatType;
     /** P-value for hypothesis test */
-    pvalue: FloatType;
+    readonly pvalue: FloatType;
 }>;
 /**
  * Curve fitting result.
  */
 export declare const CurveFitResultType: StructType<{
     /** Fitted parameters */
-    params: import("@elaraai/east").ArrayType<FloatType>;
+    readonly params: import("@elaraai/east").ArrayType<FloatType>;
     /** Whether fit converged */
-    success: BooleanType;
+    readonly success: BooleanType;
     /** Coefficient of determination (R²) */
-    r_squared: FloatType;
+    readonly r_squared: FloatType;
 }>;
 /**
  * Optimization result.
  */
 export declare const OptimizeResultType: StructType<{
     /** Optimal parameters */
-    x: import("@elaraai/east").ArrayType<FloatType>;
+    readonly x: import("@elaraai/east").ArrayType<FloatType>;
     /** Function value at optimum */
-    fun: FloatType;
+    readonly fun: FloatType;
     /** Whether optimization succeeded */
-    success: BooleanType;
+    readonly success: BooleanType;
     /** Number of iterations */
-    nit: IntegerType;
+    readonly nit: IntegerType;
 }>;
 /**
  * Model blob type for scipy interpolators.
  */
 export declare const ScipyModelBlobType: VariantType<{
     /** 1D interpolator (cloudpickle serialized) */
-    scipy_interp_1d: StructType<{
+    readonly scipy_interp_1d: StructType<{
         /** Serialized interpolator */
-        data: BlobType;
+        readonly data: BlobType;
         /** Interpolation method used */
-        kind: VariantType<{
+        readonly kind: VariantType<{
             /** Linear interpolation (default) */
-            linear: NullType;
+            readonly linear: NullType;
             /** Cubic interpolation */
-            cubic: NullType;
+            readonly cubic: NullType;
             /** Quadratic interpolation */
-            quadratic: NullType;
+            readonly quadratic: NullType;
         }>;
     }>;
 }>;
@@ -223,9 +242,9 @@ export declare const ScipyModelBlobType: VariantType<{
  */
 export declare const DualAnnealBoundsType: StructType<{
     /** Lower bounds for each variable */
-    lower: import("@elaraai/east").ArrayType<FloatType>;
+    readonly lower: import("@elaraai/east").ArrayType<FloatType>;
     /** Upper bounds for each variable */
-    upper: import("@elaraai/east").ArrayType<FloatType>;
+    readonly upper: import("@elaraai/east").ArrayType<FloatType>;
 }>;
 /**
  * Configuration for scipy.optimize.dual_annealing.
@@ -235,151 +254,187 @@ export declare const DualAnnealBoundsType: StructType<{
  */
 export declare const DualAnnealConfigType: StructType<{
     /** Maximum function evaluations (default: 1000) */
-    maxfun: OptionType<IntegerType>;
+    readonly maxfun: OptionType<IntegerType>;
     /** Maximum iterations (default: 1000) */
-    maxiter: OptionType<IntegerType>;
+    readonly maxiter: OptionType<IntegerType>;
     /** Initial temperature (default: 5230) */
-    initial_temp: OptionType<FloatType>;
+    readonly initial_temp: OptionType<FloatType>;
     /** Temperature restart threshold (default: 2e-5) */
-    restart_temp_ratio: OptionType<FloatType>;
+    readonly restart_temp_ratio: OptionType<FloatType>;
     /** Visiting distribution parameter (default: 2.62) */
-    visit: OptionType<FloatType>;
+    readonly visit: OptionType<FloatType>;
     /** Acceptance distribution parameter (default: -5.0) */
-    accept: OptionType<FloatType>;
+    readonly accept: OptionType<FloatType>;
     /** Random seed for reproducibility */
-    seed: OptionType<IntegerType>;
+    readonly seed: OptionType<IntegerType>;
     /** Disable local search for speed (default: false) */
-    no_local_search: OptionType<BooleanType>;
+    readonly no_local_search: OptionType<BooleanType>;
 }>;
 /**
  * Result from dual annealing optimization.
  */
 export declare const DualAnnealResultType: StructType<{
     /** Best solution found */
-    x: import("@elaraai/east").ArrayType<FloatType>;
+    readonly x: import("@elaraai/east").ArrayType<FloatType>;
     /** Best objective value */
-    fun: FloatType;
+    readonly fun: FloatType;
     /** Number of function evaluations */
-    nfev: IntegerType;
+    readonly nfev: IntegerType;
     /** Number of iterations */
-    nit: IntegerType;
+    readonly nit: IntegerType;
     /** Whether optimization succeeded */
-    success: BooleanType;
+    readonly success: BooleanType;
     /** Status message */
-    message: StringType;
+    readonly message: StringType;
 }>;
 /**
  * Fit a parametric curve to data using nonlinear least squares.
  */
 export declare const scipy_curve_fit: import("@elaraai/east").PlatformDefinition<[VariantType<{
     /** y = a * exp(-b * x), 2 params: [a, b] */
-    exponential_decay: NullType;
+    readonly exponential_decay: NullType;
     /** y = a + b * exp(-c * x), 3 params: [a, b, c] */
-    exponential_with_offset: NullType;
+    readonly exponential_with_offset: NullType;
     /** y = a * exp(b * x), 2 params: [a, b] */
-    exponential_growth: NullType;
+    readonly exponential_growth: NullType;
     /** y = L / (1 + exp(-k * (x - x0))), 3 params: [L, k, x0] */
-    logistic: NullType;
+    readonly logistic: NullType;
     /** y = a * exp(-b * exp(-c * x)), 3 params: [a, b, c] */
-    gompertz: NullType;
+    readonly gompertz: NullType;
     /** y = a * x^b, 2 params: [a, b] */
-    power_law: NullType;
+    readonly power_law: NullType;
     /** y = a + b * x, 2 params: [a, b] */
-    linear: NullType;
+    readonly linear: NullType;
     /** y = a + b*x + c*x^2, 3 params: [a, b, c] */
-    quadratic: NullType;
+    readonly quadratic: NullType;
     /** y = a + b*x + c*x^2 + d*x^3, 4 params: [a, b, c, d] */
-    cubic: NullType;
+    readonly cubic: NullType;
     /** Custom function provided by user */
-    custom: StructType<{
-        /** The curve function */
-        fn: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
+    readonly custom: StructType<{
+        /** The curve function: (x, params, fixed_params) -> y */
+        readonly fn: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
         /** Number of parameters to optimize */
-        n_params: IntegerType;
+        readonly n_params: IntegerType;
         /** Optional parameter bounds */
-        param_bounds: OptionType<StructType<{
+        readonly param_bounds: OptionType<StructType<{
             /** Lower bounds for each parameter */
-            lower: import("@elaraai/east").ArrayType<FloatType>;
+            readonly lower: import("@elaraai/east").ArrayType<FloatType>;
             /** Upper bounds for each parameter */
-            upper: import("@elaraai/east").ArrayType<FloatType>;
+            readonly upper: import("@elaraai/east").ArrayType<FloatType>;
         }>>;
+        /** Optional fixed parameters passed to fn but not optimized */
+        readonly fixed_params: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
     }>;
 }>, import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
     /** Maximum number of function evaluations */
-    max_iter: OptionType<IntegerType>;
+    readonly max_iter: OptionType<IntegerType>;
     /** Initial guess for parameters */
-    initial_guess: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
+    readonly initial_guess: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
 }>], StructType<{
     /** Fitted parameters */
-    params: import("@elaraai/east").ArrayType<FloatType>;
+    readonly params: import("@elaraai/east").ArrayType<FloatType>;
     /** Whether fit converged */
-    success: BooleanType;
+    readonly success: BooleanType;
     /** Coefficient of determination (R²) */
-    r_squared: FloatType;
+    readonly r_squared: FloatType;
 }>>;
 /**
  * Compute descriptive statistics for data.
  */
 export declare const scipy_stats_describe: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], StructType<{
     /** Number of observations */
-    count: IntegerType;
+    readonly count: IntegerType;
     /** Mean value */
-    mean: FloatType;
+    readonly mean: FloatType;
     /** Variance */
-    variance: FloatType;
+    readonly variance: FloatType;
     /** Skewness */
-    skewness: FloatType;
+    readonly skewness: FloatType;
     /** Kurtosis */
-    kurtosis: FloatType;
+    readonly kurtosis: FloatType;
     /** Minimum value */
-    min: FloatType;
+    readonly min: FloatType;
     /** Maximum value */
-    max: FloatType;
+    readonly max: FloatType;
 }>>;
 /**
  * Compute Pearson correlation coefficient.
  */
 export declare const scipy_stats_pearsonr: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], StructType<{
     /** Correlation coefficient */
-    correlation: FloatType;
+    readonly correlation: FloatType;
     /** P-value for hypothesis test */
-    pvalue: FloatType;
+    readonly pvalue: FloatType;
 }>>;
 /**
  * Compute Spearman rank correlation.
  */
 export declare const scipy_stats_spearmanr: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], StructType<{
     /** Correlation coefficient */
-    correlation: FloatType;
+    readonly correlation: FloatType;
     /** P-value for hypothesis test */
-    pvalue: FloatType;
+    readonly pvalue: FloatType;
+}>>;
+/**
+ * Compute percentiles of data.
+ * @param data - Input data vector
+ * @param percentiles - Percentile values to compute (0-100)
+ * @returns Values at the specified percentiles
+ */
+export declare const scipy_stats_percentile: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], import("@elaraai/east").ArrayType<FloatType>>;
+/**
+ * Compute interquartile range (Q3 - Q1).
+ */
+export declare const scipy_stats_iqr: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
+/**
+ * Compute median value.
+ */
+export declare const scipy_stats_median: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
+/**
+ * Compute median absolute deviation (robust std estimate).
+ */
+export declare const scipy_stats_mad: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
+/**
+ * Compute robust statistics in one call (median, iqr, mad, q1, q3).
+ */
+export declare const scipy_stats_robust: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], StructType<{
+    /** Median value */
+    readonly median: FloatType;
+    /** Interquartile range (Q3 - Q1) */
+    readonly iqr: FloatType;
+    /** Median absolute deviation */
+    readonly mad: FloatType;
+    /** 25th percentile */
+    readonly q1: FloatType;
+    /** 75th percentile */
+    readonly q3: FloatType;
 }>>;
 /**
  * Fit 1D interpolator to data.
  */
 export declare const scipy_interpolate_1d_fit: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
     /** Interpolation method */
-    kind: OptionType<VariantType<{
+    readonly kind: OptionType<VariantType<{
         /** Linear interpolation (default) */
-        linear: NullType;
+        readonly linear: NullType;
         /** Cubic interpolation */
-        cubic: NullType;
+        readonly cubic: NullType;
         /** Quadratic interpolation */
-        quadratic: NullType;
+        readonly quadratic: NullType;
     }>>;
 }>], VariantType<{
     /** 1D interpolator (cloudpickle serialized) */
-    scipy_interp_1d: StructType<{
+    readonly scipy_interp_1d: StructType<{
         /** Serialized interpolator */
-        data: BlobType;
+        readonly data: BlobType;
         /** Interpolation method used */
-        kind: VariantType<{
+        readonly kind: VariantType<{
             /** Linear interpolation (default) */
-            linear: NullType;
+            readonly linear: NullType;
             /** Cubic interpolation */
-            cubic: NullType;
+            readonly cubic: NullType;
             /** Quadratic interpolation */
-            quadratic: NullType;
+            readonly quadratic: NullType;
         }>;
     }>;
 }>>;
@@ -388,17 +443,17 @@ export declare const scipy_interpolate_1d_fit: import("@elaraai/east").PlatformD
  */
 export declare const scipy_interpolate_1d_predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
     /** 1D interpolator (cloudpickle serialized) */
-    scipy_interp_1d: StructType<{
+    readonly scipy_interp_1d: StructType<{
         /** Serialized interpolator */
-        data: BlobType;
+        readonly data: BlobType;
         /** Interpolation method used */
-        kind: VariantType<{
+        readonly kind: VariantType<{
             /** Linear interpolation (default) */
-            linear: NullType;
+            readonly linear: NullType;
             /** Cubic interpolation */
-            cubic: NullType;
+            readonly cubic: NullType;
             /** Quadratic interpolation */
-            quadratic: NullType;
+            readonly quadratic: NullType;
         }>;
     }>;
 }>, import("@elaraai/east").ArrayType<FloatType>], import("@elaraai/east").ArrayType<FloatType>>;
@@ -407,69 +462,69 @@ export declare const scipy_interpolate_1d_predict: import("@elaraai/east").Platf
  */
 export declare const scipy_optimize_minimize: import("@elaraai/east").PlatformDefinition<[FunctionType<[import("@elaraai/east").ArrayType<FloatType>], FloatType>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
     /** Optimization method */
-    method: OptionType<VariantType<{
+    readonly method: OptionType<VariantType<{
         /** BFGS algorithm */
-        bfgs: NullType;
+        readonly bfgs: NullType;
         /** L-BFGS-B algorithm (default) */
-        l_bfgs_b: NullType;
+        readonly l_bfgs_b: NullType;
         /** Nelder-Mead simplex */
-        nelder_mead: NullType;
+        readonly nelder_mead: NullType;
         /** Powell's method */
-        powell: NullType;
+        readonly powell: NullType;
         /** Conjugate gradient */
-        cg: NullType;
+        readonly cg: NullType;
     }>>;
     /** Maximum number of iterations */
-    max_iter: OptionType<IntegerType>;
+    readonly max_iter: OptionType<IntegerType>;
     /** Tolerance for convergence */
-    tol: OptionType<FloatType>;
+    readonly tol: OptionType<FloatType>;
 }>], StructType<{
     /** Optimal parameters */
-    x: import("@elaraai/east").ArrayType<FloatType>;
+    readonly x: import("@elaraai/east").ArrayType<FloatType>;
     /** Function value at optimum */
-    fun: FloatType;
+    readonly fun: FloatType;
     /** Whether optimization succeeded */
-    success: BooleanType;
+    readonly success: BooleanType;
     /** Number of iterations */
-    nit: IntegerType;
+    readonly nit: IntegerType;
 }>>;
 /**
  * Minimize a quadratic function with analytical gradient.
  */
 export declare const scipy_optimize_minimize_quadratic: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, StructType<{
     /** Quadratic term (symmetric positive definite) */
-    A: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
+    readonly A: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
     /** Linear term */
-    b: import("@elaraai/east").ArrayType<FloatType>;
+    readonly b: import("@elaraai/east").ArrayType<FloatType>;
     /** Constant term */
-    c: FloatType;
+    readonly c: FloatType;
 }>, StructType<{
     /** Optimization method */
-    method: OptionType<VariantType<{
+    readonly method: OptionType<VariantType<{
         /** BFGS algorithm */
-        bfgs: NullType;
+        readonly bfgs: NullType;
         /** L-BFGS-B algorithm (default) */
-        l_bfgs_b: NullType;
+        readonly l_bfgs_b: NullType;
         /** Nelder-Mead simplex */
-        nelder_mead: NullType;
+        readonly nelder_mead: NullType;
         /** Powell's method */
-        powell: NullType;
+        readonly powell: NullType;
         /** Conjugate gradient */
-        cg: NullType;
+        readonly cg: NullType;
     }>>;
     /** Maximum number of iterations */
-    max_iter: OptionType<IntegerType>;
+    readonly max_iter: OptionType<IntegerType>;
     /** Tolerance for convergence */
-    tol: OptionType<FloatType>;
+    readonly tol: OptionType<FloatType>;
 }>], StructType<{
     /** Optimal parameters */
-    x: import("@elaraai/east").ArrayType<FloatType>;
+    readonly x: import("@elaraai/east").ArrayType<FloatType>;
     /** Function value at optimum */
-    fun: FloatType;
+    readonly fun: FloatType;
     /** Whether optimization succeeded */
-    success: BooleanType;
+    readonly success: BooleanType;
     /** Number of iterations */
-    nit: IntegerType;
+    readonly nit: IntegerType;
 }>>;
 /**
  * Global optimization using dual annealing.
@@ -486,39 +541,39 @@ export declare const scipy_optimize_minimize_quadratic: import("@elaraai/east").
  */
 export declare const scipy_optimize_dual_annealing: import("@elaraai/east").PlatformDefinition<[FunctionType<[import("@elaraai/east").ArrayType<FloatType>], FloatType>, OptionType<import("@elaraai/east").ArrayType<FloatType>>, StructType<{
     /** Lower bounds for each variable */
-    lower: import("@elaraai/east").ArrayType<FloatType>;
+    readonly lower: import("@elaraai/east").ArrayType<FloatType>;
     /** Upper bounds for each variable */
-    upper: import("@elaraai/east").ArrayType<FloatType>;
+    readonly upper: import("@elaraai/east").ArrayType<FloatType>;
 }>, StructType<{
     /** Maximum function evaluations (default: 1000) */
-    maxfun: OptionType<IntegerType>;
+    readonly maxfun: OptionType<IntegerType>;
     /** Maximum iterations (default: 1000) */
-    maxiter: OptionType<IntegerType>;
+    readonly maxiter: OptionType<IntegerType>;
     /** Initial temperature (default: 5230) */
-    initial_temp: OptionType<FloatType>;
+    readonly initial_temp: OptionType<FloatType>;
     /** Temperature restart threshold (default: 2e-5) */
-    restart_temp_ratio: OptionType<FloatType>;
+    readonly restart_temp_ratio: OptionType<FloatType>;
     /** Visiting distribution parameter (default: 2.62) */
-    visit: OptionType<FloatType>;
+    readonly visit: OptionType<FloatType>;
     /** Acceptance distribution parameter (default: -5.0) */
-    accept: OptionType<FloatType>;
+    readonly accept: OptionType<FloatType>;
     /** Random seed for reproducibility */
-    seed: OptionType<IntegerType>;
+    readonly seed: OptionType<IntegerType>;
     /** Disable local search for speed (default: false) */
-    no_local_search: OptionType<BooleanType>;
+    readonly no_local_search: OptionType<BooleanType>;
 }>], StructType<{
     /** Best solution found */
-    x: import("@elaraai/east").ArrayType<FloatType>;
+    readonly x: import("@elaraai/east").ArrayType<FloatType>;
     /** Best objective value */
-    fun: FloatType;
+    readonly fun: FloatType;
     /** Number of function evaluations */
-    nfev: IntegerType;
+    readonly nfev: IntegerType;
     /** Number of iterations */
-    nit: IntegerType;
+    readonly nit: IntegerType;
     /** Whether optimization succeeded */
-    success: BooleanType;
+    readonly success: BooleanType;
     /** Status message */
-    message: StringType;
+    readonly message: StringType;
 }>>;
 /**
  * Type definitions for scipy functions.
@@ -529,202 +584,216 @@ export declare const ScipyTypes: {
     readonly ScalarObjectiveType: FunctionType<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
     readonly OptimizeMethodType: VariantType<{
         /** BFGS algorithm */
-        bfgs: NullType;
+        readonly bfgs: NullType;
         /** L-BFGS-B algorithm (default) */
-        l_bfgs_b: NullType;
+        readonly l_bfgs_b: NullType;
         /** Nelder-Mead simplex */
-        nelder_mead: NullType;
+        readonly nelder_mead: NullType;
         /** Powell's method */
-        powell: NullType;
+        readonly powell: NullType;
         /** Conjugate gradient */
-        cg: NullType;
+        readonly cg: NullType;
     }>;
     readonly InterpolationKindType: VariantType<{
         /** Linear interpolation (default) */
-        linear: NullType;
+        readonly linear: NullType;
         /** Cubic interpolation */
-        cubic: NullType;
+        readonly cubic: NullType;
         /** Quadratic interpolation */
-        quadratic: NullType;
+        readonly quadratic: NullType;
     }>;
     readonly OptimizeConfigType: StructType<{
         /** Optimization method */
-        method: OptionType<VariantType<{
+        readonly method: OptionType<VariantType<{
             /** BFGS algorithm */
-            bfgs: NullType;
+            readonly bfgs: NullType;
             /** L-BFGS-B algorithm (default) */
-            l_bfgs_b: NullType;
+            readonly l_bfgs_b: NullType;
             /** Nelder-Mead simplex */
-            nelder_mead: NullType;
+            readonly nelder_mead: NullType;
             /** Powell's method */
-            powell: NullType;
+            readonly powell: NullType;
             /** Conjugate gradient */
-            cg: NullType;
+            readonly cg: NullType;
         }>>;
         /** Maximum number of iterations */
-        max_iter: OptionType<IntegerType>;
+        readonly max_iter: OptionType<IntegerType>;
         /** Tolerance for convergence */
-        tol: OptionType<FloatType>;
+        readonly tol: OptionType<FloatType>;
     }>;
     readonly InterpolateConfigType: StructType<{
         /** Interpolation method */
-        kind: OptionType<VariantType<{
+        readonly kind: OptionType<VariantType<{
             /** Linear interpolation (default) */
-            linear: NullType;
+            readonly linear: NullType;
             /** Cubic interpolation */
-            cubic: NullType;
+            readonly cubic: NullType;
             /** Quadratic interpolation */
-            quadratic: NullType;
+            readonly quadratic: NullType;
         }>>;
     }>;
     readonly ParamBoundsType: StructType<{
         /** Lower bounds for each parameter */
-        lower: import("@elaraai/east").ArrayType<FloatType>;
+        readonly lower: import("@elaraai/east").ArrayType<FloatType>;
         /** Upper bounds for each parameter */
-        upper: import("@elaraai/east").ArrayType<FloatType>;
+        readonly upper: import("@elaraai/east").ArrayType<FloatType>;
     }>;
-    readonly CustomCurveFunctionType: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
+    readonly CustomCurveFunctionType: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
     readonly CurveFunctionType: VariantType<{
         /** y = a * exp(-b * x), 2 params: [a, b] */
-        exponential_decay: NullType;
+        readonly exponential_decay: NullType;
         /** y = a + b * exp(-c * x), 3 params: [a, b, c] */
-        exponential_with_offset: NullType;
+        readonly exponential_with_offset: NullType;
         /** y = a * exp(b * x), 2 params: [a, b] */
-        exponential_growth: NullType;
+        readonly exponential_growth: NullType;
         /** y = L / (1 + exp(-k * (x - x0))), 3 params: [L, k, x0] */
-        logistic: NullType;
+        readonly logistic: NullType;
         /** y = a * exp(-b * exp(-c * x)), 3 params: [a, b, c] */
-        gompertz: NullType;
+        readonly gompertz: NullType;
         /** y = a * x^b, 2 params: [a, b] */
-        power_law: NullType;
+        readonly power_law: NullType;
         /** y = a + b * x, 2 params: [a, b] */
-        linear: NullType;
+        readonly linear: NullType;
         /** y = a + b*x + c*x^2, 3 params: [a, b, c] */
-        quadratic: NullType;
+        readonly quadratic: NullType;
         /** y = a + b*x + c*x^2 + d*x^3, 4 params: [a, b, c, d] */
-        cubic: NullType;
+        readonly cubic: NullType;
         /** Custom function provided by user */
-        custom: StructType<{
-            /** The curve function */
-            fn: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
+        readonly custom: StructType<{
+            /** The curve function: (x, params, fixed_params) -> y */
+            readonly fn: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
             /** Number of parameters to optimize */
-            n_params: IntegerType;
+            readonly n_params: IntegerType;
             /** Optional parameter bounds */
-            param_bounds: OptionType<StructType<{
+            readonly param_bounds: OptionType<StructType<{
                 /** Lower bounds for each parameter */
-                lower: import("@elaraai/east").ArrayType<FloatType>;
+                readonly lower: import("@elaraai/east").ArrayType<FloatType>;
                 /** Upper bounds for each parameter */
-                upper: import("@elaraai/east").ArrayType<FloatType>;
+                readonly upper: import("@elaraai/east").ArrayType<FloatType>;
             }>>;
+            /** Optional fixed parameters passed to fn but not optimized */
+            readonly fixed_params: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
         }>;
     }>;
     readonly CurveFitConfigType: StructType<{
         /** Maximum number of function evaluations */
-        max_iter: OptionType<IntegerType>;
+        readonly max_iter: OptionType<IntegerType>;
         /** Initial guess for parameters */
-        initial_guess: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
+        readonly initial_guess: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
     }>;
     readonly QuadraticConfigType: StructType<{
         /** Quadratic term (symmetric positive definite) */
-        A: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
+        readonly A: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
         /** Linear term */
-        b: import("@elaraai/east").ArrayType<FloatType>;
+        readonly b: import("@elaraai/east").ArrayType<FloatType>;
         /** Constant term */
-        c: FloatType;
+        readonly c: FloatType;
     }>;
     readonly StatsDescribeResultType: StructType<{
         /** Number of observations */
-        count: IntegerType;
+        readonly count: IntegerType;
         /** Mean value */
-        mean: FloatType;
+        readonly mean: FloatType;
         /** Variance */
-        variance: FloatType;
+        readonly variance: FloatType;
         /** Skewness */
-        skewness: FloatType;
+        readonly skewness: FloatType;
         /** Kurtosis */
-        kurtosis: FloatType;
+        readonly kurtosis: FloatType;
         /** Minimum value */
-        min: FloatType;
+        readonly min: FloatType;
         /** Maximum value */
-        max: FloatType;
+        readonly max: FloatType;
+    }>;
+    readonly RobustStatsResultType: StructType<{
+        /** Median value */
+        readonly median: FloatType;
+        /** Interquartile range (Q3 - Q1) */
+        readonly iqr: FloatType;
+        /** Median absolute deviation */
+        readonly mad: FloatType;
+        /** 25th percentile */
+        readonly q1: FloatType;
+        /** 75th percentile */
+        readonly q3: FloatType;
     }>;
     readonly CorrelationResultType: StructType<{
         /** Correlation coefficient */
-        correlation: FloatType;
+        readonly correlation: FloatType;
         /** P-value for hypothesis test */
-        pvalue: FloatType;
+        readonly pvalue: FloatType;
     }>;
     readonly CurveFitResultType: StructType<{
         /** Fitted parameters */
-        params: import("@elaraai/east").ArrayType<FloatType>;
+        readonly params: import("@elaraai/east").ArrayType<FloatType>;
         /** Whether fit converged */
-        success: BooleanType;
+        readonly success: BooleanType;
         /** Coefficient of determination (R²) */
-        r_squared: FloatType;
+        readonly r_squared: FloatType;
     }>;
     readonly OptimizeResultType: StructType<{
         /** Optimal parameters */
-        x: import("@elaraai/east").ArrayType<FloatType>;
+        readonly x: import("@elaraai/east").ArrayType<FloatType>;
         /** Function value at optimum */
-        fun: FloatType;
+        readonly fun: FloatType;
         /** Whether optimization succeeded */
-        success: BooleanType;
+        readonly success: BooleanType;
         /** Number of iterations */
-        nit: IntegerType;
+        readonly nit: IntegerType;
     }>;
     readonly ModelBlobType: VariantType<{
         /** 1D interpolator (cloudpickle serialized) */
-        scipy_interp_1d: StructType<{
+        readonly scipy_interp_1d: StructType<{
             /** Serialized interpolator */
-            data: BlobType;
+            readonly data: BlobType;
             /** Interpolation method used */
-            kind: VariantType<{
+            readonly kind: VariantType<{
                 /** Linear interpolation (default) */
-                linear: NullType;
+                readonly linear: NullType;
                 /** Cubic interpolation */
-                cubic: NullType;
+                readonly cubic: NullType;
                 /** Quadratic interpolation */
-                quadratic: NullType;
+                readonly quadratic: NullType;
             }>;
         }>;
     }>;
     readonly DualAnnealBoundsType: StructType<{
         /** Lower bounds for each variable */
-        lower: import("@elaraai/east").ArrayType<FloatType>;
+        readonly lower: import("@elaraai/east").ArrayType<FloatType>;
         /** Upper bounds for each variable */
-        upper: import("@elaraai/east").ArrayType<FloatType>;
+        readonly upper: import("@elaraai/east").ArrayType<FloatType>;
     }>;
     readonly DualAnnealConfigType: StructType<{
         /** Maximum function evaluations (default: 1000) */
-        maxfun: OptionType<IntegerType>;
+        readonly maxfun: OptionType<IntegerType>;
         /** Maximum iterations (default: 1000) */
-        maxiter: OptionType<IntegerType>;
+        readonly maxiter: OptionType<IntegerType>;
         /** Initial temperature (default: 5230) */
-        initial_temp: OptionType<FloatType>;
+        readonly initial_temp: OptionType<FloatType>;
         /** Temperature restart threshold (default: 2e-5) */
-        restart_temp_ratio: OptionType<FloatType>;
+        readonly restart_temp_ratio: OptionType<FloatType>;
         /** Visiting distribution parameter (default: 2.62) */
-        visit: OptionType<FloatType>;
+        readonly visit: OptionType<FloatType>;
         /** Acceptance distribution parameter (default: -5.0) */
-        accept: OptionType<FloatType>;
+        readonly accept: OptionType<FloatType>;
         /** Random seed for reproducibility */
-        seed: OptionType<IntegerType>;
+        readonly seed: OptionType<IntegerType>;
         /** Disable local search for speed (default: false) */
-        no_local_search: OptionType<BooleanType>;
+        readonly no_local_search: OptionType<BooleanType>;
     }>;
     readonly DualAnnealResultType: StructType<{
         /** Best solution found */
-        x: import("@elaraai/east").ArrayType<FloatType>;
+        readonly x: import("@elaraai/east").ArrayType<FloatType>;
         /** Best objective value */
-        fun: FloatType;
+        readonly fun: FloatType;
         /** Number of function evaluations */
-        nfev: IntegerType;
+        readonly nfev: IntegerType;
         /** Number of iterations */
-        nit: IntegerType;
+        readonly nit: IntegerType;
         /** Whether optimization succeeded */
-        success: BooleanType;
+        readonly success: BooleanType;
         /** Status message */
-        message: StringType;
+        readonly message: StringType;
     }>;
 };
 /**
@@ -736,226 +805,249 @@ export declare const Scipy: {
     /** Fit parametric curve to data */
     readonly curveFit: import("@elaraai/east").PlatformDefinition<[VariantType<{
         /** y = a * exp(-b * x), 2 params: [a, b] */
-        exponential_decay: NullType;
+        readonly exponential_decay: NullType;
         /** y = a + b * exp(-c * x), 3 params: [a, b, c] */
-        exponential_with_offset: NullType;
+        readonly exponential_with_offset: NullType;
         /** y = a * exp(b * x), 2 params: [a, b] */
-        exponential_growth: NullType;
+        readonly exponential_growth: NullType;
         /** y = L / (1 + exp(-k * (x - x0))), 3 params: [L, k, x0] */
-        logistic: NullType;
+        readonly logistic: NullType;
         /** y = a * exp(-b * exp(-c * x)), 3 params: [a, b, c] */
-        gompertz: NullType;
+        readonly gompertz: NullType;
         /** y = a * x^b, 2 params: [a, b] */
-        power_law: NullType;
+        readonly power_law: NullType;
         /** y = a + b * x, 2 params: [a, b] */
-        linear: NullType;
+        readonly linear: NullType;
         /** y = a + b*x + c*x^2, 3 params: [a, b, c] */
-        quadratic: NullType;
+        readonly quadratic: NullType;
         /** y = a + b*x + c*x^2 + d*x^3, 4 params: [a, b, c, d] */
-        cubic: NullType;
+        readonly cubic: NullType;
         /** Custom function provided by user */
-        custom: StructType<{
-            /** The curve function */
-            fn: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
+        readonly custom: StructType<{
+            /** The curve function: (x, params, fixed_params) -> y */
+            readonly fn: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
             /** Number of parameters to optimize */
-            n_params: IntegerType;
+            readonly n_params: IntegerType;
             /** Optional parameter bounds */
-            param_bounds: OptionType<StructType<{
+            readonly param_bounds: OptionType<StructType<{
                 /** Lower bounds for each parameter */
-                lower: import("@elaraai/east").ArrayType<FloatType>;
+                readonly lower: import("@elaraai/east").ArrayType<FloatType>;
                 /** Upper bounds for each parameter */
-                upper: import("@elaraai/east").ArrayType<FloatType>;
+                readonly upper: import("@elaraai/east").ArrayType<FloatType>;
             }>>;
+            /** Optional fixed parameters passed to fn but not optimized */
+            readonly fixed_params: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
         }>;
     }>, import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
         /** Maximum number of function evaluations */
-        max_iter: OptionType<IntegerType>;
+        readonly max_iter: OptionType<IntegerType>;
         /** Initial guess for parameters */
-        initial_guess: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
+        readonly initial_guess: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
     }>], StructType<{
         /** Fitted parameters */
-        params: import("@elaraai/east").ArrayType<FloatType>;
+        readonly params: import("@elaraai/east").ArrayType<FloatType>;
         /** Whether fit converged */
-        success: BooleanType;
+        readonly success: BooleanType;
         /** Coefficient of determination (R²) */
-        r_squared: FloatType;
+        readonly r_squared: FloatType;
     }>>;
     /** Compute descriptive statistics */
     readonly statsDescribe: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], StructType<{
         /** Number of observations */
-        count: IntegerType;
+        readonly count: IntegerType;
         /** Mean value */
-        mean: FloatType;
+        readonly mean: FloatType;
         /** Variance */
-        variance: FloatType;
+        readonly variance: FloatType;
         /** Skewness */
-        skewness: FloatType;
+        readonly skewness: FloatType;
         /** Kurtosis */
-        kurtosis: FloatType;
+        readonly kurtosis: FloatType;
         /** Minimum value */
-        min: FloatType;
+        readonly min: FloatType;
         /** Maximum value */
-        max: FloatType;
+        readonly max: FloatType;
     }>>;
     /** Compute Pearson correlation */
     readonly statsPearsonr: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], StructType<{
         /** Correlation coefficient */
-        correlation: FloatType;
+        readonly correlation: FloatType;
         /** P-value for hypothesis test */
-        pvalue: FloatType;
+        readonly pvalue: FloatType;
     }>>;
     /** Compute Spearman correlation */
     readonly statsSpearmanr: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], StructType<{
         /** Correlation coefficient */
-        correlation: FloatType;
+        readonly correlation: FloatType;
         /** P-value for hypothesis test */
-        pvalue: FloatType;
+        readonly pvalue: FloatType;
+    }>>;
+    /** Compute percentiles */
+    readonly statsPercentile: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], import("@elaraai/east").ArrayType<FloatType>>;
+    /** Compute interquartile range */
+    readonly statsIqr: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
+    /** Compute median */
+    readonly statsMedian: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
+    /** Compute median absolute deviation */
+    readonly statsMad: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
+    /** Compute robust statistics (median, iqr, mad, q1, q3) */
+    readonly statsRobust: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>], StructType<{
+        /** Median value */
+        readonly median: FloatType;
+        /** Interquartile range (Q3 - Q1) */
+        readonly iqr: FloatType;
+        /** Median absolute deviation */
+        readonly mad: FloatType;
+        /** 25th percentile */
+        readonly q1: FloatType;
+        /** 75th percentile */
+        readonly q3: FloatType;
     }>>;
     /** Fit 1D interpolator */
     readonly interpolate1dFit: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
         /** Interpolation method */
-        kind: OptionType<VariantType<{
+        readonly kind: OptionType<VariantType<{
             /** Linear interpolation (default) */
-            linear: NullType;
+            readonly linear: NullType;
             /** Cubic interpolation */
-            cubic: NullType;
+            readonly cubic: NullType;
             /** Quadratic interpolation */
-            quadratic: NullType;
+            readonly quadratic: NullType;
         }>>;
     }>], VariantType<{
         /** 1D interpolator (cloudpickle serialized) */
-        scipy_interp_1d: StructType<{
+        readonly scipy_interp_1d: StructType<{
             /** Serialized interpolator */
-            data: BlobType;
+            readonly data: BlobType;
             /** Interpolation method used */
-            kind: VariantType<{
+            readonly kind: VariantType<{
                 /** Linear interpolation (default) */
-                linear: NullType;
+                readonly linear: NullType;
                 /** Cubic interpolation */
-                cubic: NullType;
+                readonly cubic: NullType;
                 /** Quadratic interpolation */
-                quadratic: NullType;
+                readonly quadratic: NullType;
             }>;
         }>;
     }>>;
     /** Evaluate 1D interpolator */
     readonly interpolate1dPredict: import("@elaraai/east").PlatformDefinition<[VariantType<{
         /** 1D interpolator (cloudpickle serialized) */
-        scipy_interp_1d: StructType<{
+        readonly scipy_interp_1d: StructType<{
             /** Serialized interpolator */
-            data: BlobType;
+            readonly data: BlobType;
             /** Interpolation method used */
-            kind: VariantType<{
+            readonly kind: VariantType<{
                 /** Linear interpolation (default) */
-                linear: NullType;
+                readonly linear: NullType;
                 /** Cubic interpolation */
-                cubic: NullType;
+                readonly cubic: NullType;
                 /** Quadratic interpolation */
-                quadratic: NullType;
+                readonly quadratic: NullType;
             }>;
         }>;
     }>, import("@elaraai/east").ArrayType<FloatType>], import("@elaraai/east").ArrayType<FloatType>>;
     /** Minimize scalar function */
     readonly optimizeMinimize: import("@elaraai/east").PlatformDefinition<[FunctionType<[import("@elaraai/east").ArrayType<FloatType>], FloatType>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
         /** Optimization method */
-        method: OptionType<VariantType<{
+        readonly method: OptionType<VariantType<{
             /** BFGS algorithm */
-            bfgs: NullType;
+            readonly bfgs: NullType;
             /** L-BFGS-B algorithm (default) */
-            l_bfgs_b: NullType;
+            readonly l_bfgs_b: NullType;
             /** Nelder-Mead simplex */
-            nelder_mead: NullType;
+            readonly nelder_mead: NullType;
             /** Powell's method */
-            powell: NullType;
+            readonly powell: NullType;
             /** Conjugate gradient */
-            cg: NullType;
+            readonly cg: NullType;
         }>>;
         /** Maximum number of iterations */
-        max_iter: OptionType<IntegerType>;
+        readonly max_iter: OptionType<IntegerType>;
         /** Tolerance for convergence */
-        tol: OptionType<FloatType>;
+        readonly tol: OptionType<FloatType>;
     }>], StructType<{
         /** Optimal parameters */
-        x: import("@elaraai/east").ArrayType<FloatType>;
+        readonly x: import("@elaraai/east").ArrayType<FloatType>;
         /** Function value at optimum */
-        fun: FloatType;
+        readonly fun: FloatType;
         /** Whether optimization succeeded */
-        success: BooleanType;
+        readonly success: BooleanType;
         /** Number of iterations */
-        nit: IntegerType;
+        readonly nit: IntegerType;
     }>>;
     /** Minimize quadratic function */
     readonly optimizeMinimizeQuadratic: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<FloatType>, StructType<{
         /** Quadratic term (symmetric positive definite) */
-        A: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
+        readonly A: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
         /** Linear term */
-        b: import("@elaraai/east").ArrayType<FloatType>;
+        readonly b: import("@elaraai/east").ArrayType<FloatType>;
         /** Constant term */
-        c: FloatType;
+        readonly c: FloatType;
     }>, StructType<{
         /** Optimization method */
-        method: OptionType<VariantType<{
+        readonly method: OptionType<VariantType<{
             /** BFGS algorithm */
-            bfgs: NullType;
+            readonly bfgs: NullType;
             /** L-BFGS-B algorithm (default) */
-            l_bfgs_b: NullType;
+            readonly l_bfgs_b: NullType;
             /** Nelder-Mead simplex */
-            nelder_mead: NullType;
+            readonly nelder_mead: NullType;
             /** Powell's method */
-            powell: NullType;
+            readonly powell: NullType;
             /** Conjugate gradient */
-            cg: NullType;
+            readonly cg: NullType;
         }>>;
         /** Maximum number of iterations */
-        max_iter: OptionType<IntegerType>;
+        readonly max_iter: OptionType<IntegerType>;
         /** Tolerance for convergence */
-        tol: OptionType<FloatType>;
+        readonly tol: OptionType<FloatType>;
     }>], StructType<{
         /** Optimal parameters */
-        x: import("@elaraai/east").ArrayType<FloatType>;
+        readonly x: import("@elaraai/east").ArrayType<FloatType>;
         /** Function value at optimum */
-        fun: FloatType;
+        readonly fun: FloatType;
         /** Whether optimization succeeded */
-        success: BooleanType;
+        readonly success: BooleanType;
         /** Number of iterations */
-        nit: IntegerType;
+        readonly nit: IntegerType;
     }>>;
     /** Global optimization using dual annealing */
     readonly optimizeDualAnnealing: import("@elaraai/east").PlatformDefinition<[FunctionType<[import("@elaraai/east").ArrayType<FloatType>], FloatType>, OptionType<import("@elaraai/east").ArrayType<FloatType>>, StructType<{
         /** Lower bounds for each variable */
-        lower: import("@elaraai/east").ArrayType<FloatType>;
+        readonly lower: import("@elaraai/east").ArrayType<FloatType>;
         /** Upper bounds for each variable */
-        upper: import("@elaraai/east").ArrayType<FloatType>;
+        readonly upper: import("@elaraai/east").ArrayType<FloatType>;
     }>, StructType<{
         /** Maximum function evaluations (default: 1000) */
-        maxfun: OptionType<IntegerType>;
+        readonly maxfun: OptionType<IntegerType>;
         /** Maximum iterations (default: 1000) */
-        maxiter: OptionType<IntegerType>;
+        readonly maxiter: OptionType<IntegerType>;
         /** Initial temperature (default: 5230) */
-        initial_temp: OptionType<FloatType>;
+        readonly initial_temp: OptionType<FloatType>;
         /** Temperature restart threshold (default: 2e-5) */
-        restart_temp_ratio: OptionType<FloatType>;
+        readonly restart_temp_ratio: OptionType<FloatType>;
         /** Visiting distribution parameter (default: 2.62) */
-        visit: OptionType<FloatType>;
+        readonly visit: OptionType<FloatType>;
         /** Acceptance distribution parameter (default: -5.0) */
-        accept: OptionType<FloatType>;
+        readonly accept: OptionType<FloatType>;
         /** Random seed for reproducibility */
-        seed: OptionType<IntegerType>;
+        readonly seed: OptionType<IntegerType>;
         /** Disable local search for speed (default: false) */
-        no_local_search: OptionType<BooleanType>;
+        readonly no_local_search: OptionType<BooleanType>;
     }>], StructType<{
         /** Best solution found */
-        x: import("@elaraai/east").ArrayType<FloatType>;
+        readonly x: import("@elaraai/east").ArrayType<FloatType>;
         /** Best objective value */
-        fun: FloatType;
+        readonly fun: FloatType;
         /** Number of function evaluations */
-        nfev: IntegerType;
+        readonly nfev: IntegerType;
         /** Number of iterations */
-        nit: IntegerType;
+        readonly nit: IntegerType;
         /** Whether optimization succeeded */
-        success: BooleanType;
+        readonly success: BooleanType;
         /** Status message */
-        message: StringType;
+        readonly message: StringType;
     }>>;
     /** Type definitions */
     readonly Types: {
@@ -964,202 +1056,216 @@ export declare const Scipy: {
         readonly ScalarObjectiveType: FunctionType<[import("@elaraai/east").ArrayType<FloatType>], FloatType>;
         readonly OptimizeMethodType: VariantType<{
             /** BFGS algorithm */
-            bfgs: NullType;
+            readonly bfgs: NullType;
             /** L-BFGS-B algorithm (default) */
-            l_bfgs_b: NullType;
+            readonly l_bfgs_b: NullType;
             /** Nelder-Mead simplex */
-            nelder_mead: NullType;
+            readonly nelder_mead: NullType;
             /** Powell's method */
-            powell: NullType;
+            readonly powell: NullType;
             /** Conjugate gradient */
-            cg: NullType;
+            readonly cg: NullType;
         }>;
         readonly InterpolationKindType: VariantType<{
             /** Linear interpolation (default) */
-            linear: NullType;
+            readonly linear: NullType;
             /** Cubic interpolation */
-            cubic: NullType;
+            readonly cubic: NullType;
             /** Quadratic interpolation */
-            quadratic: NullType;
+            readonly quadratic: NullType;
         }>;
         readonly OptimizeConfigType: StructType<{
             /** Optimization method */
-            method: OptionType<VariantType<{
+            readonly method: OptionType<VariantType<{
                 /** BFGS algorithm */
-                bfgs: NullType;
+                readonly bfgs: NullType;
                 /** L-BFGS-B algorithm (default) */
-                l_bfgs_b: NullType;
+                readonly l_bfgs_b: NullType;
                 /** Nelder-Mead simplex */
-                nelder_mead: NullType;
+                readonly nelder_mead: NullType;
                 /** Powell's method */
-                powell: NullType;
+                readonly powell: NullType;
                 /** Conjugate gradient */
-                cg: NullType;
+                readonly cg: NullType;
             }>>;
             /** Maximum number of iterations */
-            max_iter: OptionType<IntegerType>;
+            readonly max_iter: OptionType<IntegerType>;
             /** Tolerance for convergence */
-            tol: OptionType<FloatType>;
+            readonly tol: OptionType<FloatType>;
         }>;
         readonly InterpolateConfigType: StructType<{
             /** Interpolation method */
-            kind: OptionType<VariantType<{
+            readonly kind: OptionType<VariantType<{
                 /** Linear interpolation (default) */
-                linear: NullType;
+                readonly linear: NullType;
                 /** Cubic interpolation */
-                cubic: NullType;
+                readonly cubic: NullType;
                 /** Quadratic interpolation */
-                quadratic: NullType;
+                readonly quadratic: NullType;
             }>>;
         }>;
         readonly ParamBoundsType: StructType<{
             /** Lower bounds for each parameter */
-            lower: import("@elaraai/east").ArrayType<FloatType>;
+            readonly lower: import("@elaraai/east").ArrayType<FloatType>;
             /** Upper bounds for each parameter */
-            upper: import("@elaraai/east").ArrayType<FloatType>;
+            readonly upper: import("@elaraai/east").ArrayType<FloatType>;
         }>;
-        readonly CustomCurveFunctionType: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
+        readonly CustomCurveFunctionType: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
         readonly CurveFunctionType: VariantType<{
             /** y = a * exp(-b * x), 2 params: [a, b] */
-            exponential_decay: NullType;
+            readonly exponential_decay: NullType;
             /** y = a + b * exp(-c * x), 3 params: [a, b, c] */
-            exponential_with_offset: NullType;
+            readonly exponential_with_offset: NullType;
             /** y = a * exp(b * x), 2 params: [a, b] */
-            exponential_growth: NullType;
+            readonly exponential_growth: NullType;
             /** y = L / (1 + exp(-k * (x - x0))), 3 params: [L, k, x0] */
-            logistic: NullType;
+            readonly logistic: NullType;
             /** y = a * exp(-b * exp(-c * x)), 3 params: [a, b, c] */
-            gompertz: NullType;
+            readonly gompertz: NullType;
             /** y = a * x^b, 2 params: [a, b] */
-            power_law: NullType;
+            readonly power_law: NullType;
             /** y = a + b * x, 2 params: [a, b] */
-            linear: NullType;
+            readonly linear: NullType;
             /** y = a + b*x + c*x^2, 3 params: [a, b, c] */
-            quadratic: NullType;
+            readonly quadratic: NullType;
             /** y = a + b*x + c*x^2 + d*x^3, 4 params: [a, b, c, d] */
-            cubic: NullType;
+            readonly cubic: NullType;
             /** Custom function provided by user */
-            custom: StructType<{
-                /** The curve function */
-                fn: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
+            readonly custom: StructType<{
+                /** The curve function: (x, params, fixed_params) -> y */
+                readonly fn: FunctionType<[FloatType, import("@elaraai/east").ArrayType<FloatType>, import("@elaraai/east").ArrayType<FloatType>], FloatType>;
                 /** Number of parameters to optimize */
-                n_params: IntegerType;
+                readonly n_params: IntegerType;
                 /** Optional parameter bounds */
-                param_bounds: OptionType<StructType<{
+                readonly param_bounds: OptionType<StructType<{
                     /** Lower bounds for each parameter */
-                    lower: import("@elaraai/east").ArrayType<FloatType>;
+                    readonly lower: import("@elaraai/east").ArrayType<FloatType>;
                     /** Upper bounds for each parameter */
-                    upper: import("@elaraai/east").ArrayType<FloatType>;
+                    readonly upper: import("@elaraai/east").ArrayType<FloatType>;
                 }>>;
+                /** Optional fixed parameters passed to fn but not optimized */
+                readonly fixed_params: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
             }>;
         }>;
         readonly CurveFitConfigType: StructType<{
             /** Maximum number of function evaluations */
-            max_iter: OptionType<IntegerType>;
+            readonly max_iter: OptionType<IntegerType>;
             /** Initial guess for parameters */
-            initial_guess: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
+            readonly initial_guess: OptionType<import("@elaraai/east").ArrayType<FloatType>>;
         }>;
         readonly QuadraticConfigType: StructType<{
             /** Quadratic term (symmetric positive definite) */
-            A: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
+            readonly A: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
             /** Linear term */
-            b: import("@elaraai/east").ArrayType<FloatType>;
+            readonly b: import("@elaraai/east").ArrayType<FloatType>;
             /** Constant term */
-            c: FloatType;
+            readonly c: FloatType;
         }>;
         readonly StatsDescribeResultType: StructType<{
             /** Number of observations */
-            count: IntegerType;
+            readonly count: IntegerType;
             /** Mean value */
-            mean: FloatType;
+            readonly mean: FloatType;
             /** Variance */
-            variance: FloatType;
+            readonly variance: FloatType;
             /** Skewness */
-            skewness: FloatType;
+            readonly skewness: FloatType;
             /** Kurtosis */
-            kurtosis: FloatType;
+            readonly kurtosis: FloatType;
             /** Minimum value */
-            min: FloatType;
+            readonly min: FloatType;
             /** Maximum value */
-            max: FloatType;
+            readonly max: FloatType;
+        }>;
+        readonly RobustStatsResultType: StructType<{
+            /** Median value */
+            readonly median: FloatType;
+            /** Interquartile range (Q3 - Q1) */
+            readonly iqr: FloatType;
+            /** Median absolute deviation */
+            readonly mad: FloatType;
+            /** 25th percentile */
+            readonly q1: FloatType;
+            /** 75th percentile */
+            readonly q3: FloatType;
         }>;
         readonly CorrelationResultType: StructType<{
             /** Correlation coefficient */
-            correlation: FloatType;
+            readonly correlation: FloatType;
             /** P-value for hypothesis test */
-            pvalue: FloatType;
+            readonly pvalue: FloatType;
         }>;
         readonly CurveFitResultType: StructType<{
             /** Fitted parameters */
-            params: import("@elaraai/east").ArrayType<FloatType>;
+            readonly params: import("@elaraai/east").ArrayType<FloatType>;
             /** Whether fit converged */
-            success: BooleanType;
+            readonly success: BooleanType;
             /** Coefficient of determination (R²) */
-            r_squared: FloatType;
+            readonly r_squared: FloatType;
         }>;
         readonly OptimizeResultType: StructType<{
             /** Optimal parameters */
-            x: import("@elaraai/east").ArrayType<FloatType>;
+            readonly x: import("@elaraai/east").ArrayType<FloatType>;
             /** Function value at optimum */
-            fun: FloatType;
+            readonly fun: FloatType;
             /** Whether optimization succeeded */
-            success: BooleanType;
+            readonly success: BooleanType;
             /** Number of iterations */
-            nit: IntegerType;
+            readonly nit: IntegerType;
         }>;
         readonly ModelBlobType: VariantType<{
             /** 1D interpolator (cloudpickle serialized) */
-            scipy_interp_1d: StructType<{
+            readonly scipy_interp_1d: StructType<{
                 /** Serialized interpolator */
-                data: BlobType;
+                readonly data: BlobType;
                 /** Interpolation method used */
-                kind: VariantType<{
+                readonly kind: VariantType<{
                     /** Linear interpolation (default) */
-                    linear: NullType;
+                    readonly linear: NullType;
                     /** Cubic interpolation */
-                    cubic: NullType;
+                    readonly cubic: NullType;
                     /** Quadratic interpolation */
-                    quadratic: NullType;
+                    readonly quadratic: NullType;
                 }>;
             }>;
         }>;
         readonly DualAnnealBoundsType: StructType<{
             /** Lower bounds for each variable */
-            lower: import("@elaraai/east").ArrayType<FloatType>;
+            readonly lower: import("@elaraai/east").ArrayType<FloatType>;
             /** Upper bounds for each variable */
-            upper: import("@elaraai/east").ArrayType<FloatType>;
+            readonly upper: import("@elaraai/east").ArrayType<FloatType>;
         }>;
         readonly DualAnnealConfigType: StructType<{
             /** Maximum function evaluations (default: 1000) */
-            maxfun: OptionType<IntegerType>;
+            readonly maxfun: OptionType<IntegerType>;
             /** Maximum iterations (default: 1000) */
-            maxiter: OptionType<IntegerType>;
+            readonly maxiter: OptionType<IntegerType>;
             /** Initial temperature (default: 5230) */
-            initial_temp: OptionType<FloatType>;
+            readonly initial_temp: OptionType<FloatType>;
             /** Temperature restart threshold (default: 2e-5) */
-            restart_temp_ratio: OptionType<FloatType>;
+            readonly restart_temp_ratio: OptionType<FloatType>;
             /** Visiting distribution parameter (default: 2.62) */
-            visit: OptionType<FloatType>;
+            readonly visit: OptionType<FloatType>;
             /** Acceptance distribution parameter (default: -5.0) */
-            accept: OptionType<FloatType>;
+            readonly accept: OptionType<FloatType>;
             /** Random seed for reproducibility */
-            seed: OptionType<IntegerType>;
+            readonly seed: OptionType<IntegerType>;
             /** Disable local search for speed (default: false) */
-            no_local_search: OptionType<BooleanType>;
+            readonly no_local_search: OptionType<BooleanType>;
         }>;
         readonly DualAnnealResultType: StructType<{
             /** Best solution found */
-            x: import("@elaraai/east").ArrayType<FloatType>;
+            readonly x: import("@elaraai/east").ArrayType<FloatType>;
             /** Best objective value */
-            fun: FloatType;
+            readonly fun: FloatType;
             /** Number of function evaluations */
-            nfev: IntegerType;
+            readonly nfev: IntegerType;
             /** Number of iterations */
-            nit: IntegerType;
+            readonly nit: IntegerType;
             /** Whether optimization succeeded */
-            success: BooleanType;
+            readonly success: BooleanType;
             /** Status message */
-            message: StringType;
+            readonly message: StringType;
         }>;
     };
 };