solver-core-compute/src/types/index.ts

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

/**
 * Type Definitions for Solver Core
 * Shared between Node.js and Deno runtimes
 */

// ===== CORE TYPES =====

export interface Position {
  id?: string;
  x: number;
  y: number;
  width: number;
  height: number;
  rotation?: number;
}

export interface Constraint {
  type: 'overlap' | 'boundary' | 'aspect_ratio' | 'proximity' | 'alignment' | 'min_width' | 'min_height' | 'min_clearance' | 'work_triangle';
  params: any;
  id?: string;
  weight?: number;
}

export interface ConstraintResult {
  satisfied: boolean;
  violations: Array<{
    constraint: Constraint;
    positions: [Position, Position] | Position[];
    penalty: number;
  }>;
}

// ===== SOLVER TYPES =====

export interface SolveParams {
  positions: Position[];
  constraints: Constraint[];
  timeLimit?: number;
  useParallel?: boolean;
  useMultiObjective?: boolean;
}

// Note: Solution type is exported from io-contract.ts

export interface SolveStrategy {
  name: string;
  timeLimit?: number;
  maxIterations?: number;
}

// ===== ALGORITHM TYPES =====

// Simulated Annealing
export interface SAConfig {
  initialTemperature: number;
  finalTemperature: number;
  coolingRate: number;
  maxIterations: number;
  perturbation: number;
  minImprovement: number;
}

export interface SABestSolution {
  positions: Position[];
  cost: number;
  iteration: number;
  algorithm: string;
}

// Genetic Algorithm
export interface GAConfig {
  populationSize: number;
  maxGenerations: number;
  mutationRate: number;
  crossoverRate: number;
  eliteSize: number;
  tournamentSize: number;
  elitism: boolean;
}

export interface GAIndividual {
  chromosome: Position[];
  fitness: number;
  age: number;
}

export interface GASolution {
  positions: Position[];
  fitness: number;
  generation: number;
  algorithm: string;
  metrics: {
    populationSize: number;
    averageFitness: number;
    diversity: number;
  };
}

// Local Search
export interface LSConfig {
  maxIterations: number;
  stepSize: number;
  perturbation: number;
  neighborsPerIteration: number;
  restartLimit: number;
  tabuListSize?: number;
}

export interface LSNeighbor {
  positions: Position[];
  cost: number;
  moveType: string;
}

export interface LSSolution {
  positions: Position[];
  cost: number;
  iterations: number;
  algorithm: string;
  metrics: {
    improvements: number;
    restarts: number;
    neighborhoodEvaluations: number;
  };
}

// Pareto Front / Multi-Objective
export interface Objective {
  name: string;
  type: 'minimize' | 'maximize';
  weight: number;
  evaluator: (solution: Position[]) => number;
}

export interface MultiObjectiveSolution {
  positions: Position[];
  objectiveValues: number[];
  isDominated: boolean;
}

// Optimization
export interface PrunedSearchSpace {
  domains: Map<number, PositionDomain>;
  reducedConstraints: Constraint[];
}

export interface PositionDomain {
  minX: number;
  maxX: number;
  minY: number;
  maxY: number;
}

export interface AdaptiveResolutionConfig {
  initialGridSize: number;
  maxGridSize: number;
  refinementThreshold: number;
}

export interface GridCell {
  x: number;
  y: number;
  size: number;
  occupied: boolean;
}