@startuml
interface MinimumPriorityQueue<T> {
  +insert(id: T, priority: number): void
  +extract(): Nullable<WithPriority<T>>
}

class BinaryMinimumPriorityQueue<T> {
  -ids: T[]
  -values: number[]
  -length: number
}
BinaryMinimumPriorityQueue ..|> MinimumPriorityQueue

interface MinimumSpanningTreeCalculator{
  +calculate(adjacencyMatrix: number[][]): {\n  previous: Nullable<number>[],\n  totalCost: number\n}
}

class Prim {
}
Prim ..|> MinimumSpanningTreeCalculator
Prim ..> MinimumPriorityQueue 

interface ShortestPathCalculator {
  +calculate(\n  heightMap: HeightMap,\n  source: Position2D,\n  exploredMap: ExploredMap\n): {\n  previousMap: PreviousMap,\n  distanceMap: DistanceMap\n}
}

class UniformCostSearch {
}
UniformCostSearch ..|> ShortestPathCalculator 
UniformCostSearch ..> MinimumPriorityQueue

interface AgentState {
  +positions: Position2D[];
  +fitness: number;
}

interface Agent {
  +process(): void
}
Agent --|> AgentState

interface AgentParams { 
}

class AcoAgentParams {
  +PHEROMON_SELECTION_WEIGHT: number;
}
AcoAgentParams --|> AgentParams 

class EbaAgentParams {
  +RANDOM_WALK_STEP: number;
  +PULSE_RATE: number;
}
EbaAgentParams --|> AgentParams 

class PsoAgentParams {
  LEARNING_RATE: number;
  VELOCITY_CHANGE_VELOCITY_COEFF: number;
  VELOCITY_CHANGE_LOCAL_POSITION_COEFF: number;
  VELOCITY_CHANGE_GLOBAL_POSITION_COEFF: number;
}
PsoAgentParams --|> AgentParams 

class AfsaAgentParams {
  +MAX_PARTNER_LIMIT: number;
  +VISUAL_LIMIT: number;
  +STEP_LIMIT: number;
}
AfsaAgentParams --|> AgentParams 

abstract class BaseAgent {
  #PARAMS: AgentParams;
  #heightMap: HeightMap,
  #cities: Position2D[],
  #citiesDistanceMap: DistanceMap[],
  #citiesPreviousMap: PreviousMap[],
  #HEIGHTMAP_DIMENSION: number;
  #STEINER_COUNT: number;

  #{abstract} behave(): void
  #updateFitness(): void
  #evalFitnessFor(\n  positions: Position2D[],\n  heightMap: HeightMap,\n  cities: Position2D[],\n  citiesDistanceMap: DistanceMap[],\n  citiesPreviousMap: PreviousMap[]\n): number
}
BaseAgent ..|> Agent
BaseAgent ..> ShortestPathCalculator 
BaseAgent ..> MinimumSpanningTreeCalculator
BaseAgent ..> AgentParams

class AcoAgent {
  -PARAMS: AcoAgentParams;
  -pheromonMatrices: HeightMap[];
  +tabuPositions: Position2D[][];

  -behave(): void
  -updatePheromonLevels(): void
}
AcoAgent --|> BaseAgent
AcoAgent ..> AcoAgentParams

class EbaAgent {
  -PARAMS: EbaAgentParams;
  -globalBestAgentState: AgentState;
  -realPositions: Position2D[];

  -behave(): void
}
EbaAgent --|> BaseAgent
EbaAgent ..> EbaAgentParams
EbaAgent ..> AgentState 

class PsoAgent {
  -PARAMS: PsoAgentParams;
  -globalBestAgentState: AgentState;
  -velocity: Position2D[];
  -localBestAgentState: AgentState;

  -behave(): void
  -updateLocalBestState(): void
}
PsoAgent --|> BaseAgent
PsoAgent ..> PsoAgentParams 
PsoAgent ..> AgentState

