From cb5b95b3e670466bcb593975cfbbe10c466ccd83 Mon Sep 17 00:00:00 2001 From: JGray17 Date: Fri, 4 Sep 2020 00:03:03 +0000 Subject: [PATCH] Final submission --- jgray51.ipynb | 308 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 308 insertions(+) create mode 100644 jgray51.ipynb diff --git a/jgray51.ipynb b/jgray51.ipynb new file mode 100644 index 0000000..d743a0a --- /dev/null +++ b/jgray51.ipynb @@ -0,0 +1,308 @@ +{ + "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": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "1\n", + "1\n", + "1\n", + "2\n", + "2\n", + "3\n", + "4\n", + "5\n", + "7\n", + "9\n", + "12\n", + "16\n", + "21\n", + "28\n", + "37\n", + "49\n", + "65\n", + "86\n", + "114\n", + "151\n", + "200\n", + "265\n", + "351\n", + "465\n", + "616\n", + "816\n", + "1081\n", + "1432\n", + "1897\n", + "2513\n", + "3329\n", + "4410\n", + "5842\n", + "7739\n", + "10252\n", + "13581\n", + "17991\n", + "23833\n", + "31572\n", + "41824\n", + "55405\n", + "73396\n", + "97229\n", + "128801\n", + "170625\n", + "226030\n", + "299426\n", + "396655\n", + "525456\n", + "696081\n", + "922111\n" + ] + } + ], + "source": [ + "num1 = 0\n", + "num2 = 1\n", + "num3 = 0\n", + "temp = 0\n", + "\n", + "print(num1)\n", + "print(num2)\n", + "\n", + "while(num3 <= 1000000):\n", + " temp = num1 + num2\n", + " num1 = num2\n", + " num2 = num3\n", + " num3 = temp\n", + " if(num3 <= 1000000):\n", + " print(num3)" + ] + }, + { + "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": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.46 0.49839743177508444\n" + ] + } + ], + "source": [ + "data = np.random.binomial(1, .5, 1000)\n", + "\n", + "mean = sum(data)/1000\n", + "stdv = np.std(data)\n", + "\n", + "print(mean, stdv)" + ] + }, + { + "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": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.random.normal(0, 5, 100)\n", + "e = np.random.normal(0, 5, 100)\n", + "y = 0.5*x+e\n", + "plot = plt.scatter(x, y)" + ] + }, + { + "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 +}