├── .gitattributes ├── .gitignore ├── HW_1.ipynb ├── HW_10.ipynb ├── HW_2.ipynb ├── HW_3.ipynb ├── HW_4.ipynb ├── HW_5.ipynb ├── HW_6.ipynb ├── HW_7.ipynb ├── HW_8.ipynb ├── HW_9 ├── .ipynb_checkpoints │ └── HW_9-checkpoint.ipynb ├── HW_9.ipynb └── data │ ├── gauss_R2.csv │ ├── hw_regression_data.csv │ ├── reg_ex_table.png │ └── reg_mean_pic.png └── README.md /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .gitattributes 2 | .DS_Store 3 | -------------------------------------------------------------------------------- /HW_1.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "nbgrader": { 7 | "grade": false, 8 | "locked": false, 9 | "solution": false 10 | } 11 | }, 12 | "source": [ 13 | " **IMPORTANT: ** Only modify cells which have the following comment\n", 14 | "\n", 15 | "```python\n", 16 | "# modify this cell\n", 17 | "```\n", 18 | "\n", 19 | " Do not add any new cells when submitting homework. For Docker users, to test out new code, use the coding **scratchpad** by clicking the triangular icon in the bottom right corner of the screen. (**hotkey:** control-B) \n", 20 | "\n" 21 | ] 22 | }, 23 | { 24 | "cell_type": "markdown", 25 | "metadata": { 26 | "nbgrader": { 27 | "grade": false, 28 | "locked": false, 29 | "solution": false 30 | } 31 | }, 32 | "source": [ 33 | "# Exercises:" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": { 39 | "nbgrader": { 40 | "grade": false, 41 | "locked": false, 42 | "solution": false 43 | } 44 | }, 45 | "source": [ 46 | "**Note: ** Make sure you have read the *What is Probability?* notebook before attempting these exercises." 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": { 52 | "nbgrader": { 53 | "grade": false, 54 | "locked": false, 55 | "solution": false 56 | } 57 | }, 58 | "source": [ 59 | "In this excercise you will write code to estimate the probability that $n$ flips of a fair coin will result in number of `\"heads\"` between $k_1$ and $k_2$.\n", 60 | "\n", 61 | "You should write the body of two functions:\n", 62 | "1. **`seq_sum`**: generates a random sequence of coin flips and counts the number of heads.\n", 63 | "2. **`estimate_prob`**: Using calls to `seq_sum`, estimate the probability of the number of heads being between $k_1$ and $k_2$. \n" 64 | ] 65 | }, 66 | { 67 | "cell_type": "markdown", 68 | "metadata": { 69 | "nbgrader": { 70 | "grade": false, 71 | "locked": false, 72 | "solution": false 73 | } 74 | }, 75 | "source": [ 76 | "### Notebook Setup:" 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": { 82 | "nbgrader": { 83 | "grade": false, 84 | "locked": false, 85 | "solution": false 86 | } 87 | }, 88 | "source": [ 89 | "The folowing magic command downloads many python packages like *numpy* and allows the notebooks to plot graphs with *matplotlib*. \n", 90 | "\n", 91 | "**DO NOT** import other packages. You already have all the packages you need.\n" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": 1, 97 | "metadata": {}, 98 | "outputs": [ 99 | { 100 | "name": "stdout", 101 | "output_type": "stream", 102 | "text": [ 103 | "Populating the interactive namespace from numpy and matplotlib\n" 104 | ] 105 | } 106 | ], 107 | "source": [ 108 | "%pylab inline" 109 | ] 110 | }, 111 | { 112 | "cell_type": "markdown", 113 | "metadata": {}, 114 | "source": [ 115 | "Specifically, you can now use `random.rand(x)` which for some $x \\in N$ generates $x$ random numbers. You **will** use this command in your homework." 116 | ] 117 | }, 118 | { 119 | "cell_type": "code", 120 | "execution_count": 2, 121 | "metadata": {}, 122 | "outputs": [ 123 | { 124 | "data": { 125 | "text/plain": [ 126 | "0.2834288796977271" 127 | ] 128 | }, 129 | "execution_count": 2, 130 | "metadata": {}, 131 | "output_type": "execute_result" 132 | } 133 | ], 134 | "source": [ 135 | "random.rand()" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": 3, 141 | "metadata": {}, 142 | "outputs": [ 143 | { 144 | "data": { 145 | "text/plain": [ 146 | "array([0.4424793 , 0.1028654 , 0.27975932, 0.86693149])" 147 | ] 148 | }, 149 | "execution_count": 3, 150 | "metadata": {}, 151 | "output_type": "execute_result" 152 | } 153 | ], 154 | "source": [ 155 | "random.rand(4)" 156 | ] 157 | }, 158 | { 159 | "cell_type": "markdown", 160 | "metadata": {}, 161 | "source": [ 162 | "## Exercise 1:\n", 163 | "\n", 164 | "Write a function, **seq_sum**, which generates $n$ random coin flips from a fair coin and then returns the number of heads. A fair coin is defined to be a coin where $P($heads$)=\\frac{1}{2}$ \n", 165 | "\n", 166 | "The output type should be a numpy integer, **hint:** use `random.rand()` \n", 167 | "\n", 168 | " * **Code:** *\n", 169 | "```python\n", 170 | "x = seq_sum(100)\n", 171 | "print x\n", 172 | "print [seq_sum(2) for x in range(20)]\n", 173 | "```\n", 174 | "\n", 175 | "\n", 176 | " * **Output:** *\n", 177 | "```\n", 178 | "49\n", 179 | "[0, 1, 1, 1, 1, 2, 1, 2, 1, 1, 0, 0, 2, 1, 1, 1, 0, 0, 1, 1]\n", 180 | "```" 181 | ] 182 | }, 183 | { 184 | "cell_type": "markdown", 185 | "metadata": {}, 186 | "source": [ 187 | "* Write your code for seq_sum in the cell below" 188 | ] 189 | }, 190 | { 191 | "cell_type": "code", 192 | "execution_count": 4, 193 | "metadata": { 194 | "collapsed": true 195 | }, 196 | "outputs": [], 197 | "source": [ 198 | "# modify this cell\n", 199 | "import random\n", 200 | "\n", 201 | "def seq_sum(n):\n", 202 | " \"\"\" input: n, generate a sequence of n random coin flips\n", 203 | " output: return the number of heads \n", 204 | " Hint: For simplicity, use 1,0 to represent head,tails\n", 205 | " \"\"\"\n", 206 | " total_heads = 0\n", 207 | " total_tails = 0\n", 208 | " count = 0\n", 209 | " while count < n:\n", 210 | " coin = random.randint(0, 1)\n", 211 | " if coin == 1:\n", 212 | " total_heads += 1\n", 213 | " count += 1\n", 214 | " \n", 215 | " elif coin == 0:\n", 216 | " total_tails += 1\n", 217 | " count += 1\n", 218 | " \n", 219 | " return total_heads\n" 220 | ] 221 | }, 222 | { 223 | "cell_type": "markdown", 224 | "metadata": {}, 225 | "source": [ 226 | "* if the following cell runs without error you receive some points." 227 | ] 228 | }, 229 | { 230 | "cell_type": "code", 231 | "execution_count": 5, 232 | "metadata": { 233 | "nbgrader": { 234 | "grade": true, 235 | "grade_id": "ex1", 236 | "locked": true, 237 | "points": "5", 238 | "solution": false 239 | } 240 | }, 241 | "outputs": [ 242 | { 243 | "name": "stdout", 244 | "output_type": "stream", 245 | "text": [ 246 | "51\n" 247 | ] 248 | } 249 | ], 250 | "source": [ 251 | "# checking function \n", 252 | "\n", 253 | "x = seq_sum(100)\n", 254 | "print(x)\n", 255 | "assert unique([seq_sum(2) for x in range(0,200)]).tolist() == [0, 1, 2]\n", 256 | "\n", 257 | "#\n", 258 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 259 | "#\n" 260 | ] 261 | }, 262 | { 263 | "cell_type": "markdown", 264 | "metadata": {}, 265 | "source": [ 266 | "## Exercise 2:\n", 267 | "\n", 268 | "Write a function, **estimate_prob**, that uses **seq_sum** to estimate the following probability:\n", 269 | "\n", 270 | "$$ P(\\; k_1 <= \\text{number of heads in $n$ flips} < k_2 ) $$\n", 271 | "\n", 272 | "The function should estimate the probability by running $m$ different trials of **`seq_sum(n)`**, probably using a *`for`* loop.\n", 273 | "\n", 274 | "In order to receive full credit **estimate_prob** MUST call **seq_sum** (aka: seq_sum is located inside the **estimate_prob** function)\n", 275 | "\n", 276 | " * **Code:** *\n", 277 | "```python\n", 278 | "x = estimate_prob(100,45,55,1000)\n", 279 | "print x\n", 280 | "print type(x)\n", 281 | "```\n", 282 | "\n", 283 | " * **Output:** *\n", 284 | "```\n", 285 | "0.686\n", 286 | "\n", 287 | "```" 288 | ] 289 | }, 290 | { 291 | "cell_type": "code", 292 | "execution_count": 6, 293 | "metadata": { 294 | "collapsed": true 295 | }, 296 | "outputs": [], 297 | "source": [ 298 | "# Modify this cell\n", 299 | "\n", 300 | "def estimate_prob(n,k1,k2,m):\n", 301 | " \"\"\"Estimate the probability that n flips of a fair coin result in k1 to k2 heads\n", 302 | " n: the number of coin flips (length of the sequence)\n", 303 | " k1,k2: the trial is successful if the number of heads is \n", 304 | " between k1 and k2-1\n", 305 | " m: the number of trials (number of sequences of length n)\n", 306 | " \n", 307 | " output: the estimated probability \n", 308 | " \"\"\"\n", 309 | " successful_trial = 0\n", 310 | " for i in range(m):\n", 311 | " x = seq_sum(n)\n", 312 | " if x>k1 and xk2:\n", 315 | " successful_trial+=0\n", 316 | " \n", 317 | " #print(successful_trial)\n", 318 | " estimated_probability = successful_trial/m\n", 319 | " return estimated_probability\n" 320 | ] 321 | }, 322 | { 323 | "cell_type": "code", 324 | "execution_count": 7, 325 | "metadata": {}, 326 | "outputs": [ 327 | { 328 | "name": "stdout", 329 | "output_type": "stream", 330 | "text": [ 331 | "0.946\n" 332 | ] 333 | } 334 | ], 335 | "source": [ 336 | "# this is a small sanity check\n", 337 | "# the true check for this function is further down\n", 338 | "\n", 339 | "x = estimate_prob(100,40,60,1000)\n", 340 | "print(x)\n", 341 | "assert 'float' in str(type(x))" 342 | ] 343 | }, 344 | { 345 | "cell_type": "markdown", 346 | "metadata": {}, 347 | "source": [ 348 | "### Estimate vs. True Probability\n", 349 | "\n", 350 | "We can now check how to see how close these estimates are to the true probabilities." 351 | ] 352 | }, 353 | { 354 | "cell_type": "markdown", 355 | "metadata": {}, 356 | "source": [ 357 | "### Helper Functions\n", 358 | "\n", 359 | "These helper functions are used to calculate the actual probabilities. They are used to test your code.\n", 360 | "\n", 361 | "It is not required that you understand how they work." 362 | ] 363 | }, 364 | { 365 | "cell_type": "code", 366 | "execution_count": 8, 367 | "metadata": { 368 | "collapsed": true, 369 | "nbgrader": { 370 | "grade": false, 371 | "locked": true, 372 | "solution": false 373 | } 374 | }, 375 | "outputs": [], 376 | "source": [ 377 | "def calc_prob(n,k1,k2):\n", 378 | " \"\"\"Calculate the probability using a normal approximation\"\"\"\n", 379 | " n=float(n);k1=float(k1);k2=float(k2)\n", 380 | " z1=(k1-0.5*n)/(sqrt(n)/2)\n", 381 | " z2=(k2-0.5*n)/(sqrt(n)/2)\n", 382 | " return (erf(z2/sqrt(2))-erf(z1/sqrt(2)))/2\n", 383 | "\n", 384 | "from math import erf,sqrt\n", 385 | "def evaluate(n,q1,q2,m,r=100):\n", 386 | " \"\"\"Run calc_range many times and test whether the estimates are consistent with calc_prob\"\"\"\n", 387 | " k1=int(q1*n)\n", 388 | " k2=int(q2*n)\n", 389 | " p=calc_prob(n,k1,k2)\n", 390 | " std=sqrt(p*(1-p)/m)\n", 391 | " print(\"computed prob=%5.3f, std=%5.3f\" %(p,std))\n", 392 | "\n", 393 | " L=[estimate_prob(n,k1,k2,m) for i in range(r)]\n", 394 | " med=np.median(L)\n", 395 | " print(\"ran estimator %d times, with parameters n=%d,k1=%d,k2=%d,m=%d\" %(r,n,k1,k2,m))\n", 396 | " print('median of estimates=%5.3f, error of median estimator=%5.3f, std= %f5.3'%(med,med-p,std))\n", 397 | " return L,med,p,std,abs((med-p)/std)" 398 | ] 399 | }, 400 | { 401 | "cell_type": "code", 402 | "execution_count": 9, 403 | "metadata": { 404 | "collapsed": true, 405 | "nbgrader": { 406 | "grade": false, 407 | "locked": true, 408 | "solution": false 409 | } 410 | }, 411 | "outputs": [], 412 | "source": [ 413 | "def test_report_assert(n,q1,q2,m,r=100):\n", 414 | " k1=int(q1*n)\n", 415 | " k2=int(q2*n)\n", 416 | " L,med,p,std,norm_err=evaluate(n,q1,q2,m,r=100)\n", 417 | " hist(L);\n", 418 | " plot([p,p],plt.ylim(),'r',label='true prob')\n", 419 | " plot([med,med],plt.ylim(),'k',label='median of %d estimates'%r)\n", 420 | " mid_y=mean(plt.ylim())\n", 421 | " plot([p-std,p+std],[mid_y,mid_y],'g',label='+-std')\n", 422 | " legend();\n", 423 | " print('normalized error of median=',norm_err,'should be <1.0')\n", 424 | " title('r=%d,n=%d,k1=%d,k2=%d,m=%d,\\nnorm_err=%4.3f'%(r,n,k1,k2,m,norm_err))\n", 425 | " assert norm_err<1.0" 426 | ] 427 | }, 428 | { 429 | "cell_type": "markdown", 430 | "metadata": {}, 431 | "source": [ 432 | "### Testing your Functions" 433 | ] 434 | }, 435 | { 436 | "cell_type": "markdown", 437 | "metadata": {}, 438 | "source": [ 439 | "* We now test your functions. The graphs below show how close your estimated probability is to the true probability for various values of $k_1$ and $k_2$. You can see that your answer is never exactly the correct probability. \n", 440 | "* For full credit, the code below must run without error." 441 | ] 442 | }, 443 | { 444 | "cell_type": "code", 445 | "execution_count": 10, 446 | "metadata": { 447 | "nbgrader": { 448 | "grade": true, 449 | "grade_id": "ex2", 450 | "locked": true, 451 | "points": "5", 452 | "solution": false 453 | } 454 | }, 455 | "outputs": [ 456 | { 457 | "name": "stdout", 458 | "output_type": "stream", 459 | "text": [ 460 | "#### test no. 1\n", 461 | "computed prob=0.954, std=0.021\n", 462 | "ran estimator 100 times, with parameters n=100,k1=40,k2=60,m=100\n", 463 | "median of estimates=0.940, error of median estimator=-0.014, std= 0.0208405.3\n", 464 | "normalized error of median= 0.6957692550136406 should be <1.0\n", 465 | "#### test no. 2\n", 466 | "computed prob=0.159, std=0.037\n", 467 | "ran estimator 100 times, with parameters n=100,k1=55,k2=100,m=100\n", 468 | "median of estimates=0.130, error of median estimator=-0.029, std= 0.0365355.3\n", 469 | "normalized error of median= 0.7843141288500418 should be <1.0\n", 470 | "#### test no. 3\n", 471 | "computed prob=0.146, std=0.035\n", 472 | "ran estimator 100 times, with parameters n=100,k1=47,k2=49,m=100\n", 473 | "median of estimates=0.070, error of median estimator=-0.076, std= 0.0353595.3\n", 474 | "normalized error of median= 2.163135793265594 should be <1.0\n" 475 | ] 476 | }, 477 | { 478 | "ename": "AssertionError", 479 | "evalue": "", 480 | "output_type": "error", 481 | "traceback": [ 482 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 483 | "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", 484 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'#### test no.'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m+=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mtest_report_assert\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mq1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mq2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 12\u001b[0m \u001b[0mtight_layout\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", 485 | "\u001b[0;32m\u001b[0m in \u001b[0;36mtest_report_assert\u001b[0;34m(n, q1, q2, m, r)\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'normalized error of median='\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnorm_err\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'should be <1.0'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0mtitle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'r=%d,n=%d,k1=%d,k2=%d,m=%d,\\nnorm_err=%4.3f'\u001b[0m\u001b[0;34m%\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mk1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mk2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnorm_err\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mnorm_err\u001b[0m\u001b[0;34m<\u001b[0m\u001b[0;36m1.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 486 | "\u001b[0;31mAssertionError\u001b[0m: " 487 | ] 488 | }, 489 | { 490 | "data": { 491 | "image/png": "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\n", 492 | "text/plain": [ 493 | "
" 494 | ] 495 | }, 496 | "metadata": {}, 497 | "output_type": "display_data" 498 | } 499 | ], 500 | "source": [ 501 | "# checking functions\n", 502 | "\n", 503 | "m=100\n", 504 | "i=1\n", 505 | "figure(figsize=[10,12])\n", 506 | "for n in [100,1000]:\n", 507 | " for q1,q2 in [(0.4,0.6),(0.55,1.00),(0.47,0.499)]:\n", 508 | " fig=subplot(3,2,i)\n", 509 | " print('#### test no.',i)\n", 510 | " i+=1\n", 511 | " test_report_assert(n,q1,q2,m,r=100)\n", 512 | "tight_layout()" 513 | ] 514 | }, 515 | { 516 | "cell_type": "code", 517 | "execution_count": 11, 518 | "metadata": { 519 | "nbgrader": { 520 | "grade": true, 521 | "grade_id": "ex3", 522 | "locked": true, 523 | "points": "5", 524 | "solution": false 525 | } 526 | }, 527 | "outputs": [ 528 | { 529 | "ename": "AssertionError", 530 | "evalue": "estimate is incorrect. should be 0.002000, instead is 0.001000", 531 | "output_type": "error", 532 | "traceback": [ 533 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 534 | "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", 535 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m>=\u001b[0m\u001b[0mk1\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m<\u001b[0m\u001b[0mk2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0ms\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mLog\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mm\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0mn_correct\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;36m100\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mnn\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0ms\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mLog\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"estimate is incorrect. should be %4f, instead is %4f\"\u001b[0m\u001b[0;34m%\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 16\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mLog\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'should call seq_sum %d times, called it %d times'\u001b[0m\u001b[0;34m%\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mLog\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0mn_correct\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'the parameter n should be %d but sometimes it was not.'\u001b[0m\u001b[0;34m%\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", 536 | "\u001b[0;31mAssertionError\u001b[0m: estimate is incorrect. should be 0.002000, instead is 0.001000" 537 | ] 538 | } 539 | ], 540 | "source": [ 541 | "# checking functions \n", 542 | "from numpy import random\n", 543 | "def seq_sum(n):\n", 544 | " #Log.append(n)\n", 545 | " s=sum(random.randn(n)>0.5)\n", 546 | " Log.append((n,s))\n", 547 | " return s\n", 548 | "\n", 549 | "n,k1,k2,m = 100,45,50,1000\n", 550 | "for r in range(10):\n", 551 | " Log=[]\n", 552 | " a=estimate_prob(n,k1,k2,m)\n", 553 | " b=float(sum([(s>=k1 and s **IMPORTANT: ** When submitting this homework notebook, please modify only the cells that start with:\n", 8 | "\n", 9 | "```python\n", 10 | "# modify this cell\n", 11 | "```" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 1, 17 | "metadata": {}, 18 | "outputs": [], 19 | "source": [ 20 | "from scipy import stats\n", 21 | "from math import sqrt" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "# Confidence Interval" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": {}, 34 | "source": [ 35 | "For a sample with size large enough, by central limit theorem we can assume its mean follows normal distribution. And if we also know the standard deviation of the population, we are able to calculate a confidence interval to estimate the population mean." 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "## Problem 1" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "metadata": {}, 48 | "source": [ 49 | "A confidence interval is usually given by sample mean $m$ plus and minus a margin of error $r$:\n", 50 | "$$[m-r,m+r]$$\n", 51 | "The confidence interval is larger (less precise) for large confidence level, and smaller (more precise) for small confidence level.\n", 52 | "\n", 53 | "For this problem, you are asked to write a function **Error** that calculates the margin of error $r$ given sample size $n$, confidence level $p$ and standard deviation of the population $s$." 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": {}, 59 | "source": [ 60 | " **Code:**\n", 61 | "```python\n", 62 | "Error(40,0.95,20)\n", 63 | "\n", 64 | "Error(40,0.95,10) \n", 65 | "```\n", 66 | "\n", 67 | "\n", 68 | " **Output**\n", 69 | "```\n", 70 | "6.1979503230456148\n", 71 | "3.0989751615228074\n", 72 | "```" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": 6, 78 | "metadata": { 79 | "collapsed": true, 80 | "nbgrader": { 81 | "grade": false, 82 | "locked": false, 83 | "solution": false 84 | } 85 | }, 86 | "outputs": [], 87 | "source": [ 88 | "# modify this cell\n", 89 | "\n", 90 | "def Error(n,p,s):\n", 91 | " # inputs: sample size n, confidence level p and standard deviation s\n", 92 | " # output: margin of error r\n", 93 | " \n", 94 | " return stats.norm.ppf((p+1)/2)*s/sqrt(n)\n" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": 7, 100 | "metadata": { 101 | "nbgrader": { 102 | "grade": true, 103 | "grade_id": "ex1", 104 | "locked": true, 105 | "points": "5", 106 | "solution": false 107 | } 108 | }, 109 | "outputs": [], 110 | "source": [ 111 | "# Check Function\n", 112 | "assert abs(Error(60,0.9,20)-4.2469938027546128) < 10**-5 \n", 113 | "assert abs(Error(60,0.9,10)-2.1234969013773064) < 10**-5\n", 114 | "\n", 115 | "#\n", 116 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 117 | "#\n" 118 | ] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": {}, 123 | "source": [ 124 | "# Problem 2" 125 | ] 126 | }, 127 | { 128 | "cell_type": "markdown", 129 | "metadata": {}, 130 | "source": [ 131 | "For this problem, you are asked to write a function **Confidence** that calculates the confidence level $p$ given sample size $n$, margin of error $r$ and standard deviation of the population $s$." 132 | ] 133 | }, 134 | { 135 | "cell_type": "markdown", 136 | "metadata": {}, 137 | "source": [ 138 | " **Code:**\n", 139 | "```python\n", 140 | "Confidence(40,6,20)\n", 141 | "\n", 142 | "Confidence(40,8,20) \n", 143 | "```\n", 144 | "\n", 145 | "\n", 146 | " **Output**\n", 147 | "```\n", 148 | "0.94222042887640267\n", 149 | "0.98858796361399826\n", 150 | "```" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": 8, 156 | "metadata": { 157 | "collapsed": true 158 | }, 159 | "outputs": [], 160 | "source": [ 161 | "# modify this cell\n", 162 | "\n", 163 | "def Confidence(n,r,s):\n", 164 | " # inputs: sample size n, margin of error r, and standard deviation s\n", 165 | " # output: confidnce level r\n", 166 | " \n", 167 | " return stats.norm.cdf(float(r)/(s/sqrt(n)))*2 - 1\n" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": 9, 173 | "metadata": { 174 | "collapsed": true, 175 | "nbgrader": { 176 | "grade": true, 177 | "grade_id": "ex2", 178 | "locked": true, 179 | "points": "5", 180 | "solution": false 181 | } 182 | }, 183 | "outputs": [], 184 | "source": [ 185 | "# Check Function\n", 186 | "assert abs(Confidence(60,5,20)-0.94719248858388649) < 10**-5 \n", 187 | "assert abs(Confidence(60,6,20)-0.97986324844965367) < 10**-5\n", 188 | "\n", 189 | "#\n", 190 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 191 | "#\n" 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": null, 197 | "metadata": {}, 198 | "outputs": [], 199 | "source": [] 200 | } 201 | ], 202 | "metadata": { 203 | "kernelspec": { 204 | "display_name": "Python 3", 205 | "language": "python", 206 | "name": "python3" 207 | }, 208 | "language_info": { 209 | "codemirror_mode": { 210 | "name": "ipython", 211 | "version": 3 212 | }, 213 | "file_extension": ".py", 214 | "mimetype": "text/x-python", 215 | "name": "python", 216 | "nbconvert_exporter": "python", 217 | "pygments_lexer": "ipython3", 218 | "version": "3.6.5" 219 | }, 220 | "toc": { 221 | "colors": { 222 | "hover_highlight": "#DAA520", 223 | "navigate_num": "#000000", 224 | "navigate_text": "#333333", 225 | "running_highlight": "#FF0000", 226 | "selected_highlight": "#FFD700", 227 | "sidebar_border": "#EEEEEE", 228 | "wrapper_background": "#FFFFFF" 229 | }, 230 | "moveMenuLeft": true, 231 | "nav_menu": { 232 | "height": "12px", 233 | "width": "252px" 234 | }, 235 | "navigate_menu": true, 236 | "number_sections": true, 237 | "sideBar": true, 238 | "threshold": 4, 239 | "toc_cell": false, 240 | "toc_section_display": "block", 241 | "toc_window_display": false, 242 | "widenNotebook": false 243 | } 244 | }, 245 | "nbformat": 4, 246 | "nbformat_minor": 2 247 | } 248 | -------------------------------------------------------------------------------- /HW_2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "nbgrader": { 7 | "grade": false, 8 | "locked": true, 9 | "solution": false 10 | } 11 | }, 12 | "source": [ 13 | " **IMPORTANT: ** When submitting this homework notebook, please modify only the cells that start with:\n", 14 | "\n", 15 | "```python\n", 16 | "# modify this cell\n", 17 | "```" 18 | ] 19 | }, 20 | { 21 | "cell_type": "markdown", 22 | "metadata": { 23 | "nbgrader": { 24 | "grade": false, 25 | "locked": true, 26 | "solution": false 27 | } 28 | }, 29 | "source": [ 30 | "### Import Stuff\n", 31 | "\n", 32 | "Notice that we do not import *numpy* or *scipy* neither of these packages are need for this homework. For our solutions, the only command we needed to import was `itertools.product()`" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 1, 38 | "metadata": { 39 | "collapsed": true, 40 | "nbgrader": { 41 | "grade": false, 42 | "locked": true, 43 | "solution": false 44 | } 45 | }, 46 | "outputs": [], 47 | "source": [ 48 | "import itertools\n", 49 | "from itertools import product" 50 | ] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": { 55 | "nbgrader": { 56 | "grade": false, 57 | "locked": true, 58 | "solution": false 59 | } 60 | }, 61 | "source": [ 62 | "# Sets\n", 63 | "Read the notebook on sets before attempting these exercises" 64 | ] 65 | }, 66 | { 67 | "cell_type": "markdown", 68 | "metadata": { 69 | "nbgrader": { 70 | "grade": false, 71 | "locked": true, 72 | "solution": false 73 | } 74 | }, 75 | "source": [ 76 | "# Problem 1" 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": { 82 | "nbgrader": { 83 | "grade": false, 84 | "locked": true, 85 | "solution": false 86 | } 87 | }, 88 | "source": [ 89 | "De Morgan's first law states the following for any two sets $A$ and $B$\n", 90 | "$$(A\\cup B)^c = A^c\\cap B^c$$\n", 91 | "\n", 92 | "In the following two exercises we calculate $(A\\cup B)^c$ in two different ways. Both functions must take $A$, $B$ and the universal set $U$ as their inputs." 93 | ] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": { 98 | "nbgrader": { 99 | "grade": false, 100 | "locked": true, 101 | "solution": false 102 | } 103 | }, 104 | "source": [ 105 | "## Exercise 1.1" 106 | ] 107 | }, 108 | { 109 | "cell_type": "markdown", 110 | "metadata": { 111 | "nbgrader": { 112 | "grade": false, 113 | "locked": true, 114 | "solution": false 115 | } 116 | }, 117 | "source": [ 118 | "\n", 119 | "Write the function **complement_of_union** that first determines $A\\cup B$ and then evaluates the complement of this set. Output the tuple: $\\begin{pmatrix}A\\cup B,\\, (A\\cup B)^c\\end{pmatrix}$.\n", 120 | "\n", 121 | "\n", 122 | "\n", 123 | " **Code**\n", 124 | "```python\n", 125 | "A = {1, 2, 3}\n", 126 | "B = {3, -6, 2, 0}\n", 127 | "U = {-10, -9, -8, -7, -6, 0, 1, 2, 3, 4}\n", 128 | "complement_of_union(A, B, U)\n", 129 | "```\n", 130 | "\n", 131 | " **Output**\n", 132 | "```\n", 133 | "({-6, 0, 1, 2, 3}, {-10, -9, -8, -7, 4})\n", 134 | "```\n" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 2, 140 | "metadata": { 141 | "collapsed": true, 142 | "scrolled": true 143 | }, 144 | "outputs": [], 145 | "source": [ 146 | "# modify this cell\n", 147 | "\n", 148 | "def complement_of_union(A, B, U):\n", 149 | " # inputs: A, B and U are of type 'set'\n", 150 | " # output: a tuple of the type (set, set)\n", 151 | " unionAB= A.union(B)\n", 152 | " complimentAB= U.difference(unionAB)\n", 153 | " return (unionAB, complimentAB)\n" 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": 3, 159 | "metadata": { 160 | "collapsed": true, 161 | "nbgrader": { 162 | "grade": true, 163 | "grade_id": "ex1", 164 | "locked": true, 165 | "points": "5", 166 | "solution": false 167 | } 168 | }, 169 | "outputs": [ 170 | { 171 | "name": "stdout", 172 | "output_type": "stream", 173 | "text": [ 174 | "({3, 4, 5, -6, 13}, {-4, 12, -2})\n" 175 | ] 176 | } 177 | ], 178 | "source": [ 179 | "# Check Function\n", 180 | "\n", 181 | "A = {-6, 3, 4, 5}\n", 182 | "B = {-6, 5, 13}\n", 183 | "U = A|B|{12,-2, -4}\n", 184 | "x=complement_of_union(A,B,U)\n", 185 | "print(x)\n", 186 | "#assert( complement_of_union(A, B, U) == ({0, 1, 2, 3, 4, 5, 7, 8, 9, 10, -6, -4, -3}, {-4, -3, 7, 10}) )\n", 187 | "\n", 188 | "#\n", 189 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 190 | "#\n" 191 | ] 192 | }, 193 | { 194 | "cell_type": "markdown", 195 | "metadata": { 196 | "nbgrader": { 197 | "grade": false, 198 | "locked": true, 199 | "solution": false 200 | } 201 | }, 202 | "source": [ 203 | "## Exercsise 1.2\n", 204 | "\n", 205 | "Write the function **intersection_of_complements** that first determines $A^c$ and $B^c$ and then evaluates the intersection of their complements. Output the tuple: $\\begin{pmatrix}A^c, \\, A^c\\cap B^c\\end{pmatrix}$\n", 206 | "\n", 207 | " **Code**\n", 208 | "```python\n", 209 | "A = {1, 2, 3}\n", 210 | "B = {3, -6, 2, 0}\n", 211 | "U = {-10, -9, -8, -7, -6, 0, 1, 2, 3, 4}\n", 212 | "intersection_of_complements(A, B, U)\n", 213 | "```\n", 214 | "\n", 215 | " **Output**\n", 216 | "```\n", 217 | "({-10, -9, -8, -7, -6, 0, 4}, {-10, -9, -8, -7, 4})\n", 218 | "```\n" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": 4, 224 | "metadata": { 225 | "collapsed": true 226 | }, 227 | "outputs": [], 228 | "source": [ 229 | "# modify this cell\n", 230 | "\n", 231 | "def intersection_of_complements(A, B, U):\n", 232 | " # inputs: A, B and U are of type 'set'\n", 233 | " # output: a tuple of the form (set, set)\n", 234 | " Ac= U-A\n", 235 | " AcBc= Ac.intersection(U-B)\n", 236 | " return(Ac,AcBc)\n" 237 | ] 238 | }, 239 | { 240 | "cell_type": "code", 241 | "execution_count": 5, 242 | "metadata": { 243 | "collapsed": true, 244 | "nbgrader": { 245 | "grade": true, 246 | "grade_id": "ex2", 247 | "locked": true, 248 | "points": "5", 249 | "solution": false 250 | } 251 | }, 252 | "outputs": [ 253 | { 254 | "name": "stdout", 255 | "output_type": "stream", 256 | "text": [ 257 | "({13, -4, 12, -2}, {-4, 12, -2})\n" 258 | ] 259 | } 260 | ], 261 | "source": [ 262 | "# Check Function\n", 263 | "\n", 264 | "A = {-6, 3, 4, 5}\n", 265 | "B = {-6, 5, 13}\n", 266 | "U = A|B|{-2, 12, -4}\n", 267 | "#assert( intersection_of_complements(A, B, U) == ({-6, -4, -3, 0, 7, 8, 9, 10}, {-4, -3, 7, 10}) )\n", 268 | "x= intersection_of_complements(A, B, U)\n", 269 | "print(x)\n", 270 | "#\n", 271 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 272 | "#\n" 273 | ] 274 | }, 275 | { 276 | "cell_type": "markdown", 277 | "metadata": { 278 | "nbgrader": { 279 | "grade": false, 280 | "locked": true, 281 | "solution": false 282 | } 283 | }, 284 | "source": [ 285 | "# Problem 2" 286 | ] 287 | }, 288 | { 289 | "cell_type": "markdown", 290 | "metadata": { 291 | "nbgrader": { 292 | "grade": false, 293 | "locked": true, 294 | "solution": false 295 | } 296 | }, 297 | "source": [ 298 | "This problem illustrates a property of cartesian products of unions of two or more sets. For four sets $A$, $B$, $S$ and $T$, the following holds:\n", 299 | "\n", 300 | "$$(A\\cup B)\\times(S\\cup T) = (A\\times S)\\cup(A\\times T)\\cup(B\\times S)\\cup(B\\times T)$$\n", 301 | "\n", 302 | "Write the following functions to determine $(A\\cup B)\\times(S\\cup T)$ in two different ways.\n" 303 | ] 304 | }, 305 | { 306 | "cell_type": "markdown", 307 | "metadata": { 308 | "nbgrader": { 309 | "grade": false, 310 | "locked": true, 311 | "solution": false 312 | } 313 | }, 314 | "source": [ 315 | "## Exercies 2.1\n", 316 | "\n", 317 | "Write function **product_of_unions** that first determines $(A\\cup B)$ and $(S\\cup T)$ and then evaluates the cartesian products of these unions. Output the tuple $\\begin{pmatrix}(A\\cup B),\\, (A\\cup B)\\times(S\\cup T)\\end{pmatrix}$.\n", 318 | "\n", 319 | " **Code**\n", 320 | "```python\n", 321 | "A = {1, 2}\n", 322 | "B = {1, 3}\n", 323 | "S = {-1, 0}\n", 324 | "T = {0, 10}\n", 325 | "product_of_unions(A, B, S, T)\n", 326 | "```\n", 327 | "\n", 328 | "\n", 329 | " **Output**\n", 330 | "```\n", 331 | "({1, 2, 3},\n", 332 | " {(1, -1),\n", 333 | " (1, 0),\n", 334 | " (1, 10),\n", 335 | " (2, -1),\n", 336 | " (2, 0),\n", 337 | " (2, 10),\n", 338 | " (3, -1),\n", 339 | " (3, 0),\n", 340 | " (3, 10)})\n", 341 | "```\n" 342 | ] 343 | }, 344 | { 345 | "cell_type": "code", 346 | "execution_count": 6, 347 | "metadata": { 348 | "collapsed": true 349 | }, 350 | "outputs": [], 351 | "source": [ 352 | "# modify this cell\n", 353 | "\n", 354 | "def product_of_unions(A, B, S, T):\n", 355 | " # inputs: A, B, S and T are sets\n", 356 | " # output: a tuple of the type (set, set)\n", 357 | " unionAB= A.union(B)\n", 358 | " unionST= S.union(T)\n", 359 | " x=set()\n", 360 | " for pair in product(unionAB, unionST):\n", 361 | " x.add(pair)\n", 362 | " return(unionAB, x)\n", 363 | "\n" 364 | ] 365 | }, 366 | { 367 | "cell_type": "code", 368 | "execution_count": 7, 369 | "metadata": { 370 | "collapsed": true, 371 | "nbgrader": { 372 | "grade": true, 373 | "grade_id": "ex3", 374 | "locked": true, 375 | "points": "5", 376 | "solution": false 377 | } 378 | }, 379 | "outputs": [ 380 | { 381 | "name": "stdout", 382 | "output_type": "stream", 383 | "text": [ 384 | "({5}, {(5, -1), (5, 0)})\n" 385 | ] 386 | } 387 | ], 388 | "source": [ 389 | "# Check Function\n", 390 | "\n", 391 | "A = {5}\n", 392 | "B = {5}\n", 393 | "S = {-1, 0}\n", 394 | "T = {0}\n", 395 | "#assert( product_of_unions(A, B, S, T) == ({5, 6}, {(5, -1), (5, 0), (5, 1), (5, 2), (6, -1), (6, 0), (6, 1), (6, 2)}) )\n", 396 | "y= product_of_unions(A, B, S, T)\n", 397 | "print(y)\n", 398 | "#\n", 399 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 400 | "#\n" 401 | ] 402 | }, 403 | { 404 | "cell_type": "markdown", 405 | "metadata": { 406 | "nbgrader": { 407 | "grade": false, 408 | "locked": true, 409 | "solution": false 410 | } 411 | }, 412 | "source": [ 413 | "## Exercise 2.2\n", 414 | "\n", 415 | "Write a function **union_of_products** that first determines $(A\\times S)$ and the other three cartesian products that appear on the right hand side of the identity above, then evaluates the union of these cartesian products. Output the tuple $\\begin{pmatrix}(A\\times S),\\, (A\\times S)\\cup(A\\times T)\\cup(B\\times S)\\cup(B\\times T)\\end{pmatrix}$.\n", 416 | "\n", 417 | " **Code**\n", 418 | "```python\n", 419 | "A = {1, 2}\n", 420 | "B = {1, 3}\n", 421 | "S = {-1, 0}\n", 422 | "T = {0, 10}\n", 423 | "union_of_products(A, B, S, T)\n", 424 | "```\n", 425 | "\n", 426 | "\n", 427 | " **Output**\n", 428 | "```\n", 429 | "({(1, -1), (1, 0), (2, -1), (2, 0)},\n", 430 | " {(1, -1),\n", 431 | " (1, 0),\n", 432 | " (1, 10),\n", 433 | " (2, -1),\n", 434 | " (2, 0),\n", 435 | " (2, 10),\n", 436 | " (3, -1),\n", 437 | " (3, 0),\n", 438 | " (3, 10)})\n", 439 | "```" 440 | ] 441 | }, 442 | { 443 | "cell_type": "code", 444 | "execution_count": 8, 445 | "metadata": { 446 | "collapsed": true, 447 | "scrolled": true 448 | }, 449 | "outputs": [], 450 | "source": [ 451 | "# modify this cell\n", 452 | "\n", 453 | "def union_of_products(A, B, S, T):\n", 454 | " # inputs: A, B, S and T are sets\n", 455 | " # output: a tuple of the type (set, set)\n", 456 | " productAS= set()\n", 457 | " for pair in product(A,S):\n", 458 | " productAS.add(pair)\n", 459 | " productAT= set()\n", 460 | " for pair in product(A,T):\n", 461 | " productAT.add(pair)\n", 462 | " productBS= set()\n", 463 | " for pair in product(B,S):\n", 464 | " productBS.add(pair)\n", 465 | " productBT= set()\n", 466 | " for pair in product(B,T):\n", 467 | " productBT.add(pair)\n", 468 | " unionfinal= productAS.union(productAT.union(productBS.union(productBT)))\n", 469 | " return(productAS, unionfinal)\n" 470 | ] 471 | }, 472 | { 473 | "cell_type": "code", 474 | "execution_count": 10, 475 | "metadata": { 476 | "collapsed": true, 477 | "nbgrader": { 478 | "grade": true, 479 | "grade_id": "ex4", 480 | "locked": true, 481 | "points": "5", 482 | "solution": false 483 | } 484 | }, 485 | "outputs": [ 486 | { 487 | "name": "stdout", 488 | "output_type": "stream", 489 | "text": [ 490 | "({(5, -1), (5, 0)}, {(5, -1), (5, 0)})\n" 491 | ] 492 | } 493 | ], 494 | "source": [ 495 | "# Check Function\n", 496 | "\n", 497 | "A = {5}\n", 498 | "B = {5}\n", 499 | "S = {-1, 0}\n", 500 | "T = {0}\n", 501 | "#assert( union_of_products(A, B, S, T) == \\\n", 502 | "# ({(5, -1), (5, 0), (5, 1)}, \\\n", 503 | " # {(5, -1), (5, 0), (5, 1), (5, 2), (6, -1), (6, 0), (6, 1), (6, 2)}) \\\n", 504 | " # )\n", 505 | "z= union_of_products(A, B, S, T)\n", 506 | "print(z)\n", 507 | "#\n", 508 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 509 | "#\n" 510 | ] 511 | }, 512 | { 513 | "cell_type": "code", 514 | "execution_count": null, 515 | "metadata": {}, 516 | "outputs": [], 517 | "source": [] 518 | } 519 | ], 520 | "metadata": { 521 | "kernelspec": { 522 | "display_name": "Python 3", 523 | "language": "python", 524 | "name": "python3" 525 | }, 526 | "language_info": { 527 | "codemirror_mode": { 528 | "name": "ipython", 529 | "version": 3 530 | }, 531 | "file_extension": ".py", 532 | "mimetype": "text/x-python", 533 | "name": "python", 534 | "nbconvert_exporter": "python", 535 | "pygments_lexer": "ipython3", 536 | "version": "3.6.5" 537 | }, 538 | "toc": { 539 | "nav_menu": { 540 | "height": "48px", 541 | "width": "252px" 542 | }, 543 | "number_sections": true, 544 | "sideBar": true, 545 | "skip_h1_title": false, 546 | "toc_cell": false, 547 | "toc_position": [], 548 | "toc_section_display": "block", 549 | "toc_window_display": false 550 | } 551 | }, 552 | "nbformat": 4, 553 | "nbformat_minor": 2 554 | } 555 | -------------------------------------------------------------------------------- /HW_3.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | " **IMPORTANT: ** When submitting this homework notebook, please modify only the cells that start with:\n", 8 | "\n", 9 | "```python\n", 10 | "# modify this cell\n", 11 | "```" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": {}, 17 | "source": [ 18 | "*Note:* No packages should be imported for this assignment" 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "# Sets: The Inclusion-Exclusion Principle" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "## Problem 1" 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "### Problem 1.1" 40 | ] 41 | }, 42 | { 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "\n", 47 | "The inclusion-exclusion principle states that for two sets $A$ and $B$,\n", 48 | "\n", 49 | "$$|A\\cup B|=|A|+|B|-|A\\cap B|.$$\n", 50 | "\n", 51 | "Write the following functions to determine $|A\\cup B|$ in two different ways.\n", 52 | "\n", 53 | "A function **union** that determines first $A\\cup B$ and then evaluates the union's size.\n", 54 | "Output the ordered pair $(A\\cup B, |A\\cup B|)$.\n", 55 | "\n", 56 | " * **Sample run** *\n", 57 | "```python\n", 58 | "A = {1, 2, 3}\n", 59 | "B = {3, -6, 2, 0}\n", 60 | "print union(A, B)\n", 61 | "```\n", 62 | "\n", 63 | " * **Expected Output** *\n", 64 | "```\n", 65 | "({-6, 0, 1, 2, 3}, 5)\n", 66 | "```" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 1, 72 | "metadata": { 73 | "collapsed": true, 74 | "scrolled": true 75 | }, 76 | "outputs": [], 77 | "source": [ 78 | "# modify this cell\n", 79 | "\n", 80 | "def union(A, B):\n", 81 | " # inputs: A and B are of type 'set'\n", 82 | " # output: a tuple of the type (set, set_length)\n", 83 | " \n", 84 | " C= A.union(B)\n", 85 | " return(C, len(C))\n" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 2, 91 | "metadata": { 92 | "collapsed": true, 93 | "nbgrader": { 94 | "grade": true, 95 | "grade_id": "ex1", 96 | "locked": true, 97 | "points": "5", 98 | "solution": false 99 | } 100 | }, 101 | "outputs": [], 102 | "source": [ 103 | "A = {1,4,-3, \"bob\"}\n", 104 | "B = {2,1,-3,\"jill\"}\n", 105 | "assert union(A,B) == ({-3, 1, 2, 4, 'bob', 'jill'}, 6)\n", 106 | "\n", 107 | "#\n", 108 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 109 | "#\n" 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "### Problem 1.2" 117 | ] 118 | }, 119 | { 120 | "cell_type": "markdown", 121 | "metadata": {}, 122 | "source": [ 123 | "A function **inclusion_exclusion** that first deterimines $|A|$, $|B|$, $A\\cap B$, and $|A\\cap B|$, and then uses the inclusion-exclusion formula to determine $|A\\cup B|$. \n", 124 | "Output the tuple $(|A|, |B|, |A\\cap B|, |A\\cup B|)$.\n", 125 | "\n", 126 | "\n", 127 | " * **Sample run:** *\n", 128 | "```python\n", 129 | "A = {1, 2, 3}\n", 130 | "B = {3, -6, 2, 0}\n", 131 | "print inclusion_exclusion(A, B)\n", 132 | "print \"notice: 3 + 4 - 2 == 5\"\n", 133 | "```\n", 134 | "\n", 135 | " * **Expected Output:** *\n", 136 | "```\n", 137 | "(3, 4, 2, 5)\n", 138 | "notice: 3 + 4 - 2 == 5\n", 139 | "```" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 3, 145 | "metadata": { 146 | "collapsed": true 147 | }, 148 | "outputs": [], 149 | "source": [ 150 | "# modify this cell\n", 151 | "\n", 152 | "def inclusion_exclusion(A, B):\n", 153 | " # inputs: A and B are of type 'set'\n", 154 | " # output: a tuple of four integers\n", 155 | " C= A.intersection(B)\n", 156 | " D= A.union(B)\n", 157 | " return(len(A),len(B),len(C),len(D))\n" 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": 4, 163 | "metadata": { 164 | "collapsed": true, 165 | "nbgrader": { 166 | "grade": true, 167 | "grade_id": "ex2", 168 | "locked": true, 169 | "points": "5", 170 | "solution": false 171 | } 172 | }, 173 | "outputs": [], 174 | "source": [ 175 | "# Check Function\n", 176 | "\n", 177 | "A = {1, 2, 3, 4, 5}\n", 178 | "B = {0, 2, -6, 5, 8, 9}\n", 179 | "assert inclusion_exclusion(A, B) == (5, 6, 2, 9)\n", 180 | "\n", 181 | "#\n", 182 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 183 | "#\n" 184 | ] 185 | }, 186 | { 187 | "cell_type": "markdown", 188 | "metadata": {}, 189 | "source": [ 190 | "## Problem 2" 191 | ] 192 | }, 193 | { 194 | "cell_type": "markdown", 195 | "metadata": {}, 196 | "source": [ 197 | "The inclusion-exclusion principle says that for three sets $A$, $B$ and $C$, \n", 198 | "\n", 199 | "$$|A\\cup B\\cup C|=|A|+|B|+|C|-|A\\cap B|-|B\\cap C|-|C\\cap A|+|A\\cap B\\cap C|$$\n", 200 | "\n", 201 | "We will write the following functions to determine $|A\\cup B\\cup C|$ in two different ways." 202 | ] 203 | }, 204 | { 205 | "cell_type": "markdown", 206 | "metadata": {}, 207 | "source": [ 208 | "### Problem 2.1" 209 | ] 210 | }, 211 | { 212 | "cell_type": "markdown", 213 | "metadata": {}, 214 | "source": [ 215 | "Write function **union3** that first determines $A\\cup B\\cup C$ and then evaluates the size of this union.\n", 216 | "Output the tuple $(A\\cup B\\cup C, |A\\cup B\\cup C|)$.\n", 217 | "\n", 218 | " * **Sample run:** *\n", 219 | "```python\n", 220 | "A = {1, 2, 3, 4, 5}\n", 221 | "B = {0, 2, -6, 5, 8, 9}\n", 222 | "C = {2, 10}\n", 223 | "union3(A, B, C)\n", 224 | "```\n", 225 | "\n", 226 | "\n", 227 | " * **Expected Output:** *\n", 228 | "```\n", 229 | "({-6, 0, 1, 2, 3, 4, 5, 8, 9, 10}, 10)\n", 230 | "```" 231 | ] 232 | }, 233 | { 234 | "cell_type": "code", 235 | "execution_count": 5, 236 | "metadata": { 237 | "collapsed": true, 238 | "scrolled": true 239 | }, 240 | "outputs": [], 241 | "source": [ 242 | "# modify this cell\n", 243 | "\n", 244 | "def union3(A, B, C):\n", 245 | " # inputs: A, B and C are of type 'set'\n", 246 | " # output: a tuple of the type (set, set_length)\n", 247 | " D= A.union(B.union(C))\n", 248 | " return(D, len(D))\n" 249 | ] 250 | }, 251 | { 252 | "cell_type": "code", 253 | "execution_count": 6, 254 | "metadata": { 255 | "collapsed": true, 256 | "nbgrader": { 257 | "grade": true, 258 | "grade_id": "ex3", 259 | "locked": true, 260 | "points": "5", 261 | "solution": false 262 | } 263 | }, 264 | "outputs": [], 265 | "source": [ 266 | "# check Function\n", 267 | "A = {1, 2, 4, 5, 10}\n", 268 | "B = {5, 2, -6, 5, 8, 9}\n", 269 | "C = {2, 10, 13}\n", 270 | "assert union3(A,B,C) == ({-6, 1, 2, 4, 5, 8, 9, 10, 13}, 9)\n", 271 | "\n", 272 | "#\n", 273 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 274 | "#\n" 275 | ] 276 | }, 277 | { 278 | "cell_type": "markdown", 279 | "metadata": {}, 280 | "source": [ 281 | "### Problem 2.2" 282 | ] 283 | }, 284 | { 285 | "cell_type": "markdown", 286 | "metadata": {}, 287 | "source": [ 288 | "A function **inclusion_exclusion3** that first deterimines the sizes of $A$, $B$, $C$ and their mutual intersections, and then uses the inclusion-exclusion principle to determine the size of the union. Output the tuple $(|A\\cap B\\cap C|, |A\\cup B\\cup C|)$. Note that for brevity we are asking you to output the intermediate answer just for $A\\cap B\\cap C$, but you need to calculate all. \n", 289 | "\n", 290 | " * **Sample run:** *\n", 291 | "```python\n", 292 | "A = {1, 2, 3, 4, 5}\n", 293 | "B = {0, 2, -6, 5, 8, 9}\n", 294 | "C = {2, 10}\n", 295 | "print inclusion_exclusion3(A, B, C)\n", 296 | "```\n", 297 | "\n", 298 | "\n", 299 | " * **Expected Output:** *\n", 300 | "```\n", 301 | "(1, 10)\n", 302 | "```" 303 | ] 304 | }, 305 | { 306 | "cell_type": "code", 307 | "execution_count": 7, 308 | "metadata": { 309 | "collapsed": true 310 | }, 311 | "outputs": [], 312 | "source": [ 313 | "# modify this cell\n", 314 | "\n", 315 | "def inclusion_exclusion3(A, B, C):\n", 316 | " # inputs: A, B and C are of type 'set'\n", 317 | " # output: a tuple of two integers\n", 318 | " D= A.intersection(B.intersection(C))\n", 319 | " E= A.union(B.union(C))\n", 320 | " return(len(D),len(E))\n" 321 | ] 322 | }, 323 | { 324 | "cell_type": "code", 325 | "execution_count": 8, 326 | "metadata": { 327 | "collapsed": true, 328 | "nbgrader": { 329 | "grade": true, 330 | "grade_id": "ex4", 331 | "locked": true, 332 | "points": "5", 333 | "solution": false 334 | } 335 | }, 336 | "outputs": [], 337 | "source": [ 338 | "# Check Function\n", 339 | "\n", 340 | "A = {1, 2, 4, 5, 10}\n", 341 | "B = {5, 2, -6, 5, 8, 9, 10}\n", 342 | "C = {2, 10, 13}\n", 343 | "assert inclusion_exclusion3(A,B,C) == (2, 9)\n", 344 | "\n", 345 | "#\n", 346 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 347 | "#\n" 348 | ] 349 | }, 350 | { 351 | "cell_type": "code", 352 | "execution_count": null, 353 | "metadata": { 354 | "collapsed": true 355 | }, 356 | "outputs": [], 357 | "source": [ 358 | "\n", 359 | "\n", 360 | "\n", 361 | "\n", 362 | "\n" 363 | ] 364 | } 365 | ], 366 | "metadata": { 367 | "kernelspec": { 368 | "display_name": "Python 3", 369 | "language": "python", 370 | "name": "python3" 371 | }, 372 | "language_info": { 373 | "codemirror_mode": { 374 | "name": "ipython", 375 | "version": 3 376 | }, 377 | "file_extension": ".py", 378 | "mimetype": "text/x-python", 379 | "name": "python", 380 | "nbconvert_exporter": "python", 381 | "pygments_lexer": "ipython3", 382 | "version": "3.6.5" 383 | }, 384 | "toc": { 385 | "colors": { 386 | "hover_highlight": "#DAA520", 387 | "navigate_num": "#000000", 388 | "navigate_text": "#333333", 389 | "running_highlight": "#FF0000", 390 | "selected_highlight": "#FFD700", 391 | "sidebar_border": "#EEEEEE", 392 | "wrapper_background": "#FFFFFF" 393 | }, 394 | "moveMenuLeft": true, 395 | "nav_menu": { 396 | "height": "48px", 397 | "width": "252px" 398 | }, 399 | "navigate_menu": true, 400 | "number_sections": true, 401 | "sideBar": true, 402 | "threshold": 4, 403 | "toc_cell": false, 404 | "toc_section_display": "block", 405 | "toc_window_display": false, 406 | "widenNotebook": false 407 | } 408 | }, 409 | "nbformat": 4, 410 | "nbformat_minor": 2 411 | } 412 | -------------------------------------------------------------------------------- /HW_4.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | " **IMPORTANT: ** When submitting this homework notebook, only modify the cells that start with:\n", 8 | "\n", 9 | "```python\n", 10 | "# modify this cell\n", 11 | "```\n", 12 | "\n", 13 | " Do not add any new cells and do not import any packages. For working on the notebook, we reccomend you create a copy that you can use to test ideas." 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": {}, 19 | "source": [ 20 | "# Integer compositions\n", 21 | "\n", 22 | "A $k$-composition of an integer $n$ is a $k$-tuple of positive integesrs that sum to $n$. As we saw, there are $\\binom{n-1}{k-1}$ such compositions. For example, there are $\\binom{4-1}{3-1}=\\binom32=3\\quad$ 3-compositions of 4: $(1,1,2)$, $(1,2,1)$, and $(2,1,1)$.\n", 23 | "\n", 24 | "The following problems ask you to generate such compositions, verify the above formula computationally, and to generate and enumerate constrined compositions." 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "### Helper Code" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 1, 37 | "metadata": { 38 | "collapsed": true 39 | }, 40 | "outputs": [], 41 | "source": [ 42 | "import sys\n", 43 | "import numpy as np\n", 44 | "import scipy as sp\n", 45 | "from scipy.special import *" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "This helper function not used in your homework. You don't need to know how it works." 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": 2, 58 | "metadata": { 59 | "collapsed": true 60 | }, 61 | "outputs": [], 62 | "source": [ 63 | "def print_compositions(func_out):\n", 64 | " for x in func_out:\n", 65 | " string = \"\"\n", 66 | " for i in x:\n", 67 | " string = string + str(i)+ \" + \"\n", 68 | " print(string[0:-2]) \n", 69 | " " 70 | ] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "metadata": {}, 75 | "source": [ 76 | "## Problem 1" 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": {}, 82 | "source": [ 83 | "Write a function **compositions** that takes two natural numbers $k$ and $n$ as inputs and returns the set of all tuples of size $k$ that sum to $n$. \n", 84 | "\n", 85 | " **Code:**\n", 86 | "```python\n", 87 | "func_out = compositions(3,4)\n", 88 | "\n", 89 | "print \"all possible combinations: \"\n", 90 | "print_compositions(func_out)\n", 91 | "print;print \"Actual Output from compositions(3,4)\"; func_out\n", 92 | "```\n", 93 | "\n", 94 | "\n", 95 | " **Output**\n", 96 | "```\n", 97 | "all possible combinations: \n", 98 | "1 + 2 + 1 \n", 99 | "2 + 1 + 1 \n", 100 | "1 + 1 + 2 \n", 101 | "\n", 102 | "Actual Output from: compositions(3,4)\n", 103 | "{(1, 1, 2), (1, 2, 1), (2, 1, 1)}\n", 104 | "```" 105 | ] 106 | }, 107 | { 108 | "cell_type": "markdown", 109 | "metadata": { 110 | "nbgrader": { 111 | "grade": true, 112 | "grade_id": "ex1", 113 | "locked": true, 114 | "points": "5", 115 | "solution": false 116 | } 117 | }, 118 | "source": [ 119 | "#### This is not for general, but for specific (for 2)\n", 120 | "from itertools import combinations_with_replacement\n", 121 | "def compositions(k, n):\n", 122 | " # inputs: k and n are of type 'int'\n", 123 | " # output: a set of tuples\n", 124 | " f=[]\n", 125 | " l= range(1,n)\n", 126 | " c= combinations_with_replacement(l,k)\n", 127 | " for i,j in c:\n", 128 | " if i+j==n:\n", 129 | " f.append((i,j))\n", 130 | " f.append((j,i))\n", 131 | " return set(f)" 132 | ] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": 5, 137 | "metadata": {}, 138 | "outputs": [], 139 | "source": [ 140 | "# modify this cell\n", 141 | "\n", 142 | "def compositions(k, n):\n", 143 | " # inputs: k and n are of type 'int'\n", 144 | " # output: a set of tuples\n", 145 | " if k == 1:\n", 146 | " return {(n,)}\n", 147 | " else:\n", 148 | " s = set()\n", 149 | " for i in range(1, n):\n", 150 | " for j in compositions(k - 1, n - i): #i + n-i = n\n", 151 | " s.add((i,) + j)\n", 152 | " return s" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": 6, 158 | "metadata": { 159 | "collapsed": true 160 | }, 161 | "outputs": [], 162 | "source": [ 163 | "# Check Function\n", 164 | "func_out = compositions(2, 8)\n", 165 | "assert type(func_out).__name__ == \"set\"\n", 166 | "assert func_out == {(1, 7), (2, 6), (3, 5), (4, 4), (5, 3), (6, 2), (7, 1)}\n", 167 | "\n", 168 | "#\n", 169 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 170 | "#\n" 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "## Problem 2\n", 178 | "\n", 179 | "Write a function **composition_formula** that takes two positive integers, $k$ and $n$,\n", 180 | "and returns the number of $k$-compositions of $n$ calculated in two different ways:\n", 181 | "first by calculating the number of compositions returned by **compositions**, \n", 182 | "then by using the binomial formula $\\binom{n-1}{k-1}$. The returned value should be a\n", 183 | "tuple consisting of the (same) integer calculated in the two ways.\n", 184 | "\n", 185 | " **Code**\n", 186 | "```python\n", 187 | "print len(compositions(3, 4))\n", 188 | "print int(binom(4-1, 3-1))\n", 189 | "print composition_formula(3, 4)\n", 190 | "```\n", 191 | "\n", 192 | " **Output**\n", 193 | "```python\n", 194 | "3\n", 195 | "3\n", 196 | "(3, 3)\n", 197 | "```" 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": 7, 203 | "metadata": { 204 | "collapsed": true, 205 | "nbgrader": { 206 | "grade": true, 207 | "grade_id": "ex2", 208 | "locked": true, 209 | "points": "5", 210 | "solution": false 211 | } 212 | }, 213 | "outputs": [], 214 | "source": [ 215 | "# modify this cell\n", 216 | "\n", 217 | "def composition_formula(k, n):\n", 218 | " # inputs: k and n are of type 'int'\n", 219 | " # output: a set of tuples, (int, int)\n", 220 | " a= len(compositions(k,n))\n", 221 | " b= int(binom(n-1,k-1))\n", 222 | " return a,b" 223 | ] 224 | }, 225 | { 226 | "cell_type": "code", 227 | "execution_count": 8, 228 | "metadata": { 229 | "collapsed": true 230 | }, 231 | "outputs": [], 232 | "source": [ 233 | "# Check Function\n", 234 | "assert composition_formula(4, 12) == (165,165)\n", 235 | "\n", 236 | "#\n", 237 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 238 | "#\n" 239 | ] 240 | }, 241 | { 242 | "cell_type": "markdown", 243 | "metadata": {}, 244 | "source": [ 245 | "## Problem 3\n", 246 | "\n", 247 | "Let $\\boldsymbol{m}=(m_1,...,m_k)$ be a vector of $k$ positive integers. A $k$-composition $(a_1,...,a_k)$ of $n$ is $\\boldsymbol{m}$-constrained if $a_i\\leq m_i$ for all $1\\le i\\le k$. For example, $(1,1,3)$ and $(2,1,2)$ are the only $(2,1,4)$-constrined 3-partitions of 5. \n", 248 | "\n", 249 | "Write a function **constrained_compositions** that takes a natural number $n$ and a vector $\\boldsymbol{m}$ of $k$ positive integers, and prints the set of all $\\boldsymbol m$-constrained $k$-compositions of $n$. Note that $k$ can be inferred from $\\boldsymbol m$. \n", 250 | "\n", 251 | "Hint: You may invoke the **compositions** function.\n", 252 | "\n", 253 | " **Code**\n", 254 | "```python\n", 255 | "func_out = constrained_compositions(7, [3, 2, 5])\n", 256 | "\n", 257 | "print \"all possible combinations: \"\n", 258 | "print_compositions(func_out)\n", 259 | "print;print \"Actual Output from compositions(3,7)\"; func_out\n", 260 | "```\n", 261 | "\n", 262 | "\n", 263 | " **Output**\n", 264 | "```\n", 265 | "all possible combinations: \n", 266 | "1 + 2 + 4 \n", 267 | "2 + 1 + 4 \n", 268 | "3 + 2 + 2 \n", 269 | "3 + 1 + 3 \n", 270 | "1 + 1 + 5 \n", 271 | "2 + 2 + 3 \n", 272 | "\n", 273 | "Actual Output from compositions(3,7)\n", 274 | "{(1, 1, 5), (1, 2, 4), (2, 1, 4), (2, 2, 3), (3, 1, 3), (3, 2, 2)}\n", 275 | "```" 276 | ] 277 | }, 278 | { 279 | "cell_type": "markdown", 280 | "metadata": { 281 | "nbgrader": { 282 | "grade": true, 283 | "grade_id": "ex3", 284 | "locked": true, 285 | "points": "5", 286 | "solution": false 287 | } 288 | }, 289 | "source": [ 290 | "#### This is not for general, but for specific (for 3)\n", 291 | "def constrained_compositions(n, m):\n", 292 | " # inputs: n is of type 'int' and m is a list of integers\n", 293 | " # output: a set of tuples\n", 294 | " l=[]\n", 295 | " i=m[0]\n", 296 | " j=m[1]\n", 297 | " k=m[2]\n", 298 | " while i>0:\n", 299 | " if i+j+k==n:\n", 300 | " l.append((i,j,k))\n", 301 | " while j>0:\n", 302 | " if i+j+k==n:\n", 303 | " l.append((i,j,k))\n", 304 | " while k>0:\n", 305 | " if i+j+k==n:\n", 306 | " l.append((i,j,k))\n", 307 | " k=k-1\n", 308 | " k=m[2]\n", 309 | " j=j-1\n", 310 | " j=m[1]\n", 311 | " i=i-1\n", 312 | " \n", 313 | " return set(l)\n" 314 | ] 315 | }, 316 | { 317 | "cell_type": "code", 318 | "execution_count": 19, 319 | "metadata": {}, 320 | "outputs": [], 321 | "source": [ 322 | "# modify this cell\n", 323 | "\n", 324 | "def constrained_compositions(n, m):\n", 325 | " # inputs: n is of type 'int' and m is a list of integers\n", 326 | " # output: a set of tuples\n", 327 | " k = len(m)\n", 328 | " s = set()\n", 329 | " for c in compositions(k, n):\n", 330 | " if sum([c[i] <= m[i] for i in range(k)]) == k: #taking the sets of all comb. which are less than equal to the given \n", 331 | " s.add(c)\n", 332 | " return s" 333 | ] 334 | }, 335 | { 336 | "cell_type": "code", 337 | "execution_count": 20, 338 | "metadata": { 339 | "collapsed": true 340 | }, 341 | "outputs": [], 342 | "source": [ 343 | "# Check Function\n", 344 | "func_out = constrained_compositions(7, [1,4,4])\n", 345 | "assert type(func_out).__name__ == \"set\"\n", 346 | "assert constrained_compositions(7, [1,4,4]) == {(1, 2, 4), (1, 3, 3), (1, 4, 2)}\n", 347 | "\n", 348 | "#\n", 349 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 350 | "#\n" 351 | ] 352 | }, 353 | { 354 | "cell_type": "code", 355 | "execution_count": null, 356 | "metadata": { 357 | "collapsed": true 358 | }, 359 | "outputs": [], 360 | "source": [ 361 | "\n", 362 | "\n", 363 | "\n", 364 | "\n", 365 | "\n", 366 | "\n", 367 | "\n", 368 | "\n" 369 | ] 370 | } 371 | ], 372 | "metadata": { 373 | "kernelspec": { 374 | "display_name": "Python 3", 375 | "language": "python", 376 | "name": "python3" 377 | }, 378 | "language_info": { 379 | "codemirror_mode": { 380 | "name": "ipython", 381 | "version": 3 382 | }, 383 | "file_extension": ".py", 384 | "mimetype": "text/x-python", 385 | "name": "python", 386 | "nbconvert_exporter": "python", 387 | "pygments_lexer": "ipython3", 388 | "version": "3.6.5" 389 | }, 390 | "toc": { 391 | "colors": { 392 | "hover_highlight": "#DAA520", 393 | "navigate_num": "#000000", 394 | "navigate_text": "#333333", 395 | "running_highlight": "#FF0000", 396 | "selected_highlight": "#FFD700", 397 | "sidebar_border": "#EEEEEE", 398 | "wrapper_background": "#FFFFFF" 399 | }, 400 | "moveMenuLeft": true, 401 | "nav_menu": { 402 | "height": "48px", 403 | "width": "252px" 404 | }, 405 | "navigate_menu": true, 406 | "number_sections": true, 407 | "sideBar": true, 408 | "threshold": 4, 409 | "toc_cell": false, 410 | "toc_section_display": "block", 411 | "toc_window_display": false, 412 | "widenNotebook": false 413 | } 414 | }, 415 | "nbformat": 4, 416 | "nbformat_minor": 2 417 | } 418 | -------------------------------------------------------------------------------- /HW_5.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "nbgrader": { 7 | "grade": false, 8 | "locked": false, 9 | "solution": false 10 | } 11 | }, 12 | "source": [ 13 | " **IMPORTANT: ** When submitting this homework notebook, please modify only the cells that start with:\n", 14 | "\n", 15 | "```python\n", 16 | "# modify this cell\n", 17 | "```\n" 18 | ] 19 | }, 20 | { 21 | "cell_type": "markdown", 22 | "metadata": { 23 | "nbgrader": { 24 | "grade": false, 25 | "locked": false, 26 | "solution": false 27 | } 28 | }, 29 | "source": [ 30 | "# Different Dice\n", 31 | "\n", 32 | "\n", 33 | "So far we mostly considered standard 6-faced dice. The following problems explore dice with different number of faces. " 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 1, 39 | "metadata": { 40 | "nbgrader": { 41 | "grade": false, 42 | "locked": false, 43 | "solution": false 44 | } 45 | }, 46 | "outputs": [ 47 | { 48 | "name": "stdout", 49 | "output_type": "stream", 50 | "text": [ 51 | "Populating the interactive namespace from numpy and matplotlib\n" 52 | ] 53 | } 54 | ], 55 | "source": [ 56 | "import numpy as np\n", 57 | "%pylab inline" 58 | ] 59 | }, 60 | { 61 | "cell_type": "markdown", 62 | "metadata": { 63 | "nbgrader": { 64 | "grade": false, 65 | "locked": false, 66 | "solution": false 67 | } 68 | }, 69 | "source": [ 70 | "## Problem 1" 71 | ] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "metadata": { 76 | "nbgrader": { 77 | "grade": false, 78 | "locked": false, 79 | "solution": false 80 | } 81 | }, 82 | "source": [ 83 | "Suppose that a 6-sided die is rolled $n$ times. Let $X_i$ be the value of the top face at the $i$th roll,\n", 84 | "and let $X\\triangleq\\max_{1\\le i\\le n} X_i$ be the highest value observed. For example, if $n=3$ and the three\n", 85 | "rolls are 4, 1, and 4, then $X_1=4, X_2=1, X_3=4$ and $X=4$. \n", 86 | "\n", 87 | "To find the distribution of $X$, observe first that $X\\le x$ iff $X_i\\le x$ for all $1\\le i\\le n$,\n", 88 | "hence $P(X\\le x)=(x/6)^n$. It follows that $P(X=x)=P(X\\le x)-P(X\\le x-1)=(x/6)^n-((x-1)/6)^n$.\n", 89 | "For example, $P(X=1)=(1/6)^n$, and $P(X=2)=(1/3)^n-(1/6)^n$.\n", 90 | "\n", 91 | "In this problem we assume that each of the $n$ dice has a potentially different number of faces, denoted $f_i$,\n", 92 | "and ask you to write a function **largest_face** that determines the probability $P(x)$ that the highest top face observed is $x$. **largest_face** takes a vector $\\boldsymbol f$ of positive integers, interpreted as the number of faces of each of the dice, and a value $x$ and returns $P(x)$. For example, if $\\boldsymbol f=[2, 5, 7]$, then three dice are rolled, and $P(1)=(1/2)\\cdot(1/5)\\cdot(1/7)$ as all dice must be 1, while $P(7)=1/7$ as the third die must turn up 7.\n", 93 | "\n", 94 | "* **Sample run** *\n", 95 | "```python\n", 96 | "print largest_face([2,5,8],8)\n", 97 | "print largest_face([2], 1)\n", 98 | "largest_face( [3,4], 2)\n", 99 | "print largest_face([2, 5, 7, 3], 3)\n", 100 | "```\n", 101 | "\n", 102 | "\n", 103 | "* **Expected Output** *\n", 104 | "```\n", 105 | "0.125\n", 106 | "0.5\n", 107 | "0.25\n", 108 | "0.180952380952\n", 109 | "```" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": 2, 115 | "metadata": { 116 | "collapsed": true, 117 | "scrolled": true 118 | }, 119 | "outputs": [], 120 | "source": [ 121 | "# modify this cell\n", 122 | "\n", 123 | "def largest_face(f, x_max):\n", 124 | " # inputs: m is a list of integers and m_max is an integer\n", 125 | " # output: a variable of type 'float'\n", 126 | " # Example: Here we want to get the probability of getting largest face as 2 for two dices.\n", 127 | " # That should be 3 combinations out of total 36 combinations : 1,2 2,1, 2,2\n", 128 | " # According to formula : P(2)= (2/6)^2 - (1/6)^2 = 3/36\n", 129 | " return np.prod([x_max/float(n) for n in f if x_max <= n]) - np.prod([(x_max - 1) / float(n) for n in f if x_max <= n])\n", 130 | " " 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": 3, 136 | "metadata": { 137 | "collapsed": true, 138 | "nbgrader": { 139 | "grade": true, 140 | "grade_id": "ex_1", 141 | "locked": true, 142 | "points": "5", 143 | "solution": false 144 | } 145 | }, 146 | "outputs": [], 147 | "source": [ 148 | "# Check Function\n", 149 | "\n", 150 | "assert abs( largest_face([5],3) - 0.19999999999999996 ) < 10**-5\n", 151 | "assert abs( largest_face( [11,5,4], 5) - 0.16363636363636364 ) < 10**-5\n", 152 | "assert abs( largest_face(range(1,10), 3) - 0.011348104056437391 ) < 10**-5 \n", 153 | "\n", 154 | "\n", 155 | "#\n", 156 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 157 | "#\n" 158 | ] 159 | }, 160 | { 161 | "cell_type": "markdown", 162 | "metadata": { 163 | "nbgrader": { 164 | "grade": false, 165 | "locked": false, 166 | "solution": false 167 | } 168 | }, 169 | "source": [ 170 | "## Problem 2" 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": { 176 | "nbgrader": { 177 | "grade": false, 178 | "locked": false, 179 | "solution": false 180 | } 181 | }, 182 | "source": [ 183 | "Write a function **face_sum** that takes a vector $\\boldsymbol f$ that as in the previous problem represents the number of faces of each die, and a positive integer $s$, and returns the probability that the sum of the top faces observed is $s$. For example, if $\\boldsymbol f=[3, 4, 5]$ and $s\\le 2$ or $s\\ge 13$, **face_sum** returns 0, and if $s=3$ or $s=12$, it returns $(1/3)\\cdot(1/4)\\cdot(1/5)=1/60$.\n", 184 | "\n", 185 | "Hint: The **constrained-composition** function you wrote for an earlier probelm may prove handy. \n", 186 | "\n", 187 | " * **Sample run** *\n", 188 | "```python\n", 189 | "print face_sum([3, 4, 5], 13)\n", 190 | "print face_sum([2,2],3)\n", 191 | "print face_sum([3, 4, 5], 7)\n", 192 | "```\n", 193 | "\n", 194 | "\n", 195 | " * **Expected Output** *\n", 196 | "```\n", 197 | "0.0\n", 198 | "0.5\n", 199 | "0.18333333\n", 200 | "```" 201 | ] 202 | }, 203 | { 204 | "cell_type": "markdown", 205 | "metadata": { 206 | "nbgrader": { 207 | "grade": false, 208 | "locked": false, 209 | "solution": false 210 | } 211 | }, 212 | "source": [ 213 | "### Helper Code\n", 214 | "\n", 215 | "Below is a correct implementation of **constrained_composition**. Call this function in your implementation of **face_sum**." 216 | ] 217 | }, 218 | { 219 | "cell_type": "code", 220 | "execution_count": 4, 221 | "metadata": { 222 | "collapsed": true, 223 | "nbgrader": { 224 | "grade": false, 225 | "locked": false, 226 | "solution": false 227 | } 228 | }, 229 | "outputs": [], 230 | "source": [ 231 | "def constrained_compositions(n, m):\n", 232 | " # inputs: n is of type 'int' and m is a list of integers\n", 233 | " # output: a set of tuples\n", 234 | " \n", 235 | " k = len(m)\n", 236 | " parts = set()\n", 237 | " if k == n:\n", 238 | " if 1 <= min(m):\n", 239 | " parts.add((1,)*n)\n", 240 | " if k == 1:\n", 241 | " if n <= m[0]:\n", 242 | " parts.add((n,))\n", 243 | " else:\n", 244 | " for x in range(1, min(n-k+2,m[0]+1)):\n", 245 | " for y in constrained_compositions(n-x, m[1:]):\n", 246 | " parts.add((x,)+y)\n", 247 | " return parts" 248 | ] 249 | }, 250 | { 251 | "cell_type": "markdown", 252 | "metadata": { 253 | "nbgrader": { 254 | "grade": false, 255 | "locked": false, 256 | "solution": false 257 | } 258 | }, 259 | "source": [ 260 | "### exercise:" 261 | ] 262 | }, 263 | { 264 | "cell_type": "code", 265 | "execution_count": 5, 266 | "metadata": { 267 | "collapsed": true 268 | }, 269 | "outputs": [], 270 | "source": [ 271 | "# modify this cell\n", 272 | "\n", 273 | "def face_sum(m, s):\n", 274 | " # inputs: m is list of integers and s is an integer\n", 275 | " # output: a variable of type 'float'\n", 276 | " # Example: Here we want to see to get the probability of largest face summing up to the number provided\n", 277 | " # As for [2,2], we have (1,1),(1,2),(2,1),(2,2) as all possible combinations of largest faces\n", 278 | " # For getting 3 as sum, we have its probability as 2/4 = 0.5\n", 279 | " l1= len(constrained_compositions(s,m))\n", 280 | " l2=1\n", 281 | " for i in m:\n", 282 | " l2= i*l2\n", 283 | " probability= l1/l2\n", 284 | " return probability" 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": 6, 290 | "metadata": { 291 | "collapsed": true, 292 | "nbgrader": { 293 | "grade": true, 294 | "grade_id": "ex_2", 295 | "locked": true, 296 | "points": "5", 297 | "solution": false 298 | } 299 | }, 300 | "outputs": [], 301 | "source": [ 302 | "# Check Function\n", 303 | "assert sum(abs( face_sum([2,2],2) - 0.25 )) < 10**-5\n", 304 | "assert sum(abs( face_sum([2,2],10) - 0.0 )) < 10**-5\n", 305 | "assert sum(abs( face_sum(range(1,10),20) - 0.03037092151675485 )) < 10**-5\n", 306 | "\n", 307 | "#\n", 308 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 309 | "#\n" 310 | ] 311 | }, 312 | { 313 | "cell_type": "code", 314 | "execution_count": null, 315 | "metadata": { 316 | "collapsed": true, 317 | "nbgrader": { 318 | "grade": false, 319 | "locked": false, 320 | "solution": false 321 | } 322 | }, 323 | "outputs": [], 324 | "source": [ 325 | "\n", 326 | "\n", 327 | "\n", 328 | "\n", 329 | "\n", 330 | "\n" 331 | ] 332 | } 333 | ], 334 | "metadata": { 335 | "kernelspec": { 336 | "display_name": "Python 3", 337 | "language": "python", 338 | "name": "python3" 339 | }, 340 | "language_info": { 341 | "codemirror_mode": { 342 | "name": "ipython", 343 | "version": 3 344 | }, 345 | "file_extension": ".py", 346 | "mimetype": "text/x-python", 347 | "name": "python", 348 | "nbconvert_exporter": "python", 349 | "pygments_lexer": "ipython3", 350 | "version": "3.6.5" 351 | }, 352 | "toc": { 353 | "colors": { 354 | "hover_highlight": "#DAA520", 355 | "navigate_num": "#000000", 356 | "navigate_text": "#333333", 357 | "running_highlight": "#FF0000", 358 | "selected_highlight": "#FFD700", 359 | "sidebar_border": "#EEEEEE", 360 | "wrapper_background": "#FFFFFF" 361 | }, 362 | "moveMenuLeft": true, 363 | "nav_menu": { 364 | "height": "48px", 365 | "width": "252px" 366 | }, 367 | "navigate_menu": true, 368 | "number_sections": true, 369 | "sideBar": true, 370 | "threshold": 4, 371 | "toc_cell": false, 372 | "toc_section_display": "block", 373 | "toc_window_display": false, 374 | "widenNotebook": false 375 | } 376 | }, 377 | "nbformat": 4, 378 | "nbformat_minor": 2 379 | } 380 | -------------------------------------------------------------------------------- /HW_6.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "nbgrader": { 7 | "grade": false, 8 | "locked": false, 9 | "solution": false 10 | } 11 | }, 12 | "source": [ 13 | " **IMPORTANT: ** When submitting this homework notebook, please modify only the cells that start with:\n", 14 | "\n", 15 | "```python\n", 16 | "# modify this cell\n", 17 | "```" 18 | ] 19 | }, 20 | { 21 | "cell_type": "markdown", 22 | "metadata": {}, 23 | "source": [ 24 | "# Conditional Probability and Baye's Rule\n" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "## Problem" 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "There are two urns $A$ and $B$. Urn $A$ contains $r_A$ red balls and $w_A$ white balls whereas urn $B$ contains $r_B$ red balls and $w_B$ white balls. One of the urns is picked at random and then one ball is picked at random from this urn. Write a function **conditional_probability** that calculates the conditional probability that the randomly chosen ball belonged to urn $A$ given that it is white. Assume that $\\frac{r_A}{w_A}\\neq\\frac{r_B}{w_B}$.\n", 39 | "\n", 40 | " **Code**\n", 41 | "```python\n", 42 | "rA, wA, rB, wB = 1., 2., 2., 1.\n", 43 | "conditional__probability(rA, wA, rB, wB) \n", 44 | "```\n", 45 | "\n", 46 | " **Output**\n", 47 | "```\n", 48 | "0.6666666666666666\n", 49 | "```" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 15, 55 | "metadata": { 56 | "collapsed": true, 57 | "scrolled": true 58 | }, 59 | "outputs": [], 60 | "source": [ 61 | "# modify this cell\n", 62 | "\n", 63 | "def conditional__probability(rA, wA, rB, wB):\n", 64 | " # inputs: all of them are of type 'float'\n", 65 | " # output: a variable of type 'float'\n", 66 | " Prob_white_in_A= wA/(rA+wA)\n", 67 | " Prob_white = wA/(rA+wA) + wB/(rB+wB)\n", 68 | " return Prob_white_in_A/Prob_white\n" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": 16, 74 | "metadata": {}, 75 | "outputs": [ 76 | { 77 | "data": { 78 | "text/plain": [ 79 | "0.6666666666666666" 80 | ] 81 | }, 82 | "execution_count": 16, 83 | "metadata": {}, 84 | "output_type": "execute_result" 85 | } 86 | ], 87 | "source": [ 88 | "conditional__probability(1.,2.,2.,1.)" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": 17, 94 | "metadata": { 95 | "collapsed": true, 96 | "nbgrader": { 97 | "grade": true, 98 | "grade_id": "ex1", 99 | "locked": true, 100 | "points": "5", 101 | "solution": false 102 | } 103 | }, 104 | "outputs": [], 105 | "source": [ 106 | "assert( abs(conditional__probability(2., 4., 3., 3.) -0.5714285714285715) < 10**-5) \n", 107 | "assert( abs(conditional__probability(1., 3., 5., 2.) -0.7241379310344829) < 10**-5) \n", 108 | "\n", 109 | "#\n", 110 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 111 | "#\n" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": null, 117 | "metadata": { 118 | "collapsed": true 119 | }, 120 | "outputs": [], 121 | "source": [ 122 | "\n", 123 | "\n", 124 | "\n", 125 | "\n", 126 | "\n", 127 | "\n", 128 | "\n" 129 | ] 130 | } 131 | ], 132 | "metadata": { 133 | "kernelspec": { 134 | "display_name": "Python 3", 135 | "language": "python", 136 | "name": "python3" 137 | }, 138 | "language_info": { 139 | "codemirror_mode": { 140 | "name": "ipython", 141 | "version": 3 142 | }, 143 | "file_extension": ".py", 144 | "mimetype": "text/x-python", 145 | "name": "python", 146 | "nbconvert_exporter": "python", 147 | "pygments_lexer": "ipython3", 148 | "version": "3.6.5" 149 | }, 150 | "toc": { 151 | "colors": { 152 | "hover_highlight": "#DAA520", 153 | "navigate_num": "#000000", 154 | "navigate_text": "#333333", 155 | "running_highlight": "#FF0000", 156 | "selected_highlight": "#FFD700", 157 | "sidebar_border": "#EEEEEE", 158 | "wrapper_background": "#FFFFFF" 159 | }, 160 | "moveMenuLeft": true, 161 | "nav_menu": { 162 | "height": "48px", 163 | "width": "252px" 164 | }, 165 | "navigate_menu": true, 166 | "number_sections": true, 167 | "sideBar": true, 168 | "threshold": 4, 169 | "toc_cell": false, 170 | "toc_section_display": "block", 171 | "toc_window_display": false, 172 | "widenNotebook": false 173 | } 174 | }, 175 | "nbformat": 4, 176 | "nbformat_minor": 2 177 | } 178 | -------------------------------------------------------------------------------- /HW_7.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | " **IMPORTANT: ** When submitting this homework notebook, please modify only the cells that start with:\n", 8 | "\n", 9 | "```python\n", 10 | "# modify this cell\n", 11 | "```" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": {}, 17 | "source": [ 18 | "**Note:** notice that no packages are imported for this assignment. This is because you do not need any python packages." 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "# Probability Inequalities\n" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "For the binomial distribution $X\\sim B_{p,n}$ with mean $\\mu=np$ and variance $\\sigma^2=np(1-p)$, \n", 33 | "we would like to upper bound the probability $P(X\\ge c\\cdot \\mu)$ for $c\\ge1$. \n", 34 | "The lectures introduced three bounds:\n", 35 | "\n", 36 | "Markov: $$P(X\\ge \\alpha\\mu)\\le \\frac{1}{\\alpha},\\quad\\quad\\forall \\alpha\\ge 1,$$\n", 37 | "Chebyshev: $$P(|X-\\mu|\\ge \\alpha\\sigma)\\le \\frac{1}{\\alpha^2},\\quad\\quad \\forall \\alpha\\ge 1,$$\n", 38 | "Note that, while double-sided, this inequality also bounds $P(X\\ge\\mu+\\alpha)$\n", 39 | "$$P(X\\ge \\mu+\\alpha\\sigma)\\le P(|X-\\mu|\\ge \\alpha\\sigma)\\le \\frac{1}{\\alpha^2},$$\n", 40 | "Chernoff: $$P(X\\ge (1+\\delta)\\mu)\\le e^{-\\frac{\\delta^2}{2+\\delta}\\mu},\\quad\\quad\\forall \\delta\\ge0.$$\n" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 1, 46 | "metadata": { 47 | "collapsed": true 48 | }, 49 | "outputs": [], 50 | "source": [ 51 | "from math import exp, sqrt" 52 | ] 53 | }, 54 | { 55 | "cell_type": "markdown", 56 | "metadata": {}, 57 | "source": [ 58 | "import exponential function exp from math" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "metadata": {}, 64 | "source": [ 65 | "## Problem 1" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "Write three functions **Markov**, **Chebyshev** and **Chernoff** that take $n$, $p$ and $c$ as inputs and return the upper bounds for $P(X\\ge c\\cdot np)$ given by the above Markov, Chebyshev, and Chernoff inequalities as outputs.\n", 73 | "\n", 74 | " **Code:**\n", 75 | "```python\n", 76 | "print Markov(100.,0.2,1.5)\n", 77 | "print Chebyshev(100.,0.2,1.5)\n", 78 | "print Chernoff(100.,0.2,1.5)\n", 79 | "```\n", 80 | "\n", 81 | "\n", 82 | " **Output**\n", 83 | "```\n", 84 | "0.6666666666666666\n", 85 | "0.16\n", 86 | "0.1353352832366127\n", 87 | "\n", 88 | "```" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": 2, 94 | "metadata": { 95 | "collapsed": true 96 | }, 97 | "outputs": [], 98 | "source": [ 99 | "\n", 100 | "# modify this cell\n", 101 | "\n", 102 | "def Markov(n, p, c):\n", 103 | " # inputs: 3 floats as described above\n", 104 | " # output: a variable of type float\n", 105 | " return 1/c\n" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 3, 111 | "metadata": { 112 | "collapsed": true 113 | }, 114 | "outputs": [], 115 | "source": [ 116 | "\n", 117 | "# modify this cell\n", 118 | "\n", 119 | "def Chebyshev(n, p, c):\n", 120 | " # inputs: 3 floats as described above\n", 121 | " # output: a variable of type float\n", 122 | " std_dev= sqrt(n*p*(1-p))\n", 123 | " a= (c*n*p-n*p)/std_dev\n", 124 | " return 1/a**2\n" 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": 4, 130 | "metadata": { 131 | "collapsed": true 132 | }, 133 | "outputs": [], 134 | "source": [ 135 | "\n", 136 | "# modify this cell\n", 137 | "\n", 138 | "def Chernoff(n, p, c):\n", 139 | " # inputs: 3 floats as described above\n", 140 | " # output: a variable of type float\n", 141 | " delta=c-1\n", 142 | " return exp(-delta*delta*n*p/(2+delta))\n" 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": 5, 148 | "metadata": { 149 | "nbgrader": { 150 | "grade": true, 151 | "grade_id": "ex1", 152 | "locked": true, 153 | "points": "5", 154 | "solution": false 155 | } 156 | }, 157 | "outputs": [], 158 | "source": [ 159 | "assert (Markov(200.,0.25,1.25)-0.8)< 10**-5\n", 160 | "assert (Chebyshev(100.,0.25,1.25)-0.48)< 10**-5\n", 161 | "assert (Chernoff(100.,0.25,1.25)-0.4993517885992762)< 10**-5\n", 162 | "#\n", 163 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 164 | "#\n" 165 | ] 166 | }, 167 | { 168 | "cell_type": "code", 169 | "execution_count": null, 170 | "metadata": {}, 171 | "outputs": [], 172 | "source": [] 173 | } 174 | ], 175 | "metadata": { 176 | "kernelspec": { 177 | "display_name": "Python 3", 178 | "language": "python", 179 | "name": "python3" 180 | }, 181 | "language_info": { 182 | "codemirror_mode": { 183 | "name": "ipython", 184 | "version": 3 185 | }, 186 | "file_extension": ".py", 187 | "mimetype": "text/x-python", 188 | "name": "python", 189 | "nbconvert_exporter": "python", 190 | "pygments_lexer": "ipython3", 191 | "version": "3.6.5" 192 | }, 193 | "toc": { 194 | "colors": { 195 | "hover_highlight": "#DAA520", 196 | "navigate_num": "#000000", 197 | "navigate_text": "#333333", 198 | "running_highlight": "#FF0000", 199 | "selected_highlight": "#FFD700", 200 | "sidebar_border": "#EEEEEE", 201 | "wrapper_background": "#FFFFFF" 202 | }, 203 | "moveMenuLeft": true, 204 | "nav_menu": { 205 | "height": "48px", 206 | "width": "252px" 207 | }, 208 | "navigate_menu": true, 209 | "number_sections": true, 210 | "sideBar": true, 211 | "threshold": 4, 212 | "toc_cell": false, 213 | "toc_section_display": "block", 214 | "toc_window_display": false, 215 | "widenNotebook": false 216 | } 217 | }, 218 | "nbformat": 4, 219 | "nbformat_minor": 2 220 | } 221 | -------------------------------------------------------------------------------- /HW_8.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "nbgrader": { 7 | "grade": false, 8 | "locked": true, 9 | "solution": false 10 | } 11 | }, 12 | "source": [ 13 | " **IMPORTANT: ** When submitting this homework notebook, please modify only the cells that start with:\n", 14 | "\n", 15 | "```python\n", 16 | "# modify this cell\n", 17 | "```" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 1, 23 | "metadata": { 24 | "nbgrader": { 25 | "grade": false, 26 | "locked": true, 27 | "solution": false 28 | } 29 | }, 30 | "outputs": [ 31 | { 32 | "name": "stdout", 33 | "output_type": "stream", 34 | "text": [ 35 | "Populating the interactive namespace from numpy and matplotlib\n" 36 | ] 37 | } 38 | ], 39 | "source": [ 40 | "%pylab inline" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": { 46 | "nbgrader": { 47 | "grade": false, 48 | "locked": true, 49 | "solution": false 50 | } 51 | }, 52 | "source": [ 53 | "# Mean Squrare Error" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": { 59 | "nbgrader": { 60 | "grade": false, 61 | "locked": true, 62 | "solution": false 63 | } 64 | }, 65 | "source": [ 66 | "In the lecture we considered the sample-mean estimator for the distribution mean.\n", 67 | "Another estimator for the distribution mean is the min-max-mean estimator that takes the mean (average) of the smallest\n", 68 | "and largest observed values. For example, for the sample {1, 2, 1, 5, 1},\n", 69 | "the sample mean is (1+2+1+5+1)/5=2 while the min-max-mean is (1+5)/2=3.\n", 70 | "In this problem we ask you to run a simulation that approximates\n", 71 | "the mean squared error (MSE) of the two estimators for a uniform distribution.\n", 72 | "\n", 73 | "Take a continuous uniform distribution between $a$ and $b$ - given as parameters.\n", 74 | "Draw a 10-observation sample from this distribution, and calculate\n", 75 | "the sample-mean and the min-max-mean. Repeat the experiment 1,000,000\n", 76 | "times, and for each estimator calculate its average bias, and its\n", 77 | "(Bessel-corrected) sample-variance over the 1,000,000 estimates. \n", 78 | "Take the square of the average bias plus the sample variance\n", 79 | "as your MSE estimates.\n", 80 | "\n", 81 | "Note that you can use the function numpy.random.uniform to generate random samples. You can calculate the mean and variance using the formulas presented in the lecture or via the function numpy.mean and numpy.var. To calculate the unbiased sample variance using function numpy.var, you will need to set ddof=1." 82 | ] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": { 87 | "nbgrader": { 88 | "grade": false, 89 | "locked": true, 90 | "solution": false 91 | } 92 | }, 93 | "source": [ 94 | "## Problem 1" 95 | ] 96 | }, 97 | { 98 | "cell_type": "markdown", 99 | "metadata": { 100 | "nbgrader": { 101 | "grade": false, 102 | "locked": true, 103 | "solution": false 104 | } 105 | }, 106 | "source": [ 107 | "For this problem, you are asked to write a function **Sample_Mean_MSE** that experimentally calculates the MSE of the sample-mean estimator for samples drawn from uniform distribution given the bounds $a$ and $b$." 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": { 113 | "nbgrader": { 114 | "grade": false, 115 | "locked": true, 116 | "solution": false 117 | } 118 | }, 119 | "source": [ 120 | " **Code:**\n", 121 | "```python\n", 122 | "Sample_Mean_MSE(0,10) \n", 123 | "```\n", 124 | "\n", 125 | "\n", 126 | " **Output**\n", 127 | "```\n", 128 | "0.83433254206591267\n", 129 | "```" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 2, 135 | "metadata": { 136 | "collapsed": true, 137 | "nbgrader": { 138 | "grade": false, 139 | "locked": false, 140 | "solution": false 141 | } 142 | }, 143 | "outputs": [], 144 | "source": [ 145 | "# modify this cell\n", 146 | "\n", 147 | "def Sample_Mean_MSE(a,b):\n", 148 | " # inputs: bounds for uniform distribution a and b\n", 149 | " # sample size is 10\n", 150 | " # number of experiments is 1,000,000\n", 151 | " # output: MSE for sample mean estimator with sample size 10\n", 152 | " return sum((sum(uniform(a, b) for _ in range(10))/float(10) - (a + b)/2)**2 for _ in range(1000000))/float(1000000)" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": null, 158 | "metadata": { 159 | "collapsed": true, 160 | "nbgrader": { 161 | "grade": true, 162 | "grade_id": "ex1", 163 | "locked": true, 164 | "points": "5", 165 | "solution": false 166 | } 167 | }, 168 | "outputs": [], 169 | "source": [ 170 | "# Check Function\n", 171 | "assert abs(Sample_Mean_MSE(-5,5)-0.83333333333333) < 0.05\n", 172 | "assert abs(Sample_Mean_MSE(-10,10)-3.33333333333333) < 0.05\n", 173 | "\n", 174 | "#\n", 175 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 176 | "#\n" 177 | ] 178 | }, 179 | { 180 | "cell_type": "markdown", 181 | "metadata": { 182 | "nbgrader": { 183 | "grade": false, 184 | "locked": true, 185 | "solution": false 186 | } 187 | }, 188 | "source": [ 189 | "## Problem 2" 190 | ] 191 | }, 192 | { 193 | "cell_type": "markdown", 194 | "metadata": { 195 | "nbgrader": { 196 | "grade": false, 197 | "locked": true, 198 | "solution": false 199 | } 200 | }, 201 | "source": [ 202 | "For this problem, you are asked to write a function **MinMax_Mean_MSE** that experimentally calculates the MSE of the min-max-mean estimator for samples drawn from uniform distribution given the bounds $a$ and $b$." 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": { 208 | "nbgrader": { 209 | "grade": false, 210 | "locked": true, 211 | "solution": false 212 | } 213 | }, 214 | "source": [ 215 | " **Code:**\n", 216 | "```python\n", 217 | "MinMax_Mean_MSE(0,10) \n", 218 | "```\n", 219 | "\n", 220 | "\n", 221 | " **Output**\n", 222 | "```\n", 223 | "0.37865973633197908\n", 224 | "```" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": null, 230 | "metadata": { 231 | "collapsed": true 232 | }, 233 | "outputs": [], 234 | "source": [ 235 | "# modify this cell\n", 236 | "\n", 237 | "def MinMax_Mean_MSE(a,b):\n", 238 | " # inputs: bounds for uniform distribution a and b\n", 239 | " # sample size is 10\n", 240 | " # number of experiments is 1,000,000\n", 241 | " # output: MSE for sample mean estimator with sample size 10\n", 242 | " return sum(((max(s)+min(s))/2 - (a+b)/2)**2 for _ in range(1000000) for s in [[uniform(a, b) for _ in range(10)]])/float(1000000)\n" 243 | ] 244 | }, 245 | { 246 | "cell_type": "code", 247 | "execution_count": null, 248 | "metadata": { 249 | "nbgrader": { 250 | "grade": true, 251 | "grade_id": "ex2", 252 | "locked": true, 253 | "points": "5", 254 | "solution": false 255 | } 256 | }, 257 | "outputs": [], 258 | "source": [ 259 | "# Check Function\n", 260 | "assert abs(MinMax_Mean_MSE(-5,5)-0.37882324043882964) < 0.05\n", 261 | "assert abs(MinMax_Mean_MSE(-10,10)-1.5151124438250361) < 0.05\n", 262 | "\n", 263 | "#\n", 264 | "# AUTOGRADER TEST - DO NOT REMOVE\n", 265 | "#\n" 266 | ] 267 | }, 268 | { 269 | "cell_type": "code", 270 | "execution_count": null, 271 | "metadata": {}, 272 | "outputs": [], 273 | "source": [] 274 | } 275 | ], 276 | "metadata": { 277 | "kernelspec": { 278 | "display_name": "Python 3", 279 | "language": "python", 280 | "name": "python3" 281 | }, 282 | "language_info": { 283 | "codemirror_mode": { 284 | "name": "ipython", 285 | "version": 3 286 | }, 287 | "file_extension": ".py", 288 | "mimetype": "text/x-python", 289 | "name": "python", 290 | "nbconvert_exporter": "python", 291 | "pygments_lexer": "ipython3", 292 | "version": "3.6.5" 293 | }, 294 | "toc": { 295 | "colors": { 296 | "hover_highlight": "#DAA520", 297 | "navigate_num": "#000000", 298 | "navigate_text": "#333333", 299 | "running_highlight": "#FF0000", 300 | "selected_highlight": "#FFD700", 301 | "sidebar_border": "#EEEEEE", 302 | "wrapper_background": "#FFFFFF" 303 | }, 304 | "moveMenuLeft": true, 305 | "nav_menu": { 306 | "height": "12px", 307 | "width": "252px" 308 | }, 309 | "navigate_menu": true, 310 | "number_sections": true, 311 | "sideBar": true, 312 | "threshold": 4, 313 | "toc_cell": false, 314 | "toc_section_display": "block", 315 | "toc_window_display": false, 316 | "widenNotebook": false 317 | } 318 | }, 319 | "nbformat": 4, 320 | "nbformat_minor": 2 321 | } 322 | -------------------------------------------------------------------------------- /HW_9/data/gauss_R2.csv: -------------------------------------------------------------------------------- 1 | x,y 2 | -0.110298781754,0.252064000767 3 | 2.05324016716,-0.324025348673 4 | 0.337559735465,-0.0274555113603 5 | 0.371275790216,0.425773253 6 | -0.0928635455748,-0.369918715833 7 | -1.74475151221,0.0633223172029 8 | 2.06963544819,-0.000376641032288 9 | 0.323277785593,-0.352087353603 10 | -0.727480029891,-0.0522804392108 11 | -0.931947275553,0.0408292413487 12 | 0.555035138441,0.215870455463 13 | -1.1840343267,-0.932011042609 14 | 0.741989161215,-0.764806159742 15 | -0.506683637853,-0.59999977658 16 | -1.29383328249,0.64870479315 17 | -0.219461222541,-0.905200868592 18 | -0.319768581594,0.349054985362 19 | -0.288551934258,0.530384798551 20 | 0.650875832229,0.205726105146 21 | -0.141505734578,0.213656329318 22 | -1.46650855091,-0.228964706857 23 | 0.0585578924465,1.41077848413 24 | -0.389278192857,0.530390219084 25 | 1.84468287822,0.204135723332 26 | 0.895986843085,0.507373793135 27 | 0.29772472684,0.168085732046 28 | -0.265586553889,-0.952309401349 29 | 0.499645990554,1.14154534098 30 | 0.643815861948,-0.30318863471 31 | -0.376416824019,-1.37872349802 32 | -1.60226115382,1.13624640678 33 | 1.49658667815,0.56318731409 34 | 1.34843245601,1.35284616147 35 | 0.288076135491,-1.24236433603 36 | 0.702759443566,0.757452752252 37 | 0.270812306096,-0.496119915741 38 | 0.639655575583,0.725014083134 39 | 1.24489097217,1.92887488318 40 | -0.0936841429576,-0.959848994057 41 | -2.01856591236,-0.14514595123 42 | 1.90836662756,0.510960167428 43 | 1.62925637861,-0.18288433248 44 | -0.347404452729,1.31153116223 45 | -0.24174675889,-0.9408789046 46 | -1.99271506273,0.0284415292566 47 | 0.454143807084,0.780498730146 48 | -0.591650121558,-0.95226518469 49 | 0.300642852696,1.27313212078 50 | -0.971150875593,-0.431225352628 51 | -1.57797831038,-0.384824321854 52 | -0.5867676206,0.209142269312 53 | -0.222718771908,-0.310192764867 54 | -0.52691996048,-1.91608284465 55 | -0.343957592288,-0.384859254059 56 | -0.699091322042,-0.456902014349 57 | 0.0601278034825,-0.708262601056 58 | 0.707224197196,-0.23701945299 59 | 1.54287337547,-0.194331431075 60 | 0.588849491479,-0.537479429125 61 | -0.630714710891,-0.866728860486 62 | 1.7843841044,0.322069379254 63 | 0.600284820378,0.247724499191 64 | -1.28697118218,-0.784831908857 65 | 3.01441444898,0.0247907936857 66 | 2.00448304965,0.015366721623 67 | 0.115359745731,1.31303881316 68 | 1.20975152846,0.999304126209 69 | -1.89530637917,-0.179433549364 70 | -0.905051587782,0.604619300103 71 | 0.673059172894,0.294184058534 72 | 0.178524643058,0.415798176478 73 | -1.33167445893,0.325907602428 74 | -0.517264345579,-1.33007582759 75 | -0.665770434986,-0.5708923624 76 | -0.543662552234,-0.85094908326 77 | 0.273554137101,-1.78324485503 78 | 0.59340131166,0.429955196794 79 | -1.8238458601,-0.149867803459 80 | 0.113978005424,0.938142674748 81 | -0.896990711413,-1.3304620578 82 | 0.723187496372,-0.395911247154 83 | 0.0695680187016,1.68217455133 84 | -0.722800502488,1.75960358033 85 | -0.105529403475,-0.13105429933 86 | -1.12738176586,-1.66981647948 87 | 0.278666789,-0.0768888142052 88 | -0.54306552576,1.08043726094 89 | -0.973087321054,0.412485754106 90 | 2.15047408859,0.993927868191 91 | -0.544784272155,-0.355141539922 92 | -0.182189093031,0.166222790448 93 | -1.58616708381,-0.716112155575 94 | 1.1877341909,-1.59694051151 95 | 0.0206972424205,1.5007441346 96 | 1.25225370064,0.22603312533 97 | 0.787889727648,0.734369566582 98 | -0.928022068092,-0.402474674354 99 | -0.360692607123,2.29959331161 100 | 0.638565107022,2.66917627367 101 | -0.905567114605,0.548814682527 102 | -1.32984370125,-0.0783073606531 103 | 1.59856189495,-0.201300909709 104 | -0.389674331221,-0.417883169783 105 | 0.340680277139,0.0276642460978 106 | -0.680003521361,-0.205023676751 107 | -0.692806470967,-0.570565740609 108 | 0.651575819198,-0.720155465714 109 | -0.290874994707,-1.15433438505 110 | 0.0862042476485,-0.467516378612 111 | -0.129454034226,-1.3299187753 112 | 0.0740854724058,0.263143521893 113 | -0.154918927975,-1.10764421758 114 | -1.9508618105,0.272660355969 115 | 0.825162046601,-1.18609428448 116 | -2.39559369425,-1.14022103264 117 | -0.00404040855873,1.27218270962 118 | -0.990781035847,-0.336086738886 119 | 0.512901797972,-1.33398250058 120 | -0.250071817518,-1.61954256222 121 | -1.45203982521,-0.796755373841 122 | 0.677199303459,1.47504465511 123 | 0.0318737046241,-0.317493463731 124 | -1.51488481698,0.767789884246 125 | 1.85440751344,1.41856458894 126 | -0.427118092497,0.0471078268226 127 | -0.156774218254,0.605008582598 128 | 0.383483466869,-0.791745278069 129 | 1.53867745495,-0.528284371965 130 | 1.71876198126,-0.676772554947 131 | 0.187723085552,-1.4603332054 132 | 1.22295748934,-1.71843255764 133 | -1.09760649525,-1.42939669992 134 | -0.329526878724,-0.0835470772296 135 | 0.955167769601,1.00425639626 136 | 0.946936412739,-0.0245270159646 137 | -0.933942909641,1.07763069772 138 | 1.34091377215,0.289197992258 139 | -0.109417266553,1.72748506764 140 | 0.834577448161,1.13218332005 141 | 1.55253101259,-1.47582177581 142 | 0.268211270191,1.02070698805 143 | 0.639442194756,0.00872808437867 144 | 0.134694943283,-0.274356844141 145 | -0.0084269997516,-0.841862013262 146 | 1.5440110139,0.335947182622 147 | -0.21345973966,0.315356921342 148 | 0.806031495269,0.751416521402 149 | -1.39200802161,-0.461407880326 150 | 1.93870430259,-2.1826783524 151 | 1.77118414901,-1.43197872883 152 | -1.74062415968,1.82206249791 153 | 0.409574998225,-0.393178939324 154 | 1.00216525014,0.258451867794 155 | 0.723374580236,-1.20425226532 156 | 1.36518506402,-0.0414148781374 157 | 1.87556063471,0.829779925605 158 | 0.153686298543,0.900435385525 159 | -0.519706664471,0.893844022724 160 | 1.87361213321,0.0127655469649 161 | 1.38968125327,0.776799591254 162 | -0.0150294913095,-0.0445510188978 163 | 0.0554662834038,-0.213445543163 164 | 0.354379459067,-0.29065963732 165 | 0.205392974511,-1.03251134409 166 | -0.919226798374,-0.172774717622 167 | 1.84294066792,-0.400977075569 168 | -0.870484543246,0.653370893594 169 | -0.63169807311,1.08648371008 170 | -0.709574392976,0.858577060385 171 | 0.214815908951,0.105107816788 172 | 0.287325166607,1.26632747673 173 | -1.25198499401,0.56843555198 174 | 0.947522157569,-0.526591247422 175 | 1.93428714105,-2.11229550927 176 | 0.437959228977,1.62486563852 177 | 0.320923780785,0.520255285099 178 | 1.36835266411,0.857210626674 179 | 0.337551344816,-0.290556083334 180 | -0.488526301526,1.16909558218 181 | 1.23603721022,0.123186247103 182 | 1.22923824156,1.84946801079 183 | -1.53847781846,1.12387974702 184 | 0.32142419355,0.0636609726374 185 | -0.108215495286,0.892222213199 186 | -0.692619741989,-0.164321825509 187 | -0.217379659934,-0.309217751999 188 | -0.270994281636,1.21321182408 189 | 0.128440845466,-1.05940980655 190 | -1.71477428068,-0.566062173198 191 | 0.153460068355,-1.63128435589 192 | 1.45348496669,0.177915287818 193 | 1.0074703633,-0.77607991092 194 | -0.198913721485,1.5249285555 195 | -0.620192229542,-2.01958935555 196 | -0.124159523955,0.587525143924 197 | -0.664315530733,-0.444138490822 198 | 0.794347833048,1.21135845403 199 | 1.42659554696,0.721714508107 200 | 0.328260582516,-0.564153736429 201 | -0.287456888157,1.22666271838 202 | -1.53524765954,0.701909515795 203 | 1.06052070443,0.821255235282 204 | -1.33707318859,-0.871857758597 205 | 0.450324965622,-0.349994155463 206 | -0.577176253087,-1.87234484832 207 | 0.511808214285,-0.156650384487 208 | 0.538223230866,-0.176385623479 209 | -0.384431532206,-0.0105022593672 210 | 0.173880876699,-0.732834134965 211 | 0.446105958297,0.610174532909 212 | -0.108858828438,-0.0623154296593 213 | -1.38497550103,-0.279954243252 214 | 0.911196385596,-1.1183485269 215 | 0.448452308055,-0.103205323305 216 | 2.77034826515,-0.37685389544 217 | 1.51888961613,-0.00126244931004 218 | -0.241721841433,-0.878605623026 219 | 0.371719928687,-0.0458946134423 220 | 0.166777061916,-1.29650315365 221 | -1.38185079707,1.64858666725 222 | 0.171828142521,-1.10654593657 223 | 0.9378049981,-1.8382201566 224 | -0.630670715145,-0.235942151462 225 | -0.136777273353,-0.0629038775635 226 | -1.46652249579,0.11854910639 227 | 1.67090516569,0.437110128377 228 | -1.37551845276,0.018827130332 229 | 0.808055049892,0.112906812746 230 | -0.112686073225,0.313255431782 231 | 0.026127127112,0.246304461046 232 | -0.225387156443,0.00311385444542 233 | -1.45183228586,-0.908990598508 234 | 0.911228650322,-0.419752891177 235 | -1.05815186724,-0.977191321109 236 | 0.595236435321,-0.82207834965 237 | -2.17224755872,1.7444070199 238 | 0.675481469159,0.050943204726 239 | 0.959478268924,-1.00057574846 240 | -0.829844584575,1.25137665892 241 | -2.24660653442,1.15462373786 242 | 0.571824707049,1.06231872669 243 | 0.134873590222,-0.00508349485566 244 | 0.786825372684,1.1575770126 245 | 0.719666047479,1.68523796311 246 | -0.164778355165,0.716179240653 247 | 0.644799253948,1.36430133063 248 | -2.05454367419,-0.0074306967013 249 | 0.768842989286,-1.51068635266 250 | 0.848728731193,0.563747607054 251 | 0.664296597496,0.642930783981 252 | 1.09890226997,1.24600414714 253 | -0.714083897803,-0.900946183535 254 | -1.06578716442,0.62760735124 255 | -0.731595143866,0.330344500574 256 | 0.77267323594,-1.27098613517 257 | -0.0102395670667,0.0509526422616 258 | -1.67960697571,-1.27696470875 259 | 1.05951635558,-0.174140542573 260 | 0.258680503436,-0.476219972505 261 | -0.507650583634,-0.33987382255 262 | 1.69778733041,0.079707193798 263 | 0.523844824017,-0.826535618551 264 | -0.0492101671655,0.523176012993 265 | -0.110277825054,0.156645224516 266 | 0.0276131311251,0.0830808450588 267 | -0.519675951872,-0.74157025607 268 | -0.518749809197,0.135617927251 269 | 0.772878281465,0.929253217699 270 | -2.39008167966,-0.346651508223 271 | 0.413340852963,0.37352737077 272 | -0.818785051758,0.233585792286 273 | -0.524020641355,-0.387527098141 274 | 0.388344572641,-0.327693089196 275 | -0.174432686571,-0.93733439102 276 | 0.851915628263,0.801651104391 277 | 0.116698070038,-1.74542949086 278 | -0.161354815276,-0.607123588542 279 | 0.828837124657,-1.40305223274 280 | -0.294621221842,0.610002875674 281 | 1.13550186552,-0.434666291925 282 | 0.563536595571,0.774091630005 283 | 0.177525458937,0.0458173036301 284 | 0.447328283669,-0.243312835532 285 | -0.298514981815,-0.125525587278 286 | -1.97921765868,2.40522057426 287 | -0.643192366858,-1.91232199645 288 | -0.248131800492,-0.502632662913 289 | 0.716134070869,-1.12819396632 290 | 0.350253736359,0.0142753702453 291 | 0.190807673108,-1.41840683896 292 | 1.67139506756,0.0410404109132 293 | 0.313458408835,-1.25463992256 294 | -2.39061218015,-1.18259407057 295 | 0.242412363345,2.39267046995 296 | -1.40310590961,-0.256829028201 297 | 0.208268906828,-0.428950613638 298 | 0.955725584382,0.227132173662 299 | -0.182315619034,-0.600792107304 300 | 0.167050824375,0.644628746391 301 | 2.03940979719,-1.51800774292 302 | -0.0174767413351,-0.716958232473 303 | 0.784448904709,0.166158502685 304 | 0.387885982085,0.886225478479 305 | -1.271427272,-1.73553113226 306 | 1.12552897673,-0.332822132085 307 | 1.77156747997,-0.265319739396 308 | 0.147761476037,-0.0175819748672 309 | -0.95380268669,1.03818952241 310 | 0.688115286012,-0.523486825594 311 | 0.166537906824,-1.18973857955 312 | 0.285858339384,1.79525823281 313 | -0.476860832423,0.0522134626803 314 | 0.0755192626227,0.220229275167 315 | -0.329469685082,-1.56529492852 316 | -0.15215858621,0.421249699673 317 | -0.622711895231,0.898313507409 318 | -0.507925416477,0.447276320265 319 | 0.178320063858,0.0410299459865 320 | 0.215653061825,0.850760509547 321 | -0.217462379506,-0.965520277709 322 | -0.279553847265,1.51713011364 323 | 1.09999501261,0.75251270564 324 | -0.620994412543,1.73324730017 325 | -0.91896952778,0.421284788726 326 | 0.745912543539,-1.12787752968 327 | 0.309669019784,0.232502295851 328 | -0.679057081129,-0.389015002996 329 | -0.336029118428,-0.232243139889 330 | -1.07456481904,-0.28762925315 331 | 0.45980378126,0.0949040168519 332 | -0.615508706922,0.778749934706 333 | 0.53448234553,1.14798634261 334 | -0.382919502107,-0.22521108446 335 | 0.162961349743,0.158224672148 336 | 0.460449988089,-0.066114212201 337 | -0.233870468472,-1.21744672794 338 | 0.404628885512,-0.586272358363 339 | -0.729506920873,0.819487716949 340 | -1.82002811877,1.80515837574 341 | -0.0140229254564,-1.00071438865 342 | -1.01513726469,0.421424013451 343 | -0.620228646687,-0.0701954209007 344 | 0.306743918496,0.640992755638 345 | -0.0493865154883,0.641155487379 346 | -0.00930028242073,1.77567669299 347 | 0.697367413117,0.00928687558456 348 | 1.74450316129,-1.01376432091 349 | 0.0632740732849,0.148577544436 350 | 2.09156135782,-0.148271208338 351 | -1.03825754693,1.7381680469 352 | 1.31048604695,-1.86372764234 353 | 0.762514856899,-0.0760846775695 354 | 1.10283544716,-0.498568227157 355 | 0.321504118661,0.222055913121 356 | 1.0933290452,1.18848321779 357 | 0.303170671078,0.321193312203 358 | 0.668112866489,0.027507286073 359 | 1.51868251903,-1.75994098576 360 | 1.18784587716,0.100195272502 361 | -1.12716353447,-1.13920960472 362 | -0.529531751671,0.689774028323 363 | -0.176458722038,-0.121532279759 364 | 1.11051516633,0.71194053174 365 | -0.496600219709,-1.42136070485 366 | 1.55614694461,0.192815507282 367 | 0.315138751679,1.06453946485 368 | -0.351089841805,-0.391331141084 369 | -0.642295470183,0.764083728063 370 | 0.347883858312,-0.898633073371 371 | 0.318862952493,1.00047728314 372 | -0.532558073892,0.298384676015 373 | 0.401731047642,-1.21867614881 374 | -0.375133489546,-0.742468105007 375 | -0.593409177114,-2.22430679 376 | -0.144267866856,1.30072880688 377 | -0.824694782567,-0.64331289079 378 | 1.28813073489,-1.1351659679 379 | 0.38033915183,1.02634906094 380 | 1.25425790135,0.000845962879275 381 | 1.14105731192,-0.300015094158 382 | -0.0227634850606,0.896294122721 383 | -0.229501825345,-1.55581810263 384 | -1.89277029803,-0.377137462435 385 | 0.622932076844,-0.5803863826 386 | -0.325328496641,-0.237183920294 387 | -1.37124430028,1.34158415673 388 | -1.10774383749,-0.542946756756 389 | 0.0912961041148,-0.287456128699 390 | 0.967604775431,2.3837324064 391 | 2.04518249861,0.652463879798 392 | 1.37657695647,-0.0809374444039 393 | 0.0252499963512,0.015808753593 394 | -2.03464605328,-0.744990279974 395 | -0.440538929037,-0.252329388038 396 | -3.95062719333,-0.376645435737 397 | 1.04536710867,-0.28800313892 398 | 1.0987602583,-0.275242518175 399 | -0.101374694875,-0.620845469811 400 | 0.186351094808,0.28930102265 401 | 1.81520769118,0.0605357434651 402 | 2.37976766285,-0.0749385123765 403 | -1.26932432772,0.288598083888 404 | 0.0364861885731,-1.73839781393 405 | -0.841213120891,0.087758618108 406 | 0.782488718487,0.657721245714 407 | -0.717213580622,-2.01378125386 408 | 0.737526222772,0.822260092273 409 | 0.130419629952,0.852957938788 410 | -1.11804062471,0.292481959106 411 | -1.33570745867,0.235479416061 412 | -1.19256887954,0.0650682304991 413 | -0.00392074533404,-1.39095891828 414 | 0.901706967199,3.22268353578 415 | 0.0474921143424,-0.803114429241 416 | -0.263646490888,0.369946449714 417 | 0.639829737742,-1.67182115929 418 | 3.03392642448,0.510675306944 419 | -0.310347035493,-0.897651818176 420 | -0.0642775924989,-0.636534072091 421 | -1.32208013654,0.328707685392 422 | 0.264166158236,0.847614435246 423 | -0.349838552289,0.323568215605 424 | 0.17181952603,-0.300013077746 425 | -0.0977283454127,-0.991880813527 426 | 2.15294723021,-1.73338360583 427 | 0.06879521172,-0.502056398601 428 | 1.01398529233,0.762322308764 429 | -1.17254799773,0.830322030013 430 | -0.194103403095,0.0173337164822 431 | -1.32407341794,1.83389043714 432 | -0.474070556214,0.231598286894 433 | -0.718074594351,1.45899947132 434 | -0.88725069456,-0.991181545341 435 | -0.994837983975,0.858388552664 436 | 0.238604341007,-2.04866811787 437 | 1.42513955,1.02794468643 438 | 1.4404753574,-0.279236893255 439 | -0.144213622972,0.975343336984 440 | -1.42579302675,1.01321895403 441 | 0.810640521078,0.225713844569 442 | -1.08616654421,0.958382708614 443 | -1.13293836412,-0.0409947031949 444 | 0.89271317631,-2.23007648756 445 | -0.817012691835,-0.752778796654 446 | -0.700920365656,1.55566380068 447 | 0.601806958485,-0.233881423035 448 | -0.471662847254,-0.334774610458 449 | -1.38401739727,-0.0573816913296 450 | 0.180451345684,1.38212584915 451 | 0.568627836591,-0.0850312625879 452 | -1.79359172424,-1.35445154647 453 | -0.311398091421,1.06298139226 454 | -0.194849588764,0.10899312852 455 | 1.38474220459,1.17285920715 456 | -0.22368553305,2.20966637599 457 | 1.35206872255,0.328529978283 458 | -0.258605999428,-1.44226486713 459 | -1.4055387897,0.292376824311 460 | -0.392931979809,-0.234254641745 461 | 0.828147946868,-1.59957541446 462 | 0.0309378294036,-1.14178593357 463 | 1.41470460521,0.106833991222 464 | -0.600776418229,0.976284857666 465 | 0.136756663934,-0.421445735555 466 | 0.474633232812,0.592308831708 467 | -0.359529903634,0.221689092873 468 | -0.917116910848,-0.0205759543677 469 | -0.925176836318,0.885957558105 470 | -0.410469192837,0.696436685401 471 | -0.495814132547,-1.4935386435 472 | 0.0813014520877,0.704967317361 473 | -0.545695016023,0.132748931935 474 | 0.597918146253,-2.90818519461 475 | -0.722110974827,-1.48125451721 476 | -0.400957505273,0.443535467091 477 | -1.50549626776,0.442750381383 478 | 1.32778479699,-0.534863758689 479 | 2.00242034193,1.42460386364 480 | 0.119659306721,-1.01071380334 481 | 0.188857619472,-2.0183042628 482 | 1.01887935807,-1.67378468089 483 | -1.34711474688,0.662448333488 484 | -1.8203578921,-1.52372773426 485 | 1.06302622817,0.763439923121 486 | 0.287651827694,-0.208656787563 487 | -0.194174910369,0.903711267746 488 | 0.746918593978,0.096132934677 489 | -0.58813894951,-0.0629541804857 490 | 0.158661176566,-0.534950897881 491 | 0.785313374889,-1.10965599194 492 | -1.13954905764,0.562601294014 493 | -0.192181921585,0.669600879971 494 | -0.287513130719,1.4376340811 495 | -0.515886552713,-0.276879502746 496 | -1.6612599889,0.80605662761 497 | 0.651391075552,0.729518217152 498 | -0.0946102677852,-0.134309710663 499 | -0.395524863365,1.14501604686 500 | 1.41151867973,0.973874440453 501 | -0.381327990049,1.75019942911 502 | -0.054519021713,0.571665695204 503 | 1.16896469063,-0.399842819964 504 | 0.437442943883,-0.688558080238 505 | -1.89203719617,3.03931351787 506 | -1.66412526535,-0.540991593922 507 | 0.603436404703,-0.0894999018249 508 | 0.690844894008,-1.91774271818 509 | 0.305854183273,-1.10655036623 510 | -0.434298359616,1.47266258618 511 | 2.3469723533,0.451499892311 512 | -0.204781036296,0.86852603994 513 | -0.920412506222,0.951696158354 514 | 0.600948352074,1.75489967741 515 | 0.552064130821,0.0235038497032 516 | 1.52334035491,-0.0447224031711 517 | 0.640442130369,-0.0264703428127 518 | -0.400902166657,0.30721301398 519 | 0.256486081274,-1.16661024896 520 | -0.199925365221,1.57565156608 521 | 0.741511432303,1.6533516822 522 | 0.50231464483,0.420620861319 523 | -1.19659742577,0.699137556475 524 | 2.07618656445,1.17731448098 525 | 0.216618841697,0.063202208402 526 | -0.557118712444,-1.59630999103 527 | -0.148442254085,0.577553784824 528 | -0.966849835402,0.00667891769927 529 | -0.736487480021,-0.525832344355 530 | 0.0287073087533,-0.141972050187 531 | -0.490965318362,1.38231518453 532 | 0.362482728586,-0.477778313045 533 | -1.51935084248,0.203109030924 534 | -0.254821800814,0.236632208526 535 | 0.168966474241,-0.149504333063 536 | 0.48524790025,0.837035734749 537 | 2.02842913428,-0.0186317258142 538 | 0.475871933226,0.910371527582 539 | 1.38470339223,0.0492268317893 540 | 0.466416586276,-0.148575550347 541 | -0.16262480122,0.639986686151 542 | -0.455720888146,0.172194498027 543 | -0.00982403350596,0.708005186459 544 | 0.495960694444,-1.59613113485 545 | 1.10926035069,-0.505033584193 546 | -0.486523548167,0.0407425656797 547 | 0.498426525557,1.30096272066 548 | 2.29466019454,-0.338212975957 549 | 0.598001345633,1.16644181518 550 | -0.173069323797,-0.0196620927813 551 | 0.227012958867,-1.67967742552 552 | -1.09249814626,-2.18634102107 553 | 0.863311203716,-0.474027323857 554 | 0.445811054339,-0.559089993977 555 | 1.15812120699,-1.46839304199 556 | 0.0150001161696,0.403160717355 557 | 0.245951851166,1.04462273596 558 | 0.557981746121,0.212540073077 559 | 0.644648400938,-0.160569761975 560 | -0.0811878659072,1.35537047934 561 | 0.819922578756,0.97658783189 562 | 2.34913291458,-0.46687649682 563 | -0.608377600388,-0.547220570071 564 | -0.134515150025,-1.45693835032 565 | -0.155122013359,-1.1150625985 566 | -0.862115631258,0.444148462403 567 | 0.658241864132,-0.652914393904 568 | 1.59476321582,0.530471517265 569 | 0.875951217888,-0.137317952764 570 | 2.18945327806,-0.647791733314 571 | -0.844586452762,-0.892687065104 572 | -0.739631935067,1.1918881399 573 | 1.06224112725,0.455321377063 574 | 0.421682984933,1.3685277638 575 | 1.17216363884,0.073331231746 576 | 0.0044695308362,-1.14617156081 577 | -0.147603919129,1.73475065153 578 | 0.42836624232,-1.58127746574 579 | 0.513155638657,-0.0697624971318 580 | -1.2703431376,0.592567136169 581 | -0.78216274529,-1.43771180725 582 | 0.0389847181114,1.35552779713 583 | -0.479432238324,0.56878409055 584 | 0.403391019958,-0.142263936415 585 | -0.557006515367,0.557178004568 586 | -3.00538956136,-1.7828085475 587 | 0.101697926951,1.31162515335 588 | 0.319190582349,-0.390020233479 589 | -0.451105967872,1.07851142923 590 | -2.90128773375,0.83140120057 591 | -0.597522573162,0.164979908204 592 | 2.15606122872,-0.314161134033 593 | -0.138123831338,-0.642711061249 594 | -0.623231704353,0.562871913443 595 | 0.179237635956,0.031599344532 596 | -1.82107278676,0.117802961727 597 | 1.8255088252,-2.2471264489 598 | -1.13351027982,-0.477940513008 599 | -0.973935204111,-0.321368303136 600 | -0.675714035095,0.82813198758 601 | 1.26666559308,0.216574462774 602 | -0.292416021925,-0.287811728357 603 | -0.365420550112,0.938177349333 604 | -1.08476722975,-0.962807487964 605 | 0.456362211975,-1.09765366134 606 | -2.76887426806,-0.0588707681688 607 | -1.80890172928,0.641425801683 608 | -0.715691154437,-1.14444028448 609 | -0.10746115468,-0.0603757559024 610 | -0.718359106595,1.01234876982 611 | 0.616088494372,-0.117186591631 612 | 1.23301037418,-0.563969928607 613 | 0.278273047754,0.24347080134 614 | -0.0936184859542,1.49616379169 615 | -1.47019102848,-0.0687179586982 616 | -1.6341603116,0.590897077433 617 | 1.3782324784,0.827729264152 618 | -0.217717493489,-1.78448645034 619 | 0.377127290989,1.21305607881 620 | 0.295611219875,-0.16115364179 621 | 0.72575283133,2.07107426072 622 | -0.34282707233,0.80799099557 623 | -0.745277023532,0.0283009859194 624 | 0.719704262873,-1.04702844977 625 | 1.60305387481,0.614860904054 626 | -0.472429488667,-0.787959685472 627 | -0.577974524157,0.951915911214 628 | 1.54282654773,0.440352121372 629 | 0.987989873703,0.64581792522 630 | 0.885203309176,-0.754775121739 631 | 0.609708407136,1.34892703617 632 | -0.742389275861,0.662425489669 633 | -1.51681131383,1.10116221534 634 | 0.144608308388,-0.492626154961 635 | -0.117969736135,0.445312430162 636 | -0.0555428648596,-0.39710499111 637 | -0.132368788916,2.14073353411 638 | 2.07460433117,0.408692085541 639 | 0.302148535386,0.36104755091 640 | 1.14383892214,0.0490527370159 641 | -0.0748994630493,-2.22555596295 642 | -0.651357563998,-0.328876795719 643 | 1.48862163422,-0.443314971475 644 | -0.391775125555,0.852977242482 645 | 0.895797163227,-1.30609184335 646 | 0.831127252432,-0.672748839347 647 | 0.317009664906,-1.22933919298 648 | 0.98215175878,0.946801993454 649 | -0.680166861546,-0.396831417103 650 | -0.260861770658,0.30084199525 651 | 0.12793440457,-0.50232639987 652 | -0.392537436509,-0.45673905118 653 | -0.961025670398,1.4217546341 654 | 0.984316433213,-1.03626904184 655 | -0.180793661956,-1.66335204986 656 | -0.215723820289,-1.0628685239 657 | -0.772528112673,2.54087827976 658 | -0.3852208056,-2.29278003533 659 | 1.34367927425,-0.769640667024 660 | -0.404108557176,-2.04748910175 661 | 1.39892750526,0.650468510147 662 | 0.153155969278,-0.872323491712 663 | 1.92281699778,-0.290060239662 664 | -0.462926261478,1.84996329048 665 | -1.86262858073,0.38707992833 666 | -2.10671707495,0.054745768689 667 | 0.603525627426,0.0623948778566 668 | 1.92981894767,0.162177932714 669 | 0.240352401445,1.56623945087 670 | 0.154224329191,2.45221297925 671 | -1.86041558083,0.157273225396 672 | 0.48102281272,-1.2936501865 673 | -0.0580747113375,0.911247638704 674 | -1.70822223124,0.949674854239 675 | -0.157799506304,0.979454328931 676 | 1.3409702653,-0.969163826219 677 | -0.760056981723,0.42498835546 678 | -1.28200620541,-1.50573562184 679 | 0.42540898185,-0.486515010182 680 | -0.325769837424,-0.509832740606 681 | -0.879317638767,2.43611274864 682 | -0.150004040616,0.664946046418 683 | -0.733359230217,-0.591169728989 684 | -0.194649037102,-0.67077206417 685 | -0.365607067865,1.99852854778 686 | 0.278086702913,1.72224568801 687 | -0.466557476877,1.5433996466 688 | 1.60224855311,0.355886614119 689 | -0.0469891998141,-1.56333154803 690 | 2.16048022332,-0.756322979291 691 | -1.21982762629,1.70014518631 692 | 0.304087145263,-0.291566195758 693 | -0.0936169118555,-0.198697728597 694 | 0.452223648907,0.722902342844 695 | 1.36167027922,0.931747909177 696 | -0.931738500194,0.613659578157 697 | -1.00668506298,-0.64394081152 698 | -0.598373509662,0.0194007571025 699 | 0.433832009094,-1.38423694301 700 | 0.400055008089,-0.248673692468 701 | -0.00783629628572,2.02440266562 702 | 0.918515907117,-1.24727300473 703 | 1.00135826549,1.05087121697 704 | 0.292454919014,0.00251420492279 705 | -0.0445399258589,-0.131989383761 706 | 0.717411620267,2.08947092413 707 | 1.37421380062,0.240659966603 708 | -0.407418574798,-0.142415502258 709 | -1.91767710596,-0.695167997793 710 | 0.363699462492,1.16029906929 711 | 0.125849687085,0.469113975228 712 | 1.43039439752,0.623700966029 713 | -1.08209173292,-0.768572840511 714 | -0.328232690611,0.761892387568 715 | 0.492685239965,-0.0487409464228 716 | -1.68960215409,-0.787756296893 717 | 0.139384269353,-0.69650291475 718 | -0.487120472078,-0.421481378702 719 | 0.755891914752,0.192525970112 720 | -0.199678410306,0.895973093488 721 | -0.428422863369,0.761234216135 722 | 0.792249036468,0.768539737881 723 | -0.265376377153,-0.445477228696 724 | -0.78842682006,1.90125181136 725 | -0.234318508882,1.78758402495 726 | 0.42622053954,1.06810669922 727 | 0.309012269802,2.09188276732 728 | 0.319411369726,-1.53342352395 729 | -1.08159966742,-0.701400456535 730 | -1.12963434023,0.136969739414 731 | 0.272552474112,0.186893473187 732 | -1.36143461325,-1.01047142405 733 | -0.436175731924,0.83122835409 734 | 0.529171524154,0.250705529101 735 | 1.71359371259,0.611877571723 736 | 0.22370660597,1.7105670123 737 | -0.265854113781,-0.215274870046 738 | -0.363322781593,-0.291655376709 739 | -1.53117348219,-0.412469522381 740 | -0.10775588288,0.863852213904 741 | 0.0503676639418,0.915664607873 742 | 0.586770593118,0.832596602705 743 | -0.617615263573,-1.94212808978 744 | 1.90347849396,-1.0395622362 745 | -0.658548589984,-1.12006992549 746 | -0.380750359606,0.381533251871 747 | 0.404145833179,0.00562114004912 748 | 0.520534912914,-0.548186942686 749 | -0.468202832489,-1.11519734905 750 | -1.53034221446,0.363549994253 751 | 0.60938847677,-0.118746426845 752 | 1.67558665097,-0.234124261939 753 | 1.3160000734,-0.181936825824 754 | 1.32791051975,-0.319705793437 755 | -0.17216901335,1.76294628475 756 | 1.50640385316,1.38236015907 757 | 1.19758976357,0.172247251431 758 | 0.58842838839,-2.61770935986 759 | -0.288163279472,-2.43298295052 760 | 0.143661095162,0.175067327454 761 | 0.83518327459,-0.422285336068 762 | -0.499899994414,-1.04030896342 763 | -1.89898473186,-1.32258533873 764 | 1.96485035202,-0.922176246949 765 | 0.0592375983307,0.749479706799 766 | -0.997670039977,1.64689814774 767 | -0.20238793492,0.49422211285 768 | 0.488966621,-0.286452634493 769 | 0.128960667365,-0.904462139953 770 | -1.14636787653,0.136425805319 771 | 0.542593520165,-0.548362606227 772 | 0.00130975651783,-0.813538023801 773 | -1.18326256652,-0.478069054617 774 | -1.4364294431,-0.361313515481 775 | -0.171745149104,-0.461753944049 776 | -1.68649743985,-0.622385311231 777 | 1.19516407003,0.199531246459 778 | 0.354328686805,-1.76530885564 779 | 0.530103826714,0.882485417601 780 | 0.194276792045,0.056784676506 781 | 0.719980449362,-1.10035009437 782 | -0.907535758369,-1.4913842176 783 | -0.382826187357,0.752081976246 784 | 0.965942691969,-0.445497536251 785 | 0.259084418289,0.204343796912 786 | -1.64397642927,0.121782449751 787 | 0.383553011922,-1.48495396732 788 | 0.281483708785,-0.773518655165 789 | -0.0615565197861,0.597734867938 790 | -1.23596225477,0.168301887047 791 | 0.00668980033186,-1.5052735626 792 | -2.61521011804,0.495108380745 793 | 0.162846525481,0.0809216566902 794 | 1.29115098798,0.649006723366 795 | 0.077493889891,-0.0146865513783 796 | -0.17091131464,-0.015339967182 797 | -0.475050781385,-1.32379153176 798 | -0.589512542686,-0.15592780458 799 | -1.08303198142,-0.208130099292 800 | 1.29934447359,-0.777801733295 801 | -1.27837912109,-0.670851135274 802 | 0.423422142092,-1.2754591281 803 | 0.131126413122,1.09392593025 804 | -0.97284412115,-1.01577953007 805 | 0.352200026791,0.614303252976 806 | 0.590971689317,0.240350355293 807 | 0.267084820143,-0.476508511223 808 | -2.49623784472,0.0417890687604 809 | -0.362824652496,0.543269942706 810 | 0.421290374481,0.646103419978 811 | 0.612427240021,0.524455491237 812 | 1.58054463942,-0.0121410350628 813 | 0.0327172801139,-0.658480684576 814 | 1.44520318199,-0.236815823753 815 | -0.814559755797,-0.425942647477 816 | -0.678845838008,-0.288916848096 817 | -0.521434769039,0.0765993226876 818 | 1.66334522564,0.702783506376 819 | 0.0254542710848,1.75509714341 820 | -0.380510520384,-0.451508238523 821 | 0.354386250615,-1.13391980658 822 | -1.22136795149,0.856377218154 823 | -1.25306226671,-1.10998238475 824 | 0.382179061089,-0.552749894319 825 | -0.872423099833,-0.703601628738 826 | 0.320470174561,-0.325550352276 827 | 1.67323399178,-1.11301304865 828 | -0.351428071472,0.178451092199 829 | -1.27144151442,0.240222578875 830 | 1.20693506686,-0.0625347601444 831 | 0.692555790317,-0.852563548926 832 | 0.798325463754,0.617622080567 833 | 1.43122269923,0.788714399038 834 | -1.94345660231,1.30215187146 835 | -1.57194699756,-0.757485973489 836 | -2.88999647906,0.264623951058 837 | -0.609465989757,0.23911183511 838 | 0.0303835708846,0.164866139481 839 | 1.01988073955,-0.113487067773 840 | -0.51290766354,-1.16055988236 841 | -0.733832144884,0.713781617164 842 | -0.190921354026,-0.897859207785 843 | -0.914896761699,1.21857942522 844 | 0.300009887045,0.0199159829629 845 | 0.833492833008,-1.36814201863 846 | 0.00646403985626,-0.0783060179397 847 | -0.319379948905,0.404434213776 848 | -0.184067455322,-0.230332372292 849 | 0.156222881504,-0.982840797921 850 | 0.120317315931,0.353198576848 851 | -0.648814795223,2.51107624954 852 | 0.658884240947,0.151834419425 853 | 0.602909020858,-0.056174759096 854 | 1.13557728325,1.68122615844 855 | 1.18988334798,0.242427183721 856 | 0.176182220337,-0.396997113985 857 | -0.102466040268,0.254935980299 858 | 0.353775767576,1.94009834252 859 | 0.326014266662,-0.573641947838 860 | 0.184750389264,1.33457093573 861 | 0.48174028676,3.80433060681 862 | 1.51627212857,1.73690551943 863 | 1.45120598877,-0.0257766748327 864 | 0.786174434576,-0.529597019582 865 | -1.43730959601,0.464019758306 866 | -0.141387201483,0.499539953898 867 | 0.57967591227,1.06299379933 868 | 0.777314555663,-0.671978694283 869 | 0.252087113606,-0.0795560485035 870 | 0.133569768357,-0.480988288643 871 | -0.521995445778,-0.560642242178 872 | 0.363608618224,-0.82389893557 873 | 1.87859048506,-1.5567140194 874 | -0.379443989587,-1.45271510681 875 | 1.25383675843,0.10774315049 876 | 1.4601715541,1.1671847566 877 | 0.115486086257,0.87929628513 878 | -0.0587300901018,-1.7619109445 879 | 0.849683799342,-0.219927947336 880 | 1.54403847889,0.348017475651 881 | 0.33362505299,1.70420690098 882 | -0.410522697905,-0.182184971382 883 | -1.00543563439,-0.263865455836 884 | -0.554342971044,2.60585594351 885 | -0.0440424162223,1.08078355436 886 | 1.0028356809,3.05519778166 887 | -0.444011617274,0.0912733506284 888 | -1.04662493872,0.332497368584 889 | -1.13800244296,1.02914229698 890 | -0.662410566196,0.0243679181077 891 | -1.70285202858,-0.013855552845 892 | -1.07464819408,-0.0891389952656 893 | 0.830088708101,0.530904109708 894 | -0.363190627258,0.356311522068 895 | -0.904900970613,-0.692594384016 896 | 0.685098267658,-1.06934926358 897 | -0.714103777819,0.746853804484 898 | -1.19707769877,-1.15718743813 899 | 0.480850153419,0.795861479816 900 | -0.259887465333,0.328801366065 901 | -1.0149790089,-0.289185493971 902 | -0.983103957572,0.474122042876 903 | 0.685354735084,-0.0976589572638 904 | 0.333978670889,1.22801661907 905 | -0.135471678542,-0.808804570971 906 | 0.5093904901,-0.497757022755 907 | 0.180467439629,-0.792572755816 908 | 0.477341723007,-0.0192298876225 909 | -1.00909387163,-0.904391382078 910 | 1.15450099528,0.301724751076 911 | -0.596213811462,1.3032265679 912 | 0.522267029572,0.0650435733112 913 | -0.500438057876,-1.91841832434 914 | -0.588211488683,-0.657413454287 915 | 0.804577258142,-0.217711409363 916 | -2.23726770204,0.551043336897 917 | -0.0413169783051,-1.15417414387 918 | -0.690158003739,-0.636702858294 919 | -0.295030542741,0.25440818083 920 | 1.96935485705,-0.829079046917 921 | -0.131806465638,1.41927572011 922 | -2.15804679051,-0.00400420691592 923 | -0.987189992158,-0.677438692533 924 | 0.433063642041,-0.592572187313 925 | 2.12424600902,-0.474084166544 926 | 0.837321630292,-0.961728655731 927 | 0.840705826162,-1.90584613938 928 | -0.475763056729,0.347518145214 929 | 0.304450015283,1.21205626351 930 | -1.21333280203,-0.413364380728 931 | -1.63775013055,0.320380716471 932 | 0.487748775939,1.57612855897 933 | 1.16127205237,-0.32721257604 934 | -0.857927651299,-0.5931742773 935 | 0.331835351729,-1.03768310269 936 | 0.419265399802,1.94555974407 937 | -0.176073260836,0.386224348443 938 | -3.10883268694,-0.984320628567 939 | -0.931448379189,-1.05667589718 940 | -2.27781859269,-1.64766900602 941 | -0.2495330924,0.0894991964092 942 | -0.871877247574,1.17169152584 943 | -0.961283386661,0.848875695741 944 | 0.443840531132,0.255602727571 945 | -1.23467891405,0.229523109412 946 | -0.170886182259,0.444534721704 947 | -1.36085850887,-0.983060251815 948 | -1.03795738062,2.35273224436 949 | -0.268160239595,-0.226269217661 950 | -1.35290901109,-1.34299298962 951 | 1.25257328105,-0.990796638734 952 | 1.40314651458,-0.852923714459 953 | -0.253526626921,1.19318040396 954 | -0.924744228133,0.348481703438 955 | 1.47422116798,0.985185749978 956 | -1.72423282691,-0.0609177451472 957 | -0.429562404087,-1.08274073203 958 | 0.573426635879,-0.382577992285 959 | -1.56581086741,0.105898674623 960 | -0.465581261287,0.710226830399 961 | -1.08471587327,-0.155175493655 962 | 0.0359426856846,-1.64227330617 963 | 0.818492566766,-0.332616581436 964 | -0.310275721937,0.827106310267 965 | 1.8980855748,0.514166232043 966 | 0.114097989663,-0.914862072667 967 | -0.19335431384,-1.05530658353 968 | 0.244615824239,1.57044688271 969 | -1.11840725802,-0.822743589705 970 | -0.322142003326,-1.5733227471 971 | 0.598623453281,-0.61456898839 972 | 1.46328735943,1.38361602968 973 | 0.314866376736,1.13226495644 974 | -1.29317821536,-0.540782833995 975 | -1.15930414348,0.174722642332 976 | -0.0933901000681,-0.617717932879 977 | 0.663783085274,0.315761470977 978 | -0.554426549993,-0.904234991534 979 | -1.50983323592,-0.162370202617 980 | 0.791961947563,-0.446050575466 981 | 0.613991304052,-0.266304026103 982 | -0.0121668046058,2.33432193016 983 | -0.399627174724,-0.668473172725 984 | 0.0769338083219,-0.417458506788 985 | -0.30154491206,0.319024421932 986 | -0.76797170833,1.74877854638 987 | -1.86534651771,0.00993116661675 988 | 1.56547298729,0.684493412044 989 | 0.673534327531,-0.137660989178 990 | 0.501763308746,1.04118876232 991 | 1.20243808286,-0.548891869212 992 | -2.35796384832,0.348634321057 993 | -0.181912929035,0.44589130503 994 | -0.00381099391535,-1.13053276336 995 | 1.15696469704,-0.573493010606 996 | -0.110877788308,-1.87673350389 997 | -1.2858768992,0.277068088817 998 | 0.149209219504,0.350021615133 999 | -0.0945312693131,0.434381118552 1000 | 0.0875081136446,1.29235416985 1001 | 0.0440065581661,1.1486589691 1002 | -------------------------------------------------------------------------------- /HW_9/data/hw_regression_data.csv: -------------------------------------------------------------------------------- 1 | study_hours,grades 2 | 32.1433679701,75.6369623697 3 | 27.4667251693,76.9326274852 4 | 21.2476379424,68.5759962534 5 | 33.7266605673,81.2214422364 6 | 36.5013089534,84.7874672949 7 | 30.0290065328,71.8153374089 8 | 31.2705976696,71.9454250799 9 | 28.9260120646,77.683478424 10 | 24.3959640324,70.4964496033 11 | 39.2894932796,80.1243463148 12 | 36.9066316898,79.2005242859 13 | 38.7797694532,81.2912143449 14 | 31.4745359388,72.6979066826 15 | 44.8821450624,85.5715063591 16 | 34.2721006996,74.3630356674 17 | 45.691805413,79.9944135692 18 | 49.2877641432,90.190610277 19 | 33.7893440821,73.083465265 20 | 34.7685413429,76.2737046798 21 | 37.3728602338,78.5335160995 22 | 35.9113731702,77.2906399782 23 | 41.6366496216,78.8465351257 24 | 46.3521365692,92.4999260121 25 | 36.5177963103,79.4884542021 26 | 32.5274177024,74.0336130379 27 | 24.1806381813,64.3423692894 28 | 33.2812078983,77.4348495073 29 | 31.2135532039,74.8932511418 30 | 40.020816961,81.1607375569 31 | 31.409875352,73.18236844 32 | 47.8053787788,85.0035145666 33 | 31.7046623893,73.2698180529 34 | 34.6345463454,77.0331389598 35 | 28.6847716746,73.49340431 36 | 34.5347673152,79.3946848708 37 | 29.6850374876,68.1447739535 38 | 42.5998592208,87.0964572057 39 | 29.5135487738,72.8235562917 40 | 46.9395384667,87.2244349859 41 | 39.3637240786,80.6853729145 42 | 37.6298753084,80.6536417916 43 | 41.2110110203,78.4708236425 44 | 29.1356522908,69.96237969 45 | 32.936719087,76.2871448098 46 | 41.9407801267,87.6983379027 47 | 33.833614783,78.5243570519 48 | 32.0164206469,73.6047936897 49 | 33.0719705581,74.4080627736 50 | 44.6254501372,86.0350654103 51 | 42.9812694334,87.6987502863 52 | 25.3453712958,70.9279549408 53 | 39.9970191473,84.9420696503 54 | 38.3580132531,76.9567167597 55 | 36.8152684876,80.6792047903 56 | 45.134072504,85.3198143195 57 | 36.6018097412,79.7871355108 58 | 34.5706889944,79.9724542823 59 | 37.4786773203,74.2259953803 60 | 33.9869491024,82.0469232984 61 | 24.8287443739,68.7726281795 62 | 32.6247930396,75.9832234613 63 | 42.6141667912,84.6527958849 64 | 44.872036336,83.49277475 65 | 36.5145839462,82.8400296674 66 | 40.1788621079,81.1914514499 67 | 42.0874861878,82.199627049 68 | 40.1022067997,79.7076682653 69 | 35.1236458339,82.3266248869 70 | 24.5401866793,68.1333742376 71 | 26.4158737924,69.8344098992 72 | 37.5192308348,76.0239408417 73 | 40.9790873186,78.5315756916 74 | 42.0206588083,77.6976521756 75 | 39.9756635505,85.3748523812 76 | 39.0528363669,79.7344150463 77 | 28.2270458614,70.7793345415 78 | 28.9003137771,70.4582725175 79 | 25.1500412842,72.015707448 80 | 38.8328536194,78.4822356091 81 | 37.4114712366,82.7569836166 82 | 33.8698143445,74.3065034606 83 | 24.6824458576,66.9869992516 84 | 21.7976186888,65.8906277286 85 | 34.7633593666,79.0300532953 86 | 28.3102225756,65.3297354255 87 | 27.610579352,72.1975157854 88 | 45.1070506032,90.901940268 89 | 24.1455167689,69.9654658017 90 | 29.6715871462,71.1970689065 91 | 34.3852389593,83.0097287784 92 | 34.4928266216,80.3430028895 93 | 39.884160104,81.2936637578 94 | 31.5955944055,74.9897232977 95 | 44.1216911058,87.0258730112 96 | 30.1836691646,70.6516824845 97 | 27.5228915133,73.7110801325 98 | 36.4373888927,81.59050331 99 | 26.7600886545,67.6763740265 100 | 28.2819142299,74.4881536576 101 | 33.3057960133,72.7383382821 102 | 29.0930900046,73.1708153879 103 | 28.9733331252,79.3682786532 104 | 31.6906566058,72.5757989614 105 | 35.6590617578,75.663329161 106 | 18.5511212955,61.5137195136 107 | 32.2876684463,73.7181648272 108 | 28.9717069367,74.8738511338 109 | 41.4317880256,81.18169769 110 | 35.8611521285,79.8422696928 111 | 36.8527318627,79.579293907 112 | 36.8244795799,75.1103826453 113 | 38.7390278523,80.6774049175 114 | 37.933006057,77.6288146918 115 | 46.3132824115,89.5054681474 116 | 42.0337095192,87.6097527741 117 | 27.5947919091,70.3758752882 118 | 34.352890784,81.5985063968 119 | 25.7641864325,74.3910448412 120 | 37.7011762915,80.7671334769 121 | 29.0310753046,72.8592878995 122 | 31.6253293612,72.4371241336 123 | 39.9280848026,75.8513684292 124 | 39.8682707768,78.615976581 125 | 42.0820062246,73.5723957293 126 | 27.6317108351,70.9725527387 127 | 32.7382599962,75.7465410664 128 | 37.396787966,73.1775211923 129 | 31.9934518358,69.8873329931 130 | 28.1161067934,68.2939787602 131 | 28.8497122318,66.7800140972 132 | 35.5832305819,77.1503922361 133 | 39.6785656071,83.4384073675 134 | 35.406027216,81.8706754513 135 | 33.5083891178,76.6745772924 136 | 43.8780972627,84.5049739401 137 | 25.9790101105,71.2540798016 138 | 31.2569341754,76.1053012077 139 | 40.8987052798,82.0295761924 140 | 34.1430855565,78.9274958433 141 | 33.0727494342,79.8522759165 142 | 33.9210018982,79.9875673604 143 | 27.9978237385,70.5881248492 144 | 38.8314857245,82.7401618457 145 | 31.8576280738,67.7783256669 146 | 47.1676705778,82.3855521088 147 | 38.1086639288,73.2881961293 148 | 31.3224181851,77.0803572137 149 | 25.0999121026,67.5490190431 150 | 37.2877776649,80.9664184316 151 | 28.3990399318,74.3772504306 152 | 29.822087485,75.468840769 153 | 35.0601476634,80.7071112062 154 | 38.4484911913,84.5467657944 155 | 39.207995026,79.4184065715 156 | 35.9822654269,75.8671006652 157 | 29.9994409343,72.5987307168 158 | 43.7136933834,80.8692970825 159 | 34.1344517524,71.6371682597 160 | 42.0854476204,81.8826505566 161 | 40.5407898026,86.4899001586 162 | 46.6366543162,81.553322221 163 | 38.5594807283,80.4469658637 164 | 40.8944659328,82.3123614001 165 | 32.1625206181,67.9257639546 166 | 42.3577854659,84.9000295072 167 | 29.0019115279,74.9323476221 168 | 38.5295821092,79.0663367587 169 | 31.8200605521,70.8577323227 170 | 38.8972944864,78.5387913595 171 | 23.0925973672,75.7083955126 172 | 34.4082609359,78.5955578601 173 | 39.6325243639,76.7354644358 174 | 44.4113522411,90.8778693429 175 | 30.6596988981,77.1011234909 176 | 39.3758308675,78.6481931201 177 | 39.8111748252,90.877976528 178 | 28.8669863287,73.8282335592 179 | 31.7605864163,77.5508174367 180 | 41.235542614,77.779029734 181 | 46.9924011907,89.0089331547 182 | 31.6251076068,72.5682940595 183 | 30.9815863186,78.3887731529 184 | 48.8966634477,87.555266709 185 | 31.661151697,73.6789452981 186 | 33.2871494316,77.6424155042 187 | 46.6854088872,87.9585407521 188 | 38.1232830453,78.5247275084 189 | 30.5701541553,73.6976810482 190 | 44.3026906064,81.9527063917 191 | 35.854322657,82.8371507289 192 | 32.1837099946,73.4152206431 193 | 46.0300425347,90.4234851793 194 | 34.6247183294,77.2155232959 195 | 47.7428117227,89.266955583 196 | 20.011511786,70.2090164358 197 | 37.8939642078,87.8335357004 198 | 22.9825288628,67.8679464573 199 | 30.571673601,76.7826918365 200 | 25.3042973792,77.5176322297 201 | 36.8553907277,76.4278891356 202 | 33.3986117479,77.2235766127 203 | 35.8310386046,86.0453235762 204 | 30.7679323175,74.3178878978 205 | 29.2548086094,72.8095822018 206 | 36.2881064911,79.9240323602 207 | 42.4037415021,83.5470887844 208 | 38.8005393123,82.3261553796 209 | 40.7742919833,79.5136746964 210 | 36.6162111325,78.6313067901 211 | 39.5673252612,83.5339023573 212 | 29.7164129016,79.0231240955 213 | 36.3225108628,75.158528111 214 | 42.7506168921,85.3586150238 215 | 23.7172293975,69.401146962 216 | 38.8291619965,83.8118296116 217 | 38.1204446255,74.9534645698 218 | 45.2616919092,86.330583713 219 | 36.454127917,75.3709550606 220 | 38.9712080848,82.085737584 221 | 39.0068809834,77.9925610136 222 | 37.5136806098,80.6696612084 223 | 35.9594414866,78.4875711504 224 | 29.5475445168,73.3970527021 225 | 30.2691854868,72.6882480122 226 | 26.2074015934,76.5037990998 227 | 35.4971767466,77.822653234 228 | 32.6303012866,76.9185489304 229 | 33.2147954674,75.2053787768 230 | 36.3253612845,76.9878073308 231 | 36.8490973044,70.9421471565 232 | 42.25510604,83.7250617002 233 | 26.2787145809,64.2994791265 234 | 38.6375069214,77.8923486551 235 | 38.2991790476,79.0021852471 236 | 32.1021493938,70.1240591504 237 | 35.9962223709,79.0896303147 238 | 34.2537541289,81.0667537836 239 | 29.9340692029,71.610678142 240 | 33.2157381106,81.6838615422 241 | 33.1601288837,79.0896385789 242 | 40.5509959364,83.6063452476 243 | 34.7480939254,75.3387258473 244 | 28.5130530584,70.4636366225 245 | 45.6838996659,85.3189853019 246 | 34.6263794449,81.1023662902 247 | 30.9827924976,75.8701676368 248 | 42.3060719859,83.8466840357 249 | 30.5841629253,76.7027371294 250 | 31.2376204983,66.4508170785 251 | 28.126708689,77.6781085215 252 | 30.4971882488,74.7123427644 253 | 44.4369497049,86.7235837566 254 | 28.3564417631,66.2671500081 255 | 39.8177869391,84.0701489929 256 | 32.6117780102,71.547243112 257 | 40.6710825735,81.1623236532 258 | 44.4159709474,83.2357425549 259 | 37.381942705,80.0074083056 260 | 30.969189759,80.4627820736 261 | 35.7161825996,82.8806945352 262 | 40.9714340248,81.2939971921 263 | 36.8782107498,77.6561636531 264 | 35.3560341857,74.7989290344 265 | 36.2082878105,76.0129635202 266 | 31.0789905707,75.8803266896 267 | 37.6369943343,79.8633195612 268 | 39.6370953634,87.2012246112 269 | 31.5082080992,76.3986823384 270 | 31.9712077002,74.0412216466 271 | 30.4230084719,67.9161156031 272 | 32.7296700223,78.9996893757 273 | 32.9456602219,77.0151263316 274 | 34.1106832219,83.2074453945 275 | 43.9287661048,83.8136266773 276 | 38.823676427,78.6827125291 277 | 32.1253802924,74.3931113873 278 | 27.1105567467,71.2328048446 279 | 40.2714231813,80.9255377156 280 | 39.1551516706,80.9320351579 281 | 26.7337533341,66.9350103823 282 | 37.8025087936,68.0349849812 283 | 43.2699717104,87.6140427653 284 | 31.5589650769,76.3726617299 285 | 33.6671970739,74.6753952333 286 | 28.1783440708,67.6021387895 287 | 44.6689538416,86.6054220007 288 | 24.2459155916,64.3411854336 289 | 40.3942134649,76.4272585449 290 | 19.2660615733,70.2616021925 291 | 45.6530043211,88.7806404236 292 | 38.9769477142,84.7273449748 293 | 21.6179219272,67.9534478974 294 | 31.4016108996,74.4433181119 295 | 33.2163287807,81.2726780262 296 | 32.5008392794,70.0061496282 297 | 29.2001704589,68.509553698 298 | 31.3006541593,75.726507908 299 | 30.0853558229,72.5536848493 300 | 38.5949391239,84.3969505618 301 | 34.726951063,77.2459605725 302 | 30.6669667914,69.5007510506 303 | 28.3762812271,76.7553834251 304 | 41.3136148097,83.7757387249 305 | 43.1201089533,81.4217932596 306 | 44.8051915801,83.5542367087 307 | 23.7112351161,68.6167013852 308 | 41.9841769568,83.758060774 309 | 39.8995141359,81.7028058982 310 | 40.1723482349,80.8445597772 311 | 37.6955602799,86.6112914154 312 | 43.7704357228,85.4110612219 313 | 46.955899715,89.9977636836 314 | 39.7985377623,86.3939985258 315 | 25.1257018738,69.8238354817 316 | 17.6022123088,70.0119550116 317 | 47.3899841086,86.27405562 318 | 32.10556953,74.010823792 319 | 43.6556398,87.1993179775 320 | 35.0834992079,77.6541349826 321 | 31.583726304,74.0792625111 322 | 37.1284289904,87.8241983799 323 | 35.2356526688,78.6345187025 324 | 39.1219958011,77.4463115248 325 | 43.9752876026,87.3445731806 326 | 38.2292498998,79.5003428012 327 | 40.5152683836,80.5636058174 328 | 42.5983268012,83.7185468075 329 | 25.8148238903,72.1716648406 330 | 32.8540263756,70.3374918993 331 | 27.3425172448,67.1839081307 332 | 40.6491600409,83.7320605769 333 | 24.7463152611,71.3391468991 334 | 27.4570015201,70.1792265485 335 | 32.4169318077,77.233822838 336 | 45.0081387146,89.2175675426 337 | 41.2133810713,87.9886253961 338 | 30.4942871285,73.0947658657 339 | 30.588492397,68.89806403 340 | 29.9477773733,71.2371943729 341 | 41.6275043946,85.4884704043 342 | 31.9047242714,67.0566488243 343 | 37.5151174856,80.0283882764 344 | 29.2699786204,70.2659026295 345 | 39.2003577482,82.9377065991 346 | 37.2323536823,78.183003575 347 | 37.1112988223,82.7213401813 348 | 42.2763128241,79.3592260413 349 | 34.2067442686,79.3991115078 350 | 26.5110240324,68.8135501085 351 | 29.5931054397,70.6363783695 352 | 39.3661924969,82.2915663352 353 | 35.4854101977,72.9576439206 354 | 46.0733959001,80.1420118455 355 | 27.9151101237,63.8818929133 356 | 36.0643608975,76.890583746 357 | 47.3526098249,86.4411011854 358 | 35.3654602832,71.2332873576 359 | 27.3862014474,72.7152263617 360 | 30.6578552849,73.3476234656 361 | 30.8427216691,76.9107612339 362 | 34.9191513478,79.5125706847 363 | 33.4473075231,76.2128428005 364 | 46.958395894,81.4138260806 365 | 29.9995157202,69.3963681348 366 | 37.6390064214,82.8610030113 367 | 42.9662205825,83.3474388045 368 | 30.3805803501,72.6020777804 369 | 29.5213173439,75.3722443014 370 | 51.8952551104,91.1142618544 371 | 30.207631586,74.9518885113 372 | 45.8190532114,84.466361821 373 | 41.4987742946,79.8395837786 374 | 28.6721290934,75.3370117163 375 | 34.6435159645,79.2336081726 376 | 33.0319660332,72.9551022594 377 | 50.628155491,90.6476410542 378 | 29.4383314379,78.253211918 379 | 30.0198693042,68.1759516652 380 | 38.5140812609,76.8375262967 381 | 35.0454640217,77.5445545548 382 | 26.7688967764,71.4822815116 383 | 37.9973513831,81.8516228084 384 | 37.8746903137,74.7701178032 385 | 30.6287976578,77.425980842 386 | 40.6893700839,75.3542909617 387 | 25.8956794264,66.8329058721 388 | 30.8010986282,76.0361323777 389 | 23.8571219851,72.757083469 390 | 40.6873715718,78.8035909609 391 | 37.8443046212,78.8024619764 392 | 45.1113219173,85.3820647671 393 | 28.9494398159,66.9584488137 394 | 38.3845183137,85.4184958215 395 | 40.2989475313,80.8931455916 396 | 28.8548500854,73.8745002973 397 | 34.9491698785,69.3599369571 398 | 27.2186216719,72.1700131652 399 | 25.400360008,77.0869392707 400 | 31.3175325398,73.8362180484 401 | 35.3322361758,80.5927820528 402 | 34.2328991467,71.237079118 403 | 28.4631812827,71.4136973105 404 | 37.4466939122,83.0497383857 405 | 36.1352559134,75.6437921758 406 | 41.3805930911,78.2154185427 407 | 34.234770514,76.9123674938 408 | 34.5619397938,80.0298615264 409 | 33.3854869505,69.0342715213 410 | 41.1646355137,82.18927654 411 | 29.3153121865,72.1965092517 412 | 40.988265337,89.857706126 413 | 44.1551688659,83.1307391348 414 | 50.4191709035,90.8725308156 415 | 37.1769712251,78.5297468358 416 | 29.8885548317,79.139763514 417 | 36.1673589235,87.959023099 418 | 47.3317708204,88.0422272215 419 | 34.0353893803,70.8445603776 420 | 43.7971427908,83.4572357657 421 | 29.22844372,75.9668052923 422 | 19.7377391883,56.3651527859 423 | 45.5591862704,87.7066352996 424 | 51.9840461615,92.6301131093 425 | 37.2867768917,79.100119406 426 | 39.4343156859,75.9309996928 427 | 35.1597935242,76.342460232 428 | 32.3415411627,76.3967187525 429 | 31.741529264,75.1292731556 430 | 33.7474538277,72.2573252421 431 | 29.9188975578,69.3754202421 432 | 29.3136110125,67.7035088927 433 | 38.8664013417,87.4581838343 434 | 33.2861852391,79.9644862834 435 | 35.0017858566,75.200535352 436 | 39.3081396607,84.5477646427 437 | 33.828257706,82.6088269511 438 | 29.4439406713,68.2304500014 439 | 34.0314398462,79.146697052 440 | 24.5150431202,71.2154232716 441 | 35.8728458962,76.976315251 442 | 49.5499908598,94.2140024875 443 | 35.8341162589,80.5083095038 444 | 17.6045365391,60.5657067648 445 | 25.4909150053,68.3036126541 446 | 33.4832386304,75.3475622975 447 | 43.5102669288,90.2891675567 448 | 44.4960622862,83.6601361326 449 | 37.2673118774,82.7780581283 450 | 48.8414618805,89.7847229686 451 | 42.0528445731,79.7831417965 452 | 31.2456276562,77.0817675293 453 | 32.3934135403,74.0367158554 454 | 33.6689331357,76.9532199834 455 | 33.0080331038,70.5117947815 456 | 27.7694795032,76.8238395943 457 | 24.1596601779,68.6199158524 458 | 41.0102848803,82.0822155029 459 | 29.1601954474,76.2954452812 460 | 32.5047312325,75.2475238272 461 | 38.182097991,76.0094492715 462 | 41.453989034,84.2698850374 463 | 29.9418254786,75.6402951256 464 | 33.1629107678,77.0612158473 465 | 24.1759424925,65.1782329175 466 | 31.2682695165,71.6422861466 467 | 22.8666125189,70.3198234118 468 | 31.5077620398,80.5197325269 469 | 39.7927267613,79.1974574979 470 | 30.2803189338,73.5039543738 471 | 43.788178353,76.7720345261 472 | 28.6380666207,72.6452333039 473 | 37.8794860846,81.7728852285 474 | 36.6130610346,81.7396042143 475 | 32.7998401764,75.4894197124 476 | 32.3792147296,75.5321202775 477 | 38.3305149946,77.5854290033 478 | 27.8245122578,78.0601713203 479 | 36.7508177731,82.0686643824 480 | 38.6830414702,79.8397889006 481 | 28.7949647889,75.4843707109 482 | 47.0831209752,85.5703468231 483 | 28.0495393718,75.1126317185 484 | 38.8875908336,76.4545164521 485 | 35.9631355487,78.9627343951 486 | 33.2050430817,75.7953376717 487 | 46.6677097688,88.0620792566 488 | 45.7327467646,88.6069360689 489 | 30.6204801265,75.0002851722 490 | 41.8340327167,94.4595529751 491 | 37.2462621053,80.1514855477 492 | 33.9303215614,78.223769903 493 | 43.1812358808,81.756828278 494 | 35.8997170527,81.3847412203 495 | 34.935018754,77.4784041205 496 | 49.6980229086,92.2530009811 497 | 49.6752250687,89.1785133819 498 | 27.4603502263,69.739418236 499 | 38.9381739618,81.6638699417 500 | 46.8370006177,86.0276360881 501 | 35.5020443544,77.9402190587 502 | 24.3003010764,68.1526887421 503 | 53.6173189243,91.8796301978 504 | 38.2732454934,85.9079014825 505 | 37.9727289585,78.493366975 506 | 40.676552503,84.1192396064 507 | 27.2484840572,76.4214822557 508 | 34.7729859757,77.0341527088 509 | 33.406168372,83.6118523643 510 | 35.300331774,78.1401426923 511 | 40.3099715073,82.338777254 512 | 47.0206622197,90.3331444883 513 | 16.8895526714,58.3383287322 514 | 42.5968568771,78.9272150904 515 | 32.9068857939,70.5089206976 516 | 35.3740235287,69.4453326763 517 | 37.6071465101,77.573467897 518 | 40.9222073179,80.1114155391 519 | 34.5870567785,75.9750507985 520 | 28.4760602903,67.2034913852 521 | 29.5752446317,69.5170552275 522 | 36.9999571681,78.8414988957 523 | 36.40395169,83.7242588658 524 | 37.0796164089,75.4225263653 525 | 33.8114338526,82.3291574071 526 | 41.1213804922,80.8603348261 527 | 33.601330735,76.0765640062 528 | 32.9544101244,76.4170877989 529 | 29.9906916642,75.3537799646 530 | 25.8526243486,65.2728880982 531 | 38.1281310742,75.2016056141 532 | 38.4160865718,80.4874573638 533 | 34.9004006223,72.9144706766 534 | 28.6517791996,76.3464962839 535 | 26.8226241454,75.409974205 536 | 25.2872977886,72.5694486194 537 | 30.5191413366,73.7590739826 538 | 31.4180331917,70.3468928032 539 | 46.6086508136,90.962067943 540 | 45.6762781893,89.2043171027 541 | 40.6558198709,82.6239478616 542 | 25.8874549308,69.6433663777 543 | 35.9892310935,74.9733106623 544 | 34.6534928137,69.0812630107 545 | 40.5115503584,81.1675358511 546 | 40.5209894427,81.1392731255 547 | 25.1698272771,69.386176893 548 | 34.1242591577,75.9293240288 549 | 30.7358306479,72.5814106807 550 | 30.2226827889,72.6564827482 551 | 30.8071691482,75.3366792882 552 | 34.0018393937,75.6294835068 553 | 32.6013932563,78.5994754033 554 | 32.9686416536,69.0997341915 555 | 35.2945048709,79.4693613496 556 | 36.075052054,78.1652720341 557 | 38.1986031943,73.253621129 558 | 41.4981466095,79.1413042692 559 | 29.2085040734,77.5930280185 560 | 39.9522772261,87.0127205256 561 | 31.2263918879,76.9547127781 562 | 24.2495141837,72.7936148349 563 | 36.38419261,78.09763853 564 | 41.4644868635,81.3596554201 565 | 42.3333508533,87.115752324 566 | 21.5960603597,65.0261349524 567 | 27.3525118564,65.9605348607 568 | 41.8258464137,89.1161689357 569 | 47.8004675532,88.0317573281 570 | 26.8862957028,71.057921267 571 | 46.3760433779,88.1372036351 572 | 26.3483107368,70.0781192958 573 | 39.6038375023,85.8706143622 574 | 34.0452193756,74.66587616 575 | 50.3322542051,91.9646261893 576 | 37.9088023337,80.0380035175 577 | 33.1916246919,76.3397510227 578 | 35.1193165871,77.1774262452 579 | 39.8844289206,77.6383085065 580 | 37.4718342379,78.6769929916 581 | 38.0123925434,74.0884871455 582 | 31.4938731706,79.3637372111 583 | 26.9500617068,72.5030046997 584 | 35.0071938313,78.5525511341 585 | 38.1812405524,79.5326776366 586 | 38.5544817205,82.3875228596 587 | 23.9293944677,73.7818984345 588 | 33.5182168661,73.7765157912 589 | 45.5554522841,88.5365669117 590 | 26.5127311848,75.6676275691 591 | 32.5252827096,73.3429510398 592 | 47.9459454151,85.9392969131 593 | 48.8232494067,92.1556866584 594 | 38.7301492819,83.4611500146 595 | 37.8644425851,84.6992078998 596 | 42.9480751903,81.7433724233 597 | 49.699639815,91.7810017423 598 | 36.2729024624,77.6191260375 599 | 47.8405481372,87.2041637414 600 | 35.3539113062,83.1773579927 601 | 29.502717706,76.6456373452 602 | 49.0557768672,93.2069873925 603 | 26.1612427443,64.4715573419 604 | 35.1838617303,77.7116125229 605 | 33.1486669959,77.8201911228 606 | 31.1302118785,73.5944941813 607 | 39.8724813502,81.5060477597 608 | 30.2399565705,75.0661246834 609 | 38.0870360492,80.1566414001 610 | 22.38740959,60.9140116996 611 | 40.3885522773,84.7164446281 612 | 48.7921644623,85.9359396901 613 | 41.582779824,82.4175414461 614 | 34.514948161,79.4340039816 615 | 29.2464048459,70.8619993052 616 | 39.6345164237,83.2619977739 617 | 31.5711727376,75.5521317268 618 | 32.2513641701,79.8759984295 619 | 40.7867796769,85.6128864455 620 | 36.0536011996,77.9186590735 621 | 36.8347031854,80.4447724638 622 | 35.4619740425,81.3225746931 623 | 41.9249992477,83.3029826805 624 | 36.8073050012,79.0106114913 625 | 37.8968766132,82.5222989119 626 | 31.4478566944,74.7749176061 627 | 26.8387857755,71.8261009644 628 | 28.8349877179,68.0002817733 629 | 26.8169917196,69.1416966199 630 | 30.7065853594,75.3453349296 631 | 41.6401708351,79.5368335838 632 | 32.9685799974,69.4401672861 633 | 38.3710925982,80.0257089412 634 | 36.4076008804,74.985338633 635 | 46.4578325209,93.2564715334 636 | 36.5154664477,83.9279690294 637 | 26.7868513106,69.0415597971 638 | 22.8915607014,70.4996585049 639 | 33.6454110708,73.0437393157 640 | 36.7015229123,74.0909732459 641 | 34.8311959448,78.5158009553 642 | 23.9424883937,69.0258009543 643 | 35.2399302169,78.0142784855 644 | 39.3342260821,76.8627945935 645 | 44.5048213234,83.4552716509 646 | 41.5045830715,83.369633722 647 | 35.2005501553,73.7081917213 648 | 33.8307111732,75.9109015419 649 | 31.422420631,69.6034861938 650 | 50.6714557502,97.748745832 651 | 25.0734655949,71.075551417 652 | 42.4763748035,87.9916615616 653 | 33.8287367164,79.2811150354 654 | 27.3028810405,69.9910405076 655 | 37.027761428,76.2358566927 656 | 40.8084849906,79.4404909029 657 | 36.3439194903,81.4591994307 658 | 42.0853734174,89.0765032074 659 | 32.2458829491,72.5953875548 660 | 30.6654629366,74.9215783721 661 | 26.9951191846,72.2757762485 662 | 32.7159484351,73.6438134083 663 | 40.7912939351,82.8175467785 664 | 36.0217665794,78.1352037281 665 | 47.8121527209,91.6729133283 666 | 32.9458338087,77.3441777407 667 | 30.1096333799,78.8598601901 668 | 31.1671930189,76.4842338053 669 | 27.3163280947,69.5292196608 670 | 33.9641135475,73.1703956843 671 | 24.3805324779,70.6209234416 672 | 44.1125960315,89.1021432407 673 | 34.4624461115,77.5109324932 674 | 40.1596595482,77.1104676298 675 | 39.0781711674,84.6474404285 676 | 31.9996699133,75.9760816361 677 | 37.8808314269,81.7510255399 678 | 25.9125650248,66.560766871 679 | 39.624679966,79.8878251 680 | 39.715325546,85.625409583 681 | 37.4016709236,80.6067005085 682 | 32.373776922,74.8033886136 683 | 35.3270284899,73.9639762787 684 | 39.4591647149,82.8644977357 685 | 39.1450053208,79.0786176054 686 | 37.3585370787,79.2885750555 687 | 33.8894011248,81.437602108 688 | 32.8163560936,77.1657244662 689 | 22.0944365269,64.5096925176 690 | 30.150607119,72.9750955809 691 | 31.2353434191,65.055846135 692 | 37.6012913617,78.6099016574 693 | 33.3052258758,73.8145075004 694 | 32.2348226304,78.6607241188 695 | 39.4359063165,79.1069918801 696 | 35.6264201129,79.8992802705 697 | 33.439816315,85.0998017844 698 | 42.2571370867,85.8158415463 699 | 33.874031227,75.7779917121 700 | 34.435624429,73.4078688585 701 | 33.4601334116,79.7824596335 702 | 28.7525866419,70.7182664067 703 | 28.8402762592,68.9295394671 704 | 41.157221652,78.811015721 705 | 44.2688333948,85.9857720345 706 | 25.4932534724,77.2917853862 707 | 36.4712801018,72.6469597277 708 | 43.3841334685,86.9230970579 709 | 35.6963616122,78.8840656452 710 | 31.4016591557,69.6156021836 711 | 39.0261206261,80.2200518636 712 | 35.3982035947,82.7618256605 713 | 34.459214874,74.8206773434 714 | 38.3855577117,83.7857075468 715 | 31.545710648,70.5929051434 716 | 48.076011081,92.5443986437 717 | 29.7933692122,76.7808215113 718 | 42.5981504758,85.5932979215 719 | 48.8649690743,87.5219089287 720 | 36.2599672178,83.3922038413 721 | 27.0029228664,70.7374261021 722 | 38.3111971705,83.6380517575 723 | 50.5513442683,81.6717755767 724 | 38.4629865217,79.5169719079 725 | 28.09337332,67.1250370192 726 | 32.5477525391,70.9560521075 727 | 25.8315606265,70.0424199693 728 | 29.7353879897,71.2463415303 729 | 30.8924582307,73.8809214006 730 | 28.5790798283,81.4863264099 731 | 46.790217134,86.6966954958 732 | 43.6148574117,81.1361216768 733 | 37.0940396324,82.7203374587 734 | 32.3412774035,73.8288984883 735 | 41.6223972524,78.8910066945 736 | 38.4074077065,83.4510722654 737 | 41.8903598516,81.962003208 738 | 31.4993934591,73.3727349522 739 | 36.6119072486,82.8690167353 740 | 52.201072816,92.5473795465 741 | 44.5360587071,77.7011850375 742 | 28.6161871226,68.8007526037 743 | 20.9150241427,62.441460334 744 | 38.5150511284,77.3502197256 745 | 45.6953036298,91.3024577535 746 | 36.1840469821,74.2956201664 747 | 26.2974793775,70.2632427564 748 | 33.2319741612,76.5376167568 749 | 51.9759618992,95.6255427859 750 | 49.9580982311,90.9085045286 751 | 33.3716725676,76.6610234063 752 | 30.6143916429,71.1153853902 753 | 43.029016781,86.7534876336 754 | 34.736005094,79.0025948605 755 | 28.9477054607,76.2698146226 756 | 30.8157936051,76.7720550386 757 | 34.3287617358,72.9394154839 758 | 24.2127217581,68.4814170984 759 | 33.2624448676,81.1865285364 760 | 31.3643086709,79.7863764683 761 | 28.5935068242,67.5732290506 762 | 29.7782075715,74.5807397242 763 | 35.1987866651,74.3229517632 764 | 36.3471926606,75.0128996142 765 | 35.0938623871,76.6504899624 766 | 31.4240570314,75.2711561354 767 | 33.3699969924,74.7287949149 768 | 38.5136347615,74.1485318657 769 | 33.4608945977,71.6151063401 770 | 30.0021617091,74.412666313 771 | 29.976476351,70.6604634112 772 | 26.4175043319,69.1224585817 773 | 47.1600524168,87.8786119915 774 | 38.458501763,85.2771276185 775 | 34.4382794055,77.0575897809 776 | 36.5562872763,81.1797887981 777 | 56.1376526727,93.4836508728 778 | 26.6613951509,73.7957099406 779 | 37.0079915309,80.3071932386 780 | 39.3018361479,82.9572947186 781 | 33.0296195181,75.0310768707 782 | 46.0306619317,86.6733053618 783 | 42.051892986,76.9468032664 784 | 34.7561940998,73.0617793629 785 | 28.8883491505,74.3237332335 786 | 28.3104292722,75.3727818741 787 | 42.388083536,89.7802092585 788 | 34.5058992875,80.741752123 789 | 30.0287971793,67.7556030025 790 | 37.5581966036,78.1392043087 791 | 35.122975758,78.6650378817 792 | 33.2356152502,69.9112324808 793 | 36.3363566762,79.8731437454 794 | 29.8054889925,70.025839659 795 | 33.2061946954,82.8816417919 796 | 25.2395952408,67.1543359453 797 | 42.1386014465,85.5065059278 798 | 50.3594020127,92.4650469345 799 | 37.168174093,84.6690285746 800 | 46.3899984717,91.3701381409 801 | 24.9768771397,70.46713633 802 | 40.6007823179,83.4300083249 803 | 33.9338478078,77.4523721044 804 | 22.943598083,64.482555807 805 | 42.6949262437,84.0374829532 806 | 42.5620870806,84.4513178759 807 | 36.4262676766,78.1492174744 808 | 31.2455033531,76.771930501 809 | 19.181549708,64.5244471576 810 | 31.7817451349,74.6829153649 811 | 40.5359824179,77.9572162135 812 | 35.106810893,78.0266840847 813 | 41.2141258029,81.2805296785 814 | 20.9564460095,65.9972072062 815 | 27.3368094529,72.7141769931 816 | 23.924992194,63.8244706908 817 | 30.270967961,71.4484750301 818 | 49.2695568599,94.9812148108 819 | 36.5739846744,72.6751067379 820 | 37.284969888,77.2847512828 821 | 31.08564634,72.7756522713 822 | 23.3266676548,69.6785214027 823 | 37.5875576734,78.6425579907 824 | 46.4024788676,82.382633553 825 | 44.9809784202,90.3799741139 826 | 37.1882895887,84.2094923356 827 | 34.9626308392,76.8041062644 828 | 32.4428521437,73.700574871 829 | 23.230960776,64.2439272085 830 | 36.3004722618,77.1665898925 831 | 31.6273190491,73.6176089313 832 | 38.9412720529,82.2091046196 833 | 29.2010117698,73.3409569372 834 | 30.6484856699,73.2596832313 835 | 37.9085807018,78.0428887613 836 | 31.7410110466,77.1889609682 837 | 37.7654180729,79.7146281984 838 | 27.7203706957,70.9772533238 839 | 36.2990973185,78.4041241804 840 | 32.8351982388,77.8648786568 841 | 45.2430781043,89.980170075 842 | 40.373899211,85.8300121267 843 | 42.6842336708,83.9042421121 844 | 35.6551404887,78.3179851549 845 | 37.5201690951,79.3069158244 846 | 31.0518015736,72.5646549957 847 | 33.8048510018,73.725536132 848 | 27.8192019668,68.2791647559 849 | 34.8610443773,71.0058718221 850 | 37.1319296225,82.4776910395 851 | 30.3391107568,77.5426744388 852 | 41.0244651377,85.38186456 853 | 29.9640328758,68.7628298385 854 | 26.4141316294,71.0306614172 855 | 20.0904181787,62.969548006 856 | 35.5888419981,79.9473726599 857 | 33.4918563147,74.8372230452 858 | 36.2002993987,80.002771315 859 | 38.5423257327,81.136834567 860 | 21.8995786669,75.7337527973 861 | 39.2013595787,75.8243732399 862 | 45.3682473355,86.42288107 863 | 30.6508473068,76.5206953693 864 | 44.2094046825,86.173916137 865 | 32.4128568754,73.3268304856 866 | 33.3707833738,77.4893624678 867 | 36.0939543371,78.0114236645 868 | 42.6251204707,86.6240222854 869 | 35.5845924465,77.1900370959 870 | 34.9827879353,81.6706343929 871 | 27.4753710017,65.3021544036 872 | 37.0636012603,76.555599702 873 | 36.8694333648,78.375423376 874 | 29.7205593137,66.7185082943 875 | 29.4137771615,68.7321922185 876 | 34.195914065,74.896447246 877 | 29.2973252374,68.0035156761 878 | 24.3622058544,65.5962189453 879 | 23.3530090232,71.8484138188 880 | 33.0189491185,73.0262934955 881 | 25.2070536324,69.6982827469 882 | 29.9854566063,72.3184090151 883 | 28.3220846817,74.3624902116 884 | 37.5603692739,77.3828375126 885 | 24.2161655328,62.854897725 886 | 34.4289689802,78.078535734 887 | 36.4903160092,74.2860075521 888 | 26.5967680098,69.0268687034 889 | 23.8374356225,64.4882379346 890 | 44.6114693931,84.773405096 891 | 39.1442130956,78.7667866213 892 | 36.8344237304,79.5701175644 893 | 36.2417418554,72.4645791672 894 | 34.2624623753,80.7559025695 895 | 33.6723471868,75.9203302599 896 | 42.6590559845,84.9527267017 897 | 35.7892582437,74.8832468334 898 | 34.7361437673,76.2780193776 899 | 28.6362357535,74.6801589978 900 | 36.3380364951,74.2592678583 901 | 26.0690738423,69.8069509444 902 | 30.7693854141,71.4219664917 903 | 42.0143948918,82.9423289612 904 | 29.3884673243,77.3892239883 905 | 21.5371694786,56.7846419761 906 | 34.3815807771,80.1485205027 907 | 33.2668249238,76.1084109123 908 | 44.1361180464,83.8348561011 909 | 37.8795474494,79.8409987429 910 | 34.6105997083,72.2699416701 911 | 28.0569232898,67.7915610625 912 | 42.7900289193,83.1297051429 913 | 44.5086620235,84.0545087996 914 | 41.1926321478,85.8948184331 915 | 29.1420926442,74.0916572763 916 | 32.842137737,78.0725200589 917 | 34.9535069623,73.8198573483 918 | 32.6012948914,77.9749745791 919 | 29.5351259553,68.7326239839 920 | 40.7714888518,82.8199711132 921 | 33.2983962093,76.6526053083 922 | 34.4463780685,75.8069959701 923 | 38.0321497274,76.9301032904 924 | 35.0449586199,82.3311126742 925 | 26.8415372677,76.1526328276 926 | 38.0245634514,77.7267121919 927 | 43.0260894401,87.3662561293 928 | 29.8134125584,77.3092962581 929 | 28.4850925942,73.2517415649 930 | 30.9421619077,73.3057389997 931 | 37.981936511,78.1776310013 932 | 31.4952707067,78.2496451589 933 | 34.0504350703,76.9296449567 934 | 39.5669969394,81.5020233286 935 | 35.464991868,75.0116067673 936 | 29.3155707814,70.6784596189 937 | 36.0828179745,84.9361324847 938 | 29.5813178106,70.9830380268 939 | 47.0156963625,81.230250511 940 | 35.6572956551,71.7980954778 941 | 30.759131296,71.1810083302 942 | 36.8354960637,75.3261343692 943 | 35.4460673005,74.9110084152 944 | 39.9310178661,83.8223537402 945 | 34.4633927546,74.0921447969 946 | 31.0127117526,74.7106430078 947 | 40.3958144895,79.9553040768 948 | 28.4974649746,76.4379688518 949 | 46.2434943621,87.8546047285 950 | 38.2517996861,78.9546994395 951 | 44.2455939328,86.7487553445 952 | 36.8209268836,83.9947510637 953 | 35.9644782976,75.1120091289 954 | 29.6226138132,71.0848493035 955 | 28.1892256444,76.8314329882 956 | 37.8590319716,78.6772576754 957 | 31.6316627,74.0740264995 958 | 44.2787339718,84.8681368853 959 | 24.5713840058,65.8981427166 960 | 30.9454709729,71.9161633092 961 | 26.3494569227,74.7204734948 962 | 34.7517996064,79.4797159913 963 | 40.1748077225,84.7598734644 964 | 30.9949412796,72.2689547951 965 | 31.4065078179,69.0536813935 966 | 23.4932384116,66.940077378 967 | 37.235622346,85.7027792398 968 | 36.4766989951,79.5516048206 969 | 23.9381693596,65.9655097082 970 | 31.8020890949,77.8617012936 971 | 31.4320741095,68.4202798212 972 | 30.6491720936,69.8212389982 973 | 50.3536403978,83.359372783 974 | 35.5764019842,73.8803191336 975 | 36.8747940022,81.4769802172 976 | 40.6763920542,81.1347406495 977 | 34.8999848105,81.6586411914 978 | 30.9366835412,73.3211191424 979 | 36.9189823962,80.018091908 980 | 32.7338958815,71.5058850358 981 | 52.378668227,88.5858239799 982 | 28.2727557426,69.3989359432 983 | 19.5713465368,69.4414082664 984 | 27.7376410195,71.7686480679 985 | 32.2482801942,76.8893294489 986 | 52.3805873516,97.3324142304 987 | 31.6146429352,77.6280597745 988 | 31.8504476874,74.2595847856 989 | 34.5997010208,78.3589294311 990 | 35.8258238741,80.542100933 991 | 24.7775467094,69.6089921663 992 | 32.6309613638,79.3926097719 993 | 37.5415014618,77.3842873711 994 | 22.5309331222,62.8276696938 995 | 35.8630925517,81.7498085792 996 | 44.6711743214,80.9852610607 997 | 24.0019331756,66.6239249853 998 | 38.5517659093,85.3268357821 999 | 39.2431730196,79.2622036709 1000 | 29.0313962109,70.2262373449 1001 | 36.6386194798,83.2340991395 1002 | -------------------------------------------------------------------------------- /HW_9/data/reg_ex_table.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ZohebAbai/DSE210x/e4a9a5295de2256a33c82c4b8b757801806a580a/HW_9/data/reg_ex_table.png -------------------------------------------------------------------------------- /HW_9/data/reg_mean_pic.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ZohebAbai/DSE210x/e4a9a5295de2256a33c82c4b8b757801806a580a/HW_9/data/reg_mean_pic.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # UCSanDiegoX: DSE210x: Statistics and Probability in Data Science using Python 2 | 3 | ## Instructors : 4 | * Alon Orlitsky, Professor, ECE and CSE Departments, UCSD 5 | * Yoav Freund, Professor, ECE Department, UCSD 6 | 7 | ## Learning Objectives 8 | The course will teach you how to visualize, understand, and reason about probabilistic and statistical concepts, and how to apply your knowledge to analyze data sets and draw meaningful conclusions from data. They will cover both theoretical and practical aspects, and will start each topic with motivation and intuition and will proceed with rigorous arguments and provable techniques. Each topic will be accompanied by a Python Notebook that you could run and modify to experiment with the material learned and get a better feel for the material covered. 9 | 10 | ## Topics Covered 11 | * Counting and combinatorics 12 | * Discrete and continuous probability 13 | * Conditional probability and Bayes’ Rule 14 | * Random variables 15 | * Expectation, variance, and correlation 16 | * Common distribution families 17 | * Probabilistic inequalities and concentration 18 | * Moments and limit theorems 19 | * Hypothesis testing 20 | * Sampling and confidence intervals 21 | * PCA and regression 22 | * Entropy and compression 23 | 24 | ## Opinion/Comments 25 | #### I audited for this course and pledged to complete it. I finished every Engagement, Quiz, Problem Set and Programming Assignment. This is a rigorous course which might be heavy for non-mathematical background learners. Once completed you will surely have a strong foundation in probability and statistics. 26 | #### I have provided my Homeworks here (as an evidence of finishing and maintaining a repository for the course), which I completed during a month's time. 27 | 28 | #### Thanks for passing by! 29 | --------------------------------------------------------------------------------