From ab636af859a06c6bfa3a2be9ffdacf1a6b40f216 Mon Sep 17 00:00:00 2001 From: johnpi1 Date: Tue, 1 Sep 2020 17:48:14 +0000 Subject: [PATCH] finished project0 --- Practice0.ipynb | 198 ------------------------------ jpi.ipynb | 312 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 312 insertions(+), 198 deletions(-) delete mode 100644 Practice0.ipynb create mode 100644 jpi.ipynb 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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\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/jpi.ipynb b/jpi.ipynb new file mode 100644 index 0000000..8cf1860 --- /dev/null +++ b/jpi.ipynb @@ -0,0 +1,312 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "IPython version: %6.6s 7.17.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": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Make a 2 row x 3 column array of random numbers\n", + "[[0.16789125 0.55729518 0.96644339]\n", + " [0.05493288 0.52254218 0.01083913]]\n", + "Add 5 to every element\n", + "[[5.16789125 5.55729518 5.96644339]\n", + " [5.05493288 5.52254218 5.01083913]]\n", + "Get the first row\n", + "[5.16789125 5.55729518 5.96644339]\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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\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": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "0\n", + "1\n", + "2\n", + "3\n", + "5\n", + "8\n", + "13\n", + "21\n", + "34\n", + "55\n", + "89\n", + "144\n", + "233\n", + "377\n", + "610\n", + "987\n", + "1597\n", + "2584\n", + "4181\n", + "6765\n", + "10946\n", + "17711\n", + "28657\n", + "46368\n", + "75025\n", + "121393\n", + "196418\n", + "317811\n", + "514229\n", + "832040\n" + ] + } + ], + "source": [ + "n1 = 0\n", + "n2 = 1\n", + "curr = 0\n", + "print(n1)\n", + "print(n2)\n", + "\n", + "while(curr<1000000):\n", + " print(curr)\n", + " curr = n1 + n2\n", + " n1=n2\n", + " n2=curr" + ] + }, + { + "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": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean: 0.491 Standard Deviation: 0.4999189934379369\n" + ] + } + ], + "source": [ + "import math \n", + "\n", + "n = 1000\n", + "p = .5\n", + "\n", + "s = np.random.binomial(1,p,n)\n", + "mean = np.mean(s)\n", + "std = np.std(s)\n", + "print('Mean:', mean, \"Standard Deviation:\", std)\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": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plotfunc():\n", + " x = np.random.normal(0,5)\n", + " e = np.random.normal(0,1)\n", + " y = 0.5*x+e\n", + " xx.append(x)\n", + " yy.append(y)\n", + " return (x, y) \n", + "\n", + "xx = []\n", + "yy = []\n", + "\n", + "count = 0\n", + "while (count < 1001):\n", + " count=count+1\n", + " plotfunc()\n", + " \n", + "plt.scatter(xx,yy)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.2" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +}