Лабораторная 3 / Вариант_Распределение Пуассона / Lab3

import math
import matplotlib.pyplot as plt
import numpy as np


class QCG:
    def __init__(self, k1, k2, a0, a1, m, c):
        self.k1 = k1
        self.k2 = k2
        self.Aprev = a0
        self.Ai = a1
        self.m = m
        self.c = c

    def next(self):
        t = self.Ai
        self.Ai = (self.k2 * t * t + self.k2 * self.Aprev + self.c) % self.m
        self.Aprev = t
        return self.Ai / self.m

    def check_first_repeat(self):
        seen = {self.Aprev: 0, self.Ai: 1}
        x = self.next()
        period = 2
        while x not in seen:
            seen[x] = period
            x = self.next()
            period += 1
        return period


r = QCG(4782, 3, 31, 67, 2**16, 2**11+1)
N = 10000
X = []

# Exponential
print("Exponential")
lambda_exp = 5
X.clear()
for i in range(N):
    z = r.next()
    X.append(-1 / lambda_exp * math.log(z))

M_expected = 1 / lambda_exp
D_expected = 1 / (lambda_exp ** 2)
M = sum(X) / N
D = sum([x ** 2 for x in X]) / N - M ** 2
M_delta = abs((M - M_expected) / M_expected) * 100
D_delta = abs((D - D_expected) / D_expected) * 100
print(f"Эмпирические: {M = :.3f}, {D = :.3f}")
print(f"Теоретические: M = {M_expected:.3f}, D = {D_expected:.3f}")
print(f"Относительные погрешности: δM = {M_delta:.2f} %, δD = {D_delta:.2f} %")

plt.hist(X, bins=30, weights=np.ones_like(X) / len(X))
plt.savefig("ms3.exponential.svg")
plt.show()


# Uniform
print("Uniform")
r = QCG(4782, 3, 31, 67, 2**16, 2**11+1)
A_uni = 5
B_uni = 10
X.clear()
for i in range(N):
    z = r.next()
    X.append(A_uni + (B_uni - A_uni) * z)

M_expected = A_uni + (B_uni - A_uni) / 2
D_expected = (B_uni - A_uni) ** 2 / 12
M = sum(X) / N
D = sum([x ** 2 for x in X]) / N - M ** 2
M_delta = abs((M - M_expected) / M_expected) * 100
D_delta = abs((D - D_expected) / D_expected) * 100
print(f"Эмпирические: {M = :.3f}, {D = :.3f}")
print(f"Теоретические: M = {M_expected:.3f}, D = {D_expected:.3f}")
print(f"Относительные погрешности: δM = {M_delta:.2f} %, δD = {D_delta:.2f} %")

plt.hist(X, bins=B_uni*8, weights=np.ones_like(X) / len(X))
plt.savefig("ms3.uniform.svg")
plt.show()


# Erlang
print("Erlang")
r = QCG(4782, 3, 31, 67, 2**16, 2**11+1)
k_erl = 3
lambda_erl = 1
X.clear()
for i in range(N):
    X.append(-1 / lambda_erl * math.log(math.prod(r.next()
                                                  for j in range(k_erl))))

M_expected = k_erl / lambda_erl
D_expected = k_erl / (lambda_erl ** 2)
M = sum(X) / N
D = sum([x ** 2 for x in X]) / N - M ** 2
M_delta = abs((M - M_expected) / M_expected) * 100
D_delta = abs((D - D_expected) / D_expected) * 100
print(f"Эмпирические: {M = :.3f}, {D = :.3f}")
print(f"Теоретические: M = {M_expected:.3f}, D = {D_expected:.3f}")
print(f"Относительные погрешности: δM = {M_delta:.2f} %, δD = {D_delta:.2f} %")

plt.hist(X, bins=30, weights=np.ones_like(X) / len(X))
plt.savefig("ms3.erlang.svg")
plt.show()


# Standard Normal
print("Standard Normal")
r = QCG(4782, 3, 31, 67, 2**16, 2**11+1)
X.clear()
for i in range(N // 2):
    z1 = r.next()
    z2 = r.next()
    X.append(math.sqrt(-2 * math.log(z1)) * math.cos(2 * math.pi * z2))
    X.append(math.sqrt(-2 * math.log(z1)) * math.sin(2 * math.pi * z2))

M_expected = 0
D_expected = 1
M = sum(X) / N
D = sum([x ** 2 for x in X]) / N - M ** 2
D_delta = abs((D - D_expected) / D_expected) * 100
print(f"Эмпирические: {M = :.3f}, {D = :.3f}")
print(f"Теоретические: M = {M_expected:.3f}, D = {D_expected:.3f}")
print(f"Относительные погрешности: δD = {D_delta:.2f} %")

plt.hist(X, bins=40, weights=np.ones_like(X) / len(X))
plt.savefig("ms3.normal.svg")
plt.show()


# Poisson
r = QCG(4782, 3, 31, 67, 2**16, 2**11+1)


def poisson_knuth_method(lmbda: float) -> int:
    if lmbda <= 0:
        raise ValueError("lambda должно быть > 0")

    L = math.exp(-lmbda)
    k = 0
    p = 1.0

    while p > L:
        k += 1
        p *= r.next()

    return k - 1


N = 100000
lambda_ = 3
X = [poisson_knuth_method(lambda_) for _ in range(N)]


M_expected = lambda_
D_expected = lambda_
M = sum(X) / N
D = sum([x ** 2 for x in X]) / N - M ** 2
D_delta = abs((D - D_expected) / D_expected) * 100
print(f"Эмпирические: {M = :.3f}, {D = :.3f}")
print(f"Теоретические: M = {M_expected:.3f}, D = {D_expected:.3f}")
print(f"Относительные погрешности: δD = {D_delta:.2f} %")

plt.hist(X, bins=max(X)*2, weights=np.ones_like(X) / len(X))
plt.savefig("ms3.Poisson.svg")
plt.show()