Моделирование (одноканальная СМО без очереди с отказами, Python)

lab1.py

#!/usr/bin/env python3


# Поток простейший. Очередь отсутствует.
data = {"lambda": 0.95, "tsred": 1, "mu": 1, "m": 0 }


def setRo(data):
    data["ro"] = data["lambda"] / data["mu"]


def setP0(data):
    ro = data["ro"]
    if ro == 1:
        result = (1 - ro) / (1 - ro ** (data["m"] + 2))
    else:
        result = 1 / (data["m"] + 2)
    data["p0"] = result


def getP(data, k):
    return k * data["p0"]

def setP(data, k):
    name = "p" + str(k)
    data[name] = getP(data, k)


def setPotkaz(data):
    data["potkaz"] = getP(data, 1)


def setQ(data):
    data["q"] = 1 - data["potkaz"]


def setPsystem(data):
    data["psystem"] = 1 - data["potkaz"]



def setA(data):
    data["A"] = data["lambda"] * data["q"]


def setNochered(data):
    m = data["m"]
    ro = data["ro"]
    p0 = data["p0"]
    if m == 1:
        chislitel =  ro * ro * (1 - (ro ** m) * (m + 1 - m * ro))
        znamenatel = (1 - ro ** (m - 2)) * (1 - ro)
        result = p0 * chislitel / znamenatel
    else:
        result = m * (m + 1) / (2 * m + 4)
    data["nochered"] = result


def setNobsl(data):
    data["nobsl"] = data["ro"] * data["q"]


def setNsystem(data):
    data["nsystem"] = data["nochered"] + data["nobsl"]


def setTochered(data):
    data["tochered"] = data["nochered"] / (data["lambda"] * data["psystem"])


def setTsystem(data):
    data["tsystem"] = data["nsystem"] / (data["lambda"] * data["psystem"])


def setAllParams(data):
    setRo(data)
    setP0(data)
    setPotkaz(data)
    setQ(data)
    setPsystem(data)
    setA(data)
    setNochered(data)
    setNobsl(data)
    setNsystem(data)
    setTochered(data)
    setTsystem(data)


def printParam(name, value):
    print("{} \t: {}".format(name, value))


def printAllParams(data):
    printParam("Коэффициент использования объекта        ", data["ro"])
    printParam("Вероятность того, что линия свободна     ", data["p0"])
    printParam("Вероятность отказа в обслуживании        ", data["potkaz"])
    printParam("Вероятность принятия заявки в систему    ", data["q"])
    printParam("Относительная пропускная способность     ", data["psystem"])
    printParam("Абсолютная пропусная способность         ", data["A"])
    printParam("Среднее число заявок в очереди           ", data["nochered"])
    printParam("Среднее число заявок в обслуживании      ", data["nobsl"])
    printParam("Среднее число заявок в СМО               ", data["nsystem"])
    printParam("Среднее время ожидания заявки в очереди  ", data["tochered"])
    printParam("Среднее время пребывания заявки в системе", data["tsystem"])

# Исполнение
setAllParams(data)
printAllParams(data)

lab2.py

#!/usr/bin/env python3


import random
from statistics import mean


# Интенсивность поступления звонков в минуту
prob = 0.95
# Среднее время обслуживания в минутах
handle_time = 1
# Величина интервала моделирования в минутах
minutes_for_model = 60 * 24 * 365  # год


# Массив со временами звонков в минутах отсчитывамых с нуля
rings = []
last_ring_time = 0.0
for minute in range(0, minutes_for_model - 1):
    rnd = random.expovariate(prob)
    if(rnd <= 0.0):
        print("rnd = ", str(rnd), " < 0")
    last_ring_time += rnd
    rings.append(last_ring_time)

rings.sort()  # Выставим звонки в порядке возрастания

handles = []
lambd = 1.0 / handle_time  # Интенсивность потока для времени разговора
for ring in rings:
    rnd = random.expovariate(lambd)
    handles.append(rnd)


reject_count = 0
for ring in range(0, len(rings) - 2):
    handle_end = rings[ring] + handles[ring]  # Время окончания обслуживания
    # Если заявка поступила во время обслуживания предыдущей
    if rings[ring + 1] < handle_end:
        reject_count += 1  # то ей отказано в обслуживании

reject_prob = reject_count / len(rings)
print("Вероятность отказа в обслуживании = " + str(reject_prob))

all_time_of_work = (rings[-1] + handles[-1])

work_percent = sum(handles) / all_time_of_work
print("Нагрузка устройства обслуживания = " + str(work_percent))

# Среднее время пребывания заявки в системе равно времени обслуживания
# (заявки начинают обслуживаться немедленно,
#  заявки недообслуживаются и очередь отсутствует)
avg_time = mean(handles)
print("Среднее время пребывания заявки в системе = {} минут".format(avg_time))

print("=================================")
print("Минимальное время отбслуживания в минутах " + str(min(handles)))
print("Максимальное время отбслуживания в минутах " + str(max(handles)))