Критерии и разница гипотез.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import display, Math\n",
    "import statistics\n",
    "import scipy.stats\n",
    "import math\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from scipy import stats\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import norm\n",
    "from scipy.stats import chi2\n",
    "from scipy.stats import t\n",
    "from scipy.stats import f\n",
    "from scipy.stats import expon\n",
    "from scipy.stats import poisson\n",
    "from scipy.stats import bernoulli\n",
    "from scipy.stats import chi2_contingency\n",
    "from scipy.stats import ksone"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <span style=\"color:orange\">Выборочное среднее и дисперсии</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "d = list(map(float, input().split(',')))\n",
    "print('Выборочное среднее: ', statistics.mean(d))\n",
    "print('Неисправленная выборочная диперсия:', (len(d) - 1)/(len(d))*statistics.variance(d))\n",
    "print('(Несмещенная) Исправленная выборочная диперсия:', statistics.variance(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Распределения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = str(input('Type of distirbution: '))  # type of distirbution\n",
    "alpha = float(input('Type alpha: '))  # Type percentage of ci interval\n",
    "if x == 'norm':\n",
    "    print('left point:', -norm.ppf(alpha / 2))\n",
    "    print('right point:', norm.ppf(alpha / 2))\n",
    "elif x == 'chi2':\n",
    "    df = int(input(': '))  # number of experiments\n",
    "    print('left point:', chi2.ppf(alpha/2, df - 1))\n",
    "    print('right point:', chi2.ppf(1 - alpha / 2, df - 1))\n",
    "elif x == 't':\n",
    "    df = int(input('Sample size: '))  # number of experiments\n",
    "    print('left point:', t.ppf((alpha/2), df - 1))\n",
    "    print('right point:', t.ppf((1 - alpha/2), df - 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = str(input('Type of distirbution: '))  # type of distirbution\n",
    "alpha = float(input('Type alpha: '))  # Type percentage of ci interval\n",
    "if x == 'norm':\n",
    "    print('point:', norm.ppf(alpha))\n",
    "elif x == 'chi2':\n",
    "    df = int(input('Sample size: '))  # number of experiments\n",
    "    print('left point:', chi2.ppf(alpha, df - 1))\n",
    "elif x == 't':\n",
    "    df = int(input('Sample size: '))  # number of experiments\n",
    "    print('left point:', t.ppf((alpha), df - 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Гипотеза о равенстве дисперсий"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sigmax = float(input('sigma^2(x): '))\n",
    "m = int(input('before sample size: '))\n",
    "sigmay = float(input('sigma^2(y): '))\n",
    "n = int(input('after sample size: '))\n",
    "alpha = float(input('alpha: '))\n",
    "\n",
    "z = round(sigmax / sigmay, 4)\n",
    "point1 = round(f.ppf(alpha / 2, m - 1, n - 1), 4)\n",
    "point2 = round(f.ppf(1 - alpha / 2, m - 1, n - 1), 4)\n",
    "point3 = round(f.ppf(alpha, m - 1, n - 1), 4)\n",
    "pvalue = f.cdf(z, m - 1, n - 1)\n",
    "print('-----------------------')\n",
    "if z > point1 and z < point2:\n",
    "    display(Math('[{}, {}]'.format(point1, point2)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('[{}, {}]'.format(point1, point2)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - reject'))\n",
    "print('-----------------------')\n",
    "if z > point3:\n",
    "    display(Math('[{}, +oo]'.format(point3)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('[{}, +oo]'.format(point3)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - reject'))\n",
    "print(pvalue)\n",
    "print('-----------------------')\n",
    "point4 = round(f.ppf(1 - alpha, m - 1, n - 1), 4)\n",
    "if z < point4:\n",
    "    display(Math('[0, {}]'.format(point4)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('[0, {}]'.format(point4)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - reject'))\n",
    "print(1 - pvalue)\n",
    "print('-----------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если дан список"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = list(map(float, input('before list: ').split(',')))\n",
    "l = list(map(float, input('after list: ').split(',')))\n",
    "alpha = float(input('alpha: '))\n",
    "\n",
    "sigmax = statistics.variance(d)\n",
    "m = len(d)\n",
    "sigmay = statistics.variance(l)\n",
    "n = len(l)\n",
    "z = round(sigmax / sigmay, 4)\n",
    "point1 = round(f.ppf(alpha / 2, m - 1, n - 1), 4)\n",
    "point2 = round(f.ppf(1 - alpha / 2, m - 1, n - 1), 4)\n",
    "point3 = round(f.ppf(alpha, m - 1, n - 1), 4)\n",
    "pvalue = f.cdf(z, m - 1, n - 1)\n",
    "\n",
    "print('-----------------------')\n",
    "if z > point1 and z < point2:\n",
    "    display(Math('[{}, {}]'.format(point1, point2)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('[{}, {}]'.format(point1, point2)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - reject'))\n",
    "print('-----------------------')\n",
    "if z > point3:\n",
    "    display(Math('[{}, +oo]'.format(point3)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('[{}, +oo]'.format(point3)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - reject'))\n",
    "print(pvalue)\n",
    "print('-----------------------')\n",
    "point4 = round(f.ppf(1 - alpha, m - 1, n - 1), 4)\n",
    "if z < point4:\n",
    "    display(Math('[0, {}]'.format(point4)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('[0, {}]'.format(point4)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - reject'))\n",
    "print(1 - pvalue)\n",
    "print('-----------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мат ожидания известны"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = list(map(float, input('before list: ').split(',')))\n",
    "l = list(map(float, input('after list: ').split(',')))\n",
    "mux = float(input('mux = '))\n",
    "muy = float(input('muy = '))\n",
    "alpha = float(input('alpha: '))\n",
    "\n",
    "m = len(d)\n",
    "n = len(l)\n",
    "dsum = sum((np.array(d) - mux) ** 2)\n",
    "lsum = sum((np.array(l) - mux) ** 2)\n",
    "z = round((1 / m * dsum) / (1 / n * lsum), 4)\n",
    "\n",
    "point1 = round(f.ppf(alpha / 2, m - 1, n - 1), 4)\n",
    "point2 = round(f.ppf(1 - alpha / 2, m - 1, n - 1), 4)\n",
    "point3 = round(f.ppf(alpha, m - 1, n - 1), 4)\n",
    "pvalue = f.cdf(z, m - 1, n - 1)\n",
    "\n",
    "print('-----------------------')\n",
    "if z > point1 and z < point2:\n",
    "    display(Math('[{}, {}]'.format(point1, point2)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('[{}, {}]'.format(point1, point2)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - reject'))\n",
    "print('-----------------------')\n",
    "if z > point3:\n",
    "    display(Math('[{}, +oo]'.format(point3)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('[{}, +oo]'.format(point3)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - reject'))\n",
    "print(pvalue)\n",
    "print('-----------------------')\n",
    "point4 = round(f.ppf(1 - alpha, m - 1, n - 1), 4)\n",
    "if z < point4:\n",
    "    display(Math('[0, {}]'.format(point4)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('[0, {}]'.format(point4)))\n",
    "    display(Math('z = {}'.format(z)))\n",
    "    display(Math('H_0 - reject'))\n",
    "print(1 - pvalue)\n",
    "print('-----------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  <span style=\"color:red\">Разница</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Связные пары - Неизвестное МО, неизвестная дисперсия"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = list(map(float, input('before list: ').split(',')))\n",
    "l = list(map(float, input('after list: ').split(',')))\n",
    "alpha = float(input('alpha: '))\n",
    "m = len(d)\n",
    "h = float(input('mu_x-mu_y = '))\n",
    "diff = []\n",
    "for i in range(len(d)):\n",
    "    diff.append(d[i] - l[i])\n",
    "\n",
    "sigma = statistics.variance(diff) ** 0.5\n",
    "mean = statistics.mean(diff)\n",
    "point = abs(t.ppf(alpha / 2, m - 1))\n",
    "point1 = abs(t.ppf(alpha, m - 1))\n",
    "z = (mean - h) / ((sigma) / (m ** 0.5))\n",
    "\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y = {}'.format(h)))\n",
    "display(Math('H_0(region) - [{}, {}]'.format(-point, point)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if abs(z) < point:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('pvalue: ', (1 - t.cdf(point, m - 1) * 2))\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y > {}'.format(h)))\n",
    "display(Math('H_0(region) - [-oo, {}]'.format(point1)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if z < point:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('pvalue: ', t.cdf(point1, m - 1))\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y < {}'.format(h)))\n",
    "display(Math('H_0(region) - [{}, +oo]'.format(-point1)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if z > point:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('pvalue: ', t.cdf(point1, m - 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t.cdf(-0.75, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Независимые выборки, известная дисперсия"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = float(input('before list avg: '))\n",
    "y = float(input('after list avg: '))\n",
    "z = int(input('before size sample: '))\n",
    "m = int(input('after size sample: '))\n",
    "sigma1 = float(input('before list sigma^2: '))\n",
    "sigma2 = float(input('after list sigma^2: '))\n",
    "d = float(input('mu_x - mu_y = '))\n",
    "alpha = float(input('Alpha: '))\n",
    "\n",
    "point = abs(norm.ppf(alpha))\n",
    "point1 = abs(norm.ppf(alpha / 2))\n",
    "se = (sigma1 / z + sigma2 / m) ** 0.5\n",
    "z = (x - y - d) / se\n",
    "\n",
    "pvalue = norm.cdf(-abs(z)) * 2\n",
    "pvalue1 = norm.cdf(-abs(z))\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y = {}'.format(d)))\n",
    "display(Math('H_0(region): [{}, {}]'.format(-point1, point1)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if abs(z) < point1:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('pvalue = ', pvalue)\n",
    "    \n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y > {}'.format(d)))\n",
    "display(Math('H_0(region): [-oo, {}]'.format(point)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if z < point:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('pvalue = ', pvalue1)\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y < {}'.format(d)))\n",
    "display(Math('H_0(region): [{}, +oo]'.format(point)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if z > -point:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('pvalue = ', pvalue1)\n",
    "print('-----------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если дан список"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = list(map(float, input('before list: ').split(',')))\n",
    "l = list(map(float, input('after list: ').split(',')))\n",
    "alpha = float(input('alpha'))\n",
    "sigma1 = float(input('before list sigma^2: '))\n",
    "sigma2 = float(input('after list sigma^2: '))\n",
    "m = len(d)\n",
    "z = len(l)\n",
    "x = statistics.mean(d)\n",
    "y = statistics.mean(l)\n",
    "h = float(input('mu_x - mu_y = '))\n",
    "\n",
    "point = round(abs(norm.ppf(alpha)), 4)\n",
    "point1 = round(abs(norm.ppf(alpha / 2)), 4)\n",
    "se = (sigma1 / m + sigma2 / z) ** 0.5\n",
    "z = round((x - y - h) / se, 4)\n",
    "pvalue = norm.cdf(-abs(z)) * 2\n",
    "pvalue1 = norm.cdf(-abs(z))\n",
    "\n",
    "\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y = {}'.format(h)))\n",
    "display(Math('[{}, {}]'.format(-point1, point1)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if abs(z) < point1:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('pvalue = ', pvalue)\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y > {}'.format(h)))\n",
    "display(Math('[-oo, {}]'.format(point)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if z < point:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('pvalue = ', pvalue1)\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y < {}'.format(h)))\n",
    "display(Math('[{}, +oo]'.format(-point)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if z > -point:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('pvalue = ', pvalue1)\n",
    "print('-----------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Независимые выборки, неизвестные дисперсии, <span style=\"color:red\">но равны</span>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = float(input('before avg: '))\n",
    "sigmax = float(input('sigma^2: '))\n",
    "m = int(input('before sample size: '))\n",
    "y = float(input('after avg: '))\n",
    "sigmay = float(input('sigma^2: '))\n",
    "n = int(input('after sample size: '))\n",
    "alpha = float(input('alpha: '))\n",
    "d = float(input('mu_x-mu_y = '))\n",
    "\n",
    "pool = ((m - 1)*sigmax + (n - 1) * sigmay) / (m + n - 2)\n",
    "z = round((x - y - d) / ((pool * (1 / m + 1 / n)) ** 0.5), 4)\n",
    "point = round(abs(t.ppf(alpha, m + n - 2)), 4)\n",
    "point1 = round(abs(t.ppf(alpha / 2, m + n - 2)), 4)\n",
    "\n",
    "pvalue = t.cdf(-abs(z), m + n - 2) * 2\n",
    "pvalue1 = t.cdf(-abs(z), m + n - 2)\n",
    "\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y = {}'.format(d)))\n",
    "display(Math('H_0(region) - [{}, {}]'.format(-point1, point1)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if abs(z) < point1:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('pvalue = ', pvalue)\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y > {}'.format(d)))\n",
    "display(Math('H_0(region) - [-oo, {}]'.format(point)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if z < point:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'.format(point)))\n",
    "print('pvalue = ', pvalue1)\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y < {}'.format(d)))\n",
    "display(Math('H_0(region) - [{}, +oo]'.format(-point)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if z > -point:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('pvalue = ', pvalue1)\n",
    "print('-----------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если дан список"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = list(map(float, input('x list: ').split(',')))\n",
    "l = list(map(float, input('y list: ').split(',')))\n",
    "alpha = float(input('alpha = '))\n",
    "h = float(input('mu_x - mu_y = '))\n",
    "\n",
    "m = len(d)\n",
    "n = len(l)\n",
    "sigma1 = statistics.variance(d)\n",
    "sigma2 = statistics.variance(l)\n",
    "x = statistics.mean(d)\n",
    "y = statistics.mean(l)\n",
    "\n",
    "pool = ((m - 1)*sigma1+(n - 1)*sigma2) / (m + n - 2)\n",
    "\n",
    "z = round((x - y - h) / ((pool * (1 / n + 1 / m)) ** 0.5), 4)\n",
    "point = round(abs(t.ppf(alpha, m + n - 2)), 4)\n",
    "point1 = round(abs(t.ppf(alpha / 2, m + n - 2)), 4)\n",
    "\n",
    "pvalue = t.cdf(-abs(z), m + n - 2) * 2\n",
    "pvalue1 = t.cdf(-abs(z), m + n - 2)\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y = {}'.format(h)))\n",
    "display(Math('H_0(region) - [{}, {}]'.format(-point1, point1)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if abs(z) < point1:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('pvalue = ', pvalue)\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y > {}'.format(h)))\n",
    "display(Math('H_0(region) - [-oo, {}]'.format(point)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if z < point:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'.format(point)))\n",
    "print('pvalue = ', pvalue1)  \n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y < {}'.format(h)))\n",
    "display(Math('H_0(region) - [{}, +oo]'.format(-point)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if z > -point:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('pvalue = ', pvalue1)\n",
    "print('-----------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Гипотеза для разности долей"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = float(input('p_x: '))\n",
    "y = float(input('p_y: '))\n",
    "z = int(input('n_x: '))\n",
    "m = int(input('n_y: '))\n",
    "sigma1 = x * (1 - x)\n",
    "sigma2 = y * (1 - y)\n",
    "d = float(input('p_x - p_y = '))\n",
    "alpha = float(input('Alpha: '))\n",
    "\n",
    "point = abs(norm.ppf(alpha))\n",
    "point1 = abs(norm.ppf(alpha / 2))\n",
    "se = (sigma1 / z + sigma2 / m) ** 0.5\n",
    "z = (x - y - d) / se\n",
    "pvalue = round(norm.cdf(-abs(z)) * 2, 4)\n",
    "pvalue1 = round(norm.cdf(-abs(z)), 4)\n",
    "print('-----------------------')\n",
    "display(Math('p_x-p_y = {}'.format(d)))\n",
    "display(Math('H_0(region): [{}, {}]'.format(-point1, point1)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if abs(z) < point1:\n",
    "    print('alpha < pvalue', ':' , alpha, '<', pvalue)\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "    print('alpha > pvalue', ':' , alpha, '>', pvalue)\n",
    "print('pvalue =', pvalue)\n",
    "print('-----------------------')\n",
    "display(Math('p_x-p_y > {}'.format(d)))\n",
    "display(Math('H_0(region): [-oo, {}]'.format(point)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if z < point:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('pvalue =', pvalue1) \n",
    "print('-----------------------')\n",
    "display(Math('p_x-p_y < {}'.format(d)))\n",
    "display(Math('H_0(region): [{}, +oo]'.format(point)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if z > -point:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('pvalue =', pvalue1) \n",
    "print('-----------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если дан список"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = list(map(float, input('before list: ').split(',')))\n",
    "l = list(map(float, input('after list: ').split(',')))\n",
    "alpha = float(input('alpha'))\n",
    "sigma1 = statistics.variance(d)\n",
    "sigma2 = statistics.variance(l)\n",
    "m = len(d)\n",
    "z = len(l)\n",
    "x = statistics.mean(d)\n",
    "y = statistics.mean(l)\n",
    "h = float(input('p_x - p_y = '))\n",
    "\n",
    "point = round(abs(norm.ppf(alpha)), 4)\n",
    "point1 = round(abs(norm.ppf(alpha / 2)), 4)\n",
    "se = (sigma1 / m + sigma2 / z) ** 0.5\n",
    "z = round((x - y - h) / se, 4)\n",
    "\n",
    "\n",
    "print('-----------------------')\n",
    "pvalue = norm.cdf(z) * 2\n",
    "display(Math('pvalue = {}'.format(pvalue)))\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y = {}'.format(h)))\n",
    "display(Math('[{}, {}]'.format(-point1, point1)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if abs(z) < point1:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y > {}'.format(h)))\n",
    "display(Math('[-oo, {}]'.format(point)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if z < point:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('-----------------------')\n",
    "display(Math('\\mu_x-\\mu_y < {}'.format(h)))\n",
    "display(Math('[{}, +oo]'.format(-point)))\n",
    "display(Math('z = {}'.format(z)))\n",
    "if z > -point:\n",
    "    display(Math('H_0 - accept'))\n",
    "else:\n",
    "    display(Math('H_0 - reject'))\n",
    "print('-----------------------')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  <span style=\"color:red\">Критерии согласия</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Критерий Пирсона - Фишера"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------\n",
      "Power_divergenceResult(statistic=280.0, pvalue=1.580420060273615e-61)\n",
      "chi2 point:  5.991464547107979\n",
      "H0 reject\n"
     ]
    }
   ],
   "source": [
    "f_obs = [120, 60, 20]\n",
    "f_exp = [180, 18, 2]\n",
    "alpha = 0.05\n",
    "\n",
    "print('-------------------')\n",
    "print(stats.chisquare(f_obs, f_exp))\n",
    "print('chi2 point: ', chi2.ppf(1 - alpha, len(f_obs) - 1))\n",
    "if stats.chisquare(f_obs, f_exp)[0] < chi2.ppf(1 - alpha, len(f_obs) - 1):\n",
    "    print('H0 accept')\n",
    "else:\n",
    "    print('H0 reject')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Критерий Колмогорова"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В первую строчку писать цифры, если их несколько то в формате [1, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Во вторую писать назавание распределения, например: 'norm', 'uniform', 'expon'.\n",
    "Только непрерывные распределения, весь список: https://docs.scipy.org/doc/scipy/reference/stats.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В третью альтернативу: $\\neq$ это 'twosided';  $<$ это 'less'; $>$ это 'greater'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если не стандартное распределение, то: \n",
    "lambda x: scipy.stats.uniform.cdf(x, loc=0, scale=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = [0.48, 0.78]\n",
    "res = stats.kstest(d, lambda x: scipy.stats.uniform.cdf(x, loc=0, scale = 1), alternative = 'two-sided')\n",
    "print('--------------')\n",
    "print(res)\n",
    "print('D_n * sqrt(n) = ', round(len(d) ** 0.5 * res[0], 6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha = 0.01\n",
    "ksone.ppf(1 - alpha, n = 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "k = float(input('kolmagorv table point = '))\n",
    "if res[0] < k:\n",
    "    print('H_0 do not reject')\n",
    "else:\n",
    "    print('reject')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Гипотеза о независимости"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs = np.array([[200, 40], [25, 100]])\n",
    "alpha = 0.05\n",
    "print('-----------------')\n",
    "print('chi2 test statistic: ', chi2_contingency(obs)[0])\n",
    "print('pvalue: ', chi2_contingency(obs)[1])\n",
    "print('dof: ', chi2_contingency(obs)[2])\n",
    "print(chi2_contingency(obs)[3])\n",
    "print('-----------------')\n",
    "print('chi2 ppf: ', chi2.ppf(1 - alpha, chi2_contingency(obs)[2]))\n",
    "if chi2_contingency(obs)[0] < chi2.ppf(1 - alpha, chi2_contingency(obs)[2]):\n",
    "    print('H0 accept')\n",
    "else:\n",
    "    print('H0 reject')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  <span style=\"color:red\">LR TESTS</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  <span style=\"color:indigo\">Exponential</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\hat \\lambda_{mle} = \\frac {n}  {\\sum {x_i}}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input('n = '))\n",
    "sumx = float(input('sumx = '))\n",
    "lambda0 = float(input('lambda0 = '))\n",
    "alpha = float(input('alpha = '))\n",
    "lambda1 = n / sumx\n",
    "\n",
    "theta0 = 1 / lambda0\n",
    "theta1 = 1 / lambda1\n",
    "res = -2 * np.log((theta1/theta0) ** n * np.exp(sumx / theta1 - sumx / theta0))\n",
    "\n",
    "print('-----------------')\n",
    "print('res = ', res )\n",
    "print('chi2 point', chi2.ppf(1 - alpha, 1))\n",
    "if chi2.ppf(1 - alpha, 1) > res:\n",
    "    print('H0 - accept')\n",
    "else:\n",
    "    print('H0 - reject')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  <span style=\"color:indigo\">Bernoulli</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H_0(p) = 0.5\n",
      "n = 100\n",
      "sumx = 42\n",
      "alpha = 0.05\n",
      "res =  2.57103607355838\n",
      "chi2 point 3.841458820694124\n",
      "H0 - accept\n"
     ]
    }
   ],
   "source": [
    "p0 = float(input('H_0(p) = '))\n",
    "n = int(input('n = '))\n",
    "sumx = float(input('sumx = '))\n",
    "alpha = float(input('alpha = '))\n",
    "p = sumx / n\n",
    "\n",
    "res = -2 * np.log((p0 ** sumx) * (1 - p0) ** (n - sumx) / ((p ** sumx) * (1 - p) ** (n - sumx)))\n",
    "print('res = ', res )\n",
    "print('chi2 point', chi2.ppf(1 - alpha, 1))\n",
    "if chi2.ppf(1 - alpha, 1) > res:\n",
    "    print('H0 - accept')\n",
    "else:\n",
    "    print('H0 - reject')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  <span style=\"color:indigo\">Poisson</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\lambda_{mle} = \\frac {\\sum x_i} {n} = \\overline {X}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sumx = float(input('sumx = '))\n",
    "n = int(input('n = '))\n",
    "avgx = sumx / n\n",
    "theta0 = float(input('lambda0 = '))\n",
    "\n",
    "res = 2 * n * (theta0 - avgx + avgx * np.log(avgx / theta0))\n",
    "print('res = ', res )\n",
    "print('chi2 point', chi2.ppf(1 - alpha, 1))\n",
    "if chi2.ppf(1 - alpha, 1) > res:\n",
    "    print('H0 - accept')\n",
    "else:\n",
    "    print('H0 - reject')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  <span style=\"color:indigo\">Normal</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $H_0 = \\mu$ and Variance unknown"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$LR = -2 * ln(\\lambda)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $\\lambda = (\\frac {\\sum {(X_i - \\overline X)} ^ 2} {{\\sum {(X_i - \\mu_0)} ^ 2}}) ^ {n/2}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sumx = float(input('\\sum {x} = '))\n",
    "sumx2 = float(input('\\sum {X_i^2} = '))\n",
    "n = int(input('n = '))\n",
    "mu0 = int(input('H_0(mu) = '))\n",
    "alpha = float(input('alpha = '))\n",
    "avgx = sumx / n\n",
    "res = -2*np.log(((sumx2-2*mu0*sumx+n * mu0**2) / (sumx2 - 2*avgx*sumx + n * avgx ** 2)) ** (-0.5*n))\n",
    "print('-----------------')\n",
    "print('res = ', res )\n",
    "print('chi2 point', chi2.ppf(1 - alpha, 1))\n",
    "if chi2.ppf(1 - alpha, 1) > res:\n",
    "    print('H0 - accept')\n",
    "else:\n",
    "    print('H0 - reject')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $H_0 = \\sigma$ and Mean unknown"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### $\\lambda = (\\frac {\\sum {(X_i - \\overline X)} ^ 2} {n * \\sigma_0^2}) ^ {0.5 * n} * exp{( -\\sum {(X_i - \\overline X)} ^ 2 * \\frac {1} {2*\\sigma_0^2} + \\frac {n} {2})}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sumx = float(input('\\sum {x} = '))\n",
    "sumx2 = float(input('\\sum {X_i^2} = '))\n",
    "n = int(input('n = '))\n",
    "sigma0 = float(input('H_0(\\sigma_0^2) = '))\n",
    "alpha = float(input('alpha = '))\n",
    "\n",
    "\n",
    "avgx = sumx / n\n",
    "sumdiff2 = sumx2 - 2 * avgx * sumx + n * avgx ** 2\n",
    "res = -2 * np.log(((sumdiff2 / (n * sigma0)) ** (0.5 * n)) * np.exp(-sumdiff2 / 2*sigma0 + n / 2))\n",
    "print('-----------------')\n",
    "print('res = ', res )\n",
    "print('chi2 point', chi2.ppf(1 - alpha, 1))\n",
    "if chi2.ppf(1 - alpha, 1) > res:\n",
    "    print('H0 - accept')\n",
    "else:\n",
    "    print('H0 - reject')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $H_0 = \\mu$ and Variance known"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### $\\lambda = exp (\\frac {-n * (\\overline {X} - \\mu_0)^2} {2*\\sigma^2})$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "avgx = float(input('X_mean'))\n",
    "mu0 = float(input('H_0(mu) = '))\n",
    "sigma0 = float(input('sigma^2 = '))\n",
    "alpha = float(input('alpha = '))\n",
    "\n",
    "res = np.exp(-n * (avgx - mu0) ** 2 / (2 * sigma0 ** 2))\n",
    "print('-----------------')\n",
    "print('res = ', res )\n",
    "print('chi2 point', chi2.ppf(1 - alpha, 1))\n",
    "if chi2.ppf(1 - alpha, 1) > res:\n",
    "    print('H0 - accept')\n",
    "else:\n",
    "    print('H0 - reject')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $H_0 = (\\mu, \\sigma)$ and all unknown"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $\\lambda = (\\frac {\\hat \\sigma} {\\sigma_0})^2 * exp(0.5* \\frac {\\sum {(X_i - \\overline X)} ^ 2} {\\hat \\sigma^2} - 0.5 * \\frac {\\sum {(X_i - \\mu_0)} ^ 2} {\\sigma_0^2})$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sumx = float(input('\\sum {x} = '))\n",
    "sumx2 = float(input('\\sum {X_i^2} = '))\n",
    "n = int(input('n = '))\n",
    "mu0 = float(input('H_0(\\mu0) = '))\n",
    "sigma0 = float(input('H_0(\\sigma_0^2) = '))\n",
    "alpha = float(input('alpha = '))\n",
    "\n",
    "\n",
    "diff_avgx2 = sumx2 - 2 * avgx * sumx + n * avgx ** 2\n",
    "diff_mu0 = sumx2 - 2 * mu0 * sumx + n * mu0 ** 2\n",
    "sigmamle2 = 1 / n * diff_avgx2\n",
    "avgx = sumx / n\n",
    "\n",
    "res = -2 * np.log((sigmamle2 / sigma0) ** (0.5 * n) * np.exp((0.5 * diff_avgx2) / sigmamle2 - (0.5 * diff_mu0) / sigma0))\n",
    "print('-----------------')\n",
    "print('res = ', res )\n",
    "print('chi2 point', chi2.ppf(1 - alpha, 2))\n",
    "if chi2.ppf(1 - alpha, 1) > res:\n",
    "    print('H0 - accept')\n",
    "else:\n",
    "    print('H0 - reject')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = list(map(float, input('list: ').split(',')))\n",
    "mu0 = int(input('H_0(mu) = '))\n",
    "sigma0 = float(input('H_0(\\sigma_0^2) = '))\n",
    "alpha = float(input('alpha = '))\n",
    "\n",
    "n = len(d)\n",
    "sumx = sum(d)\n",
    "sumx2 = sum(map(lambda i : i * i, d)) \n",
    "avgx = sumx / n\n",
    "diff_avgx2 = sumx2 - 2 * avgx * sumx + n * avgx ** 2\n",
    "diff_mu0 = sumx2 - 2 * mu0 * sumx + n * mu0 ** 2\n",
    "sigmamle2 = 1 / n * diff_avgx2\n",
    "avgx = sumx / n\n",
    "res = -2 * np.log((sigmamle2 / sigma0) ** (0.5 * n) * np.exp((0.5 * diff_avgx2) / sigmamle2 - (0.5 * diff_mu0) / sigma0))\n",
    "print('-----------------')\n",
    "print('res = ', res )\n",
    "print('chi2 point', chi2.ppf(1 - alpha, 2))\n",
    "if chi2.ppf(1 - alpha, 1) > res:\n",
    "    print('H0 - accept')\n",
    "else:\n",
    "    print('H0 - reject')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}