@elaraai/east-py-datascience 1.0.1 → 1.0.3

package/dist/src/gp/gp.d.ts

@@ -0,0 +1,447 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Gaussian Process platform functions for East.
+ *
+ * Provides Gaussian Process regression using scikit-learn.
+ * Uses cloudpickle for model serialization.
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, IntegerType, FloatType, BooleanType, BlobType, StringType, NullType } from "@elaraai/east";
+import { VectorType, MatrixType } from "../types.js";
+export { VectorType, MatrixType } from "../types.js";
+/**
+ * Kernel type for Gaussian Process.
+ */
+export declare const GPKernelType: VariantType<{
+    /** Radial Basis Function (squared exponential) */
+    readonly rbf: NullType;
+    /** Matern with nu=1/2 (exponential) */
+    readonly matern_1_2: NullType;
+    /** Matern with nu=3/2 */
+    readonly matern_3_2: NullType;
+    /** Matern with nu=5/2 */
+    readonly matern_5_2: NullType;
+    /** Rational Quadratic */
+    readonly rational_quadratic: NullType;
+    /** Dot Product (linear) */
+    readonly dot_product: NullType;
+}>;
+/**
+ * Configuration for Gaussian Process Regressor.
+ */
+export declare const GPConfigType: StructType<{
+    /** Kernel type (default rbf) */
+    readonly kernel: OptionType<VariantType<{
+        /** Radial Basis Function (squared exponential) */
+        readonly rbf: NullType;
+        /** Matern with nu=1/2 (exponential) */
+        readonly matern_1_2: NullType;
+        /** Matern with nu=3/2 */
+        readonly matern_3_2: NullType;
+        /** Matern with nu=5/2 */
+        readonly matern_5_2: NullType;
+        /** Rational Quadratic */
+        readonly rational_quadratic: NullType;
+        /** Dot Product (linear) */
+        readonly dot_product: NullType;
+    }>>;
+    /** Noise level added to diagonal (default 1e-10) */
+    readonly alpha: OptionType<FloatType>;
+    /** Number of restarts for optimizer (default 0) */
+    readonly n_restarts_optimizer: OptionType<IntegerType>;
+    /** Whether to normalize target values (default false) */
+    readonly normalize_y: OptionType<BooleanType>;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+}>;
+/**
+ * Result type for GP prediction with uncertainty.
+ */
+export declare const GPPredictResultType: StructType<{
+    /** Predicted mean values */
+    readonly mean: VectorType<FloatType>;
+    /** Predicted standard deviation (uncertainty) */
+    readonly std: VectorType<FloatType>;
+}>;
+/**
+ * Model blob type for serialized GP models.
+ */
+export declare const GPModelBlobType: VariantType<{
+    /** Gaussian Process Regressor */
+    readonly gp_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Kernel type name for reference */
+        readonly kernel_type: StringType;
+    }>;
+}>;
+/**
+ * Train a Gaussian Process Regressor.
+ *
+ * @param X - Feature matrix
+ * @param y - Target vector
+ * @param config - GP configuration
+ * @returns Trained GP model blob
+ */
+export declare const gp_train: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, VectorType<FloatType>, StructType<{
+    /** Kernel type (default rbf) */
+    readonly kernel: OptionType<VariantType<{
+        /** Radial Basis Function (squared exponential) */
+        readonly rbf: NullType;
+        /** Matern with nu=1/2 (exponential) */
+        readonly matern_1_2: NullType;
+        /** Matern with nu=3/2 */
+        readonly matern_3_2: NullType;
+        /** Matern with nu=5/2 */
+        readonly matern_5_2: NullType;
+        /** Rational Quadratic */
+        readonly rational_quadratic: NullType;
+        /** Dot Product (linear) */
+        readonly dot_product: NullType;
+    }>>;
+    /** Noise level added to diagonal (default 1e-10) */
+    readonly alpha: OptionType<FloatType>;
+    /** Number of restarts for optimizer (default 0) */
+    readonly n_restarts_optimizer: OptionType<IntegerType>;
+    /** Whether to normalize target values (default false) */
+    readonly normalize_y: OptionType<BooleanType>;
+    /** Random seed for reproducibility */
+    readonly random_state: OptionType<IntegerType>;
+}>], VariantType<{
+    /** Gaussian Process Regressor */
+    readonly gp_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Kernel type name for reference */
+        readonly kernel_type: StringType;
+    }>;
+}>>;
+/**
+ * Make predictions with a trained Gaussian Process.
+ *
+ * Returns point predictions (mean only).
+ *
+ * @param model - Trained GP model blob
+ * @param X - Feature matrix
+ * @returns Predicted values
+ */
+export declare const gp_predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** Gaussian Process Regressor */
+    readonly gp_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Kernel type name for reference */
+        readonly kernel_type: StringType;
+    }>;
+}>, MatrixType<FloatType>], VectorType<FloatType>>;
+/**
+ * Make predictions with uncertainty estimates.
+ *
+ * Returns both mean and standard deviation.
+ *
+ * @param model - Trained GP model blob
+ * @param X - Feature matrix
+ * @returns Prediction result with mean and std
+ */
+export declare const gp_predict_std: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** Gaussian Process Regressor */
+    readonly gp_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        readonly data: BlobType;
+        /** Number of input features */
+        readonly n_features: IntegerType;
+        /** Kernel type name for reference */
+        readonly kernel_type: StringType;
+    }>;
+}>, MatrixType<FloatType>], StructType<{
+    /** Predicted mean values */
+    readonly mean: VectorType<FloatType>;
+    /** Predicted standard deviation (uncertainty) */
+    readonly std: VectorType<FloatType>;
+}>>;
+/**
+ * Type definitions for GP functions.
+ */
+export declare const GPTypes: {
+    /** Kernel type */
+    readonly GPKernelType: VariantType<{
+        /** Radial Basis Function (squared exponential) */
+        readonly rbf: NullType;
+        /** Matern with nu=1/2 (exponential) */
+        readonly matern_1_2: NullType;
+        /** Matern with nu=3/2 */
+        readonly matern_3_2: NullType;
+        /** Matern with nu=5/2 */
+        readonly matern_5_2: NullType;
+        /** Rational Quadratic */
+        readonly rational_quadratic: NullType;
+        /** Dot Product (linear) */
+        readonly dot_product: NullType;
+    }>;
+    /** Configuration type */
+    readonly GPConfigType: StructType<{
+        /** Kernel type (default rbf) */
+        readonly kernel: OptionType<VariantType<{
+            /** Radial Basis Function (squared exponential) */
+            readonly rbf: NullType;
+            /** Matern with nu=1/2 (exponential) */
+            readonly matern_1_2: NullType;
+            /** Matern with nu=3/2 */
+            readonly matern_3_2: NullType;
+            /** Matern with nu=5/2 */
+            readonly matern_5_2: NullType;
+            /** Rational Quadratic */
+            readonly rational_quadratic: NullType;
+            /** Dot Product (linear) */
+            readonly dot_product: NullType;
+        }>>;
+        /** Noise level added to diagonal (default 1e-10) */
+        readonly alpha: OptionType<FloatType>;
+        /** Number of restarts for optimizer (default 0) */
+        readonly n_restarts_optimizer: OptionType<IntegerType>;
+        /** Whether to normalize target values (default false) */
+        readonly normalize_y: OptionType<BooleanType>;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+    }>;
+    /** Prediction result type with uncertainty */
+    readonly GPPredictResultType: StructType<{
+        /** Predicted mean values */
+        readonly mean: VectorType<FloatType>;
+        /** Predicted standard deviation (uncertainty) */
+        readonly std: VectorType<FloatType>;
+    }>;
+    /** Model blob type for GP models */
+    readonly ModelBlobType: VariantType<{
+        /** Gaussian Process Regressor */
+        readonly gp_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Kernel type name for reference */
+            readonly kernel_type: StringType;
+        }>;
+    }>;
+};
+/**
+ * Gaussian Process regression.
+ *
+ * Provides probabilistic regression with uncertainty quantification.
+ *
+ * @example
+ * ```ts
+ * import { East, variant } from "@elaraai/east";
+ * import { GP } from "@elaraai/east-py-datascience";
+ *
+ * const train = East.function([], GP.Types.ModelBlobType, $ => {
+ *     const X = $.let([[1.0], [2.0], [3.0], [4.0]]);
+ *     const y = $.let([1.0, 4.0, 9.0, 16.0]);
+ *     const config = $.let({
+ *         kernel: variant('some', variant('rbf', {})),
+ *         alpha: variant('some', 1e-10),
+ *         n_restarts_optimizer: variant('some', 5n),
+ *         normalize_y: variant('some', true),
+ *         random_state: variant('some', 42n),
+ *     });
+ *     return $.return(GP.train(X, y, config));
+ * });
+ * ```
+ */
+export declare const GP: {
+    /**
+     * Train a Gaussian Process regression model.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, VectorType, variant } from "@elaraai/east";
+     * import { GP, GPConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const train = East.function([], GP.Types.ModelBlobType, ($) => {
+     *     const X = $.let([[1.0], [2.0], [3.0], [4.0]]);
+     *     const y = $.let(new Float64Array([1.0, 4.0, 9.0, 16.0]));
+     *     const config = $.let({
+     *         kernel: variant("some", variant("rbf", null)),
+     *         alpha: variant("some", 1e-10),
+     *         n_restarts_optimizer: variant("some", 5n),
+     *         normalize_y: variant("some", true),
+     *         random_state: variant("some", 42n),
+     *     }, GPConfigType);
+     *     return $.return(GP.train(X, y, config));
+     * });
+     * ```
+     */
+    readonly train: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, VectorType<FloatType>, StructType<{
+        /** Kernel type (default rbf) */
+        readonly kernel: OptionType<VariantType<{
+            /** Radial Basis Function (squared exponential) */
+            readonly rbf: NullType;
+            /** Matern with nu=1/2 (exponential) */
+            readonly matern_1_2: NullType;
+            /** Matern with nu=3/2 */
+            readonly matern_3_2: NullType;
+            /** Matern with nu=5/2 */
+            readonly matern_5_2: NullType;
+            /** Rational Quadratic */
+            readonly rational_quadratic: NullType;
+            /** Dot Product (linear) */
+            readonly dot_product: NullType;
+        }>>;
+        /** Noise level added to diagonal (default 1e-10) */
+        readonly alpha: OptionType<FloatType>;
+        /** Number of restarts for optimizer (default 0) */
+        readonly n_restarts_optimizer: OptionType<IntegerType>;
+        /** Whether to normalize target values (default false) */
+        readonly normalize_y: OptionType<BooleanType>;
+        /** Random seed for reproducibility */
+        readonly random_state: OptionType<IntegerType>;
+    }>], VariantType<{
+        /** Gaussian Process Regressor */
+        readonly gp_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Kernel type name for reference */
+            readonly kernel_type: StringType;
+        }>;
+    }>>;
+    /**
+     * Make predictions (mean only) with a trained GP model.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, VectorType } from "@elaraai/east";
+     * import { GP } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [GP.Types.ModelBlobType, MatrixType(FloatType)],
+     *     VectorType(FloatType),
+     *     ($, model, X) => {
+     *         return $.return(GP.predict(model, X));
+     *     }
+     * );
+     * ```
+     */
+    readonly predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** Gaussian Process Regressor */
+        readonly gp_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Kernel type name for reference */
+            readonly kernel_type: StringType;
+        }>;
+    }>, MatrixType<FloatType>], VectorType<FloatType>>;
+    /**
+     * Make predictions with uncertainty estimates (mean + std).
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType } from "@elaraai/east";
+     * import { GP } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [GP.Types.ModelBlobType, MatrixType(FloatType)],
+     *     GP.Types.GPPredictResultType,
+     *     ($, model, X) => {
+     *         const result = $.let(GP.predictStd(model, X));
+     *         // result.mean => predicted values
+     *         // result.std  => uncertainty (standard deviation)
+     *         return $.return(result);
+     *     }
+     * );
+     * ```
+     */
+    readonly predictStd: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** Gaussian Process Regressor */
+        readonly gp_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            readonly data: BlobType;
+            /** Number of input features */
+            readonly n_features: IntegerType;
+            /** Kernel type name for reference */
+            readonly kernel_type: StringType;
+        }>;
+    }>, MatrixType<FloatType>], StructType<{
+        /** Predicted mean values */
+        readonly mean: VectorType<FloatType>;
+        /** Predicted standard deviation (uncertainty) */
+        readonly std: VectorType<FloatType>;
+    }>>;
+    /** Type definitions */
+    readonly Types: {
+        /** Kernel type */
+        readonly GPKernelType: VariantType<{
+            /** Radial Basis Function (squared exponential) */
+            readonly rbf: NullType;
+            /** Matern with nu=1/2 (exponential) */
+            readonly matern_1_2: NullType;
+            /** Matern with nu=3/2 */
+            readonly matern_3_2: NullType;
+            /** Matern with nu=5/2 */
+            readonly matern_5_2: NullType;
+            /** Rational Quadratic */
+            readonly rational_quadratic: NullType;
+            /** Dot Product (linear) */
+            readonly dot_product: NullType;
+        }>;
+        /** Configuration type */
+        readonly GPConfigType: StructType<{
+            /** Kernel type (default rbf) */
+            readonly kernel: OptionType<VariantType<{
+                /** Radial Basis Function (squared exponential) */
+                readonly rbf: NullType;
+                /** Matern with nu=1/2 (exponential) */
+                readonly matern_1_2: NullType;
+                /** Matern with nu=3/2 */
+                readonly matern_3_2: NullType;
+                /** Matern with nu=5/2 */
+                readonly matern_5_2: NullType;
+                /** Rational Quadratic */
+                readonly rational_quadratic: NullType;
+                /** Dot Product (linear) */
+                readonly dot_product: NullType;
+            }>>;
+            /** Noise level added to diagonal (default 1e-10) */
+            readonly alpha: OptionType<FloatType>;
+            /** Number of restarts for optimizer (default 0) */
+            readonly n_restarts_optimizer: OptionType<IntegerType>;
+            /** Whether to normalize target values (default false) */
+            readonly normalize_y: OptionType<BooleanType>;
+            /** Random seed for reproducibility */
+            readonly random_state: OptionType<IntegerType>;
+        }>;
+        /** Prediction result type with uncertainty */
+        readonly GPPredictResultType: StructType<{
+            /** Predicted mean values */
+            readonly mean: VectorType<FloatType>;
+            /** Predicted standard deviation (uncertainty) */
+            readonly std: VectorType<FloatType>;
+        }>;
+        /** Model blob type for GP models */
+        readonly ModelBlobType: VariantType<{
+            /** Gaussian Process Regressor */
+            readonly gp_regressor: StructType<{
+                /** Cloudpickle serialized model */
+                readonly data: BlobType;
+                /** Number of input features */
+                readonly n_features: IntegerType;
+                /** Kernel type name for reference */
+                readonly kernel_type: StringType;
+            }>;
+        }>;
+    };
+};
+//# sourceMappingURL=gp.d.ts.map

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

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

