Вы находитесь на странице: 1из 24

МИНИСТЕРСТВО НАУКИ И ВЫСШЕГО ОБРАЗОВАНИЯ РОССИЙСКОЙ ФЕДЕРАЦИИ

Федеральное государственное автономное образовательное учреждение высшего образования


«Национальный исследовательский Нижегородский государственный университет им. Н.И.
Лобачевского» (ННГУ)

Институт информационных технологий, математики и механики

Отчет по лабораторной работе

«МОДЕЛИРОВАНИЕ СЛУЧАЙНЫХ ВЕЛИЧИН И ПРОВЕРКА ГИПОТЕЗ О ВИДЕ РАСПРЕДЕЛЕНИЯ»

Выполнил:
студент группы 381803-1
Герасимов М. А.

Проверил:
Кудрявцев. Е. В.

Нижний Новгород
2021
Формулировка задачи

Плотность распределения случайной величины η задана графически:

Требуется провести компьютерное моделирование случайной величины η , теоретическое


исследование характеристик случайной величины и проверить гипотезу о виде распределения.

1. Моделирование случайных величин

Плотность вероятности случайной величины - нормирована, т.е.

+∞
∫ fη (y) dy = 1.
−∞

Пусть ? = a. При y ∈ [a, 0) функция плотности распределения имеет вид

fη (y) = ky + b.
+∞ 0 +∞
Т.к. ∫−∞ fη (y) dy = 0 + ∫a (ky + b) dy + ∫0 e−λy dy , имеем
0 +∞
∫ (ky + b) dy = 1 − ∫ e−λy dy.
a 0

0
Учитывая, что ∫a (ky + b) dy = S , где S - площадь треугольника, образованного осями координат
и прямой ky + b, получаем:

1 1 1
S= ∗ ∣a∣ ∗ 1 = 1 − ⇒ a = 2( − 1).
2 λ λ
Тогда по каноническому уравнению прямой

y − 2( λ1 − 1) fη (y) − 0) y
1
= ⇒ fη (y) = + 1.
0 − 2( λ − 1) 1−0 2(1 − λ1 )

Функция распределения имеет вид


y
Fη (y) = ∫ fη (t) dt.
−∞

Для нашей плотности распределения функция распределения

⎧0, y < 2( λ1 − 1) ⎧0, y < 2( λ1 − 1)


Fη (y) = ⎨∫a (kt + b) dt, 2( λ1 − 1) ≤ y < 0 = ⎨ 4(1−
1 2 1
2( λ1 − 1) ≤ y < 0 .
y
1 y + y + 1 − λ,
⎩ 0 ⎩ e−λt λ
)
y
∫a (kt + b) dt + ∫0 e−λt dt, y ≥ 0 − λ + 1, y ≥ 0

Рассчитаем обратную функцию G(y) : (0, 1) → (2( λ1 − 1), +∞). Имеем


−λt
x = − eλ + 1 ⇒ y = − λ1 ln(λ(1 − x)),
1 1
x= 4(1− λ1 )
y2 +y+1− λ ⇒ y = 2( (1 − λ1 )x + 1
λ − 1).

Тогда

