cs-element/dist/types/graph-interfaces.d.ts

Advanced reactive data management library with state machines, blueprints, persistence, compression, networking, and multithreading support

/**
 * Интерфейсы для системы алгоритмов работы с графами
 */
import { CSElement } from '../core/CSElement';
export type NodeId = string;
export type EdgeWeight = number;
export type GraphPath = NodeId[];
export type GraphCycle = NodeId[];
export type ConnectedComponent = NodeId[];
export type PathFindingAlgorithm = 'bfs' | 'dfs' | 'dijkstra' | 'astar';
export type CycleDetectionAlgorithm = 'dfs' | 'tarjan';
export type ComponentAnalysisAlgorithm = 'dfs' | 'bfs' | 'tarjan' | 'kosaraju';
export interface GraphAnalysisOptions {
    /** Максимальная глубина поиска */
    maxDepth?: number;
    /** Учитывать направление связей */
    directed?: boolean;
    /** Включать веса рёбер */
    weighted?: boolean;
    /** Функция для получения веса ребра */
    getEdgeWeight?: (from: CSElement, to: CSElement) => number;
    /** Фильтр для узлов */
    nodeFilter?: (node: CSElement) => boolean;
    /** Фильтр для рёбер */
    edgeFilter?: (from: CSElement, to: CSElement) => boolean;
    /** Максимальное время выполнения (мс) */
    timeout?: number;
}
export interface PathFindingOptions extends GraphAnalysisOptions {
    /** Алгоритм поиска пути */
    algorithm?: PathFindingAlgorithm;
    /** Эвристическая функция для A* */
    heuristic?: (from: CSElement, to: CSElement) => number;
    /** Максимальная длина пути */
    maxPathLength?: number;
}
export interface CycleDetectionOptions extends GraphAnalysisOptions {
    /** Алгоритм обнаружения циклов */
    algorithm?: CycleDetectionAlgorithm;
    /** Найти все циклы или только первый */
    findAll?: boolean;
    /** Минимальная длина цикла */
    minCycleLength?: number;
}
export interface ComponentAnalysisOptions extends GraphAnalysisOptions {
    /** Алгоритм анализа компонент */
    algorithm?: ComponentAnalysisAlgorithm;
    /** Анализировать сильно связанные компоненты */
    stronglyConnected?: boolean;
    /** Минимальный размер компоненты */
    minComponentSize?: number;
}
export interface PathResult {
    /** Найденный путь */
    path: GraphPath;
    /** Общая стоимость пути */
    cost: number;
    /** Количество шагов */
    steps: number;
    /** Время выполнения (мс) */
    executionTime: number;
    /** Алгоритм, использованный для поиска */
    algorithm: PathFindingAlgorithm;
    /** Дополнительная информация */
    metadata: {
        visitedNodes: number;
        exploredEdges: number;
        isOptimal: boolean;
    };
}
export interface CycleResult {
    /** Найденные циклы */
    cycles: GraphCycle[];
    /** Общее количество циклов */
    totalCycles: number;
    /** Время выполнения (мс) */
    executionTime: number;
    /** Алгоритм, использованный для поиска */
    algorithm: CycleDetectionAlgorithm;
    /** Дополнительная информация */
    metadata: {
        visitedNodes: number;
        maxCycleLength: number;
        minCycleLength: number;
        hasSelfLoops: boolean;
    };
}
export interface ComponentResult {
    /** Найденные компоненты связности */
    components: ConnectedComponent[];
    /** Общее количество компонент */
    totalComponents: number;
    /** Время выполнения (мс) */
    executionTime: number;
    /** Алгоритм, использованный для анализа */
    algorithm: ComponentAnalysisAlgorithm;
    /** Дополнительная информация */
    metadata: {
        largestComponentSize: number;
        smallestComponentSize: number;
        averageComponentSize: number;
        isolatedNodes: number;
    };
}
export interface GraphAnalysisResult {
    /** Результаты поиска путей */
    paths?: PathResult[];
    /** Результаты обнаружения циклов */
    cycles?: CycleResult;
    /** Результаты анализа компонент связности */
    components?: ComponentResult;
    /** Общая статистика графа */
    graphStats: GraphStatistics;
}
export interface GraphStatistics {
    /** Общее количество узлов */
    nodeCount: number;
    /** Общее количество рёбер */
    edgeCount: number;
    /** Максимальная глубина */
    maxDepth: number;
    /** Средняя степень узла */
    averageDegree: number;
    /** Плотность графа */
    density: number;
    /** Является ли граф связным */
    isConnected: boolean;
    /** Является ли граф ациклическим */
    isAcyclic: boolean;
    /** Является ли граф деревом */
    isTree: boolean;
    /** Диаметр графа */
    diameter: number;
}
export interface GraphRepresentation {
    /** Список смежности */
    adjacencyList: Map<NodeId, Set<NodeId>>;
    /** Матрица смежности */
    adjacencyMatrix?: number[][];
    /** Список рёбер */
    edgeList: Array<{
        from: NodeId;
        to: NodeId;
        weight?: number;
    }>;
    /** Узлы графа */
    nodes: Map<NodeId, CSElement>;
    /** Является ли граф направленным */
    directed: boolean;
    /** Является ли граф взвешенным */
    weighted: boolean;
}
export interface GraphAlgorithmsManager {
    findPath(from: CSElement, to: CSElement, options?: PathFindingOptions): Promise<PathResult | null>;
    findShortestPath(from: CSElement, to: CSElement, options?: PathFindingOptions): Promise<PathResult | null>;
    findAllPaths(from: CSElement, to: CSElement, options?: PathFindingOptions): Promise<PathResult[]>;
    detectCycles(root: CSElement, options?: CycleDetectionOptions): Promise<CycleResult>;
    hasCycle(root: CSElement, options?: CycleDetectionOptions): Promise<boolean>;
    findCycle(root: CSElement, options?: CycleDetectionOptions): Promise<GraphCycle | null>;
    findConnectedComponents(root: CSElement, options?: ComponentAnalysisOptions): Promise<ComponentResult>;
    findStronglyConnectedComponents(root: CSElement, options?: ComponentAnalysisOptions): Promise<ComponentResult>;
    isConnected(root: CSElement, options?: GraphAnalysisOptions): Promise<boolean>;
    buildGraph(root: CSElement, options?: GraphAnalysisOptions): Promise<GraphRepresentation>;
    analyzeGraph(root: CSElement, options?: GraphAnalysisOptions): Promise<GraphAnalysisResult>;
    getGraphStatistics(root: CSElement, options?: GraphAnalysisOptions): Promise<GraphStatistics>;
    getDistance(from: CSElement, to: CSElement, options?: GraphAnalysisOptions): Promise<number>;
    getNeighbors(node: CSElement, options?: GraphAnalysisOptions): CSElement[];
    getDegree(node: CSElement, options?: GraphAnalysisOptions): number;
    topologicalSort(root: CSElement, options?: GraphAnalysisOptions): Promise<NodeId[]>;
    minimumSpanningTree(root: CSElement, options?: GraphAnalysisOptions): Promise<GraphRepresentation>;
    calculateCentrality(root: CSElement, options?: GraphAnalysisOptions): Promise<Map<NodeId, number>>;
    getMetrics(): AlgorithmMetrics;
    clearCache(): void;
    configure(config: Partial<GraphAlgorithmsConfig>): void;
    on(event: string, callback: (...args: any[]) => void): void;
    off(event: string, callback: (...args: any[]) => void): void;
}
export interface GraphAlgorithmEvent {
    type: 'algorithm-start' | 'algorithm-progress' | 'algorithm-complete' | 'algorithm-error';
    algorithm: string;
    nodeId?: NodeId;
    progress?: number;
    result?: any;
    error?: Error;
    timestamp: number;
}
export type GraphAlgorithmEventCallback = (event: GraphAlgorithmEvent) => void;
export interface GraphAlgorithmsConfig {
    /** Максимальное время выполнения по умолчанию (мс) */
    defaultTimeout: number;
    /** Максимальная глубина по умолчанию */
    defaultMaxDepth: number;
    /** Включить кэширование результатов */
    enableCaching: boolean;
    /** Размер кэша */
    cacheSize: number;
    /** Включить события */
    enableEvents: boolean;
    /** Включить отладочную информацию */
    enableDebug: boolean;
}
export interface AlgorithmCache {
    /** Кэш результатов поиска путей */
    paths: Map<string, PathResult>;
    /** Кэш результатов обнаружения циклов */
    cycles: Map<string, CycleResult>;
    /** Кэш результатов анализа компонент */
    components: Map<string, ComponentResult>;
    /** Кэш статистики графов */
    statistics: Map<string, GraphStatistics>;
    /** Время жизни кэша (мс) */
    ttl: number;
}
export interface AlgorithmMetrics {
    /** Общее количество выполненных алгоритмов */
    totalExecutions: number;
    /** Среднее время выполнения по алгоритмам */
    averageExecutionTime: Map<string, number>;
    /** Количество попаданий в кэш */
    cacheHits: number;
    /** Количество промахов кэша */
    cacheMisses: number;
    /** Использование памяти */
    memoryUsage: number;
    /** Последнее время выполнения */
    lastExecutionTime: number;
}
export { GraphAlgorithmsManager as default };
//# sourceMappingURL=graph-interfaces.d.ts.map