@elaraai/east-py-datascience 1.0.0 → 1.0.1

package/dist/src/simanneal/simanneal.d.ts

@@ -1,628 +0,0 @@
-/**
- * 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, IntegerType, FloatType, BooleanType, FunctionType, VectorType } 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) */
-    readonly int_array: VectorType<IntegerType>;
-    /** Boolean array state (subset selection) */
-    readonly bool_array: VectorType<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) */
-    readonly int_array: VectorType<IntegerType>;
-    /** Boolean array state (subset selection) */
-    readonly bool_array: VectorType<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) */
-    readonly int_array: VectorType<IntegerType>;
-    /** Boolean array state (subset selection) */
-    readonly bool_array: VectorType<BooleanType>;
-}>], VariantType<{
-    /** Integer array state (permutations, assignments) */
-    readonly int_array: VectorType<IntegerType>;
-    /** Boolean array state (subset selection) */
-    readonly bool_array: VectorType<BooleanType>;
-}>>;
-/**
- * Permutation energy function type.
- *
- * Specialized for permutation-based optimization.
- */
-export declare const PermutationEnergyType: FunctionType<[VectorType<IntegerType>], FloatType>;
-/**
- * Subset energy function type.
- *
- * Specialized for subset selection optimization.
- */
-export declare const SubsetEnergyType: FunctionType<[VectorType<BooleanType>], FloatType>;
-/**
- * Simulated annealing configuration.
- */
-export declare const AnnealConfigType: StructType<{
-    /** Starting temperature (default: 25000.0) */
-    readonly t_max: OptionType<FloatType>;
-    /** Ending temperature (default: 2.5) */
-    readonly t_min: OptionType<FloatType>;
-    /** Total iterations (default: 50000) */
-    readonly steps: OptionType<IntegerType>;
-    /** Progress report frequency (default: 0 = silent) */
-    readonly updates: OptionType<IntegerType>;
-    /** Minutes for auto-calibration (default: none) */
-    readonly auto_schedule: OptionType<FloatType>;
-    /** Random seed for reproducibility */
-    readonly random_state: OptionType<IntegerType>;
-}>;
-/**
- * Simulated annealing result.
- */
-export declare const AnnealResultType: StructType<{
-    /** Best state found */
-    readonly best_state: VariantType<{
-        /** Integer array state (permutations, assignments) */
-        readonly int_array: VectorType<IntegerType>;
-        /** Boolean array state (subset selection) */
-        readonly bool_array: VectorType<BooleanType>;
-    }>;
-    /** Energy of best state */
-    readonly best_energy: FloatType;
-    /** Actual iterations performed */
-    readonly steps_taken: IntegerType;
-    /** Whether optimization completed successfully */
-    readonly 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) */
-    readonly int_array: VectorType<IntegerType>;
-    /** Boolean array state (subset selection) */
-    readonly bool_array: VectorType<BooleanType>;
-}>, FunctionType<[VariantType<{
-    /** Integer array state (permutations, assignments) */
-    readonly int_array: VectorType<IntegerType>;
-    /** Boolean array state (subset selection) */
-    readonly bool_array: VectorType<BooleanType>;
-}>], FloatType>, FunctionType<[VariantType<{
-    /** Integer array state (permutations, assignments) */
-    readonly int_array: VectorType<IntegerType>;
-    /** Boolean array state (subset selection) */
-    readonly bool_array: VectorType<BooleanType>;
-}>], VariantType<{
-    /** Integer array state (permutations, assignments) */
-    readonly int_array: VectorType<IntegerType>;
-    /** Boolean array state (subset selection) */
-    readonly bool_array: VectorType<BooleanType>;
-}>>, StructType<{
-    /** Starting temperature (default: 25000.0) */
-    readonly t_max: OptionType<FloatType>;
-    /** Ending temperature (default: 2.5) */
-    readonly t_min: OptionType<FloatType>;
-    /** Total iterations (default: 50000) */
-    readonly steps: OptionType<IntegerType>;
-    /** Progress report frequency (default: 0 = silent) */
-    readonly updates: OptionType<IntegerType>;
-    /** Minutes for auto-calibration (default: none) */
-    readonly auto_schedule: OptionType<FloatType>;
-    /** Random seed for reproducibility */
-    readonly random_state: OptionType<IntegerType>;
-}>], StructType<{
-    /** Best state found */
-    readonly best_state: VariantType<{
-        /** Integer array state (permutations, assignments) */
-        readonly int_array: VectorType<IntegerType>;
-        /** Boolean array state (subset selection) */
-        readonly bool_array: VectorType<BooleanType>;
-    }>;
-    /** Energy of best state */
-    readonly best_energy: FloatType;
-    /** Actual iterations performed */
-    readonly steps_taken: IntegerType;
-    /** Whether optimization completed successfully */
-    readonly 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<[VectorType<IntegerType>, FunctionType<[VectorType<IntegerType>], FloatType>, StructType<{
-    /** Starting temperature (default: 25000.0) */
-    readonly t_max: OptionType<FloatType>;
-    /** Ending temperature (default: 2.5) */
-    readonly t_min: OptionType<FloatType>;
-    /** Total iterations (default: 50000) */
-    readonly steps: OptionType<IntegerType>;
-    /** Progress report frequency (default: 0 = silent) */
-    readonly updates: OptionType<IntegerType>;
-    /** Minutes for auto-calibration (default: none) */
-    readonly auto_schedule: OptionType<FloatType>;
-    /** Random seed for reproducibility */
-    readonly random_state: OptionType<IntegerType>;
-}>], StructType<{
-    /** Best state found */
-    readonly best_state: VariantType<{
-        /** Integer array state (permutations, assignments) */
-        readonly int_array: VectorType<IntegerType>;
-        /** Boolean array state (subset selection) */
-        readonly bool_array: VectorType<BooleanType>;
-    }>;
-    /** Energy of best state */
-    readonly best_energy: FloatType;
-    /** Actual iterations performed */
-    readonly steps_taken: IntegerType;
-    /** Whether optimization completed successfully */
-    readonly 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<[VectorType<BooleanType>, FunctionType<[VectorType<BooleanType>], FloatType>, StructType<{
-    /** Starting temperature (default: 25000.0) */
-    readonly t_max: OptionType<FloatType>;
-    /** Ending temperature (default: 2.5) */
-    readonly t_min: OptionType<FloatType>;
-    /** Total iterations (default: 50000) */
-    readonly steps: OptionType<IntegerType>;
-    /** Progress report frequency (default: 0 = silent) */
-    readonly updates: OptionType<IntegerType>;
-    /** Minutes for auto-calibration (default: none) */
-    readonly auto_schedule: OptionType<FloatType>;
-    /** Random seed for reproducibility */
-    readonly random_state: OptionType<IntegerType>;
-}>], StructType<{
-    /** Best state found */
-    readonly best_state: VariantType<{
-        /** Integer array state (permutations, assignments) */
-        readonly int_array: VectorType<IntegerType>;
-        /** Boolean array state (subset selection) */
-        readonly bool_array: VectorType<BooleanType>;
-    }>;
-    /** Energy of best state */
-    readonly best_energy: FloatType;
-    /** Actual iterations performed */
-    readonly steps_taken: IntegerType;
-    /** Whether optimization completed successfully */
-    readonly success: BooleanType;
-}>>;
-/**
- * Type definitions for Simulated Annealing.
- */
-export declare const SimAnnealTypes: {
-    /** Discrete state type */
-    readonly DiscreteStateType: VariantType<{
-        /** Integer array state (permutations, assignments) */
-        readonly int_array: VectorType<IntegerType>;
-        /** Boolean array state (subset selection) */
-        readonly bool_array: VectorType<BooleanType>;
-    }>;
-    /** Energy function type */
-    readonly EnergyFunctionType: FunctionType<[VariantType<{
-        /** Integer array state (permutations, assignments) */
-        readonly int_array: VectorType<IntegerType>;
-        /** Boolean array state (subset selection) */
-        readonly bool_array: VectorType<BooleanType>;
-    }>], FloatType>;
-    /** Move function type */
-    readonly MoveFunctionType: FunctionType<[VariantType<{
-        /** Integer array state (permutations, assignments) */
-        readonly int_array: VectorType<IntegerType>;
-        /** Boolean array state (subset selection) */
-        readonly bool_array: VectorType<BooleanType>;
-    }>], VariantType<{
-        /** Integer array state (permutations, assignments) */
-        readonly int_array: VectorType<IntegerType>;
-        /** Boolean array state (subset selection) */
-        readonly bool_array: VectorType<BooleanType>;
-    }>>;
-    /** Permutation energy function type */
-    readonly PermutationEnergyType: FunctionType<[VectorType<IntegerType>], FloatType>;
-    /** Subset energy function type */
-    readonly SubsetEnergyType: FunctionType<[VectorType<BooleanType>], FloatType>;
-    /** Configuration type */
-    readonly ConfigType: StructType<{
-        /** Starting temperature (default: 25000.0) */
-        readonly t_max: OptionType<FloatType>;
-        /** Ending temperature (default: 2.5) */
-        readonly t_min: OptionType<FloatType>;
-        /** Total iterations (default: 50000) */
-        readonly steps: OptionType<IntegerType>;
-        /** Progress report frequency (default: 0 = silent) */
-        readonly updates: OptionType<IntegerType>;
-        /** Minutes for auto-calibration (default: none) */
-        readonly auto_schedule: OptionType<FloatType>;
-        /** Random seed for reproducibility */
-        readonly random_state: OptionType<IntegerType>;
-    }>;
-    /** Result type */
-    readonly ResultType: StructType<{
-        /** Best state found */
-        readonly best_state: VariantType<{
-            /** Integer array state (permutations, assignments) */
-            readonly int_array: VectorType<IntegerType>;
-            /** Boolean array state (subset selection) */
-            readonly bool_array: VectorType<BooleanType>;
-        }>;
-        /** Energy of best state */
-        readonly best_energy: FloatType;
-        /** Actual iterations performed */
-        readonly steps_taken: IntegerType;
-        /** Whether optimization completed successfully */
-        readonly 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(
- *     [VectorType(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.
-     *
-     * @example
-     * ```ts
-     * import { East, FloatType, IntegerType, VectorType, variant } from "@elaraai/east";
-     * import { SimAnneal, AnnealConfigType, DiscreteStateType } from "@elaraai/east-py-datascience";
-     *
-     * const solve = East.function([], SimAnneal.Types.ResultType, ($) => {
-     *     const energy = East.function([DiscreteStateType], FloatType, ($, state) => {
-     *         const cost = $.let(0.0);
-     *         $.match(state, {
-     *             int_array: ($, arr) => {
-     *                 const a0 = $.let(arr.get(0n));
-     *                 $.if(East.equal(a0, 2n), $ => {}).else($ => { $.assign(cost, cost.add(1.0)); });
-     *             },
-     *             bool_array: ($) => { $.assign(cost, 999.0); },
-     *         });
-     *         return $.return(cost);
-     *     });
-     *     const move = East.function([DiscreteStateType], DiscreteStateType, ($, state) => {
-     *         const result = $.let(state);
-     *         $.match(state, {
-     *             int_array: ($, arr) => {
-     *                 const new_arr = $.let(East.Vector.fromArray([arr.get(0n).add(1n).remainder(3n), arr.get(1n), arr.get(2n)]));
-     *                 $.assign(result, variant("int_array", new_arr));
-     *             },
-     *             bool_array: ($, arr) => { $.assign(result, variant("bool_array", arr)); },
-     *         });
-     *         return $.return(result);
-     *     });
-     *     const initial = $.let(variant("int_array", new BigInt64Array([0n, 0n, 0n])), DiscreteStateType);
-     *     const config = $.let({
-     *         t_max: variant("some", 100.0), t_min: variant("some", 0.01),
-     *         steps: variant("some", 1000n), updates: variant("none", null),
-     *         auto_schedule: variant("none", null), random_state: variant("some", 42n),
-     *     }, AnnealConfigType);
-     *     return $.return(SimAnneal.optimize(initial, energy, move, config));
-     * });
-     * ```
-     */
-    readonly optimize: import("@elaraai/east").PlatformDefinition<[VariantType<{
-        /** Integer array state (permutations, assignments) */
-        readonly int_array: VectorType<IntegerType>;
-        /** Boolean array state (subset selection) */
-        readonly bool_array: VectorType<BooleanType>;
-    }>, FunctionType<[VariantType<{
-        /** Integer array state (permutations, assignments) */
-        readonly int_array: VectorType<IntegerType>;
-        /** Boolean array state (subset selection) */
-        readonly bool_array: VectorType<BooleanType>;
-    }>], FloatType>, FunctionType<[VariantType<{
-        /** Integer array state (permutations, assignments) */
-        readonly int_array: VectorType<IntegerType>;
-        /** Boolean array state (subset selection) */
-        readonly bool_array: VectorType<BooleanType>;
-    }>], VariantType<{
-        /** Integer array state (permutations, assignments) */
-        readonly int_array: VectorType<IntegerType>;
-        /** Boolean array state (subset selection) */
-        readonly bool_array: VectorType<BooleanType>;
-    }>>, StructType<{
-        /** Starting temperature (default: 25000.0) */
-        readonly t_max: OptionType<FloatType>;
-        /** Ending temperature (default: 2.5) */
-        readonly t_min: OptionType<FloatType>;
-        /** Total iterations (default: 50000) */
-        readonly steps: OptionType<IntegerType>;
-        /** Progress report frequency (default: 0 = silent) */
-        readonly updates: OptionType<IntegerType>;
-        /** Minutes for auto-calibration (default: none) */
-        readonly auto_schedule: OptionType<FloatType>;
-        /** Random seed for reproducibility */
-        readonly random_state: OptionType<IntegerType>;
-    }>], StructType<{
-        /** Best state found */
-        readonly best_state: VariantType<{
-            /** Integer array state (permutations, assignments) */
-            readonly int_array: VectorType<IntegerType>;
-            /** Boolean array state (subset selection) */
-            readonly bool_array: VectorType<BooleanType>;
-        }>;
-        /** Energy of best state */
-        readonly best_energy: FloatType;
-        /** Actual iterations performed */
-        readonly steps_taken: IntegerType;
-        /** Whether optimization completed successfully */
-        readonly 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.
-     *
-     * @example
-     * ```ts
-     * import { East, FloatType, IntegerType, VectorType, variant } from "@elaraai/east";
-     * import { SimAnneal, AnnealConfigType } from "@elaraai/east-py-datascience";
-     *
-     * const solve = East.function([], SimAnneal.Types.ResultType, ($) => {
-     *     const energy = East.function([VectorType(IntegerType)], FloatType, ($, route) => {
-     *         const total = $.let(0.0);
-     *         $.for(East.Array.range(0n, route.length()), ($, i) => {
-     *             const from = $.let(route.get(i));
-     *             const to = $.let(route.get(i.add(1n).remainder(route.length())));
-     *             const diff = $.let(from.subtract(to).abs());
-     *             $.if(East.equal(diff, 1n).or(() => East.equal(diff, 3n)), $ => {
-     *                 $.assign(total, total.add(1.0));
-     *             }).else($ => { $.assign(total, total.add(1.414)); });
-     *         });
-     *         return $.return(total);
-     *     });
-     *     const initial = $.let(new BigInt64Array([0n, 1n, 2n, 3n]));
-     *     const config = $.let({
-     *         t_max: variant("some", 1000.0), t_min: variant("some", 0.1),
-     *         steps: variant("some", 5000n), updates: variant("none", null),
-     *         auto_schedule: variant("none", null), random_state: variant("some", 42n),
-     *     }, AnnealConfigType);
-     *     return $.return(SimAnneal.optimizePermutation(initial, energy, config));
-     * });
-     * ```
-     */
-    readonly optimizePermutation: import("@elaraai/east").PlatformDefinition<[VectorType<IntegerType>, FunctionType<[VectorType<IntegerType>], FloatType>, StructType<{
-        /** Starting temperature (default: 25000.0) */
-        readonly t_max: OptionType<FloatType>;
-        /** Ending temperature (default: 2.5) */
-        readonly t_min: OptionType<FloatType>;
-        /** Total iterations (default: 50000) */
-        readonly steps: OptionType<IntegerType>;
-        /** Progress report frequency (default: 0 = silent) */
-        readonly updates: OptionType<IntegerType>;
-        /** Minutes for auto-calibration (default: none) */
-        readonly auto_schedule: OptionType<FloatType>;
-        /** Random seed for reproducibility */
-        readonly random_state: OptionType<IntegerType>;
-    }>], StructType<{
-        /** Best state found */
-        readonly best_state: VariantType<{
-            /** Integer array state (permutations, assignments) */
-            readonly int_array: VectorType<IntegerType>;
-            /** Boolean array state (subset selection) */
-            readonly bool_array: VectorType<BooleanType>;
-        }>;
-        /** Energy of best state */
-        readonly best_energy: FloatType;
-        /** Actual iterations performed */
-        readonly steps_taken: IntegerType;
-        /** Whether optimization completed successfully */
-        readonly 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.
-     *
-     * @example
-     * ```ts
-     * import { East, FloatType, BooleanType, VectorType, variant } from "@elaraai/east";
-     * import { SimAnneal, AnnealConfigType } from "@elaraai/east-py-datascience";
-     *
-     * const solve = East.function([], SimAnneal.Types.ResultType, ($) => {
-     *     const items = $.let(new Float64Array([3.0, 7.0, 1.0, 8.0, 4.0]));
-     *     const target = $.let(12.0);
-     *     const energy = East.function([VectorType(BooleanType)], FloatType, ($, selection) => {
-     *         const sum = $.let(0.0);
-     *         $.for(East.Array.range(0n, selection.length()), ($, i) => {
-     *             $.if(selection.get(i), $ => { $.assign(sum, sum.add(items.get(i))); });
-     *         });
-     *         return $.return(sum.subtract(target).abs());
-     *     });
-     *     const initial = $.let(East.Vector.fromArray([true, true, true, true, true]));
-     *     const config = $.let({
-     *         t_max: variant("some", 500.0), t_min: variant("some", 0.1),
-     *         steps: variant("some", 2000n), updates: variant("none", null),
-     *         auto_schedule: variant("none", null), random_state: variant("some", 123n),
-     *     }, AnnealConfigType);
-     *     return $.return(SimAnneal.optimizeSubset(initial, energy, config));
-     * });
-     * ```
-     */
-    readonly optimizeSubset: import("@elaraai/east").PlatformDefinition<[VectorType<BooleanType>, FunctionType<[VectorType<BooleanType>], FloatType>, StructType<{
-        /** Starting temperature (default: 25000.0) */
-        readonly t_max: OptionType<FloatType>;
-        /** Ending temperature (default: 2.5) */
-        readonly t_min: OptionType<FloatType>;
-        /** Total iterations (default: 50000) */
-        readonly steps: OptionType<IntegerType>;
-        /** Progress report frequency (default: 0 = silent) */
-        readonly updates: OptionType<IntegerType>;
-        /** Minutes for auto-calibration (default: none) */
-        readonly auto_schedule: OptionType<FloatType>;
-        /** Random seed for reproducibility */
-        readonly random_state: OptionType<IntegerType>;
-    }>], StructType<{
-        /** Best state found */
-        readonly best_state: VariantType<{
-            /** Integer array state (permutations, assignments) */
-            readonly int_array: VectorType<IntegerType>;
-            /** Boolean array state (subset selection) */
-            readonly bool_array: VectorType<BooleanType>;
-        }>;
-        /** Energy of best state */
-        readonly best_energy: FloatType;
-        /** Actual iterations performed */
-        readonly steps_taken: IntegerType;
-        /** Whether optimization completed successfully */
-        readonly success: BooleanType;
-    }>>;
-    /**
-     * Type definitions for SimAnneal functions.
-     */
-    readonly Types: {
-        /** Discrete state type */
-        readonly DiscreteStateType: VariantType<{
-            /** Integer array state (permutations, assignments) */
-            readonly int_array: VectorType<IntegerType>;
-            /** Boolean array state (subset selection) */
-            readonly bool_array: VectorType<BooleanType>;
-        }>;
-        /** Energy function type */
-        readonly EnergyFunctionType: FunctionType<[VariantType<{
-            /** Integer array state (permutations, assignments) */
-            readonly int_array: VectorType<IntegerType>;
-            /** Boolean array state (subset selection) */
-            readonly bool_array: VectorType<BooleanType>;
-        }>], FloatType>;
-        /** Move function type */
-        readonly MoveFunctionType: FunctionType<[VariantType<{
-            /** Integer array state (permutations, assignments) */
-            readonly int_array: VectorType<IntegerType>;
-            /** Boolean array state (subset selection) */
-            readonly bool_array: VectorType<BooleanType>;
-        }>], VariantType<{
-            /** Integer array state (permutations, assignments) */
-            readonly int_array: VectorType<IntegerType>;
-            /** Boolean array state (subset selection) */
-            readonly bool_array: VectorType<BooleanType>;
-        }>>;
-        /** Permutation energy function type */
-        readonly PermutationEnergyType: FunctionType<[VectorType<IntegerType>], FloatType>;
-        /** Subset energy function type */
-        readonly SubsetEnergyType: FunctionType<[VectorType<BooleanType>], FloatType>;
-        /** Configuration type */
-        readonly ConfigType: StructType<{
-            /** Starting temperature (default: 25000.0) */
-            readonly t_max: OptionType<FloatType>;
-            /** Ending temperature (default: 2.5) */
-            readonly t_min: OptionType<FloatType>;
-            /** Total iterations (default: 50000) */
-            readonly steps: OptionType<IntegerType>;
-            /** Progress report frequency (default: 0 = silent) */
-            readonly updates: OptionType<IntegerType>;
-            /** Minutes for auto-calibration (default: none) */
-            readonly auto_schedule: OptionType<FloatType>;
-            /** Random seed for reproducibility */
-            readonly random_state: OptionType<IntegerType>;
-        }>;
-        /** Result type */
-        readonly ResultType: StructType<{
-            /** Best state found */
-            readonly best_state: VariantType<{
-                /** Integer array state (permutations, assignments) */
-                readonly int_array: VectorType<IntegerType>;
-                /** Boolean array state (subset selection) */
-                readonly bool_array: VectorType<BooleanType>;
-            }>;
-            /** Energy of best state */
-            readonly best_energy: FloatType;
-            /** Actual iterations performed */
-            readonly steps_taken: IntegerType;
-            /** Whether optimization completed successfully */
-            readonly success: BooleanType;
-        }>;
-    };
-};
-//# sourceMappingURL=simanneal.d.ts.map

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

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