solver-core-compute/dist/index.js

Shared solver library for floorplan optimization - compatible with Node.js and Deno

/**
 * Solver Core Library
 * Shared between Node.js and Deno runtimes
 *
 * This is the main entry point that exports all solvers and utilities.
 */
// Types
export * from './types/index.js';
// IO Contract
export * from './io-contract.js';
// Constraint evaluation
export { evaluateConstraints, calculateCost } from './constraint-evaluator.js';
// Algorithms
import { createSimulatedAnnealingSolver } from './algorithms/simulated-annealing.js';
import { createLocalSearchSolver } from './algorithms/local-search.js';
import { createGeneticAlgorithmSolver } from './algorithms/genetic-algorithm.js';
export { SimulatedAnnealingSolver, createSimulatedAnnealingSolver } from './algorithms/simulated-annealing.js';
export { LocalSearchSolver, createLocalSearchSolver } from './algorithms/local-search.js';
export { GeneticAlgorithmSolver, createGeneticAlgorithmSolver } from './algorithms/genetic-algorithm.js';
// Main solver factory
export class ComputeSolver {
    saSolver;
    lsSolver;
    gaSolver;
    constructor() {
        this.saSolver = createSimulatedAnnealingSolver();
        this.lsSolver = createLocalSearchSolver();
        this.gaSolver = createGeneticAlgorithmSolver();
    }
    /**
     * Solve with full optimization pipeline
     */
    async solve(params) {
        const startTime = Date.now();
        const result = this.lsSolver.solve(params.positions, params.constraints, undefined, params.timeLimit);
        const executionTime = Date.now() - startTime;
        // Count actual violations from constraint evaluation
        const { evaluateConstraints } = await import('./constraint-evaluator.js');
        const constraintResult = evaluateConstraints(result.positions, params.constraints);
        return {
            positions: result.positions,
            score: 100 - result.cost,
            violations: constraintResult.violations.length,
            executionTime,
            algorithm: result.algorithm,
            metadata: result.metrics
        };
    }
    /**
     * Solve with simulated annealing
     */
    async solveSimulatedAnnealing(positions, constraints, config) {
        const result = this.saSolver.solve(positions, constraints);
        // Count actual violations from constraint evaluation
        const { evaluateConstraints } = await import('./constraint-evaluator.js');
        const constraintResult = evaluateConstraints(result.positions, constraints);
        return {
            positions: result.positions,
            score: 100 - result.cost,
            violations: constraintResult.violations.length,
            algorithm: result.algorithm,
            iteration: result.iteration
        };
    }
    /**
     * Solve with genetic algorithm
     */
    async solveGenetic(positions, constraints, config) {
        const result = this.gaSolver.solve(positions, constraints);
        // Count actual violations from constraint evaluation
        const { evaluateConstraints } = await import('./constraint-evaluator.js');
        const constraintResult = evaluateConstraints(result.positions, constraints);
        return {
            positions: result.positions,
            score: 100 - result.fitness,
            violations: constraintResult.violations.length,
            algorithm: result.algorithm,
            generation: result.generation
        };
    }
    /**
     * Solve with local search
     */
    async solveLocalSearch(positions, constraints, config) {
        const result = this.lsSolver.solve(positions, constraints);
        // Count actual violations from constraint evaluation
        const { evaluateConstraints } = await import('./constraint-evaluator.js');
        const constraintResult = evaluateConstraints(result.positions, constraints);
        return {
            positions: result.positions,
            score: 100 - result.cost,
            violations: constraintResult.violations.length,
            algorithm: result.algorithm,
            iterations: result.iterations
        };
    }
    /**
     * Get comprehensive performance stats
     */
    getStats() {
        return {
            algorithms: {
                simulatedAnnealing: 'Available',
                geneticAlgorithm: 'Available',
                localSearch: 'Available'
            },
            features: {
                multiObjective: true,
                parallelProcessing: false
            }
        };
    }
}
export function createComputeSolver() {
    return new ComputeSolver();
}