solver-core-compute/src/index.ts

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 {
  SimulatedAnnealingSolver,
  createSimulatedAnnealingSolver
} from './algorithms/simulated-annealing.js';

import {
  LocalSearchSolver,
  createLocalSearchSolver
} from './algorithms/local-search.js';

import {
  GeneticAlgorithmSolver,
  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 {
  private saSolver: SimulatedAnnealingSolver;
  private lsSolver: LocalSearchSolver;
  private gaSolver: GeneticAlgorithmSolver;

  constructor() {
    this.saSolver = createSimulatedAnnealingSolver();
    this.lsSolver = createLocalSearchSolver();
    this.gaSolver = createGeneticAlgorithmSolver();
  }

  /**
   * Solve with full optimization pipeline
   */
  public async solve(params: {
    positions: import('./types/index.js').Position[];
    constraints: import('./types/index.js').Constraint[];
    timeLimit?: number;
    useParallel?: boolean;
    useMultiObjective?: boolean;
  }) {
    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
   */
  public async solveSimulatedAnnealing(
    positions: import('./types/index.js').Position[],
    constraints: import('./types/index.js').Constraint[],
    config?: Partial<import('./types/index.js').SAConfig>
  ) {
    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
   */
  public async solveGenetic(
    positions: import('./types/index.js').Position[],
    constraints: import('./types/index.js').Constraint[],
    config?: Partial<import('./types/index.js').GAConfig>
  ) {
    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
   */
  public async solveLocalSearch(
    positions: import('./types/index.js').Position[],
    constraints: import('./types/index.js').Constraint[],
    config?: Partial<import('./types/index.js').LSConfig>
  ) {
    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
   */
  public getStats() {
    return {
      algorithms: {
        simulatedAnnealing: 'Available',
        geneticAlgorithm: 'Available',
        localSearch: 'Available'
      },
      features: {
        multiObjective: true,
        parallelProcessing: false
      }
    };
  }
}

export function createComputeSolver(): ComputeSolver {
  return new ComputeSolver();
}