Глава 9. РАСПРЕДЕЛЕНИЯ ВЕРОЯТНОСТЕЙ

9.1. Распределение Бернулли

\[ P(X = x) = p^x (1 - p)^{1-x}, \quad x \in \{0, 1\}, 0 \le p \le 1 \]

Объяснение: Распределение Бернулли моделирует одно бинарное событие (испытание) с вероятностью успеха \(p\).

Пример: Для \(p = 0.7\), \(P(X = 1) = 0.7\), \(P(X = 0) = 1 - 0.7 = 0.3\).

Реализация (используя scipy.stats):


from scipy.stats import bernoulli

p_success = 0.7
# Вычисление P(X=1)
prob_1 = bernoulli.pmf(k=1, p=p_success)
# Вычисление P(X=0)
prob_0 = bernoulli.pmf(k=0, p=p_success)

print(f"P(X=1) for p={p_success}: {prob_1}")
print(f"P(X=0) for p={p_success}: {prob_0}")

9.2. Биномиальное распределение

\[ P(X = k) = \binom{n}{k} p^k (1 - p)^{n-k}, \quad k \in \{0, 1, \dots, n\} \] (где \(\binom{n}{k} = \frac{n!}{k!(n-k)!}\) - биномиальный коэффициент)

Объяснение: Биномиальное распределение моделирует количество успехов в \(n\) независимых испытаниях Бернулли с вероятностью успеха \(p\) в каждом.

Пример: Для \(n = 5\) и \(p = 0.5\), вычисление \(P(X = 3)\). \(P(X = 3) = \binom{5}{3} (0.5)^3 (1 - 0.5)^{5-3} = \frac{5!}{3!2!} (0.5)^3 (0.5)^2 = 10 \cdot 0.125 \cdot 0.25 = 0.3125\).

Реализация (используя scipy.stats):


from scipy.stats import binom

n_trials = 5
p_success = 0.5
k_successes = 3

prob_k = binom.pmf(k=k_successes, n=n_trials, p=p_success)
print(f"P(X={k_successes}) for n={n_trials}, p={p_success}: {prob_k}")

9.3. Распределение Пуассона

\[ P(X = k) = \frac{\lambda^k e^{-\lambda}}{k!}, \quad k \in \{0, 1, 2, \dots\} \] (где \(\lambda > 0\) - средняя интенсивность (rate) событий)

Объяснение: Распределение Пуассона моделирует количество событий, происходящих в фиксированном интервале времени или пространства, со средней интенсивностью \(\lambda\).

Пример: Для \(\lambda = 3\), вычисление \(P(X = 2)\). \(P(X = 2) = \frac{3^2 e^{-3}}{2!} = \frac{9 e^{-3}}{2} \approx \frac{9 \times 0.0498}{2} \approx 0.224\).

Реализация (используя scipy.stats):


from scipy.stats import poisson

lambda_rate = 3
k_events = 2

prob_k = poisson.pmf(k=k_events, mu=lambda_rate)
print(f"P(X={k_events}) for lambda={lambda_rate}: {prob_k}")

9.4. Равномерное распределение (непрерывное)

\[ f(x) = \frac{1}{b - a}, \quad x \in [a, b] \]

Объяснение: Непрерывное равномерное распределение присваивает одинаковую плотность вероятности всем точкам в интервале \([a, b]\).

Пример: Для \(a = 0, b = 2\), \(f(1) = \frac{1}{2 - 0} = \frac{1}{2}\).

Реализация (используя scipy.stats):


from scipy.stats import uniform

a_start = 0
b_end = 2
x_point = 1

# loc = a, scale = b - a
pdf_value = uniform.pdf(x=x_point, loc=a_start, scale=(b_end - a_start))
print(f"PDF at x={x_point} for U({a_start}, {b_end}): {pdf_value}")

9.5. Дискретное равномерное распределение

\[ P(X = x) = \frac{1}{n}, \quad x \in \{x_1, x_2, \dots, x_n\} \quad (\text{часто } x \in \{1, 2, \dots, n\}) \]

Объяснение: Дискретное равномерное распределение присваивает одинаковую вероятность \(n\) дискретным исходам.

Пример: Для \(n = 6\) (исходы 1, 2, 3, 4, 5, 6), \(P(X = 3) = \frac{1}{6}\).