η = G(U ) = {
2( (1 − λ1 )U + λ1 − 1), U ∈ (0, 1 − λ1 )
.
− λ1 ln(λ(1 − U )), U ∈ [1 − λ1 , 1)

Проведем серию наблюдений и расположим их результаты в порядке возрастания. Пусть λ = 2,


сделаем 4 выборки с количествами наблюдений 20, 100, 1000 и 10000 соответственно.

Код программы и результаты её работы приведены ниже:

import random
import numpy as np
import pandas as pd
import matplotlib
from matplotlib import pyplot as plt
import math

def part1(print_series=True):
lamb = float(input("Введите \u03BB: "))
num = int(input("Введите количество наблюдений: "))

bound = 1 - 1. / lamb
values = []
for i in range(num):
u = random.random() # генерируем число от 0 до 1
if (u < bound):
values.append(2 * (math.sqrt(bound * u) - bound))
else:
values.append(-1 / lamb * math.log(lamb * (1 - u)))

values.sort()
print(f"\n\u03BB = 2 \nМинимальное число среди наблюдений: {values[0]:.3f} \nМаксимальн
if (print_series):
print(f"\nСерия наблюдений: {values}")
return num, lamb, values

num2e1, lamb2e1, values2e1 = part1()


print("\n----------------------------------------------------\n")
num1e2, lamb1e2, values1e2 = part1()
print("\n----------------------------------------------------\n")
num1e3, lamb1e3, values1e3 = part1(print_series=False)
print("\n----------------------------------------------------\n")
num1e4, lamb1e4, values1e4 = part1(print_series=False)

Введите λ: 2
Введите количество наблюдений: 20

λ = 2
Минимальное число среди наблюдений: -0.797
Максимальное число среди наблюдений: 1.141

Серия наблюдений: [-0.7973761175653913, -0.6004314832998818, -0.30575419694865513, -0.05206

----------------------------------------------------

Введите λ: 2
Введите количество наблюдений: 100

λ = 2
Минимальное число среди наблюдений: -0.923
Максимальное число среди наблюдений: 2.311

Серия наблюдений: [-0.9228230848497634, -0.905442382596298, -0.7867863414012101, -0.7484478

----------------------------------------------------

Введите λ: 2
Введите количество наблюдений: 1000

λ = 2
Минимальное число среди наблюдений: -0.988
Максимальное число среди наблюдений: 2.700

----------------------------------------------------

Введите λ: 2
Введите количество наблюдений: 10000

λ = 2
Минимальное число среди наблюдений: -0.993
Максимальное число среди наблюдений: 4.024

2. Статистические характеристики случайных


величин

Пусть y1 , y2 , ..., yn - выборочные значения случайной величины η . Выборочная функция


распределения имеет вид:
1
F^η (y) = × число{yi : yi < y, i = 1, 2, ..., n}.
n
Математическое ожидание:
+∞
1 2 1
Mη = ∫ y ⋅ fη (y) dy = − (1 − )2 .
−∞ λ2 3 λ

Дисперсия:

+∞
2 1 2 1 2 1
− (Mη ) = ∫
2 2
Dη = M η2 y 2 ⋅ fη (y) dy − (Mη ) = (1 − )3 + 3 − ( 2 − (1 − )2 )2 .
−∞ 3 λ λ λ 3 λ

Выборочное среднее:

n
1
y = ∑ yi .
n
i=1

Выборочная дисперсия:

n
1
S = ∑(yi − y )2 .
2
n
i=1

Размах выборки:

R = y(n) − y(1) .

Выборочная медиана:

M e = { y(k) +y(k+1)
y(k+1) , n = 2k + 1
.
2
, n = 2k

Рассчитаем эти величины:

def Mn(lamb):
return -2 / 3 * (1 - 1. / lamb) ** 2 + 1. / lamb ** 2

def Dn(lamb):
return 2 / 3 * (1 - 1. / lamb) ** 3 + 2. / lamb ** 3 - Mn(lamb) ** 2

def x_mean(series):
return np.array([values.mean() for values in series])

def S_2(series):
return np.array([values.var() for values in series])

def R_(series):
return np.array([(values[-1] - values[0]) for values in series])

def Me_(series):
return np.array([np.median(values) for values in series])

nums = np.array([num2e1, num1e2, num1e3, num1e4])


lambs = np.array([lamb2e1, lamb1e2, lamb1e3, lamb1e4])
series = [np.array(values2e1), np.array(values1e2), np.array(values1e3), np.array(values1e4
columns = {"M\u03B7": Mn(lambs), "y\u0305": x_mean(series), "| M\u03B7 - y\u0305 |": abs(Mn
"D\u03B7": Dn(lambs), "S\u00B2": S_2(series), "| D\u03B7 - S\u00B2 |": abs(Dn(lam
"Me\u0302": Me_(series), "R\u0302": R_(series)}

dataframe = pd.DataFrame(columns, [f"n = {num}" for num in nums])


dataframe

Mη y̅ | Mη - y̅ | Dη S² | Dη - S² | Mê R̂

n = 20 0.083333 0.333549 0.250215 0.326389 0.242671 0.083718 0.355220 1.93795

n=
0.083333 0.045762 0.037571 0.326389 0.319241 0.007148 0.003126 3.23333
100

n=
0.083333 0.083761 0.000428 0.326389 0.316742 0.009647 0.013257 3.68853
1000

n=
0.083333 0.096427 0.013094 0.326389 0.333865 0.007476 0.007356 5.01766
10000

Построим гистограммы для наших выборок:

def fn(y, lamb):


if (y < 2 * (1.0 / lamb - 1)):
return 0
elif (2 * (1.0 / lamb - 1) <= y < 0):
return y / 2 / (1 - 1.0 / lamb) + 1
else:
return np.exp(-lamb * y)

def hist_plot(heights, values, intervals, lamb, num): #values


y_space = np.arange(2 * (1. / lamb - 1), values[-1], 1e-2)
plt.plot(y_space, [fn(y, lamb) for y in y_space], color="red", label="fn(y)")

for i in range(len(heights)):
plt.gca().add_patch(plt.Rectangle([intervals[i], 0], intervals[i + 1] - intervals[i
heights[i], facecolor="steelblue", edgecolor="stee

plt.grid()
plt.xlim(left = 2 * (1 / lamb - 1), right = values[-1])
plt.xlabel("y")
plt.ylim(bottom = 0)
plt.ylabel("f(u)")
plt.legend(loc="best")

intervals_mas = []
middles_mas = []
fn_middles_mas = []
heights_mas = []
k = int(input("Введите количество интервалов: "))
inp = int(input("Как вводить интервалы? (1 - равномерно, 2 - через G(U), 3 - вручную): "))

for num, lamb, values in zip(nums, lambs, series):


bound = 1 - 1. / lamb
if (inp == 3):
intervals = [values[0], values[-1]]
print(f"Введите {k-1} границ интервалов, каждая в пределах ({values[0]}, {values[-1
for i in range(k-1):
while(True):
tmp = float(input())
if (values[0] < tmp < values[-1]):
intervals.append(tmp)
break
else:
print(f"Некорректное значение границы интервала! Значение границ интерва

intervals.sort()
elif (inp == 1):
intervals = k
else:
intervals = []
for i in range(0, k):
if (i / k < bound):
intervals.append(2 * (math.sqrt(bound * float(i / k)) - bound))
else:
intervals.append(-1 / lamb * math.log(lamb * (1 - float(i / k))))

#intervals.append(math.inf)
if(intervals[-1] < values[-1]):
intervals.append(values[-1])

intervals.sort()

middles = [(intervals[i] + intervals[i-1]) / 2 for i in range(1, len(intervals))]


middles_mas.append(np.array(middles))
fn_middles = [fn(mid, lamb) for mid in middles]
fn_middles_mas.append(np.array(fn_middles))
heights = []
n = 0
i = 1
for val in values:
if (val <= intervals[i]):
n += 1
else:
heights.append(n / num / (intervals[i] - intervals[i-1]))
n = 1
i += 1

heights.append(n / num / (intervals[i] - intervals[i-1]))


i += 1
while (i < len(intervals)):
heights.append(0)
i += 1
heights_mas.append(np.array(heights))

plt.figure(figsize=(10, 10))
hist_plot(heights, values, intervals, lamb, num)
plt.title(f"Функция плотности и гистограммы: n = {num}")
plt.show()
intervals_mas.append(np.array(intervals))
Введите количество интервалов: 15
Как вводить интервалы? (1 - равномерно, 2 - через G(U), 3 - вручную): 2
Построим F^η (y) и Fη (y), используя наши выборки:

def F_real(y, lamb):


if (y < 2 * (1 / lamb - 1)):
return 0
elif (2 * (1 / lamb - 1) <= y < 0):
return 1 / (4 * (1 - 1 / lamb)) * y * y + y + 1 - 1 / lamb
else:
return -math.exp(-lamb * y) / lamb + 1

def F_imp(y, values):


flag = False
count = 0
for i in range(len(values)):
if (values[i] >= y):
flag = True
break
count += 1
return count * 1.0 / len(values)

def F_plot(values, lamb, num):


y_space_step = [2 * (1 / lamb - 1)] + values.tolist() + [values[-1] + 3]
y_space_plot = np.arange(2 * (1 / lamb - 1), values[-1] + 3, 1e-2)

plt.figure(figsize=(10, 10))
plt.plot(y_space_plot, [F_real(y, lamb) for y in y_space_plot], color="blue", label="Fn
plt.step(y_space_step, [F_imp(y, values) for y in y_space_step], color="green", label="
plt.grid()
plt.xlim(left = 2 * (1 / lamb - 1), right = values[-1] + 3)
plt.xlabel("y")
plt.ylim(bottom = 0, top = 1.2)
plt.ylabel("f(u)")
plt.legend(loc="best")

for num, lamb, values in zip(nums, lambs, series):


plt.figure(figsize=(10, 10))
F_plot(values, lamb, num)
plt.title(f"Теоретическая ф-я распределения vs Выборочная ф-я распределения: n = {num}"
plt.show()

<Figure size 720x720 with 0 Axes>

<Figure size 720x720 with 0 Axes>


<Figure size 720x720 with 0 Axes>
<Figure size 720x720 with 0 Axes>
Рассчитаем значение:

j j−1
D = max ( − Fη (y(j) + 0), Fη (y(j) ) − )
1≤j≤n n n

Для наших выборок:

def count_d(num, lamb, values):


maxim = 0
for j in range(num):
maxim = max(maxim, max((j + 1) / (num * 1.0) - F_real(values[j], lamb),
F_real(values[j], lamb) - j / (num * 1.0)))
return maxim

for num, lamb, values in zip(nums, lambs, series):


print(f"n = {num}, D = {count_d(num, lamb, values):.4f}\n")

n = 20, D = 0.3836

n = 100, D = 0.0678

n = 1000, D = 0.0192

n = 10000, D = 0.0118
nj
В точках zj - серединах интервалов Δ′j вычислим f (zj ) - теоретическую плотность и n∣Δ′ ∣ - высоту
j

j-го столбца гистограммы.

С учетом наших выборок получим:

for num, middles, fn_middles, heights in zip(nums, middles_mas, fn_middles_mas, heights_mas


idxs = ["z" + str(j) for j in range(1, len(middles) + 1)]
columns_2 = {"f\u03B7(z\u1D62)": fn_middles, "n\u1D62/(n|\u0394'\u1D62|)": heights}
dataframe_2 = pd.DataFrame(columns_2, idxs)
diff = pd.Series(dataframe_2["n\u1D62/(n|\u0394'\u1D62|)"] - dataframe_2["f\u03B7(z\u1D6
print(f"n = {num}")
display(dataframe_2)
print(f"max|n\u1D62/(n|\u0394'\u1D62|) - f\u03B7(z\u1D62)| = {diff.abs().max()}")
print("\n----------------------------------------------------\n")

n = 20

fη(zᵢ) nᵢ/(n|Δ'ᵢ|)

z1 0.182574 0.136931

z2 0.440773 0.330580

z3 0.574427 0.430820

z4 0.681376 0.511032

z5 0.773397 0.580047

z6 0.855462 0.641596

z7 0.930259 0.697695

z8 0.999412 0.730944

z9 0.864099 0.648716

z10 0.730297 0.548481

z11 0.596285 0.448142

z12 0.461880 0.347606

z13 0.326599 0.986521

z14 0.188562 0.288539

z15 0.116714 0.751183

max|nᵢ/(n|Δ'ᵢ|) - fη(zᵢ)| = 0.6599227525794824

----------------------------------------------------
n = 100

fη(zᵢ) nᵢ/(n|Δ'ᵢ|)

z1 0.182574 0.219089

z2 0.440773 0.661160

z3 0.574427 0.603148

z4 0.681376 0.817651

z5 0.773397 0.580047

z6 0.855462 0.513277

z7 0.930259 0.976772

z8 0.999412 0.292378

z9 0.864099 0.648716

z10 0.730297 0.877570

z11 0.596285 0.896284

z12 0.461880 0.625691

z13 0.326599 0.197304

z14 0.188562 0.230831

z15 0.036227 0.038371

max|nᵢ/(n|Δ'ᵢ|) - fη(zᵢ)| = 0.7070341812725252

----------------------------------------------------

n = 1000

fη(zᵢ) nᵢ/(n|Δ'ᵢ|)

z1 0.182574 0.180748

z2 0.440773 0.489258

z3 0.574427 0.560066

z4 0.681376 0.572356

z5 0.773397 0.696057

z6 0.855462 0.936731
fη(zᵢ) nᵢ/(n|Δ'ᵢ|)

z7 0.930259 0.948865

z8 0.999412 0.906371

z9 0.864099 0.908202

z10 0.730297 0.756904

z11 0.596285 0.636362

z12 0.461880 0.507505

z13 0.326599 0.325552

z14 0.188562 0.176009

z15 0.024534 0.038989

max|nᵢ/(n|Δ'ᵢ|) - fη(zᵢ)| = 0.10902018202991137

----------------------------------------------------

n = 10000

fη(zᵢ) nᵢ/(n|Δ'ᵢ|)

z1 0.182574 0.177188

z2 0.440773 0.415208

z3 0.574427 0.554896

z4 0.681376 0.687849

z5 0.773397 0.747101

z6 0.855462 0.884120

z7 0.930259 0.922352

z8 0.999412 0.991161

z9 0.864099 0.901715

z10 0.730297 0.725093

z11 0.596285 0.581688

z12 0.461880 0.437288

z13 0.326599 0.335911

z14 0.188562 0.210633


fη(zᵢ) nᵢ/(n|Δ'ᵢ|)

z15 0.006526 0.022903

max|nᵢ/(n|Δ'ᵢ|) - fη(zᵢ)| = 0.03761636826597814

----------------------------------------------------

3. Проверка гипотезы о виде распределения

Рассмотрим критерий χ2 для проверки согласия данных с распределением Fη (y).

Разобьем числовую ось на k интервалов: Δ′′j = (zj−1 , zj ), j = 1, k , положим z0 = −∞, zk =


+∞.

Введем эти интервалы, используя обратную функцию:

lamb = float(input("Введите \u03BB: "))


hyp_k = int(input("Ввведите количество интервалов: "))
hyp_intervals = [-np.inf, np.inf]

inp = int(input("Как вводить интервалы? (1 - через G(U), 2 - вручную): "))


if (inp == 2):
print(f"Введите {hyp_k - 1} границ интервалов: ")
for i in range(hyp_k - 1):
tmp = 0
if (i == 0):
while(True):
tmp = float(input())
if (tmp > 2 * (1.0 / lamb - 1)):
break
else:
print(f"Значение первой границы должно быть больше {2 * (1.0 / lamb - 1)
else:
tmp = float(input())
hyp_intervals.append(tmp)
else:
for i in range(1, hyp_k):
if (i / hyp_k <= bound):
hyp_intervals.append(2 * (math.sqrt(bound * i / hyp_k) - bound))
else:
hyp_intervals.append(-1 / lamb * math.log(lamb * (1 - i / hyp_k)))

hyp_intervals.sort()
print("\nГраницы интервалов:")
print(pd.Series([f"({hyp_intervals[i-1]:.3f}, {hyp_intervals[i]:.3f})" for i in range(1, le

Введите λ: 2
Ввведите количество интервалов: 5
Как вводить интервалы? (1 - через G(U), 2 - вручную): 1

Границы интервалов:
0 (-inf, -0.368)
1 (-0.368, -0.106)
2 (-0.106, 0.112)
3 (0.112, 0.458)
4 (0.458, inf)
dtype: object

Пусть nj - число наблюдений, попавших в Δ′′j , qj = PH0 (η ∈ Δ′′j ) = Fη (zj ) − Fη (zj−1 ).

k
(nj − nqj )2
R0 = ∑ .
nqj
j=1

Величина R0 характеризует меру расхождения между наблюдавшимися частотами и ожидаемым


числом попаданий в интервал при нулевой гипотезе. При справедливости нулевой гипотезы
величина R0 имеет распределение χ2 с k−1 степенями свободы.

Рассчитаем эти величины для выборки с количеством экспериментов 100, уровнем значимости
α = 0, 5 и соответствующим значением χ2 . Повторим эти операции 10 раз, каждый раз проверяя,
принимается или отклоняется гипотеза.

Результаты:

q_mas = [F_real(hyp_intervals[i], lamb) - F_real(hyp_intervals[i - 1], lamb) for i in range


num = int(input("Введите количество экспериментов: "))
num_retries = int(input("Введите количество повторений: "))
while(True):
alpha = float(input("Введите \u03B1: "))
if (0 <= alpha <= 1):
break
else:
print(f"Некорректное значение \u03B1! Значение \u03B1 должно быть в пределах [0, 1]!

xi_2 = float(input(f"Введите \u03C7\u00B2 для количества степеней свободы {hyp_k - 1} и вер

print("\n")
counter = 0
for i in range(num_retries):
bound = 1 - 1 / lamb
values = []
for i in range(num):
u = random.random() # генерируем число от 0 до 1
if (u < bound):
values.append(2 * (math.sqrt(bound * u) - bound))
else:
values.append(-1 / lamb * math.log(lamb * (1 - u)))

values.sort()
print(f"min = {values[0]:.3f}, max = {values[-1]:.3f}")

n_mas = []
n = 0
i = 1
for val in values:
if (val <= hyp_intervals[i]):
n += 1
else:
n_mas.append(n)
n = 1
i += 1
n_mas.append(n)

R0 = np.sum((np.array(n_mas) - num * np.array(q_mas)) ** 2 / (num * np.array(q_mas)))


print(f"R0 = {R0:.3f}")
idxs = ["i = " + str(j) for j in range(1, len(q_mas) + 1)]
dataframe_3 = pd.DataFrame({"q\u1D62": q_mas, "n\u1D62": n_mas}, idxs)
display(dataframe_3)
if (R0 < xi_2):
print("Гипотеза принята!")
counter += 1
else:
print("Гипотеза отклонена!")
print("\n")

print(f"\n\nГипотеза принята: {counter} раз.")


print(f"Гипотеза отклонена: {num_retries - counter} раз.")

Введите количество экспериментов: 100


Введите количество повторений: 10
Введите α: 0.5
Введите χ² для количества степеней свободы 4 и вероятности 0.5: 3.35669

min = -0.923, max = 2.122


R0 = 1.200

qᵢ nᵢ

i=1 0.2 18

i=2 0.2 20

i=3 0.2 20

i=4 0.2 18

i=5 0.2 24

Гипотеза принята!

min = -0.823, max = 2.159


R0 = 0.300

qᵢ nᵢ
qᵢ nᵢ

i=1 0.2 20

i=2 0.2 21

i=3 0.2 20

i=4 0.2 18

i=5 0.2 21

Гипотеза принята!

min = -0.949, max = 1.873


R0 = 7.700

qᵢ nᵢ

i=1 0.2 25

i=2 0.2 27

i=3 0.2 20

i=4 0.2 12

i=5 0.2 16

Гипотеза отклонена!

min = -0.732, max = 1.488


R0 = 0.500

qᵢ nᵢ

i=1 0.2 18

i=2 0.2 19

i=3 0.2 22

i=4 0.2 20

i=5 0.2 21

Гипотеза принята!

min = -0.834, max = 2.481


R0 = 6.400
qᵢ nᵢ

i=1 0.2 22

i=2 0.2 29

i=3 0.2 17

i=4 0.2 15

i=5 0.2 17

Гипотеза отклонена!

min = -0.910, max = 1.636


R0 = 2.900

qᵢ nᵢ

i=1 0.2 24

i=2 0.2 17

i=3 0.2 24

i=4 0.2 16

i=5 0.2 19

Гипотеза принята!

min = -0.771, max = 2.300


R0 = 11.800

qᵢ nᵢ

i=1 0.2 25

i=2 0.2 29

i=3 0.2 9

i=4 0.2 20

i=5 0.2 17

Гипотеза отклонена!

min = -0.932, max = 1.879


R0 = 3.800
qᵢ nᵢ

i=1 0.2 19

i=2 0.2 21

i=3 0.2 23

i=4 0.2 24

i=5 0.2 13

Гипотеза отклонена!

min = -0.805, max = 2.069


R0 = 9.500

qᵢ nᵢ

i=1 0.2 26

i=2 0.2 19

i=3 0.2 28

i=4 0.2 15

i=5 0.2 12

Гипотеза отклонена!

min = -0.942, max = 1.856


R0 = 3.300

qᵢ nᵢ

i=1 0.2 19

i=2 0.2 25

i=3 0.2 22

i=4 0.2 20

i=5 0.2 14

Гипотеза принята!
Гипотеза принята: 5 раз.
Гипотеза отклонена: 5 раз.

Вывод

Проведено компьютерное моделирование случайной величины η , теоретическое исследование


характеристик случайной величины и проверена гипотеза о виде распределения.

При увеличении числа экспериментов значения выборочной функции стремятся к значениям


теоретической функции, выборочное среднее стремится к значению математического ожидания, а
выборочная дисперсия - к теоретическому значению дисперсии.

При уровне значимости α = 0.5 в среднем в 5 из 10 запусков гипотеза H0 принимается, что


подтверждает совпадение теоретической и эмпирической функций распределения.

Вам также может понравиться