algorithms.js

function formatSequence(sequence) {
    return sequence.map((value) => `Д${value + 1}`).join(' -> ');
}

function formatNumber(value) {
    return Number(value).toFixed(2).replace(/\.00$/, '');
}

function formatPercent(value) {
    return `${(value * 100).toFixed(1)}%`;
}

function formatSigned(value, suffix = '') {
    const sign = value > 0 ? '+' : '';
    return `${sign}${Number(value).toFixed(1).replace(/\.0$/, '')}${suffix}`;
}

function getScore(schedule, criterion) {
    if (criterion === 'waiting') {
        return schedule.totalIdle;
    }
    if (criterion === 'load') {
        return -schedule.averageLoad;
    }
    return schedule.makespan;
}

class MatrixUtils {
    static createEmptyMatrix(jobs, machines) {
        return Array.from({ length: jobs }, () => Array.from({ length: machines }, () => 0));
    }

    static randomInt(min, max) {
        return Math.floor(Math.random() * (max - min + 1)) + min;
    }
}

class ScheduleBuilder {
    static build(matrix, sequence, methodName) {
        const machines = matrix[0].length;
        const jobs = matrix.length;
        const machineEnds = Array(machines).fill(0);
        const jobEnds = Array.from({ length: jobs }, () => Array(machines).fill(0));
        const machineBusy = Array(machines).fill(0);
        const jobProcessing = Array(jobs).fill(0);
        const jobStart = Array(jobs).fill(null);
        const jobFinish = Array(jobs).fill(0);
        const operations = [];
        let totalWork = 0;

        // проходим выбранную последовательность и строим операции по всем станкам
        sequence.forEach((jobIndex) => {
            for (let machineIndex = 0; machineIndex < machines; machineIndex += 1) {
                const duration = Number(matrix[jobIndex][machineIndex]) || 0;
                const previousMachineEnd = machineIndex === 0 ? 0 : jobEnds[jobIndex][machineIndex - 1];
                const start = Math.max(machineEnds[machineIndex], previousMachineEnd);
                const end = start + duration;

                jobEnds[jobIndex][machineIndex] = end;
                machineEnds[machineIndex] = end;
                machineBusy[machineIndex] += duration;
                jobProcessing[jobIndex] += duration;
                totalWork += duration;

                if (jobStart[jobIndex] === null || start < jobStart[jobIndex]) {
                    jobStart[jobIndex] = start;
                }
                if (end > jobFinish[jobIndex]) {
                    jobFinish[jobIndex] = end;
                }

                operations.push({
                    jobIndex,
                    machineIndex,
                    duration,
                    start,
                    end
                });
            }
        });

        const makespan = Math.max(...machineEnds);
        const machineIdle = machineBusy.map((work) => Math.max(makespan - work, 0));
        const jobStartSafe = jobStart.map((value) => (value === null ? 0 : value));
        const jobFlow = jobFinish.map((finish, jobIndex) => Math.max(finish - jobStartSafe[jobIndex], 0));
        const jobWaiting = jobFlow.map((flow, jobIndex) => Math.max(flow - jobProcessing[jobIndex], 0));
        const totalIdle = machineIdle.reduce((sum, value) => sum + value, 0);

        // считаем итоговые показатели для сравнения расписаний
        return {
            methodName,
            sequence: [...sequence],
            operations,
            machineCount: machines,
            jobCount: jobs,
            makespan,
            totalIdle,
            averageLoad: makespan === 0 ? 0 : totalWork / (makespan * machines),
            machineBusy,
            machineIdle,
            jobProcessing,
            jobWaiting,
            jobStart: jobStartSafe,
            jobFinish,
            jobFlow,
            score: 0,
            rank: 0
        };
    }
}

class JohnsonScheduler {
    static getSchedules(matrix) {
        const schedules = [];

        schedules.push(
            ScheduleBuilder.build(
                matrix,
                this.sortJobs(matrix, (row) => row[0], 'asc'),
                'Обобщение Джонсона: по 1-му станку'
            )
        );

        schedules.push(
            ScheduleBuilder.build(
                matrix,
                this.sortJobs(matrix, (row) => row[row.length - 1], 'desc'),
                'Обобщение Джонсона: по последнему станку'
            )
        );

        return schedules;
    }

    // возвращаем порядок деталей по выбранному правилу Джонсона
    static sortJobs(matrix, selector, direction) {
        return matrix
            .map((row, index) => ({ index, value: selector(row, index) }))
            .sort((a, b) => {
                if (direction === 'asc') {
                    return a.value - b.value || a.index - b.index;
                }
                return b.value - a.value || a.index - b.index;
            })
            .map((item) => item.index);
    }
}

class PetrovSokolitsynScheduler {
    static getSchedules(matrix) {
        const firstSums = matrix.map((row) => row.slice(1).reduce((sum, value) => sum + Number(value || 0), 0));
        const secondSums = matrix.map((row) => row.slice(0, -1).reduce((sum, value) => sum + Number(value || 0), 0));
        const diff = firstSums.map((value, index) => value - secondSums[index]);

        return [
            ScheduleBuilder.build(matrix, this.sortByArray(firstSums, 'desc'), 'Петров-Соколицын: сумма без первого станка'),
            ScheduleBuilder.build(matrix, this.sortByArray(secondSums, 'asc'), 'Петров-Соколицын: сумма без последнего станка'),
            ScheduleBuilder.build(matrix, this.sortByArray(diff, 'desc'), 'Петров-Соколицын: по разности')
        ];
    }

    // строим последовательность по заранее посчитанному массиву значений
    static sortByArray(values, direction) {
        return values
            .map((value, index) => ({ index, value }))
            .sort((a, b) => {
                if (direction === 'asc') {
                    return a.value - b.value || a.index - b.index;
                }
                return b.value - a.value || a.index - b.index;
            })
            .map((item) => item.index);
    }
}