Реализация (используя scipy.stats.randint):


from scipy.stats import randint

low_val = 1 # Нижняя граница (включительно)
high_val = 7 # Верхняя граница (не включительно, т.е. исходы 1..6)
n_outcomes = high_val - low_val
k_value = 3

prob_k = randint.pmf(k=k_value, low=low_val, high=high_val)
# Или просто 1.0 / n_outcomes
print(f"P(X={k_value}) for discrete uniform (1 to {n_outcomes}): {prob_k}")

9.6. Нормальное (Гауссово) распределение

\[ f(x) = \frac{1}{\sqrt{2\pi\sigma^2}} e^{-\frac{(x - \mu)^2}{2\sigma^2}} \] (где \(\mu\) - среднее, \(\sigma^2\) - дисперсия)

Объяснение: Нормальное распределение моделирует данные с симметричной колоколообразной формой, определяемой средним \(\mu\) и стандартным отклонением \(\sigma\). Основополагающее распределение в статистике.

Пример: Для \(\mu = 0, \sigma = 1\) (стандартное нормальное), \(f(0) = \frac{1}{\sqrt{2\pi}} e^0 = \frac{1}{\sqrt{2\pi}} \approx 0.3989\).

Реализация (используя scipy.stats):


from scipy.stats import norm

mean_mu = 0
std_dev_sigma = 1
x_point = 0

pdf_value = norm.pdf(x=x_point, loc=mean_mu, scale=std_dev_sigma)
print(f"PDF at x={x_point} for N({mean_mu}, {std_dev_sigma**2}): {pdf_value}")

9.7. Экспоненциальное распределение

\[ f(x) = \lambda e^{-\lambda x}, \quad x \ge 0 \] (где \(\lambda > 0\) - параметр интенсивности)

Объяснение: Экспоненциальное распределение моделирует время между событиями в Пуассоновском процессе (процессе с постоянной средней интенсивностью).

Пример: Для \(\lambda = 2\), \(f(1) = 2e^{-2 \times 1} = 2e^{-2} \approx 2 \times 0.1353 = 0.2706\).

Реализация (используя scipy.stats):


from scipy.stats import expon

lambda_rate = 2
# В scipy.stats.expon, scale = 1 / lambda
scale_param = 1 / lambda_rate
x_point = 1

pdf_value = expon.pdf(x=x_point, scale=scale_param)
print(f"PDF at x={x_point} for Exp(lambda={lambda_rate}): {pdf_value}")

9.8. Геометрическое распределение

\[ P(X = k) = (1 - p)^{k-1} p, \quad k \in \{1, 2, 3, \dots\} \] (где \(p\) - вероятность успеха в одном испытании, \(k\) - номер первого успешного испытания)

Объяснение: Геометрическое распределение моделирует количество испытаний Бернулли до первого успеха (включительно).

Пример: Для \(p = 0.5\), \(P(X = 3) = (1 - 0.5)^{3-1} (0.5) = (0.5)^2 (0.5) = 0.25 \times 0.5 = 0.125\).

Реализация (используя scipy.stats):


from scipy.stats import geom

p_success = 0.5
k_first_success = 3

prob_k = geom.pmf(k=k_first_success, p=p_success)
print(f"P(X={k_first_success}) for Geom(p={p_success}): {prob_k}")

9.9. Гипергеометрическое распределение

\[ P(X = k) = \frac{\binom{K}{k} \binom{N-K}{n-k}}{\binom{N}{n}} \] (где N - размер совокупности, K - количество успехов в совокупности, n - размер выборки (без возвращения), k - количество успехов в выборке)

Объяснение: Гипергеометрическое распределение моделирует количество успехов в выборке размера \(n\), извлеченной без возвращения из конечной совокупности размера N, содержащей K успехов.

Пример: Из N=20 шаров, где K=7 белых, извлекают n=5 шаров. Вероятность извлечь k=3 белых шара.

Реализация (используя scipy.stats):


from scipy.stats import hypergeom

N_population = 20
K_success_population = 7
n_sample = 5
k_success_sample = 3

# M = N (общее число объектов)
# n = K (число объектов типа "успех" в совокупности)
# N = n (размер выборки)
prob_k = hypergeom.pmf(k=k_success_sample, M=N_population, n=K_success_population, N=n_sample)
print(f"P(X={k_success_sample}) for Hypergeom(N={N_population}, K={K_success_population}, n={n_sample}): {prob_k}")

