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

package/dist/simanneal/simanneal.d.ts

@@ -0,0 +1,531 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Discrete optimization using Simulated Annealing.
+ *
+ * Provides combinatorial optimization for discrete state spaces using the
+ * simanneal library. Ideal for:
+ * - Permutation problems (TSP, scheduling)
+ * - Subset selection (feature selection, knapsack)
+ * - Assignment problems
+ * - Any discrete optimization where gradient methods don't apply
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, ArrayType, IntegerType, FloatType, BooleanType, FunctionType } from "@elaraai/east";
+/**
+ * Discrete state type for simulated annealing.
+ *
+ * Supports different representations for combinatorial problems:
+ * - int_array: Permutations, assignments, sequences of integers
+ * - bool_array: Subset selections, binary decisions
+ */
+export declare const DiscreteStateType: VariantType<{
+    /** Integer array state (permutations, assignments) */
+    int_array: ArrayType<IntegerType>;
+    /** Boolean array state (subset selection) */
+    bool_array: ArrayType<BooleanType>;
+}>;
+/**
+ * Energy function type: state -> score.
+ *
+ * Computes the objective value (energy) for a given state.
+ * Lower energy is better (minimization).
+ */
+export declare const EnergyFunctionType: FunctionType<[VariantType<{
+    /** Integer array state (permutations, assignments) */
+    int_array: ArrayType<IntegerType>;
+    /** Boolean array state (subset selection) */
+    bool_array: ArrayType<BooleanType>;
+}>], FloatType>;
+/**
+ * Move function type: state -> neighbor state.
+ *
+ * Generates a random neighbor of the current state.
+ * Should make small, local changes (e.g., swap two elements).
+ */
+export declare const MoveFunctionType: FunctionType<[VariantType<{
+    /** Integer array state (permutations, assignments) */
+    int_array: ArrayType<IntegerType>;
+    /** Boolean array state (subset selection) */
+    bool_array: ArrayType<BooleanType>;
+}>], VariantType<{
+    /** Integer array state (permutations, assignments) */
+    int_array: ArrayType<IntegerType>;
+    /** Boolean array state (subset selection) */
+    bool_array: ArrayType<BooleanType>;
+}>>;
+/**
+ * Permutation energy function type.
+ *
+ * Specialized for permutation-based optimization.
+ */
+export declare const PermutationEnergyType: FunctionType<[ArrayType<IntegerType>], FloatType>;
+/**
+ * Subset energy function type.
+ *
+ * Specialized for subset selection optimization.
+ */
+export declare const SubsetEnergyType: FunctionType<[ArrayType<BooleanType>], FloatType>;
+/**
+ * Simulated annealing configuration.
+ */
+export declare const AnnealConfigType: StructType<{
+    /** Starting temperature (default: 25000.0) */
+    t_max: OptionType<FloatType>;
+    /** Ending temperature (default: 2.5) */
+    t_min: OptionType<FloatType>;
+    /** Total iterations (default: 50000) */
+    steps: OptionType<IntegerType>;
+    /** Progress report frequency (default: 0 = silent) */
+    updates: OptionType<IntegerType>;
+    /** Minutes for auto-calibration (default: none) */
+    auto_schedule: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+}>;
+/**
+ * Simulated annealing result.
+ */
+export declare const AnnealResultType: StructType<{
+    /** Best state found */
+    best_state: VariantType<{
+        /** Integer array state (permutations, assignments) */
+        int_array: ArrayType<IntegerType>;
+        /** Boolean array state (subset selection) */
+        bool_array: ArrayType<BooleanType>;
+    }>;
+    /** Energy of best state */
+    best_energy: FloatType;
+    /** Actual iterations performed */
+    steps_taken: IntegerType;
+    /** Whether optimization completed successfully */
+    success: BooleanType;
+}>;
+/**
+ * Run simulated annealing on a discrete state space.
+ *
+ * Uses custom energy and move functions for flexible optimization.
+ *
+ * @param initial_state - Starting state
+ * @param energy_fn - Function to compute state energy (lower is better)
+ * @param move_fn - Function to generate neighbor states
+ * @param config - Annealing schedule configuration
+ * @returns Result with best state and energy
+ */
+export declare const simanneal_optimize: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** Integer array state (permutations, assignments) */
+    int_array: ArrayType<IntegerType>;
+    /** Boolean array state (subset selection) */
+    bool_array: ArrayType<BooleanType>;
+}>, FunctionType<[VariantType<{
+    /** Integer array state (permutations, assignments) */
+    int_array: ArrayType<IntegerType>;
+    /** Boolean array state (subset selection) */
+    bool_array: ArrayType<BooleanType>;
+}>], FloatType>, FunctionType<[VariantType<{
+    /** Integer array state (permutations, assignments) */
+    int_array: ArrayType<IntegerType>;
+    /** Boolean array state (subset selection) */
+    bool_array: ArrayType<BooleanType>;
+}>], VariantType<{
+    /** Integer array state (permutations, assignments) */
+    int_array: ArrayType<IntegerType>;
+    /** Boolean array state (subset selection) */
+    bool_array: ArrayType<BooleanType>;
+}>>, StructType<{
+    /** Starting temperature (default: 25000.0) */
+    t_max: OptionType<FloatType>;
+    /** Ending temperature (default: 2.5) */
+    t_min: OptionType<FloatType>;
+    /** Total iterations (default: 50000) */
+    steps: OptionType<IntegerType>;
+    /** Progress report frequency (default: 0 = silent) */
+    updates: OptionType<IntegerType>;
+    /** Minutes for auto-calibration (default: none) */
+    auto_schedule: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+}>], StructType<{
+    /** Best state found */
+    best_state: VariantType<{
+        /** Integer array state (permutations, assignments) */
+        int_array: ArrayType<IntegerType>;
+        /** Boolean array state (subset selection) */
+        bool_array: ArrayType<BooleanType>;
+    }>;
+    /** Energy of best state */
+    best_energy: FloatType;
+    /** Actual iterations performed */
+    steps_taken: IntegerType;
+    /** Whether optimization completed successfully */
+    success: BooleanType;
+}>>;
+/**
+ * Run simulated annealing on a permutation with swap moves.
+ *
+ * Convenience function for permutation-based problems (TSP, scheduling).
+ * Automatically uses swap moves to generate neighbors.
+ *
+ * @param initial_perm - Starting permutation
+ * @param energy_fn - Function to compute permutation energy
+ * @param config - Annealing schedule configuration
+ * @returns Result with best permutation and energy
+ */
+export declare const simanneal_optimize_permutation: import("@elaraai/east").PlatformDefinition<[ArrayType<IntegerType>, FunctionType<[ArrayType<IntegerType>], FloatType>, StructType<{
+    /** Starting temperature (default: 25000.0) */
+    t_max: OptionType<FloatType>;
+    /** Ending temperature (default: 2.5) */
+    t_min: OptionType<FloatType>;
+    /** Total iterations (default: 50000) */
+    steps: OptionType<IntegerType>;
+    /** Progress report frequency (default: 0 = silent) */
+    updates: OptionType<IntegerType>;
+    /** Minutes for auto-calibration (default: none) */
+    auto_schedule: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+}>], StructType<{
+    /** Best state found */
+    best_state: VariantType<{
+        /** Integer array state (permutations, assignments) */
+        int_array: ArrayType<IntegerType>;
+        /** Boolean array state (subset selection) */
+        bool_array: ArrayType<BooleanType>;
+    }>;
+    /** Energy of best state */
+    best_energy: FloatType;
+    /** Actual iterations performed */
+    steps_taken: IntegerType;
+    /** Whether optimization completed successfully */
+    success: BooleanType;
+}>>;
+/**
+ * Run simulated annealing on a subset selection with bit-flip moves.
+ *
+ * Convenience function for subset selection problems (feature selection, knapsack).
+ * Automatically uses bit-flip moves to generate neighbors.
+ *
+ * @param initial_selection - Starting selection (boolean array)
+ * @param energy_fn - Function to compute selection energy
+ * @param config - Annealing schedule configuration
+ * @returns Result with best selection and energy
+ */
+export declare const simanneal_optimize_subset: import("@elaraai/east").PlatformDefinition<[ArrayType<BooleanType>, FunctionType<[ArrayType<BooleanType>], FloatType>, StructType<{
+    /** Starting temperature (default: 25000.0) */
+    t_max: OptionType<FloatType>;
+    /** Ending temperature (default: 2.5) */
+    t_min: OptionType<FloatType>;
+    /** Total iterations (default: 50000) */
+    steps: OptionType<IntegerType>;
+    /** Progress report frequency (default: 0 = silent) */
+    updates: OptionType<IntegerType>;
+    /** Minutes for auto-calibration (default: none) */
+    auto_schedule: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+}>], StructType<{
+    /** Best state found */
+    best_state: VariantType<{
+        /** Integer array state (permutations, assignments) */
+        int_array: ArrayType<IntegerType>;
+        /** Boolean array state (subset selection) */
+        bool_array: ArrayType<BooleanType>;
+    }>;
+    /** Energy of best state */
+    best_energy: FloatType;
+    /** Actual iterations performed */
+    steps_taken: IntegerType;
+    /** Whether optimization completed successfully */
+    success: BooleanType;
+}>>;
+/**
+ * Type definitions for Simulated Annealing.
+ */
+export declare const SimAnnealTypes: {
+    /** Discrete state type */
+    readonly DiscreteStateType: VariantType<{
+        /** Integer array state (permutations, assignments) */
+        int_array: ArrayType<IntegerType>;
+        /** Boolean array state (subset selection) */
+        bool_array: ArrayType<BooleanType>;
+    }>;
+    /** Energy function type */
+    readonly EnergyFunctionType: FunctionType<[VariantType<{
+        /** Integer array state (permutations, assignments) */
+        int_array: ArrayType<IntegerType>;
+        /** Boolean array state (subset selection) */
+        bool_array: ArrayType<BooleanType>;
+    }>], FloatType>;
+    /** Move function type */
+    readonly MoveFunctionType: FunctionType<[VariantType<{
+        /** Integer array state (permutations, assignments) */
+        int_array: ArrayType<IntegerType>;
+        /** Boolean array state (subset selection) */
+        bool_array: ArrayType<BooleanType>;
+    }>], VariantType<{
+        /** Integer array state (permutations, assignments) */
+        int_array: ArrayType<IntegerType>;
+        /** Boolean array state (subset selection) */
+        bool_array: ArrayType<BooleanType>;
+    }>>;
+    /** Permutation energy function type */
+    readonly PermutationEnergyType: FunctionType<[ArrayType<IntegerType>], FloatType>;
+    /** Subset energy function type */
+    readonly SubsetEnergyType: FunctionType<[ArrayType<BooleanType>], FloatType>;
+    /** Configuration type */
+    readonly ConfigType: StructType<{
+        /** Starting temperature (default: 25000.0) */
+        t_max: OptionType<FloatType>;
+        /** Ending temperature (default: 2.5) */
+        t_min: OptionType<FloatType>;
+        /** Total iterations (default: 50000) */
+        steps: OptionType<IntegerType>;
+        /** Progress report frequency (default: 0 = silent) */
+        updates: OptionType<IntegerType>;
+        /** Minutes for auto-calibration (default: none) */
+        auto_schedule: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+    }>;
+    /** Result type */
+    readonly ResultType: StructType<{
+        /** Best state found */
+        best_state: VariantType<{
+            /** Integer array state (permutations, assignments) */
+            int_array: ArrayType<IntegerType>;
+            /** Boolean array state (subset selection) */
+            bool_array: ArrayType<BooleanType>;
+        }>;
+        /** Energy of best state */
+        best_energy: FloatType;
+        /** Actual iterations performed */
+        steps_taken: IntegerType;
+        /** Whether optimization completed successfully */
+        success: BooleanType;
+    }>;
+};
+/**
+ * Discrete optimization using Simulated Annealing.
+ *
+ * Provides combinatorial optimization for discrete state spaces.
+ * Simulated annealing is a probabilistic technique that can escape
+ * local minima by occasionally accepting worse solutions.
+ *
+ * Ideal for:
+ * - Permutation problems (TSP, job scheduling)
+ * - Subset selection (feature selection, knapsack)
+ * - Assignment problems
+ * - Any discrete optimization with many local minima
+ *
+ * @example
+ * ```ts
+ * import { East, FloatType, variant } from "@elaraai/east";
+ * import { SimAnneal } from "@elaraai/east-py-datascience";
+ *
+ * // TSP: minimize total route distance
+ * const energy = East.function(
+ *     [ArrayType(IntegerType)],
+ *     FloatType,
+ *     ($, route) => {
+ *         // Calculate total route distance
+ *         return $.return(totalDistance);
+ *     }
+ * );
+ *
+ * const config = $.let({
+ *     t_max: variant("some", 10000.0),
+ *     t_min: variant("some", 1.0),
+ *     steps: variant("some", 50000n),
+ *     updates: variant("none", null),
+ *     auto_schedule: variant("none", null),
+ *     random_state: variant("some", 42n),
+ * });
+ *
+ * const result = SimAnneal.optimizePermutation(initial, energy, config);
+ * ```
+ */
+export declare const SimAnneal: {
+    /**
+     * Run simulated annealing with custom energy and move functions.
+     */
+    readonly optimize: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** Integer array state (permutations, assignments) */
+        int_array: ArrayType<IntegerType>;
+        /** Boolean array state (subset selection) */
+        bool_array: ArrayType<BooleanType>;
+    }>, FunctionType<[VariantType<{
+        /** Integer array state (permutations, assignments) */
+        int_array: ArrayType<IntegerType>;
+        /** Boolean array state (subset selection) */
+        bool_array: ArrayType<BooleanType>;
+    }>], FloatType>, FunctionType<[VariantType<{
+        /** Integer array state (permutations, assignments) */
+        int_array: ArrayType<IntegerType>;
+        /** Boolean array state (subset selection) */
+        bool_array: ArrayType<BooleanType>;
+    }>], VariantType<{
+        /** Integer array state (permutations, assignments) */
+        int_array: ArrayType<IntegerType>;
+        /** Boolean array state (subset selection) */
+        bool_array: ArrayType<BooleanType>;
+    }>>, StructType<{
+        /** Starting temperature (default: 25000.0) */
+        t_max: OptionType<FloatType>;
+        /** Ending temperature (default: 2.5) */
+        t_min: OptionType<FloatType>;
+        /** Total iterations (default: 50000) */
+        steps: OptionType<IntegerType>;
+        /** Progress report frequency (default: 0 = silent) */
+        updates: OptionType<IntegerType>;
+        /** Minutes for auto-calibration (default: none) */
+        auto_schedule: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+    }>], StructType<{
+        /** Best state found */
+        best_state: VariantType<{
+            /** Integer array state (permutations, assignments) */
+            int_array: ArrayType<IntegerType>;
+            /** Boolean array state (subset selection) */
+            bool_array: ArrayType<BooleanType>;
+        }>;
+        /** Energy of best state */
+        best_energy: FloatType;
+        /** Actual iterations performed */
+        steps_taken: IntegerType;
+        /** Whether optimization completed successfully */
+        success: BooleanType;
+    }>>;
+    /**
+     * Run simulated annealing on a permutation with swap moves.
+     */
+    readonly optimizePermutation: import("@elaraai/east").PlatformDefinition<[ArrayType<IntegerType>, FunctionType<[ArrayType<IntegerType>], FloatType>, StructType<{
+        /** Starting temperature (default: 25000.0) */
+        t_max: OptionType<FloatType>;
+        /** Ending temperature (default: 2.5) */
+        t_min: OptionType<FloatType>;
+        /** Total iterations (default: 50000) */
+        steps: OptionType<IntegerType>;
+        /** Progress report frequency (default: 0 = silent) */
+        updates: OptionType<IntegerType>;
+        /** Minutes for auto-calibration (default: none) */
+        auto_schedule: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+    }>], StructType<{
+        /** Best state found */
+        best_state: VariantType<{
+            /** Integer array state (permutations, assignments) */
+            int_array: ArrayType<IntegerType>;
+            /** Boolean array state (subset selection) */
+            bool_array: ArrayType<BooleanType>;
+        }>;
+        /** Energy of best state */
+        best_energy: FloatType;
+        /** Actual iterations performed */
+        steps_taken: IntegerType;
+        /** Whether optimization completed successfully */
+        success: BooleanType;
+    }>>;
+    /**
+     * Run simulated annealing on a subset selection with bit-flip moves.
+     */
+    readonly optimizeSubset: import("@elaraai/east").PlatformDefinition<[ArrayType<BooleanType>, FunctionType<[ArrayType<BooleanType>], FloatType>, StructType<{
+        /** Starting temperature (default: 25000.0) */
+        t_max: OptionType<FloatType>;
+        /** Ending temperature (default: 2.5) */
+        t_min: OptionType<FloatType>;
+        /** Total iterations (default: 50000) */
+        steps: OptionType<IntegerType>;
+        /** Progress report frequency (default: 0 = silent) */
+        updates: OptionType<IntegerType>;
+        /** Minutes for auto-calibration (default: none) */
+        auto_schedule: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+    }>], StructType<{
+        /** Best state found */
+        best_state: VariantType<{
+            /** Integer array state (permutations, assignments) */
+            int_array: ArrayType<IntegerType>;
+            /** Boolean array state (subset selection) */
+            bool_array: ArrayType<BooleanType>;
+        }>;
+        /** Energy of best state */
+        best_energy: FloatType;
+        /** Actual iterations performed */
+        steps_taken: IntegerType;
+        /** Whether optimization completed successfully */
+        success: BooleanType;
+    }>>;
+    /**
+     * Type definitions for SimAnneal functions.
+     */
+    readonly Types: {
+        /** Discrete state type */
+        readonly DiscreteStateType: VariantType<{
+            /** Integer array state (permutations, assignments) */
+            int_array: ArrayType<IntegerType>;
+            /** Boolean array state (subset selection) */
+            bool_array: ArrayType<BooleanType>;
+        }>;
+        /** Energy function type */
+        readonly EnergyFunctionType: FunctionType<[VariantType<{
+            /** Integer array state (permutations, assignments) */
+            int_array: ArrayType<IntegerType>;
+            /** Boolean array state (subset selection) */
+            bool_array: ArrayType<BooleanType>;
+        }>], FloatType>;
+        /** Move function type */
+        readonly MoveFunctionType: FunctionType<[VariantType<{
+            /** Integer array state (permutations, assignments) */
+            int_array: ArrayType<IntegerType>;
+            /** Boolean array state (subset selection) */
+            bool_array: ArrayType<BooleanType>;
+        }>], VariantType<{
+            /** Integer array state (permutations, assignments) */
+            int_array: ArrayType<IntegerType>;
+            /** Boolean array state (subset selection) */
+            bool_array: ArrayType<BooleanType>;
+        }>>;
+        /** Permutation energy function type */
+        readonly PermutationEnergyType: FunctionType<[ArrayType<IntegerType>], FloatType>;
+        /** Subset energy function type */
+        readonly SubsetEnergyType: FunctionType<[ArrayType<BooleanType>], FloatType>;
+        /** Configuration type */
+        readonly ConfigType: StructType<{
+            /** Starting temperature (default: 25000.0) */
+            t_max: OptionType<FloatType>;
+            /** Ending temperature (default: 2.5) */
+            t_min: OptionType<FloatType>;
+            /** Total iterations (default: 50000) */
+            steps: OptionType<IntegerType>;
+            /** Progress report frequency (default: 0 = silent) */
+            updates: OptionType<IntegerType>;
+            /** Minutes for auto-calibration (default: none) */
+            auto_schedule: OptionType<FloatType>;
+            /** Random seed for reproducibility */
+            random_state: OptionType<IntegerType>;
+        }>;
+        /** Result type */
+        readonly ResultType: StructType<{
+            /** Best state found */
+            best_state: VariantType<{
+                /** Integer array state (permutations, assignments) */
+                int_array: ArrayType<IntegerType>;
+                /** Boolean array state (subset selection) */
+                bool_array: ArrayType<BooleanType>;
+            }>;
+            /** Energy of best state */
+            best_energy: FloatType;
+            /** Actual iterations performed */
+            steps_taken: IntegerType;
+            /** Whether optimization completed successfully */
+            success: BooleanType;
+        }>;
+    };
+};
+//# sourceMappingURL=simanneal.d.ts.map

package/dist/simanneal/simanneal.d.ts.map

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