From 18b7858ae35b8f41893543fd7419cd24ad169c70 Mon Sep 17 00:00:00 2001 From: jaredba Date: Tue, 1 Sep 2020 00:37:59 +0000 Subject: [PATCH] submit --- jalle119.ipynb | 284 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 284 insertions(+) create mode 100644 jalle119.ipynb diff --git a/jalle119.ipynb b/jalle119.ipynb new file mode 100644 index 0000000..7044b0d --- /dev/null +++ b/jalle119.ipynb @@ -0,0 +1,284 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 10, + "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": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Make a 2 row x 3 column array of random numbers\n", + "[[0.87197003 0.72375138 0.2182147 ]\n", + " [0.44168127 0.89507994 0.80098076]]\n", + "Add 5 to every element\n", + "[[5.87197003 5.72375138 5.2182147 ]\n", + " [5.44168127 5.89507994 5.80098076]]\n", + "Get the first row\n", + "[5.87197003 5.72375138 5.2182147 ]\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": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "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", + "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": [ + "num1 = 0 \n", + "print(num1)\n", + "\n", + "num2 = 1\n", + "\n", + "newNum = num1 + num2 \n", + "\n", + "while (newNum < 1000000):\n", + " print(newNum)\n", + " newNum = num1 + num2\n", + " num1 = num2 \n", + " num2 = newNum" + ] + }, + { + "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": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Standard Deviation 0.49993599590347565\n", + "Mean 0.508\n" + ] + } + ], + "source": [ + "sample = np.random.binomial (1, 0.5, 1000)\n", + "print(\"Standard Deviation \", np.std(sample))\n", + "print(\"Mean \", np.mean(sample))" + ] + }, + { + "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": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "e = np.random.normal ( 0, 1, 100 )\n", + "x = np.random.normal ( 0, 5, 100 )\n", + "\n", + "plt.scatter (x, 0.5*x+e)\n", + "plt.show()\n" + ] + }, + { + "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 +}