diff --git a/Practice0.ipynb b/Practice0.ipynb deleted file mode 100644 index 4b16c03..0000000 --- a/Practice0.ipynb +++ /dev/null @@ -1,198 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "IPython version: %6.6s 6.1.0\n" - ] - } - ], - "source": [ - "import IPython\n", - "import json\n", - "# Numpy is a library for working with Arrays\n", - "import numpy as np\n", - "# SciPy implements many different numerical algorithms\n", - "import scipy as sp\n", - "# Pandas is good with data tables\n", - "import pandas as pd\n", - "# Module for plotting\n", - "import matplotlib\n", - "#BeautifulSoup parses HTML documents (once you get them via requests)\n", - "import bs4\n", - "# Nltk helps with some natural language tasks, like stemming\n", - "import nltk\n", - "# Bson is a binary format of json to be stored in databases\n", - "import bson\n", - "# Mongo is one of common nosql databases \n", - "# it stores/searches json documents natively\n", - "import pymongo\n", - "print (\"IPython version: %6.6s\", IPython.__version__)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Make a 2 row x 3 column array of random numbers\n", - "[[ 0.20354485 0.87353642 0.79226415]\n", - " [ 0.26457656 0.23486214 0.8240387 ]]\n", - "Add 5 to every element\n", - "[[ 5.20354485 5.87353642 5.79226415]\n", - " [ 5.26457656 5.23486214 5.8240387 ]]\n", - "Get the first row\n", - "[ 5.20354485 5.87353642 5.79226415]\n" - ] - } - ], - "source": [ - "#Here is what numpy can do\\n\",\n", - "print (\"Make a 2 row x 3 column array of random numbers\")\n", - "x = np.random.random((2, 3))\n", - "print (x)\n", - "\n", - "#array operation (as in R)\n", - "print (\"Add 5 to every element\")\n", - "x = x + 5\n", - "print (x)\n", - "\n", - "# get a slice (first row) (as in R)\n", - "print (\"Get the first row\")\n", - "print (x[0, :])" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# IPython is quite modern: just press at the end of the unfinished statement to see the documentation\n", - "# on possible completions.\n", - "# In the code cell below, type x., to find built-in operations for x\n", - "x.any" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAD6BJREFUeJzt3X2MZXV9x/H3p6zQqlXAndJ1d9Mlim2wSZVOCY21sdJU\nHoxLWkMgpF2VZKPxEW11kURMG5Ol2vqQGs1WqEtLeChioEVbkKKmf7B2QEQepGxxkd0CO8bH1sR2\n9ds/7qFc19mZ3Xvm7r3z2/crmcw5v/u7cz5ez/3M4Zw7Z1NVSJLa9TOTDiBJGi+LXpIaZ9FLUuMs\neklqnEUvSY2z6CWpcRa9JDXOopekxln0ktS4VZMOALB69erasGHDpGNI0opy5513frOqZpaaNxVF\nv2HDBubm5iYdQ5JWlCSPHMw8T91IUuMseklqnEUvSY2z6CWpcRa9JDXOopekxln0ktQ4i16SGrdk\n0Se5IsneJPcOjb0/ydeS3JPk00mOHXrs4iQ7kzyY5BXjCi5JOjgH85exnwT+CrhyaOxW4OKq2pfk\nMuBi4F1JTgbOA14IPBf4XJIXVNWPlje2dPhs2HLzRLa7a+vZE9mu2rPkEX1VfRH41n5jt1TVvm71\nDmBdt7wRuKaqflhVXwd2AqcuY15J0iFajnP0rwM+2y2vBR4demx3NyZJmpBeRZ/kEmAfcNUIz92c\nZC7J3Pz8fJ8YkqRFjFz0SV4DvBK4oKqqG94DrB+atq4b+ylVta2qZqtqdmZmybtsSpJGNFLRJzkD\neCfwqqr6wdBDNwHnJTkmyYnAScCX+seUJI1qyU/dJLkaeBmwOslu4FIGn7I5Brg1CcAdVfX6qrov\nyXXA/QxO6bzRT9xI0mQtWfRVdf4Cw5cvMv99wPv6hJIkLR//MlaSGmfRS1LjLHpJapxFL0mNs+gl\nqXEWvSQ1zqKXpMZZ9JLUOItekhpn0UtS4yx6SWqcRS9JjbPoJalxFr0kNc6il6TGWfSS1DiLXpIa\nZ9FLUuMseklqnEUvSY2z6CWpcRa9JDXOopekxln0ktS4VZMOIGlhG7bcPJHt7tp69kS2q/FZ8og+\nyRVJ9ia5d2js+CS3Jnmo+35cN54kH0myM8k9SU4ZZ3hJ0tIO5tTNJ4Ez9hvbAtxWVScBt3XrAGcC\nJ3Vfm4GPLU9MSdKoliz6qvoi8K39hjcC27vl7cA5Q+NX1sAdwLFJ1ixXWEnSoRv1YuwJVfVYt/w4\ncEK3vBZ4dGje7m5MkjQhvT91U1UF1KE+L8nmJHNJ5ubn5/vGkCQdwKhF/8STp2S673u78T3A+qF5\n67qxn1JV26pqtqpmZ2ZmRowhSVrKqEV/E7CpW94E3Dg0/kfdp29OA747dIpHkjQBS36OPsnVwMuA\n1Ul2A5cCW4HrklwIPAKc203/DHAWsBP4AfDaMWSWJB2CJYu+qs4/wEOnLzC3gDf2DSVJWj7eAkGS\nGmfRS1LjLHpJapxFL0mNs+glqXEWvSQ1zqKXpMZZ9JLUOItekhrnPyWoFWFS/6ye1AKP6CWpcRa9\nJDXOopekxln0ktQ4i16SGmfRS1LjLHpJapxFL0mNs+glqXEWvSQ1zqKXpMZZ9JLUOItekhpn0UtS\n4yx6SWpcr6JPclGS+5Lcm+TqJD+b5MQkO5LsTHJtkqOXK6wk6dCNXPRJ1gJvAWar6leBo4DzgMuA\nD1bV84FvAxcuR1BJ0mj6nrpZBfxcklXA04HHgJcD13ePbwfO6bkNSVIPIxd9Ve0BPgB8g0HBfxe4\nE/hOVe3rpu0G1vYNKUkaXZ9TN8cBG4ETgecCzwDOOITnb04yl2Rufn5+1BiSpCX0OXXzu8DXq2q+\nqv4XuAF4CXBsdyoHYB2wZ6EnV9W2qpqtqtmZmZkeMSRJi+lT9N8ATkvy9CQBTgfuB24HXt3N2QTc\n2C+iJKmPPufodzC46HoX8NXuZ20D3gW8PclO4DnA5cuQU5I0olVLTzmwqroUuHS/4YeBU/v8XEnS\n8vEvYyWpcRa9JDXOopekxln0ktQ4i16SGmfRS1LjLHpJapxFL0mNs+glqXEWvSQ1zqKXpMZZ9JLU\nOItekhpn0UtS4yx6SWqcRS9JjbPoJalxFr0kNc6il6TGWfSS1DiLXpIaZ9FLUuMseklqnEUvSY2z\n6CWpcb2KPsmxSa5P8rUkDyT5zSTHJ7k1yUPd9+OWK6wk6dD1PaL/MPBPVfUrwK8BDwBbgNuq6iTg\ntm5dkjQhIxd9kmcDvw1cDlBV/1NV3wE2Atu7aduBc/qGlCSNrs8R/YnAPPA3Sb6c5BNJngGcUFWP\ndXMeB07oG1KSNLo+Rb8KOAX4WFW9GPhv9jtNU1UF1EJPTrI5yVySufn5+R4xJEmL6VP0u4HdVbWj\nW7+eQfE/kWQNQPd970JPrqptVTVbVbMzMzM9YkiSFjNy0VfV48CjSX65GzoduB+4CdjUjW0CbuyV\nUJLUy6qez38zcFWSo4GHgdcy+OVxXZILgUeAc3tuQ9JhtGHLzRPb9q6tZ09s2y3rVfRVdTcwu8BD\np/f5uZKk5eNfxkpS4yx6SWqcRS9JjbPoJalxFr0kNa7vxyt1hJnkR+8kjcYjeklqnEUvSY2z6CWp\ncRa9JDXOopekxln0ktQ4i16SGmfRS1LjLHpJapxFL0mNs+glqXEWvSQ1zqKXpMZZ9JLUOItekhpn\n0UtS4yx6SWqcRS9JjbPoJalxvYs+yVFJvpzkH7v1E5PsSLIzybVJju4fU5I0quU4on8r8MDQ+mXA\nB6vq+cC3gQuXYRuSpBH1Kvok64CzgU906wFeDlzfTdkOnNNnG5Kkfvoe0X8IeCfw4279OcB3qmpf\nt74bWNtzG5KkHkYu+iSvBPZW1Z0jPn9zkrkkc/Pz86PGkCQtoc8R/UuAVyXZBVzD4JTNh4Fjk6zq\n5qwD9iz05KraVlWzVTU7MzPTI4YkaTEjF31VXVxV66pqA3Ae8C9VdQFwO/Dqbtom4MbeKSVJIxvH\n5+jfBbw9yU4G5+wvH8M2JEkHadXSU5ZWVZ8HPt8tPwycuhw/V5LUn38ZK0mNs+glqXEWvSQ1zqKX\npMZZ9JLUOItekhpn0UtS4yx6SWqcRS9JjbPoJalxy3ILBElaDhu23DyR7e7aevZEtnu4eEQvSY2z\n6CWpcRa9JDXOopekxln0ktQ4i16SGmfRS1LjLHpJapxFL0mNs+glqXEWvSQ1zqKXpMZZ9JLUOO9e\nuQJN6g5/klamkY/ok6xPcnuS+5Pcl+St3fjxSW5N8lD3/bjliytJOlR9Tt3sA95RVScDpwFvTHIy\nsAW4rapOAm7r1iVJEzJy0VfVY1V1V7f8feABYC2wEdjeTdsOnNM3pCRpdMtyMTbJBuDFwA7ghKp6\nrHvoceCE5diGJGk0vYs+yTOBTwFvq6rvDT9WVQXUAZ63Oclckrn5+fm+MSRJB9Cr6JM8jUHJX1VV\nN3TDTyRZ0z2+Bti70HOraltVzVbV7MzMTJ8YkqRF9PnUTYDLgQeq6i+HHroJ2NQtbwJuHD2eJKmv\nPp+jfwnwh8BXk9zdjb0b2Apcl+RC4BHg3H4RJUl9jFz0VfWvQA7w8Omj/lxJ0vLyFgiS1DiLXpIa\nZ9FLUuMseklqnEUvSY2z6CWpcRa9JDXOopekxln0ktQ4i16SGmfRS1LjLHpJapxFL0mNs+glqXEW\nvSQ1rs8/PHLE27Dl5klHkLQMJvle3rX17LFvwyN6SWqcRS9JjbPoJalxFr0kNc6il6TGWfSS1DiL\nXpIaZ9FLUuMseklq3NiKPskZSR5MsjPJlnFtR5K0uLEUfZKjgI8CZwInA+cnOXkc25IkLW5c97o5\nFdhZVQ8DJLkG2Ajcv9wb8n4zkrS4cZ26WQs8OrS+uxuTJB1mE7t7ZZLNwOZu9b+SPDipLEtYDXxz\n0iFGtFKzr9TcYPZJWbHZc1mv7L90MJPGVfR7gPVD6+u6sf9XVduAbWPa/rJJMldVs5POMYqVmn2l\n5gazT4rZFzeuUzf/BpyU5MQkRwPnATeNaVuSpEWM5Yi+qvYleRPwz8BRwBVVdd84tiVJWtzYztFX\n1WeAz4zr5x9GU396aRErNftKzQ1mnxSzLyJVNe5tSJImyFsgSFLjjuiiT7I+ye1J7k9yX5K3duPv\nT/K1JPck+XSSY4eec3F3W4cHk7xiCrP/WZf77iS3JHluN54kH+my35PklGnLPvT4O5JUktXd+tRn\nT/LeJHu61/3uJGcNPWfi+8xir3mSN3f7+31J/nyacnc5DvSaXzv0eu9KcvcKyv6iJHd02eeSnNqN\nj2dfr6oj9gtYA5zSLf888O8Mbtnwe8Cqbvwy4LJu+WTgK8AxwInAfwBHTVn2Zw3NeQvw8W75LOCz\nQIDTgB3T9rp36+sZXMR/BFi9UrID7wX+eIH5U7HPLJL7d4DPAcd0j/3CNOVean8ZmvMXwHtWSnbg\nFuDMbvws4PNDy8u+rx/RR/RV9VhV3dUtfx94AFhbVbdU1b5u2h0M/g4ABrdxuKaqflhVXwd2Mrjd\nw2G3SPbvDU17BvDkRZiNwJU1cAdwbJI1hzV050DZu4c/CLyTp3LDysm+kKnYZxbJ/QZga1X9sHts\n7zTl7jIt+ponCXAucHU3tBKyF/Csbtqzgf/slseyrx/RRT8syQbgxcCO/R56HYPfsDClt3bYP3uS\n9yV5FLgAeE83beqzJ9kI7Kmqr+w3beqzd0Nv6v5z+4okx3VjU5d9v9wvAF6aZEeSLyT5jW7a1OWG\nA75PXwo8UVUPdesrIfvbgPd379MPABd308aS3aIHkjwT+BTwtuEj4iSXAPuAqyaVbSkLZa+qS6pq\nPYPcb5pkvsUMZ2fwOr+bp34xTbUFXvePAc8DXgQ8xuBUwtRZIPcq4HgGpwn+BLiuO0KeOgd6nwLn\n89TR/FRaIPsbgIu69+lFwOXj3P4RX/RJnsbg/4CrquqGofHXAK8ELqju5BkHcWuHw+lA2YdcBfxB\ntzzt2Z/H4HzqV5Ls6vLdleQXmf7sVNUTVfWjqvox8Nc8dapgarIfYH/ZDdzQnSr4EvBjBveNmZrc\nsOj7dBXw+8C1Q9NXQvZNwJPLf8+495dJXKCYli8GFzyuBD603/gZDG6pPLPf+Av5yYs8DzO5izwH\nyn7S0PKbgeu75bP5yYs8X5q2132/Obt46mLs1GcH1gwtX8TgHPHU7DOL5H498Kfd8gsYnDbItORe\nan/p3qtf2G9s6rMzOFf/sm75dODObnks+/ph/x8+TV/AbzG4KHIPcHf3dRaDizePDo19fOg5lzC4\niv8g3VXzKcv+KeDebvwfGFygfXKH+2iX/avA7LRl32/OcNFPfXbgb7ts9zC4r9Nw8U98n1kk99HA\n33X7zF3Ay6cp91L7C/BJ4PULPGeqs3fjdzL4hbQD+PVu/lj2df8yVpIad8Sfo5ek1ln0ktQ4i16S\nGmfRS1LjLHpJapxFL0mNs+glqXEWvSQ17v8ApNqW0K2lWVMAAAAASUVORK5CYII=\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "%matplotlib inline \n", - "import matplotlib.pyplot as plt\n", - "heads = np.random.binomial(500, .5, size=500)\n", - "histogram = plt.hist(heads, bins=10)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "# Task 1\n", - "## write a program to produce Fibonacci numbers up to 1000000" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Task 2\n", - "## write a program to simulate 1000 tosses of a fair coin (use np.random.binomial)\n", - "## Calculate the mean and standard deviation of that sample" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Task 3\n", - "## Produce a scatterplot of y = 0.5*x+e where x has gaussian (0, 5) and e has gaussian (0, 1) distributions \n", - "### use numpy.random.normal to generate gaussian distribution" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.5.2" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/spatel95.ipynb b/spatel95.ipynb new file mode 100644 index 0000000..435f6d0 --- /dev/null +++ b/spatel95.ipynb @@ -0,0 +1,241 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import IPython\n", + "import json\n", + "# Numpy is a library for working with Arrays\n", + "import numpy as np\n", + "# SciPy implements many different numerical algorithms\n", + "import scipy as sp\n", + "# Pandas is good with data tables\n", + "import pandas as pd\n", + "# Module for plotting\n", + "import matplotlib\n", + "#BeautifulSoup parses HTML documents (once you get them via requests)\n", + "import bs4\n", + "# Nltk helps with some natural language tasks, like stemming\n", + "import nltk\n", + "# Bson is a binary format of json to be stored in databases\n", + "import bson\n", + "# Mongo is one of common nosql databases \n", + "# it stores/searches json documents natively\n", + "import pymongo\n", + "print (\"IPython version: %6.6s\", IPython.__version__)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "#Here is what numpy can do\\n\",\n", + "print (\"Make a 2 row x 3 column array of random numbers\")\n", + "x = np.random.random((2, 3))\n", + "print (x)\n", + "\n", + "#array operation (as in R)\n", + "print (\"Add 5 to every element\")\n", + "x = x + 5\n", + "print (x)\n", + "\n", + "# get a slice (first row) (as in R)\n", + "print (\"Get the first row\")\n", + "print (x[0, :])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# IPython is quite modern: just press at the end of the unfinished statement to see the documentation\n", + "# on possible completions.\n", + "# In the code cell below, type x., to find built-in operations for x\n", + "x.any" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "%matplotlib inline \n", + "import matplotlib.pyplot as plt\n", + "heads = np.random.binomial(500, .5, size=500)\n", + "histogram = plt.hist(heads, bins=10)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "# Task 1\n", + "## write a program to produce Fibonacci numbers up to 1000000" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fibonacci Numbers: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040]\n" + ] + } + ], + "source": [ + "fibSequence = [0,1]\n", + "nthTerm=0;\n", + "i=0\n", + "while(1):\n", + " nthTerm = fibSequence[i-1] + fibSequence[i-2]\n", + " if(nthTerm > 1000000):\n", + " break\n", + " fibSequence.append(nthTerm)\n", + " \n", + "print(\"Fibonacci Numbers: \", fibSequence)\n", + " \n", + " \n", + " \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Task 2\n", + "## write a program to simulate 1000 tosses of a fair coin (use np.random.binomial)\n", + "## Calculate the mean and standard deviation of that sample" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean is: 0.6\n", + "Standard Deviation is: 0.48989794855663565\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "outcome = np.random.binomial(1,0.5,10)\n", + "size = len(outcome)\n", + "sum =0\n", + "for val in outcome:\n", + " sum += val\n", + "mean = sum/size;\n", + "\n", + "sum=0\n", + "for x in outcome:\n", + " x -= mean\n", + " x = x**2\n", + " sum += x\n", + "mean2 = sum/size\n", + "std = mean2** 0.5\n", + "\n", + "print(\"Mean is: \", mean)\n", + "print(\"Standard Deviation is: \", std)\n", + "\n", + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Task 3\n", + "## Produce a scatterplot of y = 0.5*x+e where x has gaussian (0, 5) and e has gaussian (0, 1) distributions \n", + "### use numpy.random.normal to generate gaussian distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD4CAYAAADvsV2wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAlG0lEQVR4nO3df5RcZZ3n8fe3KxWmE106SATSJARdNhwQSbQH8cDsThgliArtrwkszuqMZ7Ls0XMGhpM5YfBIQD0ym+OwO6srk1GP7ooYEGjDwBhQOOtMFMcOnRAiRH7IrwoD0dCopCGd7u/+UXWb6up7b92qul11q+/ndU6fVN+6VfepovnWU9/neb6PuTsiIjL39XS6ASIi0h4K+CIiOaGALyKSEwr4IiI5oYAvIpIT8zrdgDhHH320L1++vNPNEBHpGjt27PiVuy8Ouy/TAX/58uUMDw93uhkiIl3DzJ6Kuk8pHRGRnFDAFxHJicQB38y+bmYvmNlDVcc2mdkjZvagmd1uZn0Rj33SzHab2U4zU45GRKQDGunhfwM4r+bYPcBb3P2twC+AK2Mev9rdV7r7QGNNFBGRNCQO+O7+I+BAzbG73f1w5df7geNTbJuIiKQozVk6fwZsibjPgbvNzIG/d/fNKV5XRGROGBopsWnbXvaNjrGkr5f1a1YwuKo/tedPJeCb2VXAYeDGiFPOdveSmb0RuMfMHql8Ywh7rnXAOoBly5al0TwRkcwbGilx5W27GRufAKA0OsaVt+0GSC3otzxLx8w+DrwPuMQjai27e6ny7wvA7cAZUc/n7pvdfcDdBxYvDl07ICIy52zatncq2AfGxifYtG1vatdoKeCb2XnAXwEXuPvBiHMWmtnrg9vAucBDYeeKiOTVvtGxho43o5FpmTcBPwFWmNmzZvYJ4EvA6ymnaXaa2Q2Vc5eY2V2Vhx4D/IuZ7QL+FbjT3b+f2isQEZkDlvT1NnS8GYlz+O5+ccjhr0Wcuw84v3L7CeD0plonIpIT69esmJbDB+gtFli/ZkVq18h0LR0RkbwIBmYzP0tHRERaN7iqP9UAX0u1dEREckIBX0QkJxTwRURyQgFfRCQnFPBFRHJCAV9EJCcU8EVEckIBX0QkJxTwRURyQgFfRCQnFPBFRHJCAV9EJCcU8EVEckIBX0QkJxTwRURyoqGAb2ZfN7MXzOyhqmNHmdk9ZvZo5d9FEY/9WOWcR83sY602XEREGtNoD/8bwHk1xzYAP3T3k4AfVn6fxsyOAq4G3gGcAVwd9cEgIiKzo6GA7+4/Ag7UHL4Q+Gbl9jeBwZCHrgHucfcD7v4icA8zPzhERGQWpZHDP8bdn6vc/jfgmJBz+oFnqn5/tnJsBjNbZ2bDZja8f//+FJonIiKQ8qCtuzvgLT7HZncfcPeBxYsXp9QyERFJI+A/b2bHAVT+fSHknBKwtOr34yvHRESkTdII+FuBYNbNx4DvhZyzDTjXzBZVBmvPrRwTEZE2aXRa5k3AT4AVZvasmX0CuA54t5k9Cryr8jtmNmBmXwVw9wPAZ4GfVX6urRwTEZE2sXLaPZsGBgZ8eHi4080QEekaZrbD3QfC7tNKWxGRnFDAFxHJCQV8EZGcUMAXEckJBXwRkZxQwBcRyQkFfBGRnFDAFxHJCQV8EZGcUMAXEckJBXwRkZxQwBcRyQkFfBGRnFDAFxHJCQV8EZGcUMAXEcmJlgO+ma0ws51VP78xs8tqzvlDM3up6pzPtHpdERFpzLxWn8Dd9wIrAcysQHlz8ttDTv1nd39fq9cTEZHmpJ3S+SPgcXd/KuXnFRGRFqUd8C8Cboq4751mtsvM/snMTo16AjNbZ2bDZja8f//+lJsnIpJfqQV8M5sPXADcEnL3A8AJ7n468L+AoajncffN7j7g7gOLFy9Oq3kiIrmXZg//PcAD7v587R3u/ht3/13l9l1A0cyOTvHaIiJSR8uDtlUuJiKdY2bHAs+7u5vZGZQ/aH6d4rVFREINjZTYtG0v+0bHWNLXy/o1Kxhc1d/pZnVEKgHfzBYC7wb+a9WxSwHc/Qbgw8B/M7PDwBhwkbt7GtcWEYkyNFLiytt2MzY+AUBpdIwrb9sNkMugn0rAd/eXgTfUHLuh6vaXgC+lcS0RSUdYzxeYU73hTdv2TgX7wNj4BJu27e3q19WsNFM6ItIlwnq+67+7CxzGJ33qWLf3hveNjjV0fK5TaQWRHArr+Y5P+FSwDwS94dk2NFLirOvu5cQNd3LWdfcyNFJK5XmX9PU2dHyuU8AXyaFGeriz3RsOvm2URsdwXvtmkUbQX79mBb3FwrRjvcXCVPoqbxTwRXKokR7ubPeG4/LsrRpc1c8XPnga/X29GNDf18sXPnha16aoWqUcvkgOrV+zYloOH6BYsGk5fGhPb3i28+yDq/pzG+BrKeCL5FAQALMwS2dJXy+lkOCe1zz7bFLAF8mpqJ5vvQCf9kKmsG8bec6zzyYFfBFJbDYWMkV921AaJn0K+CKS2GwtZFKevT00S0dEEtNCpu6mHr5IF2okj55mzl0DrN1NPXyRLhO2UOnyLTtZHrJKNe1FTVrI1N0U8EW6TFgePZg5XxvQ017UpIVM3U0pHZGMikrF1MuXVw+ixuXcm0311A6wBnVwNMMm+xTwRTIobvpjVB69WhDoo849sreYyvRK1ZvvLkrpiGRQXComLI9eKxhEjcq5m9FwqiesouVs1sGR9KW5ifmTZrbbzHaa2XDI/WZmf2dmj5nZg2b2trSuLTKXDI2UInvw+0bHpuXRAazmnOpB1Kic++jB8cjnj2pT2EBxXDsle9JO6ax2919F3Pce4KTKzzuAr1T+FZGKoZFSeSOSCD1mnLjhzmm58nq5+LBFTZu27W1oemXcQHEYTdPMpnbm8C8E/k9lL9v7zazPzI5z9+fa2AaRTLvmjj2MT0SH0gkP340qLl8e9oGQpH5N9ePigrsxPfhrmmZ2pZnDd+BuM9thZutC7u8Hnqn6/dnKsWnMbJ2ZDZvZ8P79+1Nsnkj2vRiRagmTJFceNQ8fiJ1eWfu4OF55vKZpZl+aPfyz3b1kZm8E7jGzR9z9R40+ibtvBjYDDAwM1PtbE5kzmlkMVS9XHjeoun3DOZHTK3vMpr5N1NPf18v2Dec03HZpv9R6+O5eqvz7AnA7cEbNKSVgadXvx1eOieRe0KOOUjswG+gxC/2gCIJ31KBqaXRs2qrc2h590mCv9E13SaWHb2YLgR53/23l9rnAtTWnbQU+ZWbfoTxY+5Ly95Jn1TnyuB51scdYe8ZSbt1RmtFbn3CfMe/900O7ufH+p+umYkqjY1MDxGHfBKIUKm3t1yKrrpNWSucY4HYzC57z2+7+fTO7FMDdbwDuAs4HHgMOAn+a0rVFuk7tgqW4HvWmj5wOwJ0PPhcalKtX1g6NlBIF+8D4hHPZlp0NtX3Cfapnr2DfXVIJ+O7+BHB6yPEbqm478Mk0rifS7ZL2qAtmDD91ILR3Xy3I5W/atjdxsG9FGjXwpf200lakA5IuTJpw58b7n6774XBkb7Gh501DaXRs2qpbyT4FfJEOaGRhUpIeu1njz5uGNEouS/so4It0wPo1KyJn3jQjKJXQ6oyZZtuk+jndQQFfpI2C6ZKXb9mZaq69b0E5pTO4qp9FldvNiGvTwvmF2A8E1c/JPgV8kTZpZPVqo146OM6qa+/mxA134g7FQprfH8omHa5fu3KqaFst1c/JPgV8kQaElQhOqpG57gEDznrzUXXPm6RclsGB0bFx8HKPvFGLFhQp9oR/WMSVZ9YCrO6ggC+SUKv7wyZJeZz15qOm1aW5fu1Kbvzzd7Kg2Nj/quOTzivjkw09xoBTjnt9bCK/tjyz6ud0F+14JZJQXF2aJMEuyU5VP378AJecuYzPDZ42dWxopBRbQTNK0vIIAQe2P34g9pzqsQIF+O6jHr5IQq1u9pFkpyoHbrz/6Wk1bq64eRfjk40H/IKln8d/tcGUlGSLevgiCQyNlGbUfQ/UG6ysrpnTt6CI4RyMSbc4sHHrHjZu3VPOxzeht1jgbcuO5MePHwhtc2+x0PB4AsDB8UmGRkrq3Xcp9fBFEogrWbD65MWRj6vN+794cJzxCSdiXHTK6Nh4Q8G+r7c4lVPv6y0y6c72iGAf5Nybpfn23UsBXySBuLTNfY9Eb9SzceueGT3p8UmniQxNLLNyyuj6tSt5+dBhXj0c/g0iqF0/uKqfvt7w+fq9xZ7Yufyab9+9lNIRiZC0fHFUAPz00O6mUzKNevHgOFfetpseI3aAt7qtGy84lfW3TB8fKPYYX/jgWxlc1c/Ka+4Obb/m23cvBXyREI2UL17S1ztj39jVJy/mxvufbldzARLl5KuDdZCHj9oAfeMFp9bd91a6iwK+SIiki6R6iwVWn7yY9d/dNdWzLo2O8a02B/skjJm1duKmV9b7QJDuo4Avc05tb7uZIBWXpy6YMek+9dzX3LGnqXny7XbJmcsafh80335uaXnQ1syWmtl9ZvZzM9tjZn8Rcs4fmtlLZraz8vOZVq8rEqbV1bCBuDx1bXrnxYPtydO3YtGC4rTFXJJPaczSOQxc4e6nAGcCnzSzU0LO+2d3X1n5qd3vViQVcathG1EvTx18mKy/ZVejTWxZsKAq6bKqYo9x9ftPnb0GSddoOeC7+3Pu/kDl9m+BhwF9B5SOiErFlEbHEhc7C1JCSTSzArZVE+4UC5ZsYxTKe+IqLSOQ8jx8M1sOrAJ+GnL3O81sl5n9k5lFdjfMbJ2ZDZvZ8P790fObRcLEpWKSpHeqU0JZ1siYgYK9BFIbtDWz1wG3Ape5+29q7n4AOMHdf2dm5wNDwElhz+Pum4HNAAMDA9kfCZOWpTHIGli/ZsWMqYTVwoqdJZ1v3400Z16qpdLDN7Mi5WB/o7vfVnu/u//G3X9XuX0XUDSzo9O4tnS3tAZZA9Wle6NUp31qr99MsJ+NzUbSElf2QfInjVk6BnwNeNjd/zbinGMr52FmZ1Su++tWry3dr9lB1riNSAZX9bN9wzmJdmZqZlOSWps+fHpLj68V92HVqLiyD5I/afTwzwL+BDinatrl+WZ2qZldWjnnw8BDZrYL+DvgIvc59L1ZmhY1yBo3Dz7pt4IkOzMlydXH9d/TDM7B88V9WAWKPZZoRyvVvZFqLefw3f1fqDNDzN2/BHyp1WvJ3BO1KUhc7jnpRiS1K0X7FhRxh8u37Jzaqq8Qk7O3mPYFSqNjXLZlZ8wrbMzyN/Ry1nX3UhodiyzHDPC635s3NdVy07a9kW1UDl+qWZY72gMDAz48PNzpZsgsqq1ZA+VeeNyWeSduuLPulMQFxR6OKBYYPTg+Vdvm1h2lGdeJS+f8j7UrGVzVPxWAOyEI+n29RV4+dHja7Jzq96mZ91HmJjPb4e4DYfepPLJ0VDP7oybptR4cn5za1DuobRP2rSBOkCbqZLEwp/yeLDxi3oypmNVjHdpnVpJQD1+6TlhvdrYEdXPMSL2GfVJBvjTs8gb88rr3trE1knVxPXwVT5OuE/Ra08ydRwny+53sFwXfaBod6xCppZSOdKXBVf2pz5DJomBWUZIZRyL1KOBL1woLgt2sv6+Xj565LDQPrxy9pEEpHela1dMua6cxVs/S6VtQ5HevHO5IobOkDNi+4ZzYc1SbXlqlgC9dLWkQHBop8de3PcjB8fDNvTtNuXhpB6V0JDc8cQX59lMuXtpBPXzpGq1U1dy4dU9bpnE2Y0GxR6kaaQsFfMm0IMjX5uiD+jkQXu+9+sNhwfwCLx/KZrAHmD9v5sBzmiWjRQIK+JJZtQusaodcx8YnuKyqLk5QYuCaO/ZM22c2y8Ee4KWx6Xvi1r7ueh9uIkkp4EsmhPVok5YuDgLiLcNP8+PHDyTa+i9LagdskxaHE2mUAr503NBIifW37JqaNhlsDt7INMqx8Qm2P35gtpo4q4IB2+r0VRiVOpZWKeBLx23cumdGcB+fLNevyXCpp1QsWlCMrHZZS1M3pVWalikdN1qTww64Z3v7wFb1FgvTatrHBXuVUZA0pLWn7XlmttfMHjOzDSH3H2FmWyr3/9TMlqdxXcmuuC0IG+LlXvBcU1saIS5dozIKkpaWUzpmVgC+DLwbeBb4mZltdfefV532CeBFd//3ZnYR8DfA2lavLdnU6CyTRQuK02bVVBufdBbMn4d79DeB2bRwfoGDhyZSGwiOKmcctbNWsOWhSBrS6OGfATzm7k+4+yHgO8CFNedcCHyzcvu7wB8Fm5rL3JNkY/LqbwAAPTF/DftGx2ZMXWyXV8YnU531E5WHVzVMaYc0Bm37gWeqfn8WeEfUOe5+2MxeAt4A/Kr2ycxsHbAOYNmyZSk0T9otKj1RGh1j1bV388r4BGNVNW1ePDhOsWD4hIcG17h68LNtwj12b9lGxAXw2v13tdhKZkPmZum4+2ZgM5R3vOpwcyREvVWgcRt/R6ZuJpxFIVUtiz3G+jUrGH7qAN+6/+l0X0hCDg0H/d5igQ+9vZ/7HtmfOICrGqbMtjQCfglYWvX78ZVjYec8a2bzgCOBX6dwbWmzJPn59WtWNLUFYeiHQSXVc98j+5tvdAqCvWVLo2MUzKZ2wgqzaEGRq99/qoK3ZE4aAf9nwElmdiLlwH4R8J9rztkKfAz4CfBh4F7P8ma6EinJKtDaOvWtGJ9wNm7d05EB22q1g6dh8+YNuOTMZXxu8LQOtFCkvpYHbd39MPApYBvwMHCzu+8xs2vN7ILKaV8D3mBmjwF/CcyYuindIS4/Xz0Fc3BVP9s3nJPKNoSdDva9xQKrT148bZopMLUDFZQ3O3fK30SanoIqMsssyx3tgYEBHx4e7nQzpMpZ191bt9feWyxMzRtPsoI0i4JVvv19vaw+eTG37ihNew3BawRmvL7q1y/Sbma2w90HQu9TwJdGJA3gBTMm3VlSCZg3/fSZ2Lx31lSncKI+5PpjZg9p/rx0SlzAV2kFaUiwmXa91a8TXp5iWRod49YdJS5+x9LY87OmOohHpbH2jY7F3ieSNQr40rDBVf0smJ98vH9sfIKbfvpM/RMzpFC1LjBqsdSSvt7Y+0SyRgE/55qtedNoD7ab0jkwvb1xq2C1Qla6SeYWXkn7tLKzUtziqrmgenZRklWwWiEr3UCDtjkWNxgZNuD46aHdU4OvPQYN7E+SabWraDXLRrpZ3KCtevg5FjfgODRSil3wNFeCfbFgrP39pQ2VQBDpVsrh51jUwOKRvUXW37Kr4wueZtuiBUU2ffh0Pjd4Gts3nMP1a1cCcPmWna3V8BfJKPXwcyys5k1vsYAZDe0n223CUlatjGeIdAv18HMsmFPf39eL8drOSqMRFS3nitUnL55xLKpG0BU371JPX+YM9fBzrrYk79BIiZ461SA7odhjqX3rCKu8GTWeMeGunr7MGerhy5QgrZG1YG+km2IKC+5xC6Vqd+sS6Vbq4edc9WYmWezZw8yNRwo9Rg9OsGlWj8E733QUe/b9NtFAc21wHxopcfDQ4djHqFSCzAUK+DlWO1CZxWAfZmLSObZq4LWRipy1q2CTPlalEmQuUMDPoHpbCKYlbKCyW1QvGEv6OvojVsjWe6xKJchcoYCfMe2cHtjtaYpgo5UkryNq9XDcYw20EEvmlJYCvpltAt4PHAIeB/7U3UdDznsS+C0wARyOWvYrybYQbFXwDaKRBE5fb5Gx8QlePTyZShvSEHwQJqnrExXYox6revYyF7U6S+ce4C3u/lbgF8CVMeeudveVCvbx4rYQTEPwDaKR5+vv6+V9px+XqWAPr30QhlWsrBWVg1e1S8mTlgK+u99d2dMW4H7g+NablG9Rgckg8QKguJLHcTnrRQuKFHts2jGjvFDpxp8+nejazSgWrP5JEfaNjk1bQAblNleLC+BRi8+UwpG5KLVqmWZ2B7DF3b8Vct8vgRcpz7D7e3ffHPM864B1AMuWLXv7U089lUr7usXQSInLt+wMTbckSTOEzTqprv544oY7Q5/bgOvXruSq23fz8qH2DeQunF/g8x84jWvu2MOLlRW+C4o9zJ9X4KWx8bpbJEaVSVC5YsmrlqplmtkPgGND7rrK3b9XOecq4DBwY8TTnO3uJTN7I3CPmT3i7j8KO7HyYbAZyuWR67Vvrhlc1c9lW3aG3pdkcLLeGEBUzvrI3mLTm4339/Wy/A293P/Eiw1N7SwWjM9/oLwR+Cvjr6WLDo5P4hjXr105FagHTjgq9IMsrOdeu3pYRMrqpnTc/V3u/paQnyDYfxx4H3CJR3xdcPdS5d8XgNuBM1J7BXNQf0RaJ8lc8LgxgLOuu5fVJy8OzVmb0VSwD1I+Dzz9UkPB3oC1v7+UwVX9sR9SAaVeRFrX6iyd84C/Av6Tux+MOGch0OPuv63cPhe4tpXrznVRVSzjBhKTzLwJNhT/0Nv7ufPB56ZSKEfM65m63SgHbrz/6YZm/ASPC2raJN0IXD13kda0lMM3s8eAI4BfVw7d7+6XmtkS4Kvufr6ZvYlyrx7KHzDfdvfPJ3n+PO941UgeupGVplDuXc9LsRhZKwpm/F6xJ3LcIGyxlIhEi8vha4vDFHVqsDBqq8JuUugxJiI+gAy45MxlfG7wtPY2SqQLxQV8VctMSfX8due1FbLtqKXe7StmASYnPXLsIkgbqS69SGsU8FOSZOAxSty8+SSiBnP7eosNPU89zc+WL9ezX7Qguj0ObN9wTuQ1HFSiWKRFCvgpSTrwWCuNbwZRq0U3XnBqqkHfKefck+jrLU4L8AuPmMfV7z818vHB8biZSHPhm4xIJyngpyQqUNWbStnKN4NA3JTFjRecOmP1LJRz5s18GCSdejk+McnvXnmtxvzo2DhX3rabM9+0KPT8i9+xFCh/eEV9pKhEsUhrFPBT0mxNlma/GdQaXNXP9g3n8Mvr3sv2DedMDRYPrupn00dOp7f42n/qHoOLz1jKzqvPjcybt+rlQxMzZgGNjU/w5K/H+OiZy6Z69AUzPlo1IDu4qp9LzlzWUHkEEUlG5ZFTEgTYRmfpRK18Tb83+1oInXS4dUeJgROOavvsnn2jY3xu8LTYGTefGzyNgROOUnkEkZQp4KeomYVBzSyyalRc2qjQ5m0Nk36QaZGVSPoU8Dus2W8G1erN/49LG7VzFYbSMiKdpYCfAfV6s3EBPckOWfXSRrOV1ikWjIXz501VvVRaRqSzNGibcfWmbSaZ5RM3oBy3eUhvsTBtsLcRfb1FNn34dHZefS6/vO69rF+zgk3b9ja91kBEWqcefsbVK3cc1TuvTeMcMa9n2vMcMa8cyIMe9xU375qRyx8bn6jMpbfEdXrCat+0c59eEYmmHn7GxeXf43rJTrnGzqeHdnPlbbsZHZteDTOYFx9sBD4ZMXA7enB82m5ScYLNSGqDeBprDUSkdQr4GRe3oKtewCyNjnHj/U9H9s7Hxie45o49da8TzPGvF/QbXVOglbMi7aWAn3Fx+fckAbPeLJwXD44zNFKqu3BsaKTEwUOHw55iSqOrjbVyVqS9FPAzLq5sQloBMxgPiLpOkIOvt0nKy68eDk0zNbsKWUTSpUHbDKudjlm9xyuUA+n6W3a1vJFJ8E0hanpoWA4eyiUaqi8djAsEzxVIY62BiLSu1S0ONwJ/DuyvHPprd78r5LzzgP8JFCjvhHVdK9edC+otlkoysyX4d+PWPTMGZastnF+I3FEK6qdWolJHYZ8z1TOIqmnlrEjnpZHSud7dV1Z+woJ9Afgy8B7gFOBiMzslheuGarW2fDskKYlcb2ZL8Dov37KThUfMi6x82ddb5PMfOC12rn291EqjqSMNxopkUzty+GcAj7n7E+5+CPgOcOFsXKiTu04lNTRS4oqbd9WdplhvOmbt63z50OEZZZCDmvjV+Xl4rfZ8dZ4+TlQOPupDRoOxItmURg7/U2b2X4Bh4Ap3f7Hm/n7gmarfnwXeEfVkZrYOWAewbNmyhhpSb5FSpwWBOqpYWRDkh0ZK9EQUNQumY9a+zvEJZ9GCIgvmzwtNE0WlVIJvCnG59agcPDDrhd9EJD11A76Z/QA4NuSuq4CvAJ+lPPvvs8AXgT9rpUHuvhnYDOVNzBt5bNbne0cNfgb6FhRZec3dkfn4IJhevmVn6P2jB8cZ+cy5ddsRjB+URscwXpu6GbcCNi4Hr8FYke5QN+C7+7uSPJGZ/QPwjyF3lYClVb8fXzmWuvbVlm9O3AdPsWD87pXDkTNuCmZT6ZcgWNdK8jprB4Nrr9boNyINxop0j5Zy+GZ2XNWvHwAeCjntZ8BJZnaimc0HLgK2tnLdKFmf7x0VkAtWrioZN71y0n0qsEYVPIuaB1+t3rcMmL3qmSLSWa0O2v53M9ttZg8Cq4HLAcxsiZndBeDuh4FPAduAh4Gb3X1Pi9cNFbd4KAuiPpC++Men81LMtEqY/mERvM7qTcJhen2cKEnSW0k3KheR7tLSoK27/0nE8X3A+VW/3wXMmLI5G7KcYohbgBSVpoHwbynBY2pXv9ZLyUSlvaq1cwcsEWkflVZos6AQ2fVrVwJw+ZadnHXdvaw+eXFommbRgmLkt5RmBqnj6t8HZmtjcxHpLJVW6ICwVbS37ijxobf3c98j+xPPeGlmkLr6W0btLB3I1piHiKRLAb+iXqmDVs+vFrVe4L5H9rN9wzmJ29zsBujVaa9WXoeIdBcFfBrfkane+a1sKt6INIqSZXnMQ0TSpYBP4yt069W5aXVT8UYoYItIUhq0Jb2dmvaNjrW8qbiIyGxRwCe9nZqW9PUm+pDI+noBEZmbFPBpvMcdd37SD4lgeuYvr3tv6MbfIiJpUw6fxgc/652vCpIikkXmGV5VOTAw4MPDw51uRsM01VFEOsXMdrj7QNh96uHPAs2cEZEsUsCfBUl7+PomICLtpICfsqSLuBpd7CUi0irN0klZknn4jZwnIpIW9fBJN7WSdLFW1rdjFJG5J/c9/CC1Uhodw3kttVJv56goSefhN7qoS0SkVa1ucbjFzHZWfp40s50R5z1Z2Rlrp5llZp7l0EiJK27elWpqJekiLpVXEJF2a3XHq7XBbTP7IvBSzOmr3f1XrVwvTUHPPmp3p2ZTK0kXcaVR6VJEpBGp5PDNzIA/BpIXc++wept5t5JaSToPX/P1RaSd0srh/wHwvLs/GnG/A3eb2Q4zWxf3RGa2zsyGzWx4//79KTVvprgevFIrIjIX1e3hm9kPgGND7rrK3b9XuX0xcFPM05zt7iUzeyNwj5k94u4/CjvR3TcDm6FcWqFe+5oVVZO+YKbKlSIyJ9UN+O7+rrj7zWwe8EHg7THPUar8+4KZ3Q6cAYQG/HaJ2h5QwV5E5qo0UjrvAh5x92fD7jSzhWb2+uA2cC7wUArXbYlq0otI3qQxaHsRNekcM1sCfNXdzweOAW4vj+syD/i2u38/heu2TIOmIpInLQd8d/94yLF9wPmV208Ap7d6HRERaU3uV9qKiOSFAr6ISE4o4IuI5IQCvohITmR6T1sz2w881eLTHA1kpoZPHWrr7Omm9nZTW6G72puHtp7g7ovD7sh0wE+DmQ1HbeibNWrr7Omm9nZTW6G72pv3tiqlIyKSEwr4IiI5kYeAv7nTDWiA2jp7uqm93dRW6K725rqtcz6HLyIiZXno4YuICAr4IiK5MScDvpl9xMz2mNmkmQ1UHV9uZmNVG6/f0Ml2BqLaW7nvSjN7zMz2mtmaTrUxjJltNLNS1ft5fqfbVMvMzqu8d4+Z2YZOt6ceM3vSzHZX3s/hTrenmpl93cxeMLOHqo4dZWb3mNmjlX8XdbKN1SLam8m/WTNbamb3mdnPK7HgLyrHU31/52TAp1xv/4OEb7LyuLuvrPxc2uZ2RQltr5mdQrn89KnAecD/NrNC+5sX6/qq9/OuTjemWuW9+jLwHuAU4OLKe5p1qyvvZ9bmi3+D8t9htQ3AD939JOCHld+z4hvMbC9k82/2MHCFu58CnAl8svK3mur7OycDvrs/7O57O92OpGLaeyHwHXd/1d1/CTxGebcwSeYM4DF3f8LdDwHfofyeShMq25IeqDl8IfDNyu1vAoPtbFOciPZmkrs/5+4PVG7/FngY6Cfl93dOBvw6TjSzETP7f2b2B51uTB39wDNVvz9bOZYlnzKzBytfnzPzdb6iG96/Wg7cbWY7zGxdpxuTwDHu/lzl9r9R3vAo67L8N4uZLQdWAT8l5fe3awO+mf3AzB4K+YnrwT0HLHP3VcBfAt82s3+X4fZ2XJ12fwV4M7CS8nv7xU62dY44293fRjkN9Ukz+4+dblBSXp7jnfV53pn+mzWz1wG3Ape5+2+q70vj/U1ji8OOqLe5esRjXgVerdzeYWaPA/8BmPXBsWbaC5SApVW/H1851jZJ221m/wD84yw3p1Edf/8a5e6lyr8vmNntlNNSYWNRWfG8mR3n7s+Z2XHAC51uUBx3fz64nbW/WTMrUg72N7r7bZXDqb6/XdvDb4aZLQ4GPc3sTcBJwBOdbVWsrcBFZnaEmZ1Iub3/2uE2Tan8AQY+QAY2p6/xM+AkMzvRzOZTHgDf2uE2RTKzhWb2+uA2cC7Ze09rbQU+Vrn9MeB7HWxLXVn9mzUzA74GPOzuf1t1V7rvr7vPuR/K/yGfpdybfx7YVjn+IWAPsBN4AHh/p9sa197KfVcBjwN7gfd0uq017f6/wG7gwcof5nGdblNIG88HflF5D6/qdHvqtPVNwK7Kz56stRe4iXIaZLzy9/oJ4A2UZ488CvwAOKrT7azT3kz+zQJnU07XPFiJTzsrf7upvr8qrSAikhO5SumIiOSZAr6ISE4o4IuI5IQCvohITijgi4jkhAK+iEhOKOCLiOTE/wdWit1pd6ZBMgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "x= np.random.normal(0,5,500)\n", + "e = np.random.normal(0,1,500)\n", + "y = 0.5*x+e\n", + "plt.scatter(x,y)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.2" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +}