mm1

import numpy as np

Q_LIMIT = 100  # Ограничение длины очереди
BUSY = 1       # Устройство занято
IDLE = 0       # Устройство свободно

class QueueSystem:
    def __init__(self, mean_interarrival, mean_service, time_end):
        self.mean_interarrival = mean_interarrival
        self.mean_service = mean_service
        self.time_end = time_end

        # Переменные состояния
        self.sim_time = 0.0
        self.server_status = IDLE
        self.num_in_q = 0
        self.time_last_event = 0.0
        self.num_custs_delayed = 0
        self.total_of_delays = 0.0
        self.area_num_in_q = 0.0
        self.area_server_status = 0.0
        self.time_arrival = [0.0] * (Q_LIMIT + 1)

        # Инициализация списка событий
        self.time_next_event = [1.0e+30, self.expon(self.mean_interarrival), 1.0e+30, self.time_end]

    def expon(self, mean):
        """Генерация экспоненциально распределенной случайной величины."""
        return -mean * np.log(np.random.rand())

    def timing(self):
        min_time_next_event = min(self.time_next_event)
        self.sim_time = min_time_next_event
        next_event_type = self.time_next_event.index(min_time_next_event)
        if next_event_type == 0:
            print(f"Список событий пуст в момент времени {self.sim_time}")
            exit(1)
        return next_event_type

    def update_time_avg_status(self):
        time_since_last_event = self.sim_time - self.time_last_event
        self.time_last_event = self.sim_time
        self.area_num_in_q += self.num_in_q * time_since_last_event
        self.area_server_status += self.server_status * time_since_last_event

    def arrive(self):
        self.time_next_event[1] = self.sim_time + self.expon(self.mean_interarrival)

        if self.server_status == BUSY:
            self.num_in_q += 1
            if self.num_in_q > Q_LIMIT:
                print(f"Переполнение массива time_arrival в момент времени {self.sim_time}")
                exit(2)
            self.time_arrival[self.num_in_q] = self.sim_time
        else:
            delay = 0.0
            self.total_of_delays += delay
            self.num_custs_delayed += 1
            self.server_status = BUSY
            self.time_next_event[2] = self.sim_time + self.expon(self.mean_service)

    def depart(self):
        if self.num_in_q == 0:
            self.server_status = IDLE
            self.time_next_event[2] = 1.0e+30
        else:
            self.num_in_q -= 1
            delay = self.sim_time - self.time_arrival[1]
            self.total_of_delays += delay
            self.num_custs_delayed += 1
            self.time_next_event[2] = self.sim_time + self.expon(self.mean_service)

            for i in range(1, self.num_in_q + 1):
                self.time_arrival[i] = self.time_arrival[i + 1]

    def report(self):
        print(f"\nСредняя задержка в очереди: {self.total_of_delays / self.num_custs_delayed:.3f} мин")
        print(f"Среднее число требований в очереди: {self.area_num_in_q / self.sim_time:.3f}")
        print(f"Коэффициент занятости устройства: {self.area_server_status / self.sim_time:.3f}")
        print(f"Число завершенных задержек в очереди: {self.num_custs_delayed}\n")


def main():
    mean_interarrival = float(input("Введите среднее время между прибытиями требований, мин: ")) #среднее расстояние между прибытиями
    mean_service = float(input("Введите среднее время обслуживания требования, мин: ")) #среднее обслуживание
    time_end = float(input("Введите время завершения моделирования, мин: "))

    queue_system = QueueSystem(mean_interarrival, mean_service, time_end)

    while queue_system.sim_time < time_end:
        next_event_type = queue_system.timing()
        queue_system.update_time_avg_status()

        if next_event_type == 1:
            queue_system.arrive()
        elif next_event_type == 2:
            queue_system.depart()
        elif next_event_type == 3:
            queue_system.report()
            break

if __name__ == "__main__":
    main()