9.10. Бета-распределение

\[ f(x; \alpha, \beta) = \frac{1}{B(\alpha, \beta)} x^{\alpha-1} (1 - x)^{\beta-1}, \quad x \in [0, 1] \] (где \(\alpha > 0, \beta > 0\) - параметры формы, \(B(\alpha, \beta) = \frac{\Gamma(\alpha)\Gamma(\beta)}{\Gamma(\alpha+\beta)}\) - Бета-функция)

Объяснение: Бета-распределение моделирует вероятности (или пропорции), значения которых лежат в интервале [0, 1], как функцию параметров формы \(\alpha\) и \(\beta\). Часто используется как априорное распределение для параметра Бернулли/биномиального.

Пример: Для \(\alpha = 2, \beta = 3\), вычислить \(f(0.5)\).

Реализация (используя scipy.stats):


from scipy.stats import beta

alpha_param = 2
beta_param = 3
x_point = 0.5

pdf_value = beta.pdf(x=x_point, a=alpha_param, b=beta_param)
print(f"PDF at x={x_point} for Beta(alpha={alpha_param}, beta={beta_param}): {pdf_value}")

9.11. Гамма-распределение

\[ f(x; \alpha, \beta) = \frac{\beta^{\alpha}}{\Gamma(\alpha)} x^{\alpha-1} e^{-\beta x}, \quad x > 0 \] (где \(\alpha > 0\) - параметр формы, \(\beta > 0\) - параметр интенсивности (rate). Иногда параметризуется через масштаб \(\theta = 1/\beta\))

Объяснение: Гамма-распределение обобщает экспоненциальное распределение (при \(\alpha=1\)), часто используется для моделирования времени ожидания, сумм случайных величин.

Пример: Для \(\alpha = 2, \beta = 1\), вычислить \(f(1)\). \(f(1) = \frac{1^2}{\Gamma(2)} 1^{2-1} e^{-1 \times 1} = \frac{1}{1!} 1 e^{-1} = e^{-1} \approx 0.3679\).

Реализация (используя scipy.stats):


from scipy.stats import gamma

alpha_shape = 2
beta_rate = 1
# В scipy.stats.gamma, 'a' - это форма alpha, 'scale' = 1 / beta_rate
scale_param = 1 / beta_rate
x_point = 1

pdf_value = gamma.pdf(x=x_point, a=alpha_shape, scale=scale_param)
print(f"PDF at x={x_point} for Gamma(alpha={alpha_shape}, beta={beta_rate}): {pdf_value}")

9.12. Мультиномиальное распределение

\[ P(X_1 = k_1, \dots, X_c = k_c) = \frac{n!}{k_1! \dots k_c!} p_1^{k_1} \dots p_c^{k_c} \] (где n - количество испытаний, c - количество категорий, \(k_i\) - количество исходов i-й категории (\(\sum k_i = n\)), \(p_i\) - вероятность i-й категории (\(\sum p_i = 1\)))

Объяснение: Мультиномиальное распределение обобщает биномиальное распределение на случай с более чем двумя категориями исходов.

Пример: Для n=3 испытаний, c=3 категорий с вероятностями \(p = [0.2, 0.5, 0.3]\), какова вероятность получить по одному исходу каждой категории, т.е., \(k = [1, 1, 1]\). \(P = \frac{3!}{1!1!1!} (0.2)^1 (0.5)^1 (0.3)^1 = 6 \times 0.2 \times 0.5 \times 0.3 = 0.18\).

Реализация (используя scipy.stats):


from scipy.stats import multinomial

n_trials = 3
p_probs = [0.2, 0.5, 0.3]
k_counts = [1, 1, 1] # Наблюдаемые количества для каждой категории

prob_k = multinomial.pmf(x=k_counts, n=n_trials, p=p_probs)
print(f"P(k={k_counts}) for Multinomial(n={n_trials}, p={p_probs}): {prob_k}")

9.13. Распределение Хи-квадрат (\(\chi^2\))

\[ f(x; k) = \frac{1}{2^{k/2}\Gamma(k/2)} x^{k/2 - 1} e^{-x/2}, \quad x > 0 \] (где \(k\) - число степеней свободы)

Объяснение: Распределение хи-квадрат моделирует сумму квадратов \(k\) независимых стандартных нормальных случайных величин. Широко используется в проверке гипотез (например, критерий согласия Пирсона).

Пример: Для \(k = 3\) степеней свободы, вычислить \(f(2)\).

Реализация (используя scipy.stats):


from scipy.stats import chi2

k_df = 3 # Степени свободы
x_point = 2

pdf_value = chi2.pdf(x=x_point, df=k_df)
print(f"PDF at x={x_point} for Chi2(df={k_df}): {pdf_value}")

9.14. Распределение Стьюдента (t-распределение)

\[ f(t; \nu) = \frac{\Gamma((\nu+1)/2)}{\sqrt{\nu\pi}\Gamma(\nu/2)} \left(1 + \frac{t^2}{\nu}\right)^{-(\nu+1)/2} \] (где \(\nu\) - число степеней свободы)

Объяснение: Распределение Стьюдента используется для оценки параметров генеральной совокупности (например, среднего), когда размер выборки мал и дисперсия совокупности неизвестна (оценивается по выборке).

Пример: Для \(\nu = 5\) степеней свободы, вычислить \(f(1)\).

Реализация (используя scipy.stats):


from scipy.stats import t

nu_df = 5 # Степени свободы
t_point = 1

pdf_value = t.pdf(x=t_point, df=nu_df)
print(f"PDF at t={t_point} for Student's t(df={nu_df}): {pdf_value}")

9.15. F-распределение (Фишера-Снедекора)

\[ f(x; d_1, d_2) = \frac{1}{B(d_1/2, d_2/2)} \left(\frac{d_1}{d_2}\right)^{d_1/2} x^{d_1/2 - 1} \left(1 + \frac{d_1}{d_2}x\right)^{-(d_1+d_2)/2}, \quad x > 0 \] (где \(d_1, d_2\) - степени свободы числителя и знаменателя)

Объяснение: F-распределение моделирует отношение двух независимых хи-квадрат распределенных величин, деленных на их степени свободы. Широко используется в дисперсионном анализе (ANOVA) для сравнения дисперсий.

Пример: Для степеней свободы \(d_1=5, d_2=10\), вычислить \(f(2)\).

Реализация (используя scipy.stats):


from scipy.stats import f

d1_dfn = 5 # Степени свободы числителя
d2_dfd = 10 # Степени свободы знаменателя
x_point = 2

pdf_value = f.pdf(x=x_point, dfn=d1_dfn, dfd=d2_dfd)
print(f"PDF at x={x_point} for F(dfn={d1_dfn}, dfd={d2_dfd}): {pdf_value}")

9.16. Распределение Лапласа (Двойное экспоненциальное)

\[ f(x; \mu, b) = \frac{1}{2b} e^{-\frac{|x - \mu|}{b}} \] (где \(\mu\) - параметр положения (медиана), \(b > 0\) - параметр масштаба)

Объяснение: Распределение Лапласа, также известное как двойное экспоненциальное, используется для моделирования разностей или ошибок, имеет более тяжелые хвосты, чем нормальное распределение. Связано с L1 регуляризацией.

Реализация (используя scipy.stats):


from scipy.stats import laplace

mu_location = 0
b_scale = 1
x_point = 0

# loc = mu, scale = b
pdf_value = laplace.pdf(x=x_point, loc=mu_location, scale=b_scale)
print(f"PDF at x={x_point} for Laplace(mu={mu_location}, b={b_scale}): {pdf_value}")

9.17. Распределение Рэлея

\[ f(x; \sigma) = \frac{x}{\sigma^2} e^{-x^2 / (2\sigma^2)}, \quad x \ge 0 \] (где \(\sigma > 0\) - параметр масштаба)

Объяснение: Распределение Рэлея моделирует величину (модуль) двумерного вектора, компоненты которого являются независимыми нормальными случайными величинами с нулевым средним и одинаковой дисперсией \(\sigma^2\).

Реализация (используя scipy.stats):


from scipy.stats import rayleigh

sigma_scale = 1 # Параметр sigma в формуле
x_point = 2

# В scipy.stats.rayleigh, scale = sigma
pdf_value = rayleigh.pdf(x=x_point, scale=sigma_scale)
print(f"PDF at x={x_point} for Rayleigh(sigma={sigma_scale}): {pdf_value}")