package/dist/src/gp/gp.js

@@ -0,0 +1,222 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Gaussian Process platform functions for East.
+ *
+ * Provides Gaussian Process regression using scikit-learn.
+ * Uses cloudpickle for model serialization.
+ *
+ * @packageDocumentation
+ */
+import { East, StructType, VariantType, OptionType, IntegerType, FloatType, BooleanType, BlobType, StringType, NullType, } from "@elaraai/east";
+import { VectorType, MatrixType } from "../types.js";
+// Re-export shared types for convenience
+export { VectorType, MatrixType } from "../types.js";
+// ============================================================================
+// Enum Types
+// ============================================================================
+/**
+ * Kernel type for Gaussian Process.
+ */
+export const GPKernelType = VariantType({
+    /** Radial Basis Function (squared exponential) */
+    rbf: NullType,
+    /** Matern with nu=1/2 (exponential) */
+    matern_1_2: NullType,
+    /** Matern with nu=3/2 */
+    matern_3_2: NullType,
+    /** Matern with nu=5/2 */
+    matern_5_2: NullType,
+    /** Rational Quadratic */
+    rational_quadratic: NullType,
+    /** Dot Product (linear) */
+    dot_product: NullType,
+});
+// ============================================================================
+// Config Types
+// ============================================================================
+/**
+ * Configuration for Gaussian Process Regressor.
+ */
+export const GPConfigType = StructType({
+    /** Kernel type (default rbf) */
+    kernel: OptionType(GPKernelType),
+    /** Noise level added to diagonal (default 1e-10) */
+    alpha: OptionType(FloatType),
+    /** Number of restarts for optimizer (default 0) */
+    n_restarts_optimizer: OptionType(IntegerType),
+    /** Whether to normalize target values (default false) */
+    normalize_y: OptionType(BooleanType),
+    /** Random seed for reproducibility */
+    random_state: OptionType(IntegerType),
+});
+// ============================================================================
+// Result Types
+// ============================================================================
+/**
+ * Result type for GP prediction with uncertainty.
+ */
+export const GPPredictResultType = StructType({
+    /** Predicted mean values */
+    mean: VectorType(FloatType),
+    /** Predicted standard deviation (uncertainty) */
+    std: VectorType(FloatType),
+});
+// ============================================================================
+// Model Blob Types
+// ============================================================================
+/**
+ * Model blob type for serialized GP models.
+ */
+export const GPModelBlobType = VariantType({
+    /** Gaussian Process Regressor */
+    gp_regressor: StructType({
+        /** Cloudpickle serialized model */
+        data: BlobType,
+        /** Number of input features */
+        n_features: IntegerType,
+        /** Kernel type name for reference */
+        kernel_type: StringType,
+    }),
+});
+// ============================================================================
+// Platform Functions
+// ============================================================================
+/**
+ * Train a Gaussian Process Regressor.
+ *
+ * @param X - Feature matrix
+ * @param y - Target vector
+ * @param config - GP configuration
+ * @returns Trained GP model blob
+ */
+export const gp_train = East.platform("gp_train", [MatrixType(FloatType), VectorType(FloatType), GPConfigType], GPModelBlobType);
+/**
+ * Make predictions with a trained Gaussian Process.
+ *
+ * Returns point predictions (mean only).
+ *
+ * @param model - Trained GP model blob
+ * @param X - Feature matrix
+ * @returns Predicted values
+ */
+export const gp_predict = East.platform("gp_predict", [GPModelBlobType, MatrixType(FloatType)], VectorType(FloatType));
+/**
+ * Make predictions with uncertainty estimates.
+ *
+ * Returns both mean and standard deviation.
+ *
+ * @param model - Trained GP model blob
+ * @param X - Feature matrix
+ * @returns Prediction result with mean and std
+ */
+export const gp_predict_std = East.platform("gp_predict_std", [GPModelBlobType, MatrixType(FloatType)], GPPredictResultType);
+// ============================================================================
+// Grouped Export
+// ============================================================================
+/**
+ * Type definitions for GP functions.
+ */
+export const GPTypes = {
+    /** Kernel type */
+    GPKernelType,
+    /** Configuration type */
+    GPConfigType,
+    /** Prediction result type with uncertainty */
+    GPPredictResultType,
+    /** Model blob type for GP models */
+    ModelBlobType: GPModelBlobType,
+};
+/**
+ * Gaussian Process regression.
+ *
+ * Provides probabilistic regression with uncertainty quantification.
+ *
+ * @example
+ * ```ts
+ * import { East, variant } from "@elaraai/east";
+ * import { GP } from "@elaraai/east-py-datascience";
+ *
+ * const train = East.function([], GP.Types.ModelBlobType, $ => {
+ *     const X = $.let([[1.0], [2.0], [3.0], [4.0]]);
+ *     const y = $.let([1.0, 4.0, 9.0, 16.0]);
+ *     const config = $.let({
+ *         kernel: variant('some', variant('rbf', {})),
+ *         alpha: variant('some', 1e-10),
+ *         n_restarts_optimizer: variant('some', 5n),
+ *         normalize_y: variant('some', true),
+ *         random_state: variant('some', 42n),
+ *     });
+ *     return $.return(GP.train(X, y, config));
+ * });
+ * ```
+ */
+export const GP = {
+    /**
+     * Train a Gaussian Process regression model.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, VectorType, variant } from "@elaraai/east";
+     * import { GP, GPConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const train = East.function([], GP.Types.ModelBlobType, ($) => {
+     *     const X = $.let([[1.0], [2.0], [3.0], [4.0]]);
+     *     const y = $.let(new Float64Array([1.0, 4.0, 9.0, 16.0]));
+     *     const config = $.let({
+     *         kernel: variant("some", variant("rbf", null)),
+     *         alpha: variant("some", 1e-10),
+     *         n_restarts_optimizer: variant("some", 5n),
+     *         normalize_y: variant("some", true),
+     *         random_state: variant("some", 42n),
+     *     }, GPConfigType);
+     *     return $.return(GP.train(X, y, config));
+     * });
+     * ```
+     */
+    train: gp_train,
+    /**
+     * Make predictions (mean only) with a trained GP model.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, VectorType } from "@elaraai/east";
+     * import { GP } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [GP.Types.ModelBlobType, MatrixType(FloatType)],
+     *     VectorType(FloatType),
+     *     ($, model, X) => {
+     *         return $.return(GP.predict(model, X));
+     *     }
+     * );
+     * ```
+     */
+    predict: gp_predict,
+    /**
+     * Make predictions with uncertainty estimates (mean + std).
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType } from "@elaraai/east";
+     * import { GP } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [GP.Types.ModelBlobType, MatrixType(FloatType)],
+     *     GP.Types.GPPredictResultType,
+     *     ($, model, X) => {
+     *         const result = $.let(GP.predictStd(model, X));
+     *         // result.mean => predicted values
+     *         // result.std  => uncertainty (standard deviation)
+     *         return $.return(result);
+     *     }
+     * );
+     * ```
+     */
+    predictStd: gp_predict_std,
+    /** Type definitions */
+    Types: GPTypes,
+};
+//# sourceMappingURL=gp.js.map

package/dist/src/gp/gp.js.map

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