diff --git a/wboyd8.ipynb b/wboyd8.ipynb new file mode 100644 index 0000000..47f3bf5 --- /dev/null +++ b/wboyd8.ipynb @@ -0,0 +1,285 @@ +{ + "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": 12, + "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": [ + "n1 = 0\n", + "n2 = 1\n", + "count = 0\n", + " \n", + "while n1 <= 1000000:\n", + " print(n1)\n", + " nth = n1 + n2\n", + " n1 = n2\n", + " n2 = nth\n", + " count += 1" + ] + }, + { + "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.511\n", + "stdev 0.49987898535545583\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "result = np.arange(1000)\n", + "for i in range(0, 1000):\n", + " result[i] = np.random.binomial(1,0.5)\n", + " i+=1\n", + "print(\"mean\", np.mean(result))\n", + "print(\"stdev\", np.std(result))" + ] + }, + { + "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": 14, + "metadata": {}, + "outputs": [ + { + "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", + "x = np.random.normal(0, 5, 100)\n", + "e = np.random.normal(0, 1, 100)\n", + "y = 0.5 * x + e\n", + "plt.plot(x, y, 'o')\n", + "plt.show()" + ] + }, + { + "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 +}