9.18. Треугольное распределение

\[ f(x; a, b, c) = \begin{cases} \frac{2(x-a)}{(b-a)(c-a)}, & a \le x < c \\ \frac{2(b-x)}{(b-a)(b-c)}, & c \le x \le b \end{cases} \] (где \(a\) - минимум, \(b\) - максимум, \(c\) - мода (\(a \le c \le b\)))

Объяснение: Треугольное распределение моделирует данные с известными минимумом, максимумом и модой (наиболее вероятным значением).

Реализация (используя scipy.stats):


from scipy.stats import triang

a_min = 0 # Минимум
b_max = 1 # Максимум
c_mode = 0.5 # Мода

# В scipy.stats.triang:
# loc = a (минимум)
# scale = b - a (диапазон)
# c = (mode - a) / (b - a) (относительное положение моды)
c_relative = (c_mode - a_min) / (b_max - a_min)
x_point = 0.5

pdf_value = triang.pdf(x=x_point, c=c_relative, loc=a_min, scale=(b_max - a_min))
print(f"PDF at x={x_point} for Triangular(a={a_min}, b={b_max}, c={c_mode}): {pdf_value}")

9.19. Логнормальное распределение

\[ f(x; \mu, \sigma) = \frac{1}{x \sigma \sqrt{2\pi}} e^{-\frac{(\ln x - \mu)^2}{2\sigma^2}}, \quad x > 0 \] (где \(\mu, \sigma\) - среднее и стандартное отклонение логарифма переменной)

Объяснение: Логнормальное распределение моделирует данные, логарифм которых следует нормальному распределению. Часто используется для величин, которые являются произведением многих малых факторов.

Реализация (используя scipy.stats):


from scipy.stats import lognorm

mu_log = 0 # Среднее log(x)
sigma_log = 1 # Стандартное отклонение log(x)
x_point = 2

# В scipy.stats.lognorm:
# s = sigma_log (параметр формы)
# scale = exp(mu_log) (параметр масштаба)
scale_param = np.exp(mu_log)

pdf_value = lognorm.pdf(x=x_point, s=sigma_log, scale=scale_param)
print(f"PDF at x={x_point} for LogNorm(mu_log={mu_log}, sigma_log={sigma_log}): {pdf_value}")

9.20. Арксинусное распределение

\[ f(x) = \frac{1}{\pi \sqrt{x(1 - x)}}, \quad x \in (0, 1) \]

Объяснение: Арксинусное распределение (частный случай Бета-распределения с \(\alpha=\beta=0.5\)) моделирует вероятности, где крайние значения (близкие к 0 и 1) более вероятны, чем значения в середине.

Реализация (используя scipy.stats):


from scipy.stats import arcsine

x_point = 0.5

pdf_value = arcsine.pdf(x=x_point)
print(f"PDF at x={x_point} for Arcsine: {pdf_value}") # 1/(pi*sqrt(0.25)) = 1/(pi*0.5) = 2/pi ~ 0.6366

9.21. Бета-биномиальное распределение

\[ P(X = k | n, \alpha, \beta) = \binom{n}{k} \frac{B(k + \alpha, n - k + \beta)}{B(\alpha, \beta)} \] (где \(n\) - число испытаний, \(\alpha, \beta\) - параметры Бета-распределения (априорного для p))

Объяснение: Бета-биномиальное распределение моделирует количество успехов в \(n\) испытаниях Бернулли, где вероятность успеха \(p\) сама является случайной величиной, следующей Бета-распределению. Учитывает избыточную дисперсию по сравнению с биномиальным.

Реализация (используя scipy.stats):


from scipy.stats import betabinom

n_trials = 5
alpha_param = 2
beta_param = 3
k_successes = 2

prob_k = betabinom.pmf(k=k_successes, n=n_trials, a=alpha_param, b=beta_param)
print(f"P(X={k_successes}) for BetaBinom(n={n_trials}, a={alpha_param}, b={beta_param}): {prob_k}")

9.22. Распределение Коши (Лоренца)

\[ f(x; x_0, \gamma) = \frac{1}{\pi\gamma \left[1 + \left(\frac{x - x_0}{\gamma}\right)^2\right]} \] (где \(x_0\) - параметр положения (медиана), \(\gamma > 0\) - параметр масштаба (половина ширины на полувысоте))