class AfsaAgent {
  -PARAMS: AfsaAgentParams;

  -behave(): void
  -isAgentCloseEnoughToFollow(): boolean
}
AfsaAgent --|> BaseAgent
AfsaAgent ..> AfsaAgentParams 
AfsaAgent ..> AgentState

interface SimulationParams {
  +MAX_ITERATION: number;
  +CHECK_NEW_STATE_PER_ITERATION: number;
  +POPULATION_SIZE: number;
}
SimulationParams --|> AgentParams 

class AcoSimulationParams {
  +PHEROMON_EVAPORATION_RATE: number;
}
AcoSimulationParams --|> AcoAgentParams
AcoSimulationParams ..|> SimulationParams 

class AfsaSimulationParams {
}
AfsaSimulationParams --|> AfsaAgentParams
AfsaSimulationParams ..|> SimulationParams 

class EbaSimulationParams {
}
EbaSimulationParams --|> EbaAgentParams
EbaSimulationParams ..|> SimulationParams 

class PsoSimulationParams {
}
PsoSimulationParams --|> PsoAgentParams
PsoSimulationParams ..|> SimulationParams 

abstract class BaseSimulation {
  +{abstract} run(\n  PARAMS: SimulationParams,\n  heightMap: HeightMap,\n  cities: Position2D[],\n  citiesDistanceMap: DistanceMap[],\n  citiesPreviousMap: PreviousMap[],\n): Observable<AgentState>
  #updateBestAgentState(bestAgentState: AgentState, agent: Agent): void
  +getEdgesForBestAgentState(\n  bestAgentState: AgentState,\n  PARAMS: SimulationParams,\n  heightMap: HeightMap,\n  cities: Position2D[],\n  citiesDistanceMap: DistanceMap[],\n  citiesPreviousMap: PreviousMap[]\n): Edge<Position2D>[]
}
BaseSimulation ..> AgentState
BaseSimulation ..> SimulationParams
BaseSimulation ..> ShortestPathCalculator 
BaseSimulation ..> MinimumSpanningTreeCalculator
BaseSimulation ..> Agent

class AcoSimulation {
  +run(\n  PARAMS: AcoSimulationParams,\n  heightMap: HeightMap,\n  cities: Position2D[],\n  citiesDistanceMap: DistanceMap[],\n  citiesPreviousMap: PreviousMap[],\n): Observable<AgentState>
}
AcoSimulation ..|> BaseSimulation 
AcoSimulation ..> AcoSimulationParams
AcoSimulation --* AcoAgent

class AfsaSimulation {
  +run(\n  PARAMS: AfsaSimulationParams,\n  heightMap: HeightMap,\n  cities: Position2D[],\n  citiesDistanceMap: DistanceMap[],\n  citiesPreviousMap: PreviousMap[],\n): Observable<AgentState>
}
AfsaSimulation ..|> BaseSimulation 
AfsaSimulation ..> AfsaSimulationParams
AfsaSimulation --* AfsaAgent

class EbaSimulation {
  +run(\n  PARAMS: EbaSimulationParams,\n  heightMap: HeightMap,\n  cities: Position2D[],\n  citiesDistanceMap: DistanceMap[],\n  citiesPreviousMap: PreviousMap[],\n): Observable<AgentState>
}
EbaSimulation ..|> BaseSimulation 
EbaSimulation ..> EbaSimulationParams
EbaSimulation --* EbaAgent

class PsoSimulation {
  +run(\n  PARAMS: PsoSimulationParams,\n  heightMap: HeightMap,\n  cities: Position2D[],\n  citiesDistanceMap: DistanceMap[],\n  citiesPreviousMap: PreviousMap[],\n): Observable<AgentState>
}
PsoSimulation ..|> BaseSimulation 
PsoSimulation ..> PsoSimulationParams
PsoSimulation --* PsoAgent
@enduml