From 1aa1bcaa8a7ded134e9d9470ada8a931b768c929 Mon Sep 17 00:00:00 2001 From: dnguye201 Date: Tue, 1 Sep 2020 06:08:11 +0000 Subject: [PATCH 1/2] finished Assignment 0 --- dnguye18.ipynb | 323 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 323 insertions(+) create mode 100644 dnguye18.ipynb diff --git a/dnguye18.ipynb b/dnguye18.ipynb new file mode 100644 index 0000000..efc492f --- /dev/null +++ b/dnguye18.ipynb @@ -0,0 +1,323 @@ +{ + "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": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\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": [ + " x = 0\n", + " y = 1\n", + " \n", + " print(x)\n", + " while y < 1000000:\n", + " print(y)\n", + " x,y = y,x+y\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": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean : 0.506 Standard Deviation: 0.4999639987039066\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "test = np.random.binomial(1, .5, 1000)\n", + "\n", + "mean = np.mean(test)\n", + "\n", + "std = np.std(test)\n", + "\n", + "print('Mean : ', mean, 'Standard Deviation: ', std)" + ] + }, + { + "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": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "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 plot():\n", + " x = np.random.normal(0,5)\n", + " e = np.random.normal(0,1)\n", + " return(x, 0.5*x+e)\n", + "\n", + "xaxe = []\n", + "yaxe = []\n", + "\n", + "for i in range(1000):\n", + " x, y = plot()\n", + " xaxe.append(x)\n", + " yaxe.append(y)\n", + " \n", + "plt.scatter(xaxe,yaxe)\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "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 +} From f143bbb3f678e1bd9df089942bd3c2c51d306428 Mon Sep 17 00:00:00 2001 From: dnguye201 Date: Tue, 8 Sep 2020 04:16:47 +0000 Subject: [PATCH 2/2] dsadsa --- dnguye18.ipynb | 323 ------------------------------------------------- 1 file changed, 323 deletions(-) delete mode 100644 dnguye18.ipynb diff --git a/dnguye18.ipynb b/dnguye18.ipynb deleted file mode 100644 index efc492f..0000000 --- a/dnguye18.ipynb +++ /dev/null @@ -1,323 +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": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0\n", - "1\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": [ - " x = 0\n", - " y = 1\n", - " \n", - " print(x)\n", - " while y < 1000000:\n", - " print(y)\n", - " x,y = y,x+y\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": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Mean : 0.506 Standard Deviation: 0.4999639987039066\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "\n", - "test = np.random.binomial(1, .5, 1000)\n", - "\n", - "mean = np.mean(test)\n", - "\n", - "std = np.std(test)\n", - "\n", - "print('Mean : ', mean, 'Standard Deviation: ', std)" - ] - }, - { - "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": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "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 plot():\n", - " x = np.random.normal(0,5)\n", - " e = np.random.normal(0,1)\n", - " return(x, 0.5*x+e)\n", - "\n", - "xaxe = []\n", - "yaxe = []\n", - "\n", - "for i in range(1000):\n", - " x, y = plot()\n", - " xaxe.append(x)\n", - " yaxe.append(y)\n", - " \n", - "plt.scatter(xaxe,yaxe)\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "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 -}