Объяснение: Распределение Коши моделирует данные с очень тяжелыми хвостами (среднее и дисперсия не определены). Часто используется в робастной статистике.

Реализация (используя scipy.stats):


from scipy.stats import cauchy

x0_location = 0
gamma_scale = 1
x_point = 0

# loc = x0, scale = gamma
pdf_value = cauchy.pdf(x=x_point, loc=x0_location, scale=gamma_scale)
print(f"PDF at x={x_point} for Cauchy(x0={x0_location}, gamma={gamma_scale}): {pdf_value}") # 1/(pi*1*(1+0)) = 1/pi

9.23. Распределение Вейбулла

\[ f(x; k, \lambda) = \frac{k}{\lambda} \left(\frac{x}{\lambda}\right)^{k-1} e^{-(x/\lambda)^k}, \quad x \ge 0 \] (где \(k > 0\) - параметр формы, \(\lambda > 0\) - параметр масштаба)

Объяснение: Распределение Вейбулла используется в анализе надежности (времени до отказа) и моделировании времени жизни, интенсивности отказов.

Реализация (используя scipy.stats.weibull_min):


from scipy.stats import weibull_min

k_shape = 1.5 # Параметр формы k (в scipy это 'c')
lambda_scale = 1 # Параметр масштаба lambda (в scipy это 'scale')
x_point = 2

# c = k_shape, scale = lambda_scale
pdf_value = weibull_min.pdf(x=x_point, c=k_shape, scale=lambda_scale)
print(f"PDF at x={x_point} for Weibull(k={k_shape}, lambda={lambda_scale}): {pdf_value}")

Примечание: Существует также `weibull_max`. `weibull_min` соответствует приведенной формуле.

9.24. Распределение Парето

\[ f(x; x_m, \alpha) = \frac{\alpha x_m^{\alpha}}{x^{\alpha+1}}, \quad x \ge x_m \] (где \(x_m > 0\) - параметр масштаба (минимальное значение), \(\alpha > 0\) - параметр формы)

Объяснение: Распределение Парето моделирует распределение богатства, размеров городов и другие явления с тяжелыми хвостами ("принцип 80-20").

Реализация (используя scipy.stats):


from scipy.stats import pareto

alpha_shape = 1 # Параметр формы alpha (в scipy это 'b')
# В scipy, x_m неявно равен 1, если не задан loc/scale.
# Чтобы соответствовать формуле: loc=0, scale=x_m
xm_scale = 1 # Минимальное значение x_m
x_point = 2

# b = alpha_shape, scale = xm_scale
pdf_value = pareto.pdf(x=x_point, b=alpha_shape, scale=xm_scale)
print(f"PDF at x={x_point} for Pareto(alpha={alpha_shape}, xm={xm_scale}): {pdf_value}")

9.25. Лог-Коши распределение

\[ f(x; x_0, \gamma) = \frac{1}{x\pi\gamma \left[1 + \left(\frac{\ln x - \ln x_0}{\gamma}\right)^2\right]}, \quad x > 0 \] (Распределение случайной величины Y, если \(\ln Y\) имеет распределение Коши с параметрами \(\ln x_0\) и \(\gamma\))

Объяснение: Лог-Коши распределение является результатом логарифмического преобразования случайной величины, распределенной по Коши. Имеет тяжелые хвосты.

Реализация (используя scipy.stats.logcauchy):


from scipy.stats import logcauchy

# Параметры соответствующего распределения Коши для log(X)
log_x0_location = 0 # = log(x0)
gamma_scale = 1

x_point = 2 # Значение x > 0

# loc = log_x0_location, scale = gamma_scale
# pdf_value = logcauchy.pdf(x=x_point, loc=log_x0_location, scale=gamma_scale)
# Примечание: logcauchy может отсутствовать в старых версиях SciPy.
# Можно вычислить вручную, используя pdf Коши:
from scipy.stats import cauchy
import numpy as np

if x_point > 0:
    pdf_val_manual = cauchy.pdf(np.log(x_point), loc=log_x0_location, scale=gamma_scale) / x_point
else:
    pdf_val_manual = 0

print(f"PDF at x={x_point} for LogCauchy(log_x0={log_x0_location}, gamma={gamma_scale}): {pdf_val_manual}")
Предыдущая глава    Следующая глава

Другие статьи по этой теме: