t_test_one_group.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import statsmodels.formula.api as smf\n",
    "import statsmodels.stats.api as sms\n",
    "import statsmodels.stats.power as smp\n",
    "import scipy.stats\n",
    "from scipy.stats import t, norm, ttest_ind, ttest_rel, ttest_1samp\n",
    "import decimal\n",
    "import random\n",
    "#decimal.getcontext().prec = 4\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_normal_sample(n,mean,sd):\n",
    "    return np.random.normal(loc=mean,scale=sd,size=n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conf_int_one_sample(x,alfa,alternative = 'two-tailed',diff=0):\n",
    "    '''\n",
    "    alternative == 'two-tailed','left','right'\n",
    "    '''\n",
    "    mean = np.mean(x)\n",
    "    se = np.std(x,ddof=1)/np.sqrt(len(x))\n",
    "    if alternative == 'two-tailed':\n",
    "        return mean - diff - t.ppf(1-alfa/2,df=len(x)-1)*se,mean + diff + t.ppf(1-alfa/2,df=len(x)-1)*se\n",
    "    elif alternative == 'left':\n",
    "        return mean + diff - t.ppf(1-alfa,df=len(x)-1)*se\n",
    "    elif alternative == 'right':\n",
    "        return mean + diff + t.ppf(1-alfa,df=len(x)-1)*se\n",
    "    else:\n",
    "        print('wrong value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def t_test_for_one_group(x,pop_mean,diff=0,alternative='two-tailed'):\n",
    "    n = len(x)\n",
    "    sd = np.std(x,ddof=1)\n",
    "    se = sd/np.sqrt(n)\n",
    "    if diff == 0:\n",
    "        ts = (np.mean(x) - pop_mean)/se\n",
    "    else:\n",
    "        ts = (np.mean(x) - pop_mean - diff)/se\n",
    "    df = n-1\n",
    "    if alternative == \"two-tailed\":\n",
    "        p_val = t.sf(np.abs(ts),df)*2\n",
    "        #p_val = 2 * t.cdf(-abs(ts), df)\n",
    "    elif alternative == \"lesser\":\n",
    "        p_val = t.cdf(ts, df)\n",
    "    elif alternative == \"greater\":\n",
    "        p_val = 1-t.cdf(ts, df)\n",
    "    return p_val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_sample_conf_comparison(pop_mean,smpl_mean,diff): # patrzy na przedział ufności \n",
    "    podsumowanie = []\n",
    "   \n",
    "    for j in range(100):\n",
    "        samples_downs = []\n",
    "        sample = get_normal_sample(40,smpl_mean,4)\n",
    "        for k in range(1,501):\n",
    "            k =k*0.001\n",
    "            down = conf_int_one_sample(sample,k,'left')\n",
    "            samples_downs.append(down)\n",
    "\n",
    "        g1 = np.array(samples_downs) - pop_mean\n",
    "        sample_mean = smpl_mean - pop_mean\n",
    "        cent_diff = diff - pop_mean\n",
    "        \n",
    "        diff_01 = len([i for i in g1 if i>0 and sample_mean>0])\n",
    "        diff_non_01 = len([i for i in g1 if i>cent_diff and sample_mean>cent_diff])\n",
    "\n",
    "        diff_02 = len([i for i in g1 if i<=0 and sample_mean<=0])\n",
    "        diff_non_02 = len([i for i in g1 if i<=cent_diff and sample_mean<=cent_diff])\n",
    "\n",
    "        diff_03 = len([i for i in g1 if i<=0 and sample_mean>0])\n",
    "        diff_non_03 = len([i for i in g1 if i<=cent_diff and sample_mean>cent_diff])\n",
    "\n",
    "        diff_04 = len([i for i in g1 if i>0 and sample_mean<=0])\n",
    "        diff_non_04 = len([i for i in g1 if i>cent_diff and sample_mean<=cent_diff])\n",
    "\n",
    "        podsumowanie.append([diff_01,diff_non_01,diff_02,diff_non_02,diff_03,diff_non_03,diff_04,diff_non_04])\n",
    "\n",
    "    ile_wszystkich = sum([sum(i) for i in podsumowanie])/2\n",
    "\n",
    "    for i in range(len(podsumowanie)):\n",
    "        pop_dobrze = sum([i[0] for i in podsumowanie])\n",
    "        nwd_dobrze = sum([i[2] for i in podsumowanie])\n",
    "        nwd_zle = sum([i[4] for i in podsumowanie])\n",
    "        pop_zle = sum([i[6] for i in podsumowanie])\n",
    "        alt_pop_dobrze = sum([i[1] for i in podsumowanie])\n",
    "        alt_nwd_dobrze = sum([i[3] for i in podsumowanie])\n",
    "        alt_nwd_zle = sum([i[5] for i in podsumowanie])\n",
    "        alt_pop_zle = sum([i[7] for i in podsumowanie])\n",
    "\n",
    "    print('test, ocena testu')\n",
    "\n",
    "    print('pozytywny, dobrze', '\\n' , 'dla klasycznego: ', pop_dobrze,'\\n', 'dla alternatywnego: ', alt_pop_dobrze,' ')\n",
    "\n",
    "    print('\\n','pozytywny, źle', '\\n' , 'dla klasycznego: ', pop_zle,'\\n', 'dla alternatywnego: ', alt_pop_zle)\n",
    "\n",
    "    print('\\n','nie wiadomo, dobrze', '\\n' , 'dla klasycznego: ', nwd_dobrze,'\\n', 'dla alternatywnego: ', alt_nwd_dobrze)\n",
    "\n",
    "    print('\\n','nie wiadomo, źle', '\\n' , 'dla klasycznego: ', nwd_zle,'\\n', 'dla alternatywnego: ', alt_nwd_zle)\n",
    "\n",
    "    print('\\n','poprawnie', '\\n' , 'dla klasycznego: ', (pop_dobrze+nwd_dobrze)/ile_wszystkich ,'\\n', 'dla alternatywnego: ', (alt_pop_dobrze+alt_nwd_dobrze)/ile_wszystkich)\n",
    "\n",
    "    #return (pop_dobrze+nwd_dobrze)/ile_wszystkich, (alt_pop_dobrze+alt_nwd_dobrze)/ile_wszystkich\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_sample_ttest_comparison(sample_mean,pop_mean,diff,alfa):\n",
    "    #p_p   = 0  #test_rzeczywistość\n",
    "    #m_m   = 0\n",
    "    #p_m   = 0\n",
    "    #m_p   = 0\n",
    "    #a_p_p = 0\n",
    "    #a_m_m = 0\n",
    "    #a_p_m = 0\n",
    "    #a_m_p = 0\n",
    "    for i in range(100):\n",
    "        sample = get_normal_sample(40,sample_mean,4)\n",
    "        \n",
    "        stand = t_test_for_one_group(sample,pop_mean,alternative='greater')\n",
    "        alt = t_test_for_one_group(sample,pop_mean,diff,'greater')\n",
    "        if sample_mean > pop_mean:\n",
    "            if stand < alfa:\n",
    "                p_p+=1\n",
    "            else:\n",
    "                m_p +=1\n",
    "            if alt < alfa:\n",
    "                a_p_p+=1\n",
    "            else:\n",
    "                a_m_p +=1\n",
    "        else:\n",
    "            if stand < alfa:\n",
    "                m_m+=1\n",
    "            else:\n",
    "                p_m +=1\n",
    "            if alt < alfa:\n",
    "                a_m_m+=1\n",
    "            else:\n",
    "                a_p_m +=1\n",
    "        #p_values.append([stand,alt])\n",
    "        #p_values.append([t_test_for_one_group(sample,pop_mean,'greater'),t_test_for_one_group(sample,pop_mean,diff,'greater')])\n",
    "    #return p_p, m_m, p_m, m_p, a_p_p, a_m_m, a_p_m, a_m_p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test, rzeczywistość \n",
      " p_p  8717 \n",
      " m_m  0 \n",
      " a_p_p  0 \n",
      " a_m_m  4 \n",
      " p_m  0 \n",
      " m_p  1283 \n",
      " a_p_m  9996 \n",
      " a_m_p  0 \n",
      " correct:  0.8717 \n",
      " correct alt:  0.0004\n",
      "test, rzeczywistość \n",
      " p_p  9998 \n",
      " m_m  0 \n",
      " a_p_p  44 \n",
      " a_m_m  0 \n",
      " p_m  0 \n",
      " m_p  2 \n",
      " a_p_m  0 \n",
      " a_m_p  9956 \n",
      " correct:  0.9998 \n",
      " correct alt:  0.0044\n",
      "test, rzeczywistość \n",
      " p_p  10000 \n",
      " m_m  0 \n",
      " a_p_p  91 \n",
      " a_m_m  0 \n",
      " p_m  0 \n",
      " m_p  0 \n",
      " a_p_m  0 \n",
      " a_m_p  9909 \n",
      " correct:  1.0 \n",
      " correct alt:  0.0091\n",
      "test, rzeczywistość \n",
      " p_p  8700 \n",
      " m_m  0 \n",
      " a_p_p  0 \n",
      " a_m_m  2 \n",
      " p_m  0 \n",
      " m_p  1300 \n",
      " a_p_m  9998 \n",
      " a_m_p  0 \n",
      " correct:  0.87 \n",
      " correct alt:  0.0002\n",
      "test, rzeczywistość \n",
      " p_p  9880 \n",
      " m_m  0 \n",
      " a_p_p  0 \n",
      " a_m_m  0 \n",
      " p_m  0 \n",
      " m_p  120 \n",
      " a_p_m  10000 \n",
      " a_m_p  0 \n",
      " correct:  0.988 \n",
      " correct alt:  0.0\n"
     ]
    }
   ],
   "source": [
    "samplemean = [11,13,15,11,14]\n",
    "popmean = [10,10,10,10,12]\n",
    "diff_list = [12,12,12,12,16]\n",
    "for k in range(5):\n",
    "    p_p   = 0\n",
    "    m_m   = 0\n",
    "    p_m   = 0\n",
    "    m_p   = 0\n",
    "    a_p_p = 0\n",
    "    a_m_m = 0\n",
    "    a_p_m = 0\n",
    "    a_m_p = 0\n",
    "    sample_mean = samplemean[k] \n",
    "    pop_mean = popmean[k]\n",
    "    diff = diff_list[k]\n",
    "    for alfa in range(1,101):\n",
    "        alfa = alfa*0.01\n",
    "        for i in range(1,101):\n",
    "            sample = get_normal_sample(40,sample_mean,4)\n",
    "            stand = t_test_for_one_group(sample,pop_mean,diff=0,alternative='greater')\n",
    "            alt = t_test_for_one_group(sample,pop_mean,diff,'greater')\n",
    "            if sample_mean > pop_mean:\n",
    "                if stand < alfa:\n",
    "                    p_p+=1\n",
    "                elif stand >= alfa:\n",
    "                    m_p +=1\n",
    "            else:\n",
    "                if stand < alfa:\n",
    "                    m_m+=1\n",
    "                else:\n",
    "                    p_m +=1\n",
    "\n",
    "            if sample_mean > diff:\n",
    "                if alt < alfa:\n",
    "                    a_p_p+=1\n",
    "                elif alt >= alfa:\n",
    "                    a_m_p +=1\n",
    "            else:\n",
    "                if alt < alfa:\n",
    "                    a_m_m+=1\n",
    "                else:\n",
    "                    a_p_m +=1\n",
    "\n",
    "    print('test, rzeczywistość','\\n',\n",
    "          'p_p ', p_p, '\\n',  \n",
    "          'm_m ',m_m,  '\\n',  \n",
    "          'a_p_p ',a_p_p,'\\n',\n",
    "          'a_m_m ',a_m_m,'\\n',    \n",
    "          'p_m ',p_m,  '\\n',  \n",
    "          'm_p ',m_p,  '\\n',  \n",
    "          'a_p_m ',a_p_m,'\\n',\n",
    "          'a_m_p ',a_m_p,'\\n',\n",
    "          'correct: ', (p_p+m_m)/(p_p+m_m+p_m+m_p),'\\n',\n",
    "          'correct alt: ', (a_p_p+a_m_m)/(a_p_p+a_m_m+a_p_m+a_m_p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p-cor:  0.0\n",
      "n-cor:  99.7\n",
      "1t-er:  0.3\n",
      "2t-er:  0.0\n"
     ]
    }
   ],
   "source": [
    "def podejscie1(pop_mean,sample_size,sample_mean,diff=0):\n",
    "    sample = get_normal_sample(sample_size,sample_mean,4)\n",
    "    mean = np.mean(sample)\n",
    "    if mean > pop_mean+diff and sample_mean > pop_mean+diff:\n",
    "        return 'p-cor'\n",
    "    elif mean > pop_mean+diff and sample_mean <= pop_mean+diff:\n",
    "        return '1t-er'\n",
    "    elif mean <= pop_mean+diff and sample_mean <= pop_mean+diff:\n",
    "        return 'n-cor'\n",
    "    elif mean <= pop_mean+diff and sample_mean > pop_mean+diff:\n",
    "        return '2t-er'\n",
    "results = []\n",
    "#for j in range(10):\n",
    "for i in range(1000):\n",
    "        results.append(podejscie1(10,30,15,7))\n",
    "print('p-cor: ',(results.count('p-cor')/len(results))*100)\n",
    "print('n-cor: ',(results.count('n-cor')/len(results))*100)\n",
    "print('1t-er: ',(results.count('1t-er')/len(results))*100)\n",
    "print('2t-er: ',(results.count('2t-er')/len(results))*100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p-cor:  0.0\n",
      "n-cor:  0.0\n",
      "1t-er:  100.0\n",
      "2t-er:  0.0\n"
     ]
    }
   ],
   "source": [
    "def podejscie2(pop_mean,sample_size,sample_mean,alfa,diff=0):\n",
    "    sample = get_normal_sample(sample_size,sample_mean,4)\n",
    "    result = t_test_for_one_group(sample,pop_mean,alternative='greater')\n",
    "    \n",
    "    if result < alfa and sample_mean > pop_mean+diff:\n",
    "        return 'p-cor'\n",
    "    elif result < alfa and sample_mean <= pop_mean+diff:\n",
    "        return '1t-er'\n",
    "    elif result >= alfa and sample_mean <= pop_mean+diff:\n",
    "        return 'n-cor'\n",
    "    elif result > alfa and sample_mean > pop_mean+diff:\n",
    "        return '2t-er'\n",
    "results = []\n",
    "#for j in range(10):\n",
    "for i in range(1000):\n",
    "    results.append(podejscie2(10,30,15,0.05,7))\n",
    "print('p-cor: ',(results.count('p-cor')/len(results))*100)\n",
    "print('n-cor: ',(results.count('n-cor')/len(results))*100)\n",
    "print('1t-er: ',(results.count('1t-er')/len(results))*100)\n",
    "print('2t-er: ',(results.count('2t-er')/len(results))*100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p-cor:  0.0\n",
      "n-cor:  100.0\n",
      "1t-er:  0.0\n",
      "2t-er:  0.0\n"
     ]
    }
   ],
   "source": [
    "def podejscie3(pop_mean,sample_size,sample_mean,alfa,diff=0):\n",
    "    sample = get_normal_sample(sample_size,sample_mean,4)\n",
    "    result = t_test_for_one_group(sample,pop_mean,diff=diff,alternative='greater')\n",
    "    \n",
    "    if result < alfa and sample_mean > pop_mean+diff:\n",
    "        return 'p-cor'\n",
    "    elif result < alfa and sample_mean <= pop_mean+diff:\n",
    "        return '1t-er'\n",
    "    elif result >= alfa and sample_mean <= pop_mean+diff:\n",
    "        return 'n-cor'\n",
    "    elif result > alfa and sample_mean > pop_mean+diff:\n",
    "        return '2t-er'\n",
    "results = []\n",
    "#for j in range(10):\n",
    "for i in range(1000):\n",
    "    results.append(podejscie3(10,30,15,0.05,7))\n",
    "print('p-cor: ',(results.count('p-cor')/len(results))*100)\n",
    "print('n-cor: ',(results.count('n-cor')/len(results))*100)\n",
    "print('1t-er: ',(results.count('1t-er')/len(results))*100)\n",
    "print('2t-er: ',(results.count('2t-er')/len(results))*100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def podejście_2_power(pop_mean,sample_size,sample_mean,diff):\n",
    "    results = []\n",
    "    powers = []\n",
    "    alfas = []\n",
    "    for j in range(1000):\n",
    "        alfa = j*0.001\n",
    "        #for i in range(1000):\n",
    "        alfas.append(alfa)\n",
    "        results.append(podejscie2(0,30,5,alfa,diff=diff))\n",
    "        powers.append(smp.ttest_power(effect_size = diff/2, \n",
    "                                      nobs = sample_size,\n",
    "                                      alpha=alfa,\n",
    "                                      alternative ='larger'))\n",
    "        #powers.append(smp.TTestIndPower().solve_power(effect_size = (np.abs(pop_mean-sample_mean))/np.std(2,ddof=1), \n",
    "                                                      #nobs = sample_size,\n",
    "                                                      #alpha=alfa,\n",
    "                                                      #alternative ='larger'))\n",
    "    #fig, (ax1, ax2) = plt.subplots(2, sharex=True)\n",
    "    #ax2.scatter(alfas,powers)\n",
    "    #ax1.scatter(alfas,results)\n",
    "    print(np.median(powers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9999999783976847\n"
     ]
    }
   ],
   "source": [
    "podejście_2_power(10,30,14,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def podejście_3_power(pop_mean,sample_size,sample_mean,diff):\n",
    "    results = []\n",
    "    powers = []\n",
    "    alfas = []\n",
    "    for j in range(1000):\n",
    "        alfa = j*0.001\n",
    "        #for i in range(1000):\n",
    "        alfas.append(alfa)\n",
    "        results.append(podejscie3(0,30,5,alfa,diff=diff))\n",
    "        powers.append(smp.ttest_power(effect_size = diff/2, \n",
    "                                      nobs = sample_size,\n",
    "                                      alpha=alfa,\n",
    "                                      alternative ='larger'))\n",
    "        #powers.append(smp.TTestIndPower().solve_power(effect_size = (np.abs(pop_mean-sample_mean))/np.std(2,ddof=1), \n",
    "                                                      #nobs = sample_size,\n",
    "                                                      #alpha=alfa,\n",
    "                                                      #alternative ='larger'))\n",
    "    #fig, (ax1, ax2) = plt.subplots(2, sharex=True)\n",
    "    #x2.scatter(alfas,powers)\n",
    "    #ax1.scatter(alfas,results)\n",
    "    print(np.median(powers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "podejście_3_power(10,40,14,3)\n",
    "podejście_2_power(10,40,14,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "506\n",
      "494\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "results = []\n",
    "for j in range(1000):\n",
    "    alfa = j*0.001\n",
    "    #for i in range(1000):\n",
    "    results.append(podejscie3(10,40,14,alfa=alfa,diff=4))\n",
    "print(results.count('p-cor'))\n",
    "print(results.count('n-cor'))\n",
    "print(results.count('1t-er'))\n",
    "print(results.count('2t-er'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "999\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "results = []\n",
    "for j in range(1000):\n",
    "    alfa = j*0.001\n",
    "    #for i in range(1000):\n",
    "    results.append(podejscie2(10,40,14,alfa=alfa,diff=4))\n",
    "print(results.count('p-cor'))\n",
    "print(results.count('n-cor'))\n",
    "print(results.count('1t-er'))\n",
    "print(results.count('2t-er'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pods_1(sample,pop_mean,diff=0):\n",
    "    sample_size = np.size(sample)\n",
    "    sample_mean = np.mean(sample)\n",
    "    sample = get_normal_sample(sample_size,sample_mean,4)\n",
    "    mean = np.mean(sample)\n",
    "    if mean > pop_mean+diff and sample_mean > pop_mean+diff:\n",
    "        return 'cor'\n",
    "    elif mean > pop_mean+diff and sample_mean <= pop_mean+diff:\n",
    "        return '1t-er'\n",
    "    elif mean <= pop_mean+diff and sample_mean <= pop_mean+diff:\n",
    "        return 'cor'\n",
    "    elif mean <= pop_mean+diff and sample_mean > pop_mean+diff:\n",
    "        return '2t-er'\n",
    "    \n",
    "def pods_2(sample,pop_mean,alfa,diff=0):\n",
    "    sample_size = np.size(sample)\n",
    "    sample_mean = np.mean(sample)\n",
    "    result = t_test_for_one_group(sample,pop_mean,alternative='greater')\n",
    "    \n",
    "    if result < alfa and sample_mean > pop_mean+diff:\n",
    "        return 'cor'\n",
    "    elif result < alfa and sample_mean <= pop_mean+diff:\n",
    "        return '1t-er'\n",
    "    elif result >= alfa and sample_mean <= pop_mean+diff:\n",
    "        return 'cor'\n",
    "    elif result > alfa and sample_mean > pop_mean+diff:\n",
    "        return '2t-er'\n",
    "\n",
    "def pods_3(sample,pop_mean,alfa,diff=0):\n",
    "    sample_size = np.size(sample)\n",
    "    sample_mean = np.mean(sample)\n",
    "    result = t_test_for_one_group(sample,pop_mean,diff=diff,alternative='greater')\n",
    "    \n",
    "    if result < alfa and sample_mean > pop_mean+diff:\n",
    "        return 'cor'\n",
    "    elif result < alfa and sample_mean <= pop_mean+diff:\n",
    "        return '1t-er'\n",
    "    elif result >= alfa and sample_mean <= pop_mean+diff:\n",
    "        return 'cor'\n",
    "    elif result > alfa and sample_mean > pop_mean+diff:\n",
    "        return '2t-er'\n",
    "rslts_1 = []\n",
    "rslts_2 = []\n",
    "rslts_3 = []\n",
    "diffs = []\n",
    "\n",
    "for i in range(1000):\n",
    "    diff = i*0.01\n",
    "    lst_1 = []\n",
    "    lst_2 = []\n",
    "    lst_3 = []\n",
    "    for j in range(100):\n",
    "        sample = get_normal_sample(50,14,4)\n",
    "        lst_1.append(pods_1(sample,10,diff))\n",
    "        lst_2.append(pods_2(sample,10,0.01,diff))\n",
    "        lst_3.append(pods_3(sample,10,0.01,diff))\n",
    "    #rslts_2.append(pods_2(sample,10,0.01,diff))\n",
    "    #rslts_3.append(pods_3(sample,10,0.01,diff))\n",
    "    rslts_1.append(lst_1.count('cor'))\n",
    "    rslts_2.append(lst_2.count('cor'))\n",
    "    rslts_3.append(lst_3.count('cor'))\n",
    "    diffs.append(diff)\n",
    "#fig, (ax1, ax2) = plt.subplots(2, sharex=True)\n",
    "#ax1.scatter(diffs,rslts_2)\n",
    "#ax2.scatter(diffs,rslts_3)\n",
    "#ax1.set_title('podejście_2')\n",
    "#ax2.set_title('podejście_3')\n",
    "#ax1.set_xlab('δ')\n",
    "#ax.set_ylab('ilość testów zwracających prawidłową odpowiedź')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Ilość poprawnych odpowiedzi (maksymalnie 100) w zależności od pożądanej wielkości efektu. Populacja z której losowano próbę miała średnią 14, a porównywano do wartości 10.\\nPierwszy wykres przedstawia podejście 1, drugi podejście 2,a ostatni podejście 3')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, (ax1, ax2, ax3) = plt.subplots(3, sharex=True)\n",
    "ax1.scatter(diffs,rslts_1)\n",
    "ax2.scatter(diffs,rslts_2)\n",
    "ax3.scatter(diffs,rslts_3)\n",
    "#ax1.set_title('podejście_2')\n",
    "#ax2.set_title('podejście_3')\n",
    "ax1.set_xlabel('δ')\n",
    "ax1.set_ylabel('ilość testów zwracających prawidłową odpowiedź')\n",
    "ax3.set_xlabel('Ilość poprawnych odpowiedzi (maksymalnie 100) w zależności od pożądanej wielkości efektu. Populacja z której losowano próbę miała średnią 14, a porównywano do wartości 10.'+'\\n'+\n",
    "               'Pierwszy wykres przedstawia podejście 1, drugi podejście 2,a ostatni podejście 3')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.,\n",
       "        1., 0., 0., 0., 0., 0., 0., 0., 3., 0., 0., 0., 0., 0., 0., 2., 0.,\n",
       "        0., 0., 0., 0., 0., 1.]),\n",
       " array([0.00908787, 0.03325226, 0.05741665, 0.08158104, 0.10574542,\n",
       "        0.12990981, 0.1540742 , 0.17823858, 0.20240297, 0.22656736,\n",
       "        0.25073175, 0.27489613, 0.29906052, 0.32322491, 0.34738929,\n",
       "        0.37155368, 0.39571807, 0.41988246, 0.44404684, 0.46821123,\n",
       "        0.49237562, 0.51654001, 0.54070439, 0.56486878, 0.58903317,\n",
       "        0.61319755, 0.63736194, 0.66152633, 0.68569072, 0.7098551 ,\n",
       "        0.73401949, 0.75818388, 0.78234826, 0.80651265, 0.83067704,\n",
       "        0.85484143, 0.87900581, 0.9031702 , 0.92733459, 0.95149897,\n",
       "        0.97566336]),\n",
       " <a list of 40 Patch objects>)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rslts = []\n",
    "for i in range(10):\n",
    "    rslts.append(ttest_1samp(get_normal_sample(50,10+i*0.001,4),popmean=10)[1])\n",
    "rslts.sort(reverse=True)\n",
    "plt.hist(rslts,bins=40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "615\n",
      "0\n",
      "0\n",
      "385\n"
     ]
    }
   ],
   "source": [
    "def dejscie2(pop_mean,sample_size,sample_mean,alfa,diff=0):\n",
    "    sample = get_normal_sample(sample_size,sample_mean,4)\n",
    "    result = t_test_for_one_group(sample,pop_mean,alternative='greater')\n",
    "    \n",
    "    if result < alfa and sample_mean > pop_mean+diff:\n",
    "        return 'p-cor'\n",
    "    elif result < alfa and sample_mean <= pop_mean+diff:\n",
    "        return '1t-er'\n",
    "    elif result >= alfa and sample_mean <= pop_mean+diff:\n",
    "        return 'n-cor'\n",
    "    elif result > alfa and sample_mean > pop_mean+diff:\n",
    "        return '2t-er'\n",
    "results = []\n",
    "alfa = 0.01\n",
    "for i in range(1000):\n",
    "    results.append(dejscie2(0,30,2,alfa,diff=0))\n",
    "print(results.count('p-cor'))\n",
    "print(results.count('n-cor'))\n",
    "print(results.count('1t-er'))\n",
    "print(results.count('2t-er'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "613\n",
      "0\n",
      "0\n",
      "387\n"
     ]
    }
   ],
   "source": [
    "results = []\n",
    "alfa = 0.01\n",
    "for i in range(1000):\n",
    "    results.append(podejscie3(0,30,5,alfa,diff=3))\n",
    "print(results.count('p-cor'))\n",
    "print(results.count('n-cor'))\n",
    "print(results.count('1t-er'))\n",
    "print(results.count('2t-er'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x2d7dac09370>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAZGUlEQVR4nO3df3BV93nn8fezNGIoglJHoYoQpsYDFYpxE6zSZqYem63dILcOYXcKdjJOTLYD3ql39p+d4jrBDsMuYybrad3UNVapUZu0tZk2bqwOsptkvTXTjccWxgYkiMDUgCxuBGZUc4kHlfrZP+7FCP28P86933u/9/OauSOdc8+Ph2P5y4evzj2PuTsiIhKv/xC6ABERKS0N9CIikdNALyISOQ30IiKR00AvIhI5DfQiIpGbdqA3s2fMbMjMDk/yvpnZH5vZcTM7aGYrki9TREQKlUui7wRWT/F+O7Ak+9oIPFV8WSIikpRpB3p3fwU4P8Uma4C/9IxXgXlm9smkChQRkeL8TALHWACcHrU8kF13ZuyGZraRTOpn9uzZt7S0tCRwepH4nDh7EYDFn5gduBKpNPv37z/n7p/IZ58kBnqbYN2Ez1Vw9w6gA6Ctrc17enoSOL1IfNY//SMAntv02cCVSKUxs5P57pPEQD8ALBy13AwMJnBcEZlCf/82LqSPMKd+GUuXbgldjlSwJG6vfAH4cvbum18D/tXdx03biIhIGNMmejP7G+B2oMHMBoBHgY8BuPtOYC9wF3Ac+CmwoVTFishVtZbiu7u7SaVSADQ2NtLe3h64ouox7UDv7vdO874Dv5dYRSIikqgk5uhFREounwQ/3PU2I4MXr1lX1zSbeXffmHRZVUGPQBARiZwSvYiU3cudHQydPHHNuvmLFrPq/o2JHL9Wk/tklOhFRCKnRC8SgX17+jl3On3NuoaF9dy6bmmgiqaWVHKX3CjRi4hETolepIqktm/n0pGj49Zfn33NXNZC48MPl70uqWxK9CIikVOiF6kiSutSCA30IlIzdry2g6Pnx099jdVyXQubV24uQ0XloakbEZHIKdFLfLofgtSh3LdvXA7tj5WuHqkYMaX0fCjRi4hEToleErG1q5e+wfdz3r61aS6P3v2p0hSjdC5yDSV6EZHIKdFHZMuxAQ6nP8h7v5vqZ7FtSXNR5y5ZOheRoinRi4hETok+IsWmcpGpXGlGni81Lw9PiV5EJHJK9CKSk0pN5aObhuerVpqMK9GLiEROiV5EqlotJPJiaaAXqWLDXW8zMngxr33qmmarp2qN0dSNiEjklOhFqtiB937IUOpEfjulgDeuXTV/0WL1cY2YEr2ISOSU6EWqwL49/Zw7nZ7gnTbq6tsKOmbDwnpuXbe0uMKkKijRi4hEToleJCGp7du5dGT6NnW5uNSwCoCT9z0FwJJlLdyqfrFSICV6EZHImbsHOXFbW5v39PQEObdIOeTaiHoiBw7cBsBnPvNPee0XW1NrGc/M9rt7Xr+YUaIXEYmc5uhFSqSYZL3+wF/ByEV2nxnKb8czQ9D7ytTbqBl6zVGiFxGJnBK9SCW6bnHm6wZ9WlWKl9NAb2argSeAGcAud39szPs/B3wHuD57zP/t7rsTrlVEcrS1q5e+wfdLdvzWprnqE1xFpp26MbMZwJNAO9AK3GtmrWM2+z2gz91/GbgdeNzM6hKuVURECpBLol8JHHf3EwBm9iywBugbtY0Dc8zMgHrgPHA54VpFZBpbjg1wOP0BNNdBc0PJzvMmsPbAMW6qn6VexVUgl1/GLgBOj1oeyK4b7U+AZcAgcAj47+7+4dgDmdlGM+sxs56zZ88WWLKIiOQjl0RvE6wb+ymrz5H5S/4/AjcC3zezfe5+zSShu3cAHZD5wFT+5Yrkrr9/GxfSR0KX8ZE59ctK3ndV6VomkkuiHwAWjlpuJpPcR9sAfNczjgP/ArQkU6KIiBQjl0T/OrDEzG4A3gXuAb44ZptTwG8A+8zsF4BfAvLshiCSrFKn50rV3d1NKpUq2/kaGxvVt7XCTTvQu/tlM3sQeInM7ZXPuHuvmT2QfX8nsA3oNLNDZKZ6Nrv7uRLWLSIiOcrpPnp33wvsHbNu56jvB4HfTLY0ESlEqdL1pI3IT8HQ0wdLck41Mk+GHoEgIhI5PQJBRHKiZF29NNCLVJGXOzsYOhnmPof5ixaz6n49e6caaepGRCRySvRScvv29HPudDp0GR9pWFjPreuWhi6jIErUUgglehGRyCnRS8lVWnpObd/OyfsK6+VaCjOXtdD48MOhy5CIKdGLiEROiV6KsuO1HRw9XznpGKDlupYp+7UqPUutUaIXEYmcEr0UZarkXBG6H4LUodBVXKtxObQ/Nv12IglRohcRiZy5h+n/0dbW5j09PUHOLVIKSTbk7juTOU7rJ+fmtL2addcOM9vv7m357KNELyISOc3RiyQkyUS9/ukfAfDcps8mdkypXRroJSpbjg1wOP1B6DKmdFP9LPV2lbLS1I2ISOSU6CUqlZqU+/u3cSF9JLNwAfa/MfX26fQdAOx/41slqWdO/bKa7albi5ToRUQip0QvMonu7m5SqVRCR2vOvnKTTs8DYOgn95WsB6zUDiV6EZHIKdFLVRnuepuRwYtlOdctLAAW5LRtXdPsRHuqvpi9vbK9XbdXSvGU6EVEIqdEL1UlydRcSsU28T57aTkAz239XlIlTUmNv+OmRC8iEjkleql6ldZ8PKONuvq8njt1jboZw/zcJ2axftOXEqxJapUSvYhI5JTopepVWvPxJDybvetGJAka6KXqpbZv59KRyupbCzBzWYv600pF0NSNiEjklOilYDte28HR8xWQpFcAK2YUtGvLdS2V3/dWpEhK9CIikVOil8J0P8Tm1KHQVeSmcTm0Pxa6CpFglOhFRCKXU6I3s9XAE8AMYJe7j4tHZnY78EfAx4Bz7n5bgnVKpSlBQt7a1Uvf4PuJH5dTQMDbFVub5ibaT1YkX9MO9GY2A3gSuBMYAF43sxfcvW/UNvOAPwVWu/spM5tfqoJFRCQ/uST6lcBxdz8BYGbPAmuAvlHbfBH4rrufAnD3oaQLrTXV0OS6EFM1xlbqFSmNXOboFwCnRy0PMP4h3UuBnzez/2tm+83syxMdyMw2mlmPmfWcPXu2sIpFRCQvuSR6m2CdT3CcW4DfAGYBPzKzV929/5qd3DuADoC2traxx5BRKrXJtYhUn1wG+gFg4ajlZmBwgm3OuftF4KKZvQL8MtCPSAXo79/GhfSR0GXkLJ2+A4D9b3yr6GPNqV/G0qVbij6OVK9cpm5eB5aY2Q1mVgfcA7wwZpvvAbea2c+Y2c8CvwpUz/9VIiIRmzbRu/tlM3sQeInM7ZXPuHuvmT2QfX+nux8xsxeBg8CHZG7BPFzKwqUydXd3k0qlQpcxgebsq/QaGxtpb28v6hj1r2duB71lxVeTKElqXE730bv7XmDvmHU7xyx/E/hmcqWJiEgS9AgESVSxSVamNtz1NiODF0OXkYi6ptlV0wO42ukRCCIikVOiF6kitZSAX+7sYOjkidBlFGT+osWsun9j6DI+okQvIhI5JXqRGrZvTz/nTqdDlzGJNurq20p29IaF9VH2G56IEr2ISOSU6EUCmaqp+aWGVQCcvO+pktZwffZVLDVCr2xK9CIikVOiFwlkqgQ8M9soZdGmDeUqRyKmgV5qzo7XdnD0/MRTJpXix+czDdo2vNhR8nO1XNfC5pWbS34eCUdTNyIikVOil5pTDel1/cnM1M3u1fdPvWH3Q5A6VNzJzgxB7yvFHaOcGpeXpGdxzJToRUQip0QvUsW2Xr6PvpH3Q5dRXqeA7C+rR2ttmqu+w5NQohcRiZwSvVSELccGOJz+IHQZQdxUP6vgHsFKsJILJXoRkcgp0deYSm2S/YXsK2lqjC2iRC8iEj0l+hqjdFuccjU/T6XmAbB79+6Sn6tUkmiSLslQohcRiZwSvUgeypVQX8zeJ75hw9qynE/ipoFeqtpw19uMDF4MXUbi/u1M5s809PTBnLava5pdU/1kJT+auhERiZwSfRlVc1f7Qs1ftJhV928s2fFjTbEfy07dzN90c+BKJAZK9CIikVOiL6NSJltJ3r49/Zw7nQ5y7nPDmfM+//gbQc6flIaF9dy6bmnoMmqeEr2ISOSU6EUmkXQSTW3fzqUjubUwnNOwCoAV73w70RrK7k042VX47jOXtUzZW1dyo0QvIhI5JXqRIuTVaHwFsGJGTpu+c8AA+Mbnctu+kqjZeOVRohcRiZwSvUgRSpVcp2wOnkRD8FKqtGbjaiauRC8iEjslepFqU+PpVPKX00BvZquBJ4AZwC53n/Anzcx+BXgVWO/uf5tYlSJyja1dvfQNvh+6jKrU2jS35nrtTjt1Y2YzgCeBdqAVuNfMWifZbgfwUtJFiohI4XJJ9CuB4+5+AsDMngXWAH1jtvtvwN8Bv5JohSI1YMuxAQ6nP/ho+Vj2+7UHjk28Q3MdNDeUo7Qo3FQ/i21LmkOXEUwuv4xdAJwetTyQXfcRM1sArAV2TnUgM9toZj1m1nP27Nl8axURkQLkkuhtgnU+ZvmPgM3u/u9mE22e3cm9A+gAaGtrG3sMkY/092/jQvpI6DLK5gvZ1xWPcAcAX/ddQerJx5z6ZepFXOFyGegHgIWjlpuBwTHbtAHPZgf5BuAuM7vs7n+fSJUiIlKwXAb614ElZnYD8C5wD/DF0Ru4+w1XvjezTuAfNMhLMao1IXZ3d5NKpYo+Tjo9D4CDb91Z9LHK4Z//eXfQ8zc2Npatn281mnagd/fLZvYgmbtpZgDPuHuvmT2QfX/KeXkREQnL3MNMlbe1tXlPT0+Qc8t4sTbZrkS5NPJen20l+Nymz5ajJKkiZrbf3dvy2UePQBARiZwegSBAvE22RUQDvUjVebmzg6GTJ0KXURPmL1ocRa9nTd2IiEROiV6itW9PP+dOp0OXUZBzw5m6n3/8jQnebaOuPq/fxQXVsLA+8f67kh8lehGRyCnRS7SqOUU+m729cu2mFYErKY/U9u1cOpJj713JmxK9iEjklOhFJLjGhx+ecP2O13Zw9LyS/jW+k/8uSvQiIpFToheZTvdDkDpU3nOm1mS+7v6f5T1vqTQuL6jX7eaVm0tQTHXrpDPvfZToRUQip4eaiVSg9U//iJPvXWTRx2eHLiV61dYsXA81ExGRcTRHL1KhFn18th5TLInQQC81bcuxAQ6nPwhdxjjHsjWtPXAscCW5u6l+FtuWNIcuQyagqRsRkcgp0UtNyyWB9vdv40L6SBmqueoR7gDg676rrOctygXYP9Ez2EpsTv2yqu0xXC5K9CIikVOil0R1d3eTSqVCl5Gw5uyrfNLpeQAcfOvOkp2jsbGR9vb2kh1fKocSvYhI5JToJVHVlhCHu95mZPBi6DLG6fIhAH5rpIS9fE/B0NMHS3f8KdQ1zVaf4jJSohcRiZwSvdS0QlNlqRt0D48sz5wn9YOSnSOoFBDgDp18qTm4iIhUBSV6Cap6G3iXtkG3XX4PgLr6dSU7R67U3Lv6KdGLiEROiV6CUlKcWK01B5fS0kAvk0pt386lI+rXGcKlhlUAnLzvqYL2n7msZdI+rFJ7NHUjIhI5dZiS6Ox4bQdHz1f3v0QOHLgNgM985p8CV1JaLde1qC9sntRhSkRExtEcvUSnqITY/RCkDiVXTIHWj4wAsPvMUOBKSuzMEPS+UvxxGpdD+2PFHydSSvQiIpHLKdGb2WrgCWAGsMvdHxvz/peAKzEqDfxXd38ryUJFyqJSUmH29ko25Pfx+61dvfQNvl+CgircKa5eswS0Ns3l0bs/ldjxQps20ZvZDOBJoB1oBe41s9Yxm/0LcJu73wxsAzqSLlRERAqTS6JfCRx39xMAZvYssAbou7KBu/+/Udu/Srm7NIhE4kqz8oKbgzfXQXNDCSqrLW9SXY3Zp5PLHP0C4PSo5YHsusn8F6B7ojfMbKOZ9ZhZz9mzZ3OvUkRECpZLorcJ1k14872ZrSIz0P/6RO+7ewfZaZ22trYwN/BHIESzaimPL2RfSTYHV/PsuEw0IE8nl4F+AFg4arkZGBx3crObgV1Au7u/V0AtIiJSArkM9K8DS8zsBuBd4B7gi6M3MLPrge8C97l7f+JVyjWUzuJX/3rmDpJbVnw1cCUSg2kHene/bGYPAi+Rub3yGXfvNbMHsu/vBB4BPg78qZkBXM73I7oio3V3d5NKpUKXEUwqNQ+A3bt3B64krMbGxqrrQ1yJcrqP3t33AnvHrNs56vvfBX432dJERCQJegSClNxw19uMDF7Ma59bWMDUN3fFrcszjz74rZHCetpWo7qm2QX38JWp6REIIiKRU6KXorzc2cHQyROhy4jO8MhyAF5O/SBwJZObv2gxq+7P7xENEoYSvYhI5JTopShKdJPbt6efc6fTBe1rlzMfRamrX5dkSYkafg+ef/yN0GVErWFhfSJ9lZXoRUQip0QvVaEaG5Vfn30VYk62OfiKd76dWD1SXWYua6FxXTIN3pXoRUQip0QvVaHx4WSSTbWYmW2isWjThsCVSAw00AsAO17bwdHz1TU1ErMfn78NgA0vVlcPn5brWorr2SsloakbEZHIKdELQHWksO6HIHUodBVlsX5kBIDdZ4YCV5KnM0PQ+0roKipX4/IgfYmV6EVEIlfTiX5rVy99g++HLkNytib7il+fZ34u1498fdJtWpvm8ujdnypXSVLFlOhFRCJX04m+ktPQlmMDHE5/ELoMCcT/T+a//cjKhkm3eRNYe+BYmSqqHjfVz2LbkubQZVQUJXoRkcjVdKKvZEokuenv38aF9JHQZSTuEe4A4Ou+K3AlVegC7J/mWWtz6pfVVO9lJXoRkcgp0deAuBttN2dfcUmnM83BD751Z977qqG2jKVELyISOSX6GqB0V31ezD7UbMOGtYErkRhooJeKNtz1NiODF0OXUXb/dibzZx56+mDgSiRfdU2zmXf3jaHLuIambkREIqdEX2Fe7uxg6OSJ0GVIYMMjywF4OfWDwJVUj/mLFquH8SSU6EVEIqdEX2GqOZHs29PPudPp0GVEwS6/B0Bd/brAlVSP4ffg+cen+aRUmTQsrOfWdUtDl/ERJXoRkcgp0UtixiaY1PbtXDqi9oSFmNOwCoAV73w7cCVSkDfhZFfoIq5SohcRiZwSfZ7URDsPK4AVM0JXUZXeOWAAfONzlXH91PS7gnwn/3/lKdGLiEROiT5PFZFqaqhJdq2quObgsTX9DtSkOxQlehGRyCnRV6MaSiI1K/tQMzZU7+cqpHLkNNCb2WrgCWAGsMvdHxvzvmXfvwv4KXC/u1fGJxcitbWrl77B90OXISXSdybz33b9lQFfotbaNLekPaynnboxsxnAk0A70Arca2atYzZrB5ZkXxuBpxKuU0RECpRLol8JHHf3EwBm9iywBugbtc0a4C/d3YFXzWyemX3S3c8kXrEAlPRvfwnvSpJ/btNnA1ciMchloF8AnB61PAD8ag7bLACuGejNbCOZxA9wycwO51VtvBqAc6GLqBC6Flc17HlA1yJLPxdX/VK+O+Qy0NsE67yAbXD3DqADwMx63L0th/NHT9fiKl2Lq3QtrtK1uMrMevLdJ5fbKweAhaOWm4HBArYREZEAchnoXweWmNkNZlYH3AO8MGabF4AvW8avAf+q+XkRkcow7dSNu182sweBl8jcXvmMu/ea2QPZ93cCe8ncWnmczO2VG3I4d0fBVcdH1+IqXYurdC2u0rW4Ku9rYZkbZUREJFZ6BIKISOQ00IuIRK4sA72ZPWNmQ6Pvmzez68zs+2Z2LPv158tRS2iTXIvfMbNeM/vQzGrmFrJJrsU3zeyomR00s+fNbF7IGstlkmuxLXsd3jSzfzSzppA1lstE12LUe//DzNzMGkLUVm6T/Fx8w8zezf5cvGlmd013nHIl+k5g9Zh1DwE/dPclwA+zy7Wgk/HX4jDwn4CIngObk07GX4vvAze5+81AP/AH5S4qkE7GX4tvuvvN7v5p4B+AR8peVRidjL8WmNlC4E7gVLkLCqiTCa4F8Ifu/unsa+90BynLQO/urwDnx6xeA/xF9vu/AL5QjlpCm+hauPsRd/9xoJKCmeRa/KO7X84uvkrmMxnRm+RajH5q3Wwm+BBijCYZLwD+EPh9auQ6wJTXIi8h5+h/4cq99tmv8wPWIpXpq0B36CJCMrP/ZWangS9RO4l+HDP7PPCuu78VupYK8WB2Wu+ZXKa99ctYqUhm9jXgMvBXoWsJyd2/5u4LyVyHB0PXE4KZ/SzwNWr4L7oxngJuBD5N5nlij0+3Q8iB/idm9kmA7NcK6ZkmoZnZV4DfBr7k+qDHFX8N/OfQRQRyI3AD8JaZvUNmOu8NM2sMWlUg7v4Td/93d/8Q+DMyTxieUsiB/gXgK9nvvwJ8L2AtUiGyTW42A59395+GrickM1syavHzwNFQtYTk7ofcfb67/6K7/yKZZ2utcPdU4NKCuBKQs9aSuZlj6n3KEZjM7G+A28k8avQnwKPA3wN7gOvJ/Bb9d9y96F86VLpJrsV54FvAJ4Bh4E13/1yoGstlkmvxB8BM4L3sZq+6+wNBCiyjSa7FXWQeSfshcBJ4wN3fDVVjuUx0Ldz9z0e9/w7Q5u7RP7Z4kp+L28lM2zjwDrBpumeL6REIIiKR0y9jRUQip4FeRCRyGuhFRCKngV5EJHIa6EVEIqeBXkQkchroRUQi9/8BECUaK3ssjaIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "alfas = []\n",
    "cis_0 = []\n",
    "cis_1 = []\n",
    "for i in range(1,100):\n",
    "    x = get_normal_sample(30,13,4)\n",
    "    alfa = i*0.01\n",
    "    alfas.append(alfa)\n",
    "    cis_0.append(conf_int_one_sample(x,alfa)[0])\n",
    "    cis_1.append(conf_int_one_sample(x,alfa)[1])\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "ax.axis([10,15,0,1])\n",
    "for i in range(len(alfas)):\n",
    "    ax.plot([cis_0[i],cis_1[i]],[alfas[i],alfas[i]])\n",
    "ax.axvline(x=13)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x2d7daf73d60>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3df5RcZZ3n8feXRrTXFkEbBRJCWDviGdHTZycLsrO6vSorcHKMI+jEwdFGMxGP7UzPOXHdjIzOzMaBGWfW5mw75LDIRJwVVPyVUTxo1MYfc1AC24oCWUtsJAERxCTTa8tA+O4f91ZSXV0/blXduve5tz6vc3Kqu37c+6Xo+tynnvs8zzV3R0REiu+YvAsQEZF0KNBFREpCgS4iUhIKdBGRklCgi4iUhAJdRKQkFOhSamY2Z2abEz530cz+bd19J5rZ/zGzVyR4/ZfN7K3d1irSKwW6SMzdR9z9vurvZnYs8HFgq7t/M8HrL3D3j7V7npk9z8xuMLMHzeygmX3HzM7prXoRBbpIU+7+pLtvcPevpbzpEeB24LeB5wAfA75kZiMp70cGjAJdgmRmC2a2zczuNrNfmdk/mNkz4sf+0MwqZvaYme0ys1NrXneemd0bt3xnAavb7tvM7J54m7eY2ek1j7mZjcU/Xxjv+1/MbL+Zba153kYzmzezQ2b2EzM7P75/WfdOs325+33u/j/c/SF3P+zu1wDHAWf25c2UgaFAl5BdArwGeAHwQuByM3slcAXwRuAU4H7gRgAzGwU+A1wOjAI/AX6nujEzex3wp8DrgZOAbwE3NNn3R4F3uPuzgLOAr8fbOBu4HngPcALwCmCh/sWd7MvMxokCvdLuDRFpRYEuIZt19wfc/THgg8CbiEL+One/090fB7YB55rZWuBC4G53v8ndnwBmgJ/XbO8dwBXufo+7Pwn8FTBe20qv8QTwW2Z2vLv/yt3vjO9/e7z/r7r7U+6+393vbfD6RPsys+OJ+un/wt0Pdv4WiRylQJeQPVDz8/3AqfG/+6t3uvsi8EtgVfzYAzWPed02TgeuMrMDZnYAeIyoS2ZVg31fRHSAuN/MbjWzc+P7TyNq+bfTdl9mNgz8E3Cbu1+RYJsiLSnQJWSn1fy8Bngw/lfb7/1M4LnAfuCh2teYmdVt4wGibpQTav4Nu/s/1+/Y3W93943A84DPA5+q2cYLEtTecl9m9vR4u/uJWvMiPVOgS8jeZWarzew5RP3RnwQ+AVxqZuNxKP4V8F13XwC+BLzYzF4fDzn8I+Dkmu3tALaZ2YsBzOzZZvaG+p2a2XFmdomZPTvuujkEHI4f/mi8/1eZ2TFmtsrMXtSg9qb7MrOnATcBS8Bb3P2pXt4kkSoFuoTsE8BXgPvif9vjIYR/RnTy8yGi1vImAHd/FHgDcCVRN8w64DvVjbn754C/Bm40s0PAD4ELmuz7D4CF+HmXAW+Ot/E94FLgw8BB4FZqvjEk3Nd/ADYA/wU4EE9oWjSzl3f4/ogsY7rAhYTIzBaAze6+O6P9HUPUCj/d3X+WxT5F0qYWukjkLOA3LB8VI1IoCnQZeGZ2EfAN4L3u/q951yPSLXW5iIiUhFroIiIlcWxeOx4dHfW1a9d2/Lq9e/cCcOaZWvairUPRe8XxYb1XhxYWADi+i///IoPujjvueNTdT2r0WNtAN7PriIZY/cLdz2rwuAFXEc2q+zUwWTNNuqm1a9eyZ8+edk9bYWJiAoC5ubmOXztwdk9Et6+ey7OKFXZPTgLw6p07c61DpIjM7P5mjyXpctkJnN/i8QuIxvuuA7YAV3dSnIiIpKNtoMcL+z/W4ikbges9chtwgpmdklaBIiKSTBonRVexfAGkfTRe7Agz22Jme8xszyOPPJLCrmWgTE/DxER0KyIrpBHo1uC+hmMh3f0ad1/v7utPOqlhn750SVknImmMctnH8hXtVhOtiCcZmJ6G+XmoxJdGGB/Pt56+mpnJuwKRoKUR6LuAKTO7ETgHOOjuD6WwXenA2FgU5kFnXvXoc+BA9PvERAGKFimOJMMWbwAmgFEz2wd8AHgagLvvAG4mGrJYIRq2eGm/ipWVCpGFtV8jFhdhdDS6/9FH4eDBKNirFPAiXWsb6O7+pjaPO/Cu1CqSYqqGdr3aPqCxsei22kLfsCG6bfQ6EelYbjNFpUBahXWS1nT9c+KJRWqJi6RLgS7pyCKcmx1YQF01IijQC6tVtlVdu+loL0dPFJQihaBAl+IowoElyZEW9I1C+kKBnrMkn/9Gn/1EWZDJxdtEJBQK9JKpPUDMxINIprcffVwNwz7Tmys5UqBnRN/ERaTfFOglU3swqOyI5vHUmp9fPo+nSgcSkeJToGck+LC89VaY+EDy5+sIIBIcBXqJVYcszm1t8aRqX9AjFfjpYosn1jl4sP02m6ldywV0cBBJiQJdIp0OWO9mWcf6tVzia4tSqegEg0gKFOiDrlFAJjmD26gzvhq4zUK3frXF1as7LldEmlOgS3aqQV9dy6WXi0QnHTZUT618KTEFuqxU5sC79dbGw3w6oYOCBEqBLvmoVHoP1lpJQ7bblr1IASjQA5Nm3tTOFFWjMqY3QUpMgS6N9bMle+AAjIzA3Fx/ti8yoBTogUm1ARkvztVyHHqnqkMPe/H850eBLiKpUqBLY+2GHibRKvwXF5P3oau/SCQRBbp0ppNgbRb+1XHooUuz20kHJcmAAl06Mz0NN93UW7dL/UxRiLpgxsYUfCI9UKCLVPXrRLAOUpIRBbp0ptXU/lZqw7LV1P9m6/u2osAUARTokpelpeVdLr1IurhXVbMDgA4KUnAK9AJK2jPQ6BJ0nUqt8Vu7kcnJKIRPOSWFDYtIlQJd8jE21nxxrn5Pz6/v1lGXjZSEAr2AEmdPPyYWtZI0iOsvcFGv08lL1REyIgNOgS6daRXaSYO40bDFdlqFtlrYIoACXdKSxpIAnVCIi6ygQJfOpLEkQLXL5Te/SX4QWFxcvv1OR7bU0wFBSkiBLumoD8d+n9isDXj1oYsACvRyq3aDbJ9If5uN1AZrq+dV+9C76aJpFN5qbYsACvTMZXnBnE+/CoYPQ6Vmf5k1ZlvtpJeLRCu8RZpSoJfY/uEoVKfH547ctyIPOz3C9HI0qO48jYtEi8gKCvSMZdq4zHocei9Cu9anvglIASnQB12r0Eo7ZKszNBtNLKrvc9eJTpGOKdBLpD5/e13LZaoCYx2et+w6h3WiU6RniQLdzM4HrgKGgGvd/cq6xyeALwA/je/6rLv/ZYp1Sho6nPwzy2THuxinwgyzHb9u+UYU5iLdaBvoZjYEfAQ4D9gH3G5mu9z97rqnfsvdN/ShRkloRQbW96FPz7bvQul1xuci0K6Xpt3U/3aThhT4Ig0laaGfDVTc/T4AM7sR2AjUB7qELo1Znv2kfnORniQJ9FXAAzW/7wPOafC8c83s+8CDwFZ3/1H9E8xsC7AFYM2aNZ1XK/2XZqD2a32Xbq5qVE+tfCmhJIFuDe7zut/vBE5390UzuxD4PLBuxYvcrwGuAVi/fn39NiQv/Qq2Zi3/ZhOLel2fpRNp7EsHBQlMkkDfB5xW8/tqolb4Ee5+qObnm83s781s1N0fTadMyU2v3TGNWunN+tCXluDw4fbbHBqC4eHua4KVi33VU/ePFFCSQL8dWGdmZwD7gU3A79c+wcxOBh52dzezs4FjgF+mXayUXNKQTjNse+kWSqPrpxV9A5AOtQ10d3/SzKaAW4iGLV7n7j8ys8vix3cAFwPvNLMngSVgk7urS6UMug2Uasu+UfD2spZLVrSaoxRQonHo7n4zcHPdfTtqfp6FXgcfi3Qp64trdEOtbcmAZopKf7QKr7QX5wpl2GWt+oNMlid886KDVu4U6JKObq5Y1M/+53b6HT4hHmSk9BToJZL2Wi6d6GTdl6Xn9z5IJXhqqUoOFOiSitmxmcR92Zt4H2Psz6CqFubnoyOggldKRIEeiDJ8Q59ilrG6hVwaDRDZXe1yEZFUKdAHQUajQBqtztjR6os6qSbSEwV6IPqSY9XVFi9OsMpiEZTha4wOWtJHCvSC6STTjpwUnc8uQKYq04wtNi6w7fycdjMv8xxvrslFUgAKdMlWpQLPeEb0c7P10PPSKrTVspYCUKAHogy9CRCPdmlhqjLN04fmomGLoU39V2hLwSnQpbWUuzlmmWTTM3+c/7DFRpp1+SjopSAU6IHo60nRrQ0eS/yVoEJ0Xbn07D48Gm0yzS4X9XGLcEzeBUjAirDoVRaqk5BEAqcWuhSTWuQiKyjQZTm1yldSH7oUhAK9YLoah95wca7GATXF9Irp+2lbJJr6P08Po1wWoVqmGusiEQW6LHNk2GEfW+obiI4wM1yeyvY6Wl6gG60mPKn1LgFRoBdMJ9lR2dF9JjdaaCstC3ELfYaUTjQuRscftdJl0CnQc9bPCUVXvAoOH+5u+5ubdMn0bGmJ6cNbAJhcvLqrTYwMLTE2vHwce99b6c30eqFotfAlRQr0EhseBpaWGO9zn3hnlhiJx7V3W9c4dzHDtuV31vSpp0ad81IwCvSc9bVxthuo7GduPIWujbT61Idh99AoAFtHNvS+vTypdS2BUaAHrNfumGiUyxjTzPVcS5qjX1IZ5dIFNbil7BTo0lhdi7zRxSu6lfYol6RS72ev9p+rpS6BUKBnpGirKfZ7lMvQEGxNoytIRI4Y6EDPMmTzmIC5OBHdhjDKpba7Y8OBSUZGgLmdqe5DZNANdKBnKY++25GR6HZ8PPt916vtldg9SXSE62W4nySj7qCBMtCBXvq/81SWz03JPDAR/3zgACwtwcMPZ7f/NOnsqgRqoAM9L1llaau1XKYqMJbTGlyLowDDzNP+q0OQ2alWrwRKgT6g2l0qrisJTxR0MsoltxmgrfQ6O7SWDg6SIgV6n0xPw0035bsSbS8nRbtxxdIsLzncfmcPnxiNQ9++GI1yGRqKZ7U2sth7/UG28kX6QIEuqdk2PBP1jR8+3PJ507wTgLcTreUywlJfrzEaZCu/qtPWvlr00oICvU9mZtL/3HXa957HKJepyjbGFlsXuTAUtdDnspr6n0Irv1v6diBZUqDnoNuTop2OZc+6ywWSjV+fjmedTrKzv8W0kUXYqkEtWVKgF8jYmK4Q108KXyk6BXoPijadv2zUnSGynAI9cGqRZ0drbUnRJQp0MzsfuAoYAq519yvrHrf48QuBXwOT7n5nyrUGJ8mHXq34/lns08nOSqXz7eogICFoG+hmNgR8BDgP2Afcbma73P3umqddAKyL/50DXB3fSgNqdYetmwNFNweBXugAIo0kaaGfDVTc/T4AM7sR2AjUBvpG4Hp3d+A2MzvBzE5x94dSr7iOWsCSFvXJS9ElCfRVwAM1v+9jZeu70XNWAX0P9CLKKjRCWm2x1kg0DJ3xbC9Y1JZavVJ0SQLdGtznXTwHM9sCbAFYs2ZNgl23pw9gC61WW8zR7snoduvOPKsQKZ9jEjxnH3Baze+rgQe7eA7ufo27r3f39SeddFKntYqISAtJAv12YJ2ZnWFmxwGbgF11z9kFvMUiLwMOZtF/LiIiR1l0HrPNk8wuBGaIhi1e5+4fNLPLANx9RzxscRY4n2jY4qXuvqfNNh8B7u+y7lHg0S5f208h1hViTRBmXSHWBGHWFWJNEGZdadd0urs37OJIFOihMbM97r4+7zrqhVhXiDVBmHWFWBOEWVeINUGYdWVZU5IuFxERKQAFuohISRQ10K/Ju4AmQqwrxJogzLpCrAnCrCvEmiDMujKrqZB96CJJmdkc8I/ufm2C5y4CL63Oio7vOxH4OvDH7v7NNq//MnCju3+st6pFuqPVFkVi7j5S+7uZHQt8HNjaLszj11+QdF9m9g3gLODpwE+B97v7FzqrWGQ5BbpIE+7+JNCv6+T9MXC3uz9pZucAu83shZq/Ib0oah+6lJyZLZjZNjO728x+ZWb/YGbPiB/7QzOrmNljZrbLzE6ted15ZnavmR00s1nqlqUws7eZ2T3xNm8xs9NrHnMzG4t/vjDe97+Y2X4z21rzvI1mNm9mh8zsJ/Hy0pjZnJltTrIvd/9BfMCAaJmMp7F8trVIxxToErJLgNcALwBeCFxuZq8ErgDeCJxCNDntRgAzGwU+A1xONJnjJ8DvVDdmZq8D/hR4PXAS8C3ghib7/ijwDnd/FlHXyNfjbZwNXA+8BzgBeAWwUP/iJPsysy+a2W+A7wJzQMvJeCLtKNAlZLPu/oC7PwZ8EHgTUchf5+53uvvjwDbgXDNbS3SBlbvd/SZ3f4JodvPPa7b3DuAKd78nbh3/FTBe23Ku8QTwW2Z2vLv/quaCLW+P9/9Vd3/K3fe7+70NXt92X+6+AXhWXPct7v5UV++SSEyBLiGrXZL5fuDU+N+RJSPcfRH4JdFyzafWviZen792G6cDV5nZATM7ADxG1CWzqsG+LyIK2vvN7FYzOze+/zSiln87ifbl7k+4+5eB15jZaxNsV6QpBbqErLZPeQ3RCp4PEoUlAGb2TOC5wH6i9fdPq3nM6rbxAFE3ygk1/4bd/Z/rd+zut7v7RuB5wOeBT9Vs4wUJak+8r9ixCbcr0pQCXUL2LjNbbWbPIeqP/iTwCeBSMxs3s6cTdWV8190XgC8BLzaz18dDDv8IOLlmezuAbWb2YgAze7aZvaF+p2Z2nJldYmbPjrtuDgGH44c/Gu//VWZ2jJmtMrMXNai96b7M7EVmdoGZDZvZ08zszUR98bf29G7JwFOgS8g+AXwFuC/+t93dvwb8GdHJz4eIWrWbANz9UeANwJVE3TDrgO9UN+bunwP+GrjRzA4BPyS6Hm4jfwAsxM+7DHhzvI3vAZcCHwYOEoXwij74Nvsy4M+BXwCPEA1h/L1BuLC69JdmikqQzGwB2OzuuzPa3zFErfDT3f1nWexTJG1qoYtEzgJ+w/JRMSKFokCXgWdmFwHfAN7r7v+adz0i3VKXi4hISaiFLiJSEm0X5zKz64gWKPqFu5/V4HEDriKahPFrYDLJ2frR0VFfu3ZtxwXv3bsXgDPPPLPj1w6cQ9F7xfFhvVeHFhYAOL6L//8ig+6OO+54tNk1RZOstriT6ALQ1zd5/AKi4WHrgHOAq+PbltauXcuePZ0vXTExMQHA3Nxcx68dOLsnottXz+VZxQq7JycBePXOnbnWIVJEZnZ/s8fadrnE60A/1uIpG4HrPXIbcIKZndJ5mSIi0os01kNfxfL1MvbF92ld5wSmp2F+vj/bnolX8p7e3p/td2vDgeh2+0SuZQyE8XGYmcm7CslKGoFuDe5rOHTGzLYAWwDWrFmTwq7lqAqwCIwAYznXIiJ5SCPQ97F8AaTVRAsoreDu1xBfMHX9+vUaL0karadpYJ4o0AEuJlo1FojnWM5tXfmqPO2ejG637syzCpHySSPQdwFTZnYj0cnQg4N0Ga1+dpkkMTUFY2MAY1Qq48zOHj1CqMulXNR9Iu0kGbZ4AzABjJrZPuADRJfLwt13ADcTDVmsEA1bvLRfxRZFpQKLi9nsa/Pm5p/wxYnoNs8DTiMTo9Ht/EKuZRROpbL8/6UCXuq1DXR3f1Obxx14V2oVFUTeLXMZLCMj1W9iIs2l0eVSWq1CO8tWuAyGVqGt1rgkMbCBnqSFrdCWtCRpYSu0pVcDG+hJZPEVVwcNqZqfh3gidF/pwFFeAxvoofxBd98XXx133tzIyBIwzPh4N9vvn5F4lMv46nzrECmbgQ30UHR/YJklGn/ewu79wFjv49BTPgO8myjRtzKR2jalA/NQqLdeXykSU6DnrjoxqJVxjkwWOqLZH3jt9hZZ+elttC0RKQMFemaaBXd910mAU/fTbh3Fqy2i1RZFUqVAz119ePfagq597WpW9rM3+76tlrtI0ZU60MOa/JN9WH76HTA8DJUE70GlArOz/a8JBm/qv7qAJSulDvQ0FXF44d69Uet/w+RcvoXUGbSp//VT9nuhg4O0UspAD6tlLiKSjVIGej80m2RUxJa7FFfSyUdqyQ+mUgZ6oz9ktdolL4uLK//2tNiW9EMpAz1LaX4o1dqXtKSxjIBa+cUzMIFehD/Mbr9F6EBQPI1a7aFJ42SuDgrZGphAz4K6daQI1N1TXgMV6P0O3DRayqtWVRge7mwjJ5/c+P7qdsbG5llaGmH/fn2KiyjtAFarubwGKtCbCanLYmpqlpe8JJ2jztjD0YWjZ2amueuucbZt06e4aEZG4OKLFcCSzEAFerMPRSct936Hf5qh+8XpCQA2vH0utW1K9jo5wanW92AbqEBvppMPQJH6yUdGottl66EH8HVkJF5fZrztKpNyZMHMpCoVmM9oDYd+0VGpawr0WJGCuhdTzDKWc5AuxOuhzzCdax1Fp5ObUk+BThTmN92Ue8M1dYsT0W3tgWpzACsqTjMJwCQ7c62jqKpBroas1FOgx8rY0hkZAZaWguvaUJdLb8apMMNs8a48lISOUj1RoNP9308RumlWsT+4rg11ufSoh0lJ6qYpNwV6igI437jM4gTsZYwNzOVdyjLqcslPp9fDUoO5WBToPaj/Q8+uxV5/2brGRkbiro3xXopK/5J4I/EFLsZXp7pZkYGnQE9Rq5ZMmmE/NTXL2Fj7jY0tHJ1Y1K1KZZzZWTXRBlX9GHi12MOmQKd12KbVjbK0BIcP974dgG9/O9kn6mvbJgB41cVz6ew4JS8/Lbr99g/zraOshoaiSw82oj70clOgt1CpwCOPpBfEInmoDXG1sMtNgU46SwJUhXRidGgouq3OGA1FqHUNgm7WSddBoDgU6C3kd9JTJD21a6+ry6XcChfo1RZwr1dj6WXfIr3KK1jV2i63wgV6PyiopYwU3oOncIFebdXMzaW3zWy7UpKNIU9D43Ho6Y8r75TGoYv0R+ECPYmQ+7qTjiFPQ6Nx6BpXXgxqXUs3ShnooWjUlbN5c3af0iMXuJicy2yfSUyMRrfzC7mWEbQ0LtCcFR18wlHKQM9qxqZIvyx2sACXRq5IVaJAN7PzgauAIeBad7+y7vEJ4AvAT+O7Puvuf5linYWU/Ydsef98Omu5dKp9H7360NOlFrJUtQ10MxsCPgKcB+wDbjezXe5+d91Tv+XuG/pQY0tJWtyDMorliiuWX2D6jPgi0du3Z7dMbZKLUavLJT3VyVnNhvEq7AdLkhb62UDF3e8DMLMbgY1AfaAHpTbE01xHJWTvfvfyT+6RtVyumMu+mBYOnxjdDsJBth9ardUigy1JoK8CHqj5fR9wToPnnWtm3wceBLa6+4/qn2BmW4AtAGvWrOm82gbSnLafRJFa+6FOsQ+1rqLopM+8m6n+9dTKL44kgW4N7vO63+8ETnf3RTO7EPg8sG7Fi9yvAa4BWL9+ff02UtWvP8BODxRFOgBIMXRywjQNaYy40UEhG0kCfR9wWs3vq4la4Ue4+6Gan282s783s1F3fzSdMtOlkS4yKDQCZrAkCfTbgXVmdgawH9gE/H7tE8zsZOBhd3czOxs4Bvhl2sWGQq1ukaPU+g5H20B39yfNbAq4hWjY4nXu/iMzuyx+fAdwMfBOM3sSWAI2uXtfu1R60esfX+gtfB1wpCqL7pkQJkHpoBJJNA7d3W8Gbq67b0fNz7PAbLqlhSf0IBfJg5bnDUcpZ4qWgVrZMqjU2u6eAr0DWf6RpfFtoDoscHy893qA1I4yI/Fs1nH0dad0FqHn/62VCsyX/At/n45aCvQW1MWy3BSzjKUQwgtEc/9nyG4Gq3RP3SjFoUBvo0hdH6tWVRgePlrs4cPRz4uL6RyVrjx5MpXtXLR0BY8/PswkO1PZnvTXCHCxukEKQYHeQvUPOJtWeu8Xvpia+hBjY3uP/D62EP187bWbe9pub4aA5fPU73nfk+zfP6bFuURSVthAL1t3SHoXvqidTz/U4L5sNbqgxoYDk/kUUyI6cSiNFDbQy6LapdOPC1/oAhflFcLY737TQatzhQ30oo04EUlT1uu5dEInUfNT2EAvi87/8JP3tedzgYtWootf6AIX5aaWdX4U6Am0++PMsgXfSV97o4tE50kXqC4PhXaYFOjBSNbynp2dTLzFmQ3R6JbpoD5580TL/egKDSJpG8hAD7FPPL1RLkeF1kKvqg5blOJqduEMtdzzVapATxrUIU4WGqRRLtOjk4BGueRFJy3L65i8C8haiGEuUhbz81HDSvJRqhZ6M4N4wWg4+t8Z2gFMF4nOVv1Fpfs55HFkJMXF4KRjAxHotYp/tfQlINkRaWgoel51+GIo0q9r5fICclSWXSzqQ89XqQI9pOGF/TI1ta2DYYt3ATA3t6GfJXVsYXs0EH3u8nTq0nDIcDQ7WQoK+yyUKtAHQSfBNbPhHOBwYMMWYcOB7QDMTF+e4lYrgM70yWAbqEAPLNdi0/R+RYAmds8Dh5nbOtGf7Xdp92S0mMvWnRNdbiGacbrcOBDk/2CRzAxUoPdLL105U1P9698cW4z6lSvzYZ2lWlyMulzm57ub+68ulsGkLpv2ChnolUrzfro89DIUsh/jz6tCH4c+ObEz1zokPRrbHoZCBnpaNCZdJBtqXWejkIE+NgZzc71vJ/xRL71dxSi81RYjIwfiulZnXVejvneR8ihkoHcr/ABfrtf1XUJdy6U6bHHm8mzrUt97fqrDGdVS76+BCvR8dd7a7mRlxUbCXG2xOmxxiJnpT+ZdikipDFSgr8y1dIcMtuqTX7WqwvBwth32w9+J9vfFyyYy3W8jS0sjR1ZYXNh+gKWlEfh/ORclmWs18ShvZfj2UKpA77RLJe0hg63Widm7N/u+25csRm/GXQEMW7zrrnG2bYs+LUdWW3w0x4IkExr9kq1SBXqn8utP7e1kZ1LVLpfL/2cYzY7qydnOTorqRGaRlaHVWyTm7rnseP369b5nz56OXzcRf1+bS2OYSwL9OJE6NTWd+sUsGhlbiPZRWZt/C71W9aTo2stPaPtcnciUKh0cImZ2h7uvb/TYQLfQ+69xS7zXk51JhX1StHYtF7XCRdKgQG+j+yycBm4ii66VpnZH+w5/LZd+B7rWeZHBoEBPoJtul+iEa76tzrH4pGjZ1nLpVKUCs7OZ7EoCMohdNAr0PulPv29nJ1OL03y1mEYAAAXXSURBVOWShbxmlKk7SbKjQE8g/Tzsdvx7h6NjCtPlkpcswlbdPZIdBXqhjJHVkMfBpPCVYlOg96SPF6eQBNSdIVJLgd53vbaok18UeqXq60Jr0Z8Y3/Za11IK26g1D+ykuwOFWveSv0SBbmbnA1cRXV79Wne/su5xix+/EPg1MOnud6Zca4CSfIAbteLVbZKOw/TnfezmQFEh229rOoDISm0D3cyGgI8A5wH7gNvNbJe7313ztAuAdfG/c4Cr49sMlL3bY7iH11ZDaSSNQlI0FN+GVpe6cKTYkrTQzwYq7n4fgJndCGwEagN9I3C9R+sI3GZmJ5jZKe7+UOoVl0JWoVE90IU1Dh0OxLfZjENPTq1eKbYkgb4KeKDm932sbH03es4qYFmgm9kWYAvAmjVrOq21CX0Am5uIb+dyrKGRyfh2Z441iJTPMQmeYw3uq1/RK8lzcPdr3H29u68/6aSTktQnIiIJJQn0fcBpNb+vBh7s4jkiItJHSQL9dmCdmZ1hZscBm4Bddc/ZBbzFIi8DDqr/XEQkW4nWQzezC4k6q4eA69z9g2Z2GYC774iHLc4C5xMNW7zU3Vsudm5mjwD3d1n3KBDi9W5CrCvEmiDMukKsCcKsK8SaIMy60q7pdHdv2Ged2wUuemFme5ot8J6nEOsKsSYIs64Qa4Iw6wqxJgizrixrStLlIiIiBaBAFxEpiaIG+jV5F9BEiHWFWBOEWVeINUGYdYVYE4RZV2Y1FbIPXUREVipqC11EROoo0EVESiL4QDez68zsF2b2w5r7nmNmXzWzH8e3J7baRkY1vcHMfmRmT5lZLsOmmtT1ITO718x+YGafM7MTAqjpv8f1zJvZV8zs1CxralZXzWNbzczNbDTvmszsz81sf/xezcdzQjLV7L0ys3eb2d747/5v8q7JzD5Z8z4tmFnmy7A2qWvczG6L69pjZmf3a//BBzrRCk7n193334Cvufs64Gvx73nX9EPg9cA3M66l1k5W1vVV4Cx3fynwf4FtAdT0IXd/qbuPA18E3p9xTdC4LszsNKKlon+WdUE0qQn4sLuPx/9uzrgmaFCXmf1nolVWX+ruLwb+Nu+a3P33qu8T8BngsxnX1LAu4G+Av4jren/8e18EH+ju/k3gsbq7NwIfi3/+GPC6vGty93vcfW+WddRrUtdX3P3J+NfbyHjN2iY1Har59Zk0WMit35r8XQF8GPivhFVTrprU9U7gSnd/PH7OLwKoCThywZ03AjdkWRM0rcuB4+Ofn00f17kKPtCbeH51rZj49nk511MUbwO+nHcRAGb2QTN7ALiEfFroK5jZa4H97v79vGupMxV3UV2XdfdiCy8EXm5m3zWzW83s3+ddUI2XAw+7+4/zLiQ2DXwo/nv/W/r4LbmogS4dMrP3AU8C/zvvWgDc/X3ufhpRPVN512Nm/wZ4H4EcXGpcDbyA6OobDwF/l285RxxLdHHYlwHvAT4Vt4xD8CZyaJ238E7gT+K/9z8BPtqvHRU10B82s1MA4ttMv+4VjZm9FdgAXOLhTTz4BHBR3kUQheYZwPfNbIGoa+pOMzs5z6Lc/WF3P+zuTwH/i+gKYiHYB3zWI98DniJahCpXZnYs0bmsT+ZdS423crQ//9P08f9hUQN9F9GbRHz7hRxrCVp8ge/3Aq9191/nXQ+Ama2r+fW1wL151VLl7ne5+/Pcfa27ryUKrH/n7j/Ps65qwyX2u0Qn30PweeCVAGb2QuA4wljl8NXAve6+L+9CajwI/Kf451cC/esKcveg/xF9dXoIeILoQ/Z24LlEo1t+HN8+J4Cafjf++XHgYeCWQN6rCtHlAefjfzsCqOkzRMH0A+CfgFUhvFd1jy8Ao3nXBHwcuCt+r3YBp4TwXhEF+D/G/x/vBF6Zd03x/TuBy7J+j9q8V/8RuAP4PvBd4Lf7tX9N/RcRKYmidrmIiEgdBbqISEko0EVESkKBLiJSEgp0EZGSUKCLiJSEAl1EpCT+Py7gosHPv/VLAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#a = conf_int_one_sample(x,0.1)\n",
    "\n",
    "alfas = []\n",
    "cis_0 = []\n",
    "cis_1 = []\n",
    "cis_0_pod3 = []\n",
    "cis_1_pod3 = []\n",
    "\n",
    "diff = 2\n",
    "mean = 13\n",
    "pop_mean = 10\n",
    "for i in range(1,100):\n",
    "    x = get_normal_sample(30,mean,4)\n",
    "    alfa = i*0.01\n",
    "    alfas.append(alfa)\n",
    "    cis_0.append(conf_int_one_sample(x,alfa)[0])\n",
    "    cis_1.append(conf_int_one_sample(x,alfa)[1])\n",
    "    cis_0_pod3.append(conf_int_one_sample(x,alfa,diff=diff)[0])\n",
    "    cis_1_pod3.append(conf_int_one_sample(x,alfa,diff=diff)[1])\n",
    "fig, (ax1, ax2) = plt.subplots(2, sharex=True)\n",
    "#fig = plt.figure()\n",
    "#ax = fig.add_subplot(1,1,1)\n",
    "#ax.axis([9,16,0,1])\n",
    "ax1.set_title('podejście2')\n",
    "ax2.set_title('podejście3')\n",
    "reds = 0\n",
    "blues = 0\n",
    "for i in range(len(alfas)):\n",
    "    if cis_0[i] > pop_mean + diff:\n",
    "        ax1.plot([cis_0[i],cis_1[i]],[alfas[i],alfas[i]],color = 'red')\n",
    "    elif cis_0[i] > pop_mean and cis_0[i] < mean+diff:\n",
    "        ax1.plot([cis_0[i],cis_1[i]],[alfas[i],alfas[i]],color = 'blue')\n",
    "    else:\n",
    "        ax1.plot([cis_0[i],cis_1[i]],[alfas[i],alfas[i]],color = 'yellow')\n",
    "    if cis_0_pod3[i] > pop_mean + diff:\n",
    "        ax2.plot([cis_0_pod3[i],cis_1_pod3[i]],[alfas[i],alfas[i]],color = 'red')\n",
    "    elif cis_0_pod3[i] > pop_mean and cis_0[i] < mean+diff:\n",
    "        ax2.plot([cis_0_pod3[i],cis_1_pod3[i]],[alfas[i],alfas[i]],color = 'blue')\n",
    "    else:\n",
    "        ax2.plot([cis_0[i],cis_1[i]],[alfas[i],alfas[i]],color = 'yellow')\n",
    "ax1.axvline(x=pop_mean, color = 'black')\n",
    "ax1.axvline(x=pop_mean+diff, color = 'orange')\n",
    "ax1.axvline(x=mean, color = 'brown')\n",
    "ax2.axvline(x=pop_mean, color = 'black')\n",
    "ax2.axvline(x=pop_mean+diff, color = 'orange')\n",
    "ax2.axvline(x=mean, color = 'brown')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'wartość alfa')"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#a = conf_int_one_sample(x,0.1)\n",
    "\n",
    "alfas = []\n",
    "cis_0 = []\n",
    "cis_0_pod3 = []\n",
    "cis_0_pod1 = []\n",
    "\n",
    "diff = 4\n",
    "mean = 12\n",
    "pop_mean = 10\n",
    "for i in range(1,100):\n",
    "    x = get_normal_sample(30,mean,4)\n",
    "    alfa = i*0.01\n",
    "    alfas.append(alfa)\n",
    "    cis_0.append(conf_int_one_sample(x,alfa,alternative='left'))\n",
    "    cis_0_pod3.append(conf_int_one_sample(x,alfa,diff=diff,alternative='left'))\n",
    "    cis_0_pod1.append(np.mean(x))\n",
    "fig, (ax1, ax2, ax3) = plt.subplots(3, sharex=True)\n",
    "\n",
    "ax1.set_title('podejście1')\n",
    "ax2.set_title('podejście2')\n",
    "ax3.set_title('podejście3')\n",
    "\n",
    "for i in range(len(alfas)):\n",
    "    \n",
    "    if cis_0[i] > pop_mean + diff:\n",
    "        ax2.scatter(cis_0[i],alfas[i],color = 'red')\n",
    "    elif cis_0[i] > pop_mean and cis_0[i] < pop_mean+diff:\n",
    "        ax2.scatter(cis_0[i],alfas[i],color = 'blue')\n",
    "    else:\n",
    "        ax2.scatter(cis_0[i],alfas[i],color = 'yellow')\n",
    "    \n",
    "    if cis_0_pod3[i] > pop_mean + diff:\n",
    "        ax3.scatter(cis_0_pod3[i],alfas[i],color = 'red')\n",
    "    elif cis_0_pod3[i] > pop_mean and cis_0_pod3[i] < pop_mean+diff:\n",
    "        ax3.scatter(cis_0_pod3[i],alfas[i],color = 'blue')\n",
    "    else:\n",
    "        ax3.scatter(cis_0_pod3[i],alfas[i],color = 'yellow')\n",
    "    \n",
    "    if cis_0_pod1[i] > pop_mean + diff:\n",
    "        ax1.scatter(cis_0_pod1[i],alfas[i],color = 'red')\n",
    "    elif cis_0_pod1[i] > pop_mean and cis_0_pod1[i] < pop_mean+diff:\n",
    "        ax1.scatter(cis_0_pod1[i],alfas[i],color = 'blue')\n",
    "    else:\n",
    "        ax1.scatter(cis_0_pod1[i],alfas[i],color = 'yellow')\n",
    "\n",
    "ax1.axvline(x=pop_mean, color = 'black', label = 'pop_mean')\n",
    "ax1.axvline(x=pop_mean+diff, color = 'orange', label = 'pop_mean + diff')\n",
    "ax1.axvline(x=mean, color = 'brown', label = 'sample_population_mean')\n",
    "fig.legend(frameon=False, loc = 'center', bbox_to_anchor = (0.5,1.05))\n",
    "ax2.axvline(x=pop_mean, color = 'black')\n",
    "ax2.axvline(x=pop_mean+diff, color = 'orange')\n",
    "ax2.axvline(x=mean, color = 'brown')\n",
    "ax3.axvline(x=pop_mean, color = 'black')\n",
    "ax3.axvline(x=pop_mean+diff, color = 'orange')\n",
    "ax3.axvline(x=mean, color = 'brown')\n",
    "ax3.set_xlabel('dolne granice przedziałów ufności dla trzech podejść - odcinek od pop_mean do pop_mean + diff przedstawia mały efekt')\n",
    "ax2.set_ylabel('wartość alfa')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "def variation(array,n):\n",
    "    vals = [random.choice(array) for i in range(n)]\n",
    "    return vals\n",
    "delta = 4\n",
    "sd = 4\n",
    "dane = []\n",
    "mean_pop = 0\n",
    "alfa= 0.05\n",
    "mi = 2\n",
    "result1 = []\n",
    "result2 = []\n",
    "result3 = []\n",
    "ile = 0\n",
    "#for i in range(0,20):\n",
    "#    mi = delta + i*0.01\n",
    "#    for k in range(-20,21):\n",
    "#        sd = 3 + k*0.01\n",
    "#        n = 40 + int(random.randint(0,10)*4)\n",
    "#        popp = get_normal_sample(10000,mi,sd)\n",
    "#        for j in range(10):\n",
    "#            ile+=1\n",
    "#            #mi = 6\n",
    "#            sample = variation(popp,n)\n",
    "#            dane.append([t_test_for_one_group(sample,mean_pop,alternative='greater'), #pval_2\n",
    "#                         t_test_for_one_group(sample,mean_pop,alternative='greater',diff = delta), #p_val3\n",
    "#                         mi, #prawdziwa średnia\n",
    "#                         np.mean(sample)]) #estymator\n",
    "popp = get_normal_sample(10000,mi,sd)\n",
    "for i in range(1000):\n",
    "    sample = variation(popp,n)\n",
    "    dane.append([t_test_for_one_group(sample,mean_pop,alternative='greater'), #pval_2\n",
    "                 t_test_for_one_group(sample,mean_pop,alternative='greater',diff = delta), #p_val3\n",
    "                 mi, #prawdziwa średnia\n",
    "                 np.mean(sample)]) #estymator\n",
    "\n",
    "for i in dane:\n",
    "    if (i[3] > mean_pop + delta) and (i[2] > mean_pop+delta):\n",
    "        result1.append('d1')\n",
    "    elif (i[3] < mean_pop + delta) and (i[2] <= mean_pop+delta):\n",
    "        result1.append('m1')\n",
    "    elif (i[3] > mean_pop + delta) and (i[2] <= mean_pop+delta):\n",
    "        result1.append('d0')\n",
    "    elif (i[3] < mean_pop + delta) and (i[2] > mean_pop+delta):\n",
    "        result1.append('m0')\n",
    "    \n",
    "    if (i[0] < alfa) and (i[3] > mean_pop+delta) and (i[2] > mean_pop+delta):\n",
    "        result2.append('d1')\n",
    "    #elif (i[0] < alfa) and (i[3] > mean_pop+delta) and (i[2] <= mean_pop+delta):\n",
    "    #    result2.append('d0')\n",
    "    #elif (i[0] < alfa) and (i[3] < mean_pop+delta) and (i[2] > mean_pop+delta):\n",
    "    #    result2.append('m0')\n",
    "    #elif (i[0] > alfa) and (i[3] < )\n",
    "    elif (i[0] > alfa) and (i[3] > mean_pop and i[3] < mean_pop+diff):\n",
    "        result2.append('m1')\n",
    "    elif (i[3] < mean_pop):\n",
    "        result2.append('m1')\n",
    "    else:\n",
    "        result2.append('nwd')\n",
    "    \n",
    "    if (i[1] < alfa) and (i[3] > mean_pop + diff):\n",
    "        result3.append('d1')\n",
    "    elif (i[1] < alfa) and (i[3] < mean_pop + diff):\n",
    "        result3.append('m1')\n",
    "    elif i[1] > alfa:\n",
    "        result3.append('nwd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "podejście 1\n",
      "d1:  0\n",
      "d0:  0\n",
      "m1:  1000\n",
      "m0:  0\n",
      "\n",
      " podejście 2 \n",
      "\n",
      "d1:  0\n",
      "d0:  0\n",
      "m1:  12\n",
      "m0:  0\n",
      "nwd:  988\n",
      "\n",
      " podejście 3 \n",
      "\n",
      "d1:  0\n",
      "d0:  0\n",
      "m1:  0\n",
      "m0:  0\n",
      "nwd:  1000\n"
     ]
    }
   ],
   "source": [
    "print('podejście 1')\n",
    "print('d1: ',result1.count('d1'))\n",
    "print('d0: ',result1.count('d0'))\n",
    "print('m1: ',result1.count('m1'))\n",
    "print('m0: ',result1.count('m0'))\n",
    "#print(len(result1)/ile)\n",
    "print('\\n','podejście 2','\\n')\n",
    "print('d1: ',result2.count('d1'))\n",
    "print('d0: ',result2.count('d0'))\n",
    "print('m1: ',result2.count('m1'))\n",
    "print('m0: ',result2.count('m0'))\n",
    "#print('zle: ',result2.count('zle'))\n",
    "print('nwd: ',result2.count('nwd'))\n",
    "#print(len(result2)/ile)\n",
    "print('\\n','podejście 3','\\n')\n",
    "print('d1: ',result3.count('d1'))\n",
    "print('d0: ',result3.count('d0'))\n",
    "print('m1: ',result3.count('m1'))\n",
    "print('m0: ',result3.count('m0'))\n",
    "#print('zle: ',result3.count('zle'))\n",
    "print('nwd: ',result3.count('nwd'))\n",
    "#print(len(result3)/ile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}