From 392e56bcebdbc391e1c63bdaebc2f9e89270f1f8 Mon Sep 17 00:00:00 2001 From: Julian T Date: Tue, 6 Apr 2021 13:04:14 +0200 Subject: Add nix-shell and prob things --- sem6/prob/miniexam/Untitled.ipynb | 346 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 346 insertions(+) create mode 100644 sem6/prob/miniexam/Untitled.ipynb (limited to 'sem6/prob/miniexam/Untitled.ipynb') diff --git a/sem6/prob/miniexam/Untitled.ipynb b/sem6/prob/miniexam/Untitled.ipynb new file mode 100644 index 0000000..3d81069 --- /dev/null +++ b/sem6/prob/miniexam/Untitled.ipynb @@ -0,0 +1,346 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy import stats" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problem 1\n", + "\n", + "Man kan sige at distribution af et enkelt kast af den 8 kantede terning er $1/8$ for hver værdi i $[1, 8]$.\n", + "Ved at summe dem sammen kommer de til at ligne en gaussian random variable.\n", + "\n", + "Man ved også de to limits for distributionen, nemlig $[50 \\cdot 1, 50 \\cdot 8]$, og hver imellem må mean ligge.\n", + "Ud fra intervallet og mean kan man regne varience." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Man kan først finde størrelsen af intervallet, eller var * 2\n", + "var2 = 50 * 8 - 50 * 1\n", + "sigma2 = var2/2\n", + "mean = 50 * 1 + sigma2\n", + "\n", + "# Ved coin flip får man egentlig det samme distribution" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Part A\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "slots = np.zeros(500)\n", + "x = np.arange(500)\n", + "for exp in range(1000):\n", + " s = 0\n", + " for i in range(50):\n", + " r = np.random.randint(1, 9)\n", + " #r = [1, 8][np.random.randint(0, 2)]\n", + " s += r\n", + " slots[s] += 1\n", + "\n", + "plt.bar(x, slots)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problem 2\n", + "\n", + "The distribution function is given by:\n", + "$$\n", + "f(x)_\\theta = \\frac x {\\theta^2} e ^ {- \\frac x \\theta }\n", + "$$\n", + "\n", + "Then we can find the likelyhood function $f(x_1,...,x_n | \\theta)$.\n", + "\n", + "$$\n", + "f(x_1,...,x_n | \\theta) = f(x_1)_\\theta \\cdot ... \\cdot f(x_n)_\\theta = \\frac {\\prod_i x_i} {\\theta^{2n}} \\cdot \\exp \\left( -\\frac {\\sum_i} \\theta \\right)\n", + "$$\n", + "\n", + "Her kan man tage log på hver side\n", + "\n", + "$$\n", + "\\log f(x_1,...,x_n | \\theta) = \\log \\left( \\frac {\\prod_i x_i} {\\theta^{2n}} \\right) - \\frac 1 \\theta \\sum_i x_i\n", + "$$\n", + "\n", + "Og diff i forhold til $\\theta$.\n", + "\n", + "$$\n", + "\\frac d {d\\theta} \\log f(x_1,...,x_n | \\theta) = -\\frac {2n} \\theta + \\frac 1 {\\theta^2} \\sum_i x_i\n", + "$$\n", + "\n", + "Og man kan løse for $0$.\n", + "\n", + "$$\n", + "\\theta = \\frac {\\sum_i x_i} {2n}\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimated theta = 1.2944444444444445\n" + ] + } + ], + "source": [ + "# Part B\n", + "# Her indsættes samples\n", + "\n", + "samples = np.array([3.2, 1.4, 6.5, 2.2, 1.8, 2.6, 3.9, 0.5, 1.2])\n", + "N = len(samples)\n", + "\n", + "sum_samples = np.sum(samples)\n", + "\n", + "theta_est = sum_samples / (2 * N)\n", + "print(f\"Estimated theta = {theta_est}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "argmax: 1.2962962962962963\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEDCAYAAAAlRP8qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAj/ElEQVR4nO3deXScd33v8fd3NFqsxZK12JYtyWtsx3glirOTACELJKSl0JPALYUbbnALHLhcLnB7Tttzy+npdtsLtKQhDbRwaUlDSblprklCIAtJSLCdeInj2JZ3LbY2S9a+ze/+MTPORJbssT0zz6LP6xxFmplnnueryP74p9/zW8w5h4iIBF/E6wJERCQzFOgiIiGhQBcRCQkFuohISCjQRURCQoEuIhISnga6mX3XzNrN7PUMnOvdZrYj5WPYzH4jA2WKiASCeTkO3czeBfQD33fOrcngeSuBJqDOOTeYqfOKiPiZpy1059zzQHfqc2a2zMyeMLPtZvZLM1t1Eaf+MPBThbmIzCR+7EN/EPicc+4K4EvA/RdxjruBH2a0KhERn4t6XUAqMysFrgV+ZGbJpwsTr30I+JMp3tbinLs15Ry1wFrgyexWKyLiL74KdOK/MfQ45zZMfsE59yjwaBrn+G3g351zYxmuTUTE13zV5eKcOw0cNrOPAFjc+gs8zT2ou0VEZiCvhy3+EPgVsNLMms3sXuBjwL1mthPYA9x1AedbDNQDz2WhXBERX/N02KKIiGSOr7pcRETk4nl2U7S6utotXrzYq8uLiATS9u3bO51zNVO95lmgL168mG3btnl1eRGRQDKzo9O9pi4XEZGQUKCLiISEAl1EJCQU6CIiIaFAFxEJCQW6iEhIKNBFRELCb6stSpZ09I3w+K5WDPjAugXUlBV6XZKIZJgCfQZ4vaWXjz30Cr1D8RWF//fTB/jO7zbSuLjS48pEJJPU5RJy3QOjfOIft1JaGOXJL7yLJ7/wLipLCrj3e9s42jXgdXkikkHnDXQz+66ZtZvZ69O8bmb2TTNrMrNdZvbOzJcpF+uvntxHz+AoD/1uIyvnl7Fyfhnf/8+biMUcf/Dvu9FqmyLhkU4L/Z+A287x+u3AZYmP+4C/v/SyJBOOdQ3y8NZjfPyaxVxeO/vM8/WVxXz5tpW82NTFU2+c9LBCEcmk8wa6c+55oPsch9wFfN/FvQxUJPb1FI/900tHyDPj0zcuPeu1ezY1sKS6hK8/fYBYTK10kTDIRB/6QuB4yuPmxHNnMbP7zGybmW3r6OjIwKVlOsNjE/xo+3E+sK6WebOLzno9mhfhM+9ezt6207x4sNODCkUk0zIR6DbFc1M2+ZxzDzrnGp1zjTU1Uy7nKxnyywOd9A2P86F31k17zJ3ra6ksKeAHL0+7GqeIBEgmAr2Z+D6eSXVAawbOK5dgy+42KorzuXZZ1bTHFEbz+EhjHU/vbaetdyiH1YlINmQi0B8DPp4Y7XI10Ouca8vAeeUiDY9N8LM3TnLr6vnk5537R/zRTQ1MxBw/eU3/BosEXTrDFn8I/ApYaWbNZnavmW02s82JQ7YAh4Am4B+A389atZKWbUdO0T8yzq1r5p332EVVJWxsqOA/dirQRYLuvDNFnXP3nOd1B3wmYxXJJXuhqZP8POOqJdN3t6S6c90C/uTxN2hq72f53NIsVyci2aKZoiH0YlMnG+vnUFKY3soOd6yrxQwe36VWukiQKdBDpmdwlNdbe7lueXXa75k7u4grGubw9F5NMhIJMgV6yLx8qAvn4Lrl6XW3JL3n8rm83nKaE73DWapMRLJNgR4yrx7roSAaYV1dxQW97+bL4zdQf/FmexaqEpFcUKCHzGvHTrF2YTkF0Qv70V42t5S6ObP4xZvqdhEJKgV6iIxNxNjV3MuG+ooLfq+ZcfPl83ihqZPhsYnMFyciWadAD5E32/oYGY+xsaHiot5/44oahsdibDtyKrOFiUhOKNBD5LXj8SDe2DDnot6/aUkl0YhpsS6RgFKgh8jO471UlxayoPzs1RXTUVIYZWNDBS82KdBFgkiBHiJ7206zesFszKZaADM91y6rZndLL72DYxmsTERyQYEeEmMTMZra+7m8tuySznPd8mqcg18d6spQZSKSKwr0kDjY0c/oRIzVKVvNXYwN9RXMys/jJfWjiwSOAj0k9radBnjb3qEXoyAa4aqllbygfnSRwFGgh8Tetj4KohGWVpdc8rmuXlrFoY4BOvpGMlCZiOSKAj0k9radZsW8UqLn2dAiHVcurgRg+9Fz7Q0uIn6jQA+JvW2nuXz+pXW3JK1dWE5hNMKvD2uCkUiQKNBDoKNvhM7+UVZdYv95UkE0wob6CraphS4SKAr0EGhq7wdgxbzM7Ta0aUkle1pPMzAynrFzikh2KdBD4GBHPNCX1WQu0BsXVzIRc7x6TN0uIkGhQA+BpvZ+igvyqL3IKf9TeWdDBRGDrVqoSyQwFOghcLCjn2U1pZc05X+ysqJ8Vi+YzdbD6kcXCQoFeggc6hhgWc2ljz+frHFRJa8dP8XYRCzj5xaRzFOgB9zg6DgtPUMZ7T9Palw8h+GxGG+29WX83CKSeQr0gDvUMQDAsrmZD/TkuurJddZFxN8U6AGXHOGyPAuBvqC8iLllhbx2rCfj5xaRzFOgB9zB9n4iBouqijN+bjNjY0MFr2nookggKNAD7mDnAPWVxRRG87Jy/o0NczjSNUj3wGhWzi8imaNAD7ijXQMsqsr8CJekjfUVAOxQP7qI7ynQA8w5x9GuQRZVZr67JWltXTl5EVM/ukgAKNADrGdwjL7h8az0nycVF0RZNb9MgS4SAGkFupndZmb7zKzJzL46xevlZvYfZrbTzPaY2SczX6pMdrR7ECCrXS4AGxsq2HG8h4mYy+p1ROTSnDfQzSwP+BZwO7AauMfMVk867DPAG8659cBNwF+bWUGGa5VJjnbFx6Bns4UOsLF+Dv0j42eGSIqIP6XTQt8ENDnnDjnnRoGHgbsmHeOAMosvJlIKdANadzXLjnbFW+gNWexDh3gLHdDwRRGfSyfQFwLHUx43J55L9XfA5UArsBv4vHPurAVAzOw+M9tmZts6OjousmRJOto1yPzZRRTlZ2fIYtKS6hLKZ+WrH13E59IJ9KmW8JvcmXorsANYAGwA/s7Mzto+xzn3oHOu0TnXWFNTc4GlymRHuwZoyHJ3C6ROMOrJ+rVE5OKlE+jNQH3K4zriLfFUnwQedXFNwGFgVWZKlOkc7R5kcQ4CHeL96Pvb++gbHsvJ9UTkwqUT6FuBy8xsSeJG593AY5OOOQa8F8DM5gErgUOZLFTebnB0nI6+kayPcEna0FCBc7C7uTcn1xORC3feQHfOjQOfBZ4E9gKPOOf2mNlmM9ucOOxrwLVmthv4OfAV51xntooWONadmxuiSRvqKgB47XhPTq4nIhcums5BzrktwJZJzz2Q8nUrcEtmS5NzOdKZHIOem0AvL85naXUJOxToIr6lmaIBdTw5qagyN10uABvq4xOMnNMEIxE/UqAHVEvPEGWFUcqL83N2zQ0NFXT0jdDaO5yza4pI+hToAdXaM8SCilk5veaG5MqLGr4o4ksK9IBq7R2itqIop9dcNX82BdGIltIV8SkFekC19gznvIVeEI3wjgWzdWNUxKcU6AE0NDpB98AoC3Mc6BDvdtnd0svYxFkrO4iIxxToAdTWOwRAbXluu1wgHujDYzH2nejL+bVF5NwU6AHU2hMfZZLrLheILwEAsLO5J+fXFpFzU6AHUGtPvIXuRZdLfeUsKksKNNJFxIcU6AHU2juEGcybnfsuFzM7M8FIRPxFgR5ArT1D1JQWUhD15se3ob6Cpo5+rbwo4jMK9ADyYshiqg318ZUXd2nlRRFfUaAHUGvPkCf950nrkzNG1e0i4isK9IBxzsVniXowZDGpfFY+S2tKtIORiM8o0APm1OAYw2MxT7tcIL4+ulZeFPEXBXrAJIcseh7oDRV09o/QkqhHRLynQA+YFg/HoKfaoH50Ed9RoAdMWyLQc73S4mRnVl5UP7qIbyjQA6a1d5iCaISqkgJP6yiIRlizYLaWABDxEQV6wLQkhiyamdelsKF+jlZeFPERBXrAtPV4O2Qx1YYGrbwo4icK9IDxepZoqo26MSriKwr0ABmbiHGyzz+BXjdnFlUlBQp0EZ9QoAfIid5hnIOFHo9wSdLKiyL+okAPkLbe+MYWteX+aKFDfDz6wY5+TmvlRRHPKdADxC+zRFNtaEisvHhcKy+KeE2BHiAtZwLdH10uAOvqKgDYcfyUt4WIiAI9SFp7hqgozqe4IOp1KWckV15UP7qI9xToAdLWO8wCH/WfJyVvjGrlRRFvpRXoZnabme0zsyYz++o0x9xkZjvMbI+ZPZfZMgXiLXQ/9Z8nbayvoLN/VCsvinjsvIFuZnnAt4DbgdXAPWa2etIxFcD9wAedc+8APpL5UiU+7d8//edJG+rnAJpgJOK1dFrom4Am59wh59wo8DBw16RjPgo86pw7BuCca89smdI3PEbf8Di1Pmyhr6oto1ArL4p4Lp1AXwgcT3ncnHgu1Qpgjpk9a2bbzezjU53IzO4zs21mtq2jo+PiKp6hkmPQ/djlkp8XYc3CcrXQRTyWTqBPtazf5LtfUeAK4APArcAfmtmKs97k3IPOuUbnXGNNTc0FFzuTvbWxhf+6XCB+Y1QrL4p4K51AbwbqUx7XAa1THPOEc27AOdcJPA+sz0yJAm9NKvLTLNFUG+orGBnXyosiXkon0LcCl5nZEjMrAO4GHpt0zP8FbjCzqJkVA1cBezNb6szW1jNMXsSYW1bodSlTSm5J95q6XUQ8c95Ad86NA58FniQe0o845/aY2WYz25w4Zi/wBLAL+DXwkHPu9eyVPfO09gwxf3YR0Tx/Th2omzOL6tIC3RgV8VBaUw6dc1uALZOee2DS478C/ipzpUmqlp4hX035n+ytlRe1BICIV/zZ3JOztPYO+bb/PGl9XQUHOwboHdLKiyJeUKAHQCzmONHrn40tprOhoQKAXdo4WsQTCvQA6OwfYWzC+XbIYlJy5cWdujEq4gkFegC0+HzIYlL5rHyWaeVFEc8o0APAz7NEJ9tQP0crL4p4RIEeAK1nZokGINAb4isvNp/SyosiuaZAD4CWniFKCvKYPcs/G1tMZ2NigpG6XURyT4EeAK09Q9RWzMJsqmV1/GXl/DJm5eex/ajGo4vkmgI9ANoCMGQxKT8vwsaGCrYe6fa6FJEZR4EeAK0+3dhiOlcurmRv22n6hjXBSCSXFOg+Nzw2QWf/qC/3Ep3OpiWVxBzqdhHJMQW6zyWHLPpxp6LpbGyoIBoxfn1Y3S4iuaRA97m2xJBFPy/MNVlxQZQ1C8vVjy6SYwp0n2sJ0Bj0VJuWVLLzeC/DYxNelyIyYyjQfa61J97lMr88OC10iN8YHZ2Isau51+tSRGYMBbrPtfUOUV1aSGE0z+tSLkjjojkA6nYRySEFus+1BGzIYtKckgJWzCvVjVGRHFKg+1xrz1BgJhVNduXiSl49eoqJmBbqEskFBbqPOedo7Rn2/bK509m0pJK+kXH2tp32uhSRGUGB7mO9Q2MMjU0EashiqisXVwKo20UkRxToPhbUIYtJCypm0VBZzMuHurwuRWRGUKD7WHLIYpBmiU527bIqXj7UpX50kRxQoPtYawBniU52zbIqTg+Ps6dV49FFsk2B7mOtvUMU5EWoLin0upSLdu2yagBeOqhuF5FsU6D7WGvPMLUVRUQi/t/YYjo1ZYWsmFfKi02dXpciEnoKdB9r7RmiNmBT/qdy7bJqth7pZnQ85nUpIqGmQPextgBPKkp17bIqhsdi2mdUJMsU6D41PhHjxOnhwA5ZTHXV0ioihrpdRLJMge5TJ/tGiDkCO0s0VfmsfNYsLOdXujEqklUKdJ9qOZWYVDQn+IEO8eGLrx0/xeDouNeliIRWWoFuZreZ2T4zazKzr57juCvNbMLMPpy5Emem1oDPEp3sumXVjE04XtEyACJZc95AN7M84FvA7cBq4B4zWz3NcX8BPJnpImeilhBMKkq1aUklhdEIz+/v8LoUkdBKp4W+CWhyzh1yzo0CDwN3TXHc54AfA+0ZrG/GaukZorKkgOKCqNelZERRfh5XL63iuX0KdJFsSSfQFwLHUx43J547w8wWAr8JPHCuE5nZfWa2zcy2dXToL/a5tJwaCk3rPOmmlTUc6hzgWNeg16WIhFI6gT7VNMXJKy19HfiKc+6cOwI75x50zjU65xpramrSLHFmiu9UFI7+86QbV8R/5s/t1y9xItmQTqA3A/Upj+uA1knHNAIPm9kR4MPA/Wb2G5kocCaKb2wRjklFqZZUl9BQWcyz6nYRyYp0An0rcJmZLTGzAuBu4LHUA5xzS5xzi51zi4F/A37fOfeTTBc7U/QMjjE4OhG6FrqZceOKGl462MXI+Dl/mRORi3DeQHfOjQOfJT56ZS/wiHNuj5ltNrPN2S5wJkqOcKkLyRj0VDetrGFobIKth095XYpI6KQ1hMI5twXYMum5KW+AOuc+cellzWxvDVkMX6Bfs6yKgrwIz+1v5/rLqr0uRyRUNFPUh8I2qShVcUGUTUsq1Y8ukgUKdB9qOTVEUX6EypICr0vJiptW1nCgvZ/j3Rq+KJJJCnQfau2Nj3AxC+7GFufyvtXzAHjqjZMeVyISLgp0H2o5Fb4x6KkWVZWwan4ZT+054XUpIqGiQPehlp5wrIN+LresnsfWI910D4x6XYpIaCjQfWZ4bILO/pHQB/r7Vs8n5uDne9XtIpIpCnSfaesdBsI5ZDHVmoWzqS0v4mfqRxfJGAW6z4RtY4vpmBm3rJ7H8wc6GBrVrFGRTFCg+0xLT3woX9i7XABuecd8hsdiPH9AY9JFMkGB7jMtPcOYwfzycC2dO5VNSyqpKM7np7vbvC5FJBQU6D7T3D3IgvJZ5OeF/0eTnxfh9jXz+dkbJ9XtIpIB4U+NgDnWPUh9Zfi7W5LuXLeAgdEJntmnNdJFLpUC3WeOdQ/SUFnsdRk5c9XSKqpLC/mPnZOX2BeRC6VA95Gh0Qna+0ZmVKDnRYw71tXyizfb6Rse87ockUBToPtI86n4CJf6GRToAHeur2VkPMbTmmQkckkU6D5yrHtmBvrG+jksrJjFYzvU7SJyKRToPpIM9JnU5QIQiRh3rK/l+QOddPSNeF2OSGAp0H3kePcQxQV5VIV0HfRz+cgVdUzEHD95rcXrUkQCS4HuI8kRLmFdB/1cls8tY2NDBT/afhznnNfliASSAt1HjncPzrj+81QfuaKe/Sf72dXc63UpIoGkQPcJ59yMG4M+2R3raynKj/DItuNelyISSAp0n+jsH2VobGJGB/rsonxuX1PLYztbGR7TUgAiF0qB7hMzdYTLZB+5oo6+4XF++roW7BK5UAp0nzjWPQAwo9ZxmcrVS6tYWlPC91466nUpIoGjQPeJw52DRGzmTSqaLBIxPn71InYc72Hn8R6vyxEJFAW6TxzuHKBuTjGF0TyvS/Hcb11RR0lBHt/71RGvSxEJFAW6Txzq6GdJdYnXZfhCWVE+v3VFHY/vbKOrXzNHRdKlQPcB5xyHOwdYWqNAT/r4NYsYnYjx8FYNYRRJlwLdB9r7RhgcnWCpWuhnLJ9bxvXLq/neS0cYGdcQRpF0pBXoZnabme0zsyYz++oUr3/MzHYlPl4ys/WZLzW8DnXER7gsqS71uBJ/+fSNS2nvG+HH27W+i0g6zhvoZpYHfAu4HVgN3GNmqycddhi40Tm3Dvga8GCmCw2zw52JQFeXy9tcv7yatQvL+fbzBxmfiHldjojvpdNC3wQ0OecOOedGgYeBu1IPcM695Jw7lXj4MlCX2TLD7VBHP0X5EWpnF3ldiq+YGZ959zKOdg2y5fUTXpcj4nvpBPpCIPXOVHPiuencC/x0qhfM7D4z22Zm2zo6OtKvMuQOdw6wuKqESGTmrbJ4Presns+ymhLuf6ZJqzCKnEc6gT5Vykz5N8vM3k080L8y1evOuQedc43Oucaampr0qwy5Q50DGrI4jUjE2HzjMt480cdTb2iLOpFzSSfQm4H6lMd1wFl7hZnZOuAh4C7nXFdmygu/4bEJjnYNcNm8Mq9L8a3f3LiQpdUl/K8n9zERUytdZDrpBPpW4DIzW2JmBcDdwGOpB5hZA/Ao8DvOuf2ZLzO8Dnb0E3OwUoE+rWhehC/dupID7f08+mqz1+WI+NZ5A905Nw58FngS2As84pzbY2abzWxz4rA/AqqA+81sh5lty1rFIbP/ZB8AK+dryOK53L5mPmsXlvP1pw9oaV2RaaQ1Dt05t8U5t8I5t8w596eJ5x5wzj2Q+PpTzrk5zrkNiY/GbBYdJvtO9FOQF2FRlfrQz8XM+Mptq2jpGeIHL2slRpGpaKaox/af7GNpTQn5efpRnM/1l1Vzw2XVfOPnB+jo0xovIpMpRTy270QfK+er/zxdf3znOxgem+AvnnjT61JEfEeB7qG+4TFaeoZYoRuiaVs+t5R7r1/Kv21vZvvRbq/LEfEVBbqHDrT3AyjQL9Dn3rOc2vIi/vAne7QkgEgKBbqH9p1IjHBRoF+QksIof3THat5oO80Dzx30uhwR31Cge+j1ll7KiqIzfh/Ri3H72lruWFfLN35+gDdaT3tdjogvKNA9tLull7ULyzHTGi4X42t3raF8VgFffGQHo+PqehFRoHtkdDzGm219rF1Y7nUpgTWnpIA/+9Ba3jzRx18/tc/rckQ8p0D3yP6TfYxOxFijQL8k71s9j49e1cC3nz/EU3u0xK7MbAp0j+xu6QVQCz0D/uiO1axdWM5/+9FOjnYNeF2OiGcU6B7Z1dxDWVGURVXFXpcSeEX5edz/sXcSMWPzD15lYGTc65JEPKFA98j2o6d4Z8Mc3RDNkPrKYr5x9wb2n+zjs//yqsany4ykQPfAqYFR9p/s58rFc7wuJVRuWjmXr921hmf2dfDHj+3RDkcy40S9LmAm2n40vv3qlYsrPa4kfD56VQPNpwa5/9mDVJUU8MVbVnpdkkjOKNA9sPVoN/l5xvr6Cq9LCaUv3bKSrv5RvvmLJiIR4ws3r/C6JJGcUKB7YOvhbtYuLKcoP8/rUkIpEjH+7ENriTnH158+QMzBf735Mt2vkNBToOdY79AYO5t7+b0bl3ldSqhFIsZf/NY6AL6ZWD/9a3e9g6jWnZcQU6Dn2AsHOpmIOW5aWeN1KaEXiRh/+eF11JQVcv+zBzl5ephv3rOR0kL9sZdwUnMlx57d187soigb1H+eE2bGl29bxZ/+5hqe3dfOB//uhTOrXIqEjQI9h5xzPLe/gxtW1OhX/xz72FWL+OdPXc3poXHu+tYL/Nv2Zg1rlNBRquTQq8d6aO8b4b2r5npdyox0zbIqtnz+ejbUV/ClH+3k0/9nO+2nh70uSyRjFOg59NiOFgqjEd63ep7XpcxYc8uK+OdPXc0fvH8Vz+3v4Oa/eY5/3XqMiZha6xJ8CvQcGZ+I8fiuNm6+fB5lRflelzOj5UWM+961jJ9+/gZWzZ/NV368mzv/9gVeaur0ujSRS6JAz5HnD3TQNTDKnesXeF2KJCytKeVfP30137xnI71DY3z0oVf4ne+8wsuHutS/LoGk8Vs58o8vHmFuWSHvUf+5r5gZH1y/gFtWz+N7Lx3hH355iLsffJnGRXP41A1Lee/lc8nXDWwJCAV6Drx54jS/PNDJl25ZQUFU4eBHRfl5fPrGZfzutYt5ZNtxvv3cITb/YDtzywr57cZ6fruxngYtdSw+Z179atnY2Oi2bdvmybVz7VPf28Yrh7v45ZffTUVxgdflSBrGJ2I8t7+Df3nlGM/sayfm4puR3L52PrevqWVJdYnXJcoMZWbbnXONU72mFnqWPbe/g6f3nuS/37pSYR4g0bwI7718Hu+9fB6tPUM8vquVLbtP8JdP7OMvn9jH0poSrltWzXXLq7hmaTXlxbrRLd5TCz2LuvpHuPNvX6C4MMrjn7tei3GFQEvPEE++foJfHujglcPdDI5OYAYr5paxrq6c9fUVrK+rYOX8MnWvSVacq4WuQM+SvuExPvmPW9nd0suPNl/DuroKr0uSDBsdj7GzuYcXmzrZcbyHXc29dA+MAvGhkYsqi1k2t5Tlc0tZXlPK4uoSFlbMYm5ZIZGIVn6Ui3PJXS5mdhvwDSAPeMg59+eTXrfE6+8HBoFPOOdevaSqA+yN1tN88ZEdNLX38817NirMQ6ogGuHKxZVnNipxztF8aoidzT282dZHU3s/TR39PPNmO+MpE5fy84z55UUsrJjFgvJZVJUWUFVaSGVJAVUl8a+rSgqoKM6npCCq8Je0nTfQzSwP+BbwPqAZ2Gpmjznn3kg57HbgssTHVcDfJz7PCMNjE7T0DLHjWA9P7DnB03tPUlVSyHc+cSU3rtCqijOFmVFfWUx9ZTF3rHvr+bGJGEe7BjnePUhLzxAtPUO0Jj5eOdxNZ/8II+NT74FqBqUFUUqLopQWvvV5dlE+xQV5FOXnUZQfoTCaR2E0QmF+hKL8xNeJ54ry88jPi5AXMaJ5Rl7EyI+8/XE0kvwceetxXvxzxAwz4p/hzGOtL+8/6bTQNwFNzrlDAGb2MHAXkBrodwHfd/H+m5fNrMLMap1zbZku+Nl97Xzt8filXeI/ybaPcw4HOAcu8axz8Q/Odwypx7kzz531nsRBqdfuT9llvrq0gN+7cRn/5YalzCnRTVCB/LxIvNtlbumUrzvnGBydoHtglK6BUbr6R+gaGKVncJT+kQn6h8fpHxmjf2ScvuH4R1vvMAMj44yMxxgem2B4bAIvVi+YHPQYRAwMi39Ohj/x5YyN+HPxXzqSx8SPn3zetz0+67rn/8fkrHOcdc5zXzOd6571ljTrvvvKej51w9KzL3iJ0gn0hcDxlMfNnN36nuqYhcDbAt3M7gPuA2hoaLjQWgEoK8pn1fzZZ/5PJf+AJP/HJf/wpD5H4g+Mve09b/1AzZI/zPMcw9t/oMnXK0vyWThnFivnzWbV/DL9iiwXxMwoKYxSUhilvvLix7qPT8QYHo8xMjZxJuhHxmOMjMcYHY8xEXOMx2KMxxwTEy7+OfFc/LN76/NE/LjkcxD/hyeWaCDFzjRy3NsexxItodiZ5+MNp2RjKPVxLNEqik365cTx9n+ZJt/mm+rfrbOPOfebJp9jqnuJZx9zYec464wpT1SXFp51vUxIJ9CnSqfJtaZzDM65B4EHIX5TNI1rn+WKRXO4YtGci3mrSKhF8yKU5kW0gccMls64qmagPuVxHdB6EceIiEgWpRPoW4HLzGyJmRUAdwOPTTrmMeDjFnc10JuN/nMREZneeX83c86Nm9lngSeJD1v8rnNuj5ltTrz+ALCF+JDFJuLDFj+ZvZJFRGQqaXW2Oee2EA/t1OceSPnaAZ/JbGkiInIhNDdZRCQkFOgiIiGhQBcRCQkFuohISHi22qKZdQBHL/Lt1cBM29FX3/PMoO95ZriU73mRc27KRaI8C/RLYWbbpls+Mqz0Pc8M+p5nhmx9z+pyEREJCQW6iEhIBDXQH/S6AA/oe54Z9D3PDFn5ngPZhy4iImcLagtdREQmUaCLiIRE4ALdzG4zs31m1mRmX/W6nmwzs++aWbuZve51LbliZvVm9oyZ7TWzPWb2ea9ryiYzKzKzX5vZzsT3+z+9rilXzCzPzF4zs8e9riUXzOyIme02sx1mti3j5w9SH3piw+r9pGxYDdwzacPqUDGzdwH9xPdsXeN1PblgZrVArXPuVTMrA7YDvxHWn7PF9zUscc71m1k+8ALweefcyx6XlnVm9kWgEZjtnLvD63qyzcyOAI3OuaxMpApaC/3MhtXOuVEguWF1aDnnnge6va4jl5xzbc65VxNf9wF7ie9RG0ourj/xMD/xEZyW1kUyszrgA8BDXtcSFkEL9Ok2o5aQMrPFwEbgFY9LyapE18MOoB34mXMu1N9vwteBLwOx8xwXJg54ysy2m9l9mT550AI9rc2oJRzMrBT4MfAF59xpr+vJJufchHNuA/H9eDeZWai718zsDqDdObfd61py7Drn3DuB24HPJLpUMyZoga7NqGeIRF/yj4F/ds496nU9ueKc6wGeBW7ztpKsuw74YKJP+WHgPWb2A29Lyj7nXGviczvw78S7kTMmaIGezobVEnCJm4TfAfY65/7G63qyzcxqzKwi8fUs4GbgTU+LyjLn3P9wztU55xYT/3v8C+fcf/K4rKwys5LETX7MrAS4Bcjo6LVABbpzbhxIbli9F3jEObfH26qyy8x+CPwKWGlmzWZ2r9c15cB1wO8Qb7XtSHy83+uisqgWeMbMdhFvtPzMOTcjhvHNMPOAF8xsJ/Br4P85557I5AUCNWxRRESmF6gWuoiITE+BLiISEgp0EZGQUKCLiISEAl1EJCQU6CIiIaFAFxEJif8P0+PrXvkm6SQAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Prøver lige at løse den programmerbart også\n", + "thetas = np.linspace(0, 5, 1000)[1:]\n", + "res = np.empty(thetas.shape)\n", + "\n", + "for i, theta in enumerate(thetas):\n", + " f = lambda x: ((x / (theta**2)) * np.exp(-x / theta))\n", + " score = 1\n", + " for sample in samples:\n", + " score *= f(sample)\n", + " \n", + " res[i] = score\n", + "\n", + "maxtheta = thetas[np.argmax(res)]\n", + "print(f\"argmax: {maxtheta}\")\n", + "plt.plot(thetas, res)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problem 3\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "radial = np.array([5.2, 5.7, 7.6, 8.0, 7.7, 5.5, 6.7, 7.0, 8.4, 5.9])\n", + "\n", + "belted = np.array([5.1, 5.9, 7.2, 7.9, 7.8, 5.4, 6.7, 6.8, 7.9, 5.7])\n", + "belted_mean = np.mean(belted)\n", + "N = len(belted)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Part A\n", + "\n", + "Here we don't know the varience, and will therefore have to use the t distribution method.\n", + "The interval is given by:\n", + "$$\n", + "\\bar X \\pm t_{\\alpha/2,n-1} \\frac S {\\sqrt{n}}\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Then the interval becomes [6.174311863003706, 7.105688136996291]\n" + ] + } + ], + "source": [ + "alpha = 0.1\n", + "# Lets start by calculating the t value\n", + "tval = stats.t.ppf(1 - alpha, N-1)\n", + "\n", + "S = np.sqrt(np.sum((belted - belted_mean)**2) / (N - 1))\n", + "\n", + "diff = tval * S / np.sqrt(N)\n", + "print(f\"Then the interval becomes [{belted_mean - diff}, {belted_mean + diff}]\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Part B\n", + "\n", + "We can take the difference of the two and say that this should be less than or equal to $0$.\n", + "Thus the $H_0$ is $(\\mu_{belted} - \\mu_{radial}) \\leq 0$.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0.1 -0.2 0.4 0.1 -0.1 0.1 0. 0.2 0.5 0.2] 0.12999999999999998\n", + "ts: 1.9475670608117976\n", + "p-value: 0.04164574347828587\n", + "H_0 is accepted, thus radial does not make it better\n" + ] + } + ], + "source": [ + "mu_0 = 0\n", + "alpha = 0.05\n", + "diff = radial - belted\n", + "diff_mean = np.mean(diff)\n", + "print(diff, diff_mean)\n", + "\n", + "S = np.sqrt(np.sum((diff - diff_mean)**2) / (N - 1))\n", + "\n", + "ts = np.sqrt(N) * (diff_mean - mu_0) / S\n", + "print(f\"ts: {ts}\")\n", + "p_value = 1 - stats.t.cdf(ts, N - 1)\n", + "print(f\"p-value: {p_value}\")\n", + "\n", + "if p_value > alpha:\n", + " print(\"H_0 is rejected thus radial tires have better economy\")\n", + "else:\n", + " print(\"H_0 is accepted, thus radial does not make it better\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Part C\n", + "\n", + "Drivers can drive radically different in the way they brake, shift gears and apply power.\n", + "The driver is therefore as important a parameter as the car driven.\n", + "\n", + "When creating such tests it is very important to only change the variable in question, in this case the tires.\n", + "By keeping all other variables the same, one can say that a change in performance likely comes from the other tires." + ] + } + ], + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} -- cgit v1.2.3