diff --git a/.ipynb_checkpoints/Traffic Simulation-checkpoint.ipynb b/.ipynb_checkpoints/Traffic Simulation-checkpoint.ipynb new file mode 100644 index 0000000..565b005 --- /dev/null +++ b/.ipynb_checkpoints/Traffic Simulation-checkpoint.ipynb @@ -0,0 +1,208 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Traffic Simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import random\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import math\n", + "import statistics\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import random\n", + "\n", + "class Road:\n", + " \n", + " def __init__(self):\n", + " self.road = 1000\n", + " \n", + " def __str__(self):\n", + " return self.road\n", + "\n", + " \n", + "class Car:\n", + " #defining the different attributes of a car\n", + " def __init__(self, location, car_following=None):\n", + " self.speed = 0\n", + " self.min_distance = int(self.speed + 15)\n", + " self.location = location\n", + " self.car_following = car_following\n", + " self.top_speed = 33\n", + " \n", + " def accelerate(self):\n", + " if self.speed < self.top_speed:\n", + " self.speed += 2\n", + " return\n", + " else:\n", + " self.speed = self.car_following.speed\n", + " return\n", + " # a car has a 10% chance of slowing down\n", + " def slow_down(self):\n", + " random_slow = random.randint(1,10)\n", + " if random_slow == 1:\n", + " self.speed -= 2\n", + " if self.speed < 0:\n", + " self.speed = 0\n", + " \n", + " def simulation(self):\n", + " if self.car_following.location > self.min_distance:\n", + " self.accelerate()\n", + " self.slow_down()\n", + " self.location += self.speed\n", + " if self.location >= road.road:\n", + " self.location -= road.road\n", + " #This function is starting the traffic simulation.\n", + " #It is telling cars to speed up if there is too much distance between them.\n", + " #Cars will also be randomly slowing down and if the cars go past 1000m then they will go to the beginnning.\n", + " \n", + "\n", + "\n", + "road = Road()\n", + "car_list = []\n", + "location = 1000\n", + "car_in_front = None\n", + "car_locations = []\n", + "road_log = []\n", + "in_range = []\n", + "one_minute_log = []\n", + "cars_speed = []\n", + "\n", + "# this is generating a list of 30 cars\n", + "for x in range(30):\n", + " spawn_car = Car(location, car_in_front)\n", + " car_list.append(spawn_car)\n", + " car_list[0].car_following = car_list[-1]\n", + " location -= 33\n", + " car_in_front = spawn_car\n", + "\n", + "# This is simulating the race for 1 minute(60 iterations)\n", + "for x in range(60):\n", + " for car in car_list:\n", + " car.simulation()\n", + " [cars_speed.append(car.speed)]\n", + " [car_locations.append(car.location)]\n", + " [in_range.append(x)]\n", + " [road_log.append(car_locations)]\n", + " one_minute_log.append(in_range)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAAJPCAYAAADxOCSxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAOwIjQAAAADYERoBAAAAsPMNqr9UBya4Oz4AAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = traffic_log\n", + "y = one_minute_log\n", + "plt.rcParams['figure.figsize'] = 20, 10\n", + "plt.scatter(x, y, marker = \"_\", c=['r','k'])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##Optimal Speed" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average Speed: 27.61777777777778\n", + "Variance: 81.66279506172839\n", + "Standard Deviation: 9.036746929162529\n", + "Optimal_speed: 36.65452470694031\n" + ] + } + ], + "source": [ + "average_speed = statistics.mean(cars_speed)\n", + "print(\"Average Speed: {}\".format(average_speed))\n", + "var = []\n", + "for x in cars_speed:\n", + " var.append((x - average_speed)**2)\n", + "var = statistics.mean(var)\n", + "print(\"Variance: {}\".format(var))\n", + "stdv = var**(.5)\n", + "print(\"Standard Deviation: {}\".format(stdv))\n", + "optimal_speed = average_speed + stdv\n", + "\n", + "print(\"Optimal_speed: {}\".format(optimal_speed))" + ] + }, + { + "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.4.3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/.ipynb_checkpoints/Untitled-checkpoint.ipynb new file mode 100644 index 0000000..f7feb7e --- /dev/null +++ b/.ipynb_checkpoints/Untitled-checkpoint.ipynb @@ -0,0 +1,743 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 2, 3, 4, 5])" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "list_of_nums = np.array([1,2,3,4,5])\n", + "matrix_of_nums = np.array([[1,2,3],\n", + " [4,5,6],\n", + " [7,8,9]])\n", + "list_of_nums" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 2, 3],\n", + " [4, 5, 6],\n", + " [7, 8, 9]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix_of_nums" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-1, 1, 3, 5, 7])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_of_nums * 2 - 3" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1, 8, 27],\n", + " [ 64, 125, 216],\n", + " [343, 512, 729]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix_of_nums ** 3" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2, 4, 6],\n", + " [ 8, 10, 12],\n", + " [14, 16, 18]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix_of_nums + matrix_of_nums" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2, 3, 4],\n", + " [ 6, 7, 8],\n", + " [10, 11, 12]])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix_of_nums + np.array([[1],\n", + " [2],\n", + " [3]])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "ename": "ValueError", + "evalue": "operands could not be broadcast together with shapes (3,3) (3,2) ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m matrix_of_nums + np.array([[1, 2],\n\u001b[1;32m 2\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m [3, 4]])\n\u001b[0m", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (3,3) (3,2) " + ] + } + ], + "source": [ + "matrix_of_nums + np.array([[1, 2],\n", + " [2, 3],\n", + " [3, 4]])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2., 4., inf],\n", + " [ 5., 7., inf],\n", + " [ 8., 10., inf]])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix_of_nums + np.array([1, 2, float('inf')])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9\n", + "2\n", + "(3, 3)\n", + "int64\n" + ] + } + ], + "source": [ + "print(matrix_of_nums.size)\n", + "print(matrix_of_nums.ndim)\n", + "print(matrix_of_nums.shape)\n", + "print(matrix_of_nums.dtype)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52, 55, 58,\n", + " 61, 64, 67, 70, 73, 76, 79, 82, 85, 88, 91, 94, 97])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.arange(10, 100, 3)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_range = np.arange(20)\n", + "my_range" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3, 4],\n", + " [ 5, 6, 7, 8, 9],\n", + " [10, 11, 12, 13, 14],\n", + " [15, 16, 17, 18, 19]])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_range = my_range.reshape((4, 5))\n", + "my_range" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 5, 10, 15],\n", + " [ 1, 6, 11, 16],\n", + " [ 2, 7, 12, 17],\n", + " [ 3, 8, 13, 18],\n", + " [ 4, 9, 14, 19]])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_range.swapaxes(0, 1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[81, 65, 83, 74],\n", + " [24, 99, 20, 50],\n", + " [ 8, 3, 32, 28],\n", + " [68, 71, 20, 39],\n", + " [61, 38, 52, 35]])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nums = np.random.randint(1, 100, (5,4))\n", + "nums" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max: 99\n", + "Min: 3\n", + "Mean: 47.55\n", + "Sum: 951\n" + ] + } + ], + "source": [ + "print(\"Max:\", nums.max())\n", + "print(\"Min:\", nums.min())\n", + "print(\"Mean:\", nums.mean())\n", + "print(\"Sum:\", nums.sum())" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max: [81 99 83 74]\n", + "Min: [ 8 3 20 28]\n", + "Sum: [242 276 207 226]\n", + "Mean: [ 48.4 55.2 41.4 45.2]\n" + ] + } + ], + "source": [ + "print(\"Max:\",nums.max(axis=0))\n", + "print(\"Min:\",nums.min(axis=0))\n", + "print(\"Sum:\",nums.sum(axis=0))\n", + "print(\"Mean:\",nums.mean(axis=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 81, 146, 229, 303],\n", + " [ 24, 123, 143, 193],\n", + " [ 8, 11, 43, 71],\n", + " [ 68, 139, 159, 198],\n", + " [ 61, 99, 151, 186]])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nums.cumsum(axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[29, 3, 44, 13],\n", + " [12, 80, 53, 81],\n", + " [18, 18, 63, 36],\n", + " [51, 85, 20, 1],\n", + " [84, 7, 68, 50]])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nums = np.random.randint(1, 100, (5,4))\n", + "nums" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "12" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nums[2,3]\n", + "nums[1,0]" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 3, 44],\n", + " [80, 53]])" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nums [0:2, 1:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'a': 3, 'b': 1, 'n': 2}\n" + ] + } + ], + "source": [ + "word = \"banana\"\n", + "\n", + "expected_histogram = {\n", + " \"b\": 1,\n", + " \"a\": 3,\n", + " \"n\": 2\n", + "}\n", + "\n", + "def convert_to_histogram(word):\n", + " histogram = {}\n", + " for character in word:\n", + " if character in histogram:\n", + " histogram[character] = histogram[character] + 1\n", + " else:\n", + " histogram[character] = 1\n", + " return histogram\n", + "\n", + "returned_histogram = convert_to_histogram(word)\n", + "print(returned_histogram)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "945.4500000000012\n" + ] + } + ], + "source": [ + "cover_price = 24.95\n", + "discount = .4\n", + "discounted_cover_price = cover_price - (cover_price * discount)\n", + "shipping_cost = 3\n", + "secondary_shipping_cost = .75\n", + "\n", + "def get_shipping_cost(index, shipping_cost, secondary_shipping_cost):\n", + " local_shipping_cost = secondary_shipping_cost\n", + " if index == 0:\n", + " local_shipping_cost = shipping_cost\n", + " return local_shipping_cost\n", + "\n", + "def calculate_total_wholesale_cost(copies):\n", + " total_wholesale_cost = 0\n", + " for index in range(60):\n", + " local_shipping_cost = get_shipping_cost(index, shipping_cost, secondary_shipping_cost)\n", + " total_wholesale_cost += local_shipping_cost\n", + " total_wholesale_cost += discounted_cover_price\n", + " return total_wholesale_cost\n", + "wholesale_cost = calculate_total_wholesale_cost(60)\n", + "print(wholesale_cost)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'difficulty' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 110\u001b[0m \u001b[0;31m#slope = Slopes()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 111\u001b[0m \u001b[0;31m#slope.pick_slope_difficulty()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 112\u001b[0;31m \u001b[0mtrail\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mTrail\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 113\u001b[0m \u001b[0mtrail\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgreen_trail\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 69\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mblue_trail\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m200\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mblack_trail\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m250\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 71\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdifficulty\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdifficulty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 72\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 73\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtrail_pick\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'difficulty' is not defined" + ] + } + ], + "source": [ + "class Snowboard:\n", + " \n", + " def __init__(self):\n", + " self.board_width = \"\"\n", + " self.board_length = \"\"\n", + " self.board_choice = \"\"\n", + " \n", + " def __str__(self):\n", + " return \"You have picked a {} with a width of {} and length of {}\".format(self.board_width,self.board_length, self.board_choice)\n", + " #How to take the user input and put the choice into these spaces ^^^^^\n", + " \n", + " def pick_snow_board_width(self):\n", + " self.board_width = input(\"Pick: Wide, Mid_wide, or Regular > \")\n", + " if self.board_width == \"Wide\":\n", + " return \"You have chosen a wide board.\"\n", + " elif self.board_width == \"Mid_wide\":\n", + " return \"You have chosen a mid-wide board.\"\n", + " elif self.board_width == \"Regular\":\n", + " return \"You have chose a regular board\"\n", + " else:\n", + " return \"Not a board width\"\n", + " return self.board_width\n", + " \n", + " def pick_snow_board_length(self):\n", + " self.board_length = input(\"Pick: 165, 168, 169 > \")\n", + " if self.board_length == \"165\":\n", + " return \"You chose a 165mm board length\"\n", + " elif self.board_length == \"168\":\n", + " return \"You chose a 168mm board length\"\n", + " elif self.board_length == \"169\":\n", + " return \"You chose a 169mm board length\"\n", + " else:\n", + " \"Not a board length\"\n", + " return self.board_length\n", + " \n", + " def pick_snowboard(self):\n", + " self.board_choice = input(\"Pick: Burton, Lib-Tech, or Ride > \")\n", + " if self.board_choice == \"Burton\":\n", + " return \"Boo, You picked a Burton board.\"\n", + " elif self.board_choice == \"Lib_Tech\":\n", + " return \"Yay, You picked a Lib_Tech board\"\n", + " elif self.board_choice == \"Ride\":\n", + " return \"You picked a Ride board\"\n", + " return self.board_choice\n", + "\n", + "class Slopes:\n", + " \n", + " def __init__(self):\n", + " self.difficulty = \"\"\n", + " \n", + " def __str__(self):\n", + " return \"You pick {} as your difficulty\".format(self.difficulty)\n", + " \n", + " def pick_slope_difficulty(self):\n", + " self.difficulty = input(\"Please pick a slope difficulty: Green, Blue, or Black_Diamond >\")\n", + " if self.difficulty == \"Green\":\n", + " return \"You must be a beginner\"\n", + " elif self.difficulty == \"Blue\":\n", + " return \"You must be average\"\n", + " elif self.difficulty == \"Black_Diamond\":\n", + " return \"You must know what you are doing.\"\n", + " return self.difficulty\n", + "\n", + "class Trail():\n", + " \n", + " def __init__(self):\n", + " self.speed = 0\n", + " self.green_trail = 150\n", + " self.blue_trail = 200\n", + " self.black_trail = 250\n", + " \n", + " def trail_pick(self):\n", + " self.pick_slope_difficulty()\n", + " if self.difficulty == \"Green\":\n", + " return self.green_trail\n", + " elif self.difficulty == \"Blue\":\n", + " return self.blue_trail\n", + " elif self.difficulty == \"Black_Diamond\":\n", + " return self.black_trail\n", + " else:\n", + " \"Not a trail pick.\"\n", + " \n", + " def update(self):\n", + " self.traffic = random.randint(0,1)\n", + " if self.traffic == 0:\n", + " self.speed += 2\n", + " return \"You found a hole through the people\"\n", + " else:\n", + " self.speed -= 2\n", + " return \"There were too many people in front of you\"\n", + " \n", + " \n", + " def green_trail(self, speed=14, green_trail=150):\n", + " if self.speed == 0:\n", + " self.speed += 2\n", + " while self.speed > 0 <= 14:\n", + " self.update()\n", + " \n", + " def blue_trail(self):\n", + " pass\n", + " def black_trail(self):\n", + " pass\n", + " \n", + " \n", + "#snowboard = Snowboard()\n", + "#snowboard.pick_snow_board_width()\n", + "#snowboard.pick_snow_board_length()\n", + "#snowboard.pick_snowboard()\n", + "#slope = Slopes()\n", + "#slope.pick_slope_difficulty()\n", + "trail = Trail()\n", + "trail.green_trail()\n" + ] + }, + { + "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.4.3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/.ipynb_checkpoints/Untitled1-checkpoint.ipynb b/.ipynb_checkpoints/Untitled1-checkpoint.ipynb new file mode 100644 index 0000000..286dcb3 --- /dev/null +++ b/.ipynb_checkpoints/Untitled1-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Traffic Simulation.ipynb b/Traffic Simulation.ipynb new file mode 100644 index 0000000..565b005 --- /dev/null +++ b/Traffic Simulation.ipynb @@ -0,0 +1,208 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#Traffic Simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import random\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import math\n", + "import statistics\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import random\n", + "\n", + "class Road:\n", + " \n", + " def __init__(self):\n", + " self.road = 1000\n", + " \n", + " def __str__(self):\n", + " return self.road\n", + "\n", + " \n", + "class Car:\n", + " #defining the different attributes of a car\n", + " def __init__(self, location, car_following=None):\n", + " self.speed = 0\n", + " self.min_distance = int(self.speed + 15)\n", + " self.location = location\n", + " self.car_following = car_following\n", + " self.top_speed = 33\n", + " \n", + " def accelerate(self):\n", + " if self.speed < self.top_speed:\n", + " self.speed += 2\n", + " return\n", + " else:\n", + " self.speed = self.car_following.speed\n", + " return\n", + " # a car has a 10% chance of slowing down\n", + " def slow_down(self):\n", + " random_slow = random.randint(1,10)\n", + " if random_slow == 1:\n", + " self.speed -= 2\n", + " if self.speed < 0:\n", + " self.speed = 0\n", + " \n", + " def simulation(self):\n", + " if self.car_following.location > self.min_distance:\n", + " self.accelerate()\n", + " self.slow_down()\n", + " self.location += self.speed\n", + " if self.location >= road.road:\n", + " self.location -= road.road\n", + " #This function is starting the traffic simulation.\n", + " #It is telling cars to speed up if there is too much distance between them.\n", + " #Cars will also be randomly slowing down and if the cars go past 1000m then they will go to the beginnning.\n", + " \n", + "\n", + "\n", + "road = Road()\n", + "car_list = []\n", + "location = 1000\n", + "car_in_front = None\n", + "car_locations = []\n", + "road_log = []\n", + "in_range = []\n", + "one_minute_log = []\n", + "cars_speed = []\n", + "\n", + "# this is generating a list of 30 cars\n", + "for x in range(30):\n", + " spawn_car = Car(location, car_in_front)\n", + " car_list.append(spawn_car)\n", + " car_list[0].car_following = car_list[-1]\n", + " location -= 33\n", + " car_in_front = spawn_car\n", + "\n", + "# This is simulating the race for 1 minute(60 iterations)\n", + "for x in range(60):\n", + " for car in car_list:\n", + " car.simulation()\n", + " [cars_speed.append(car.speed)]\n", + " [car_locations.append(car.location)]\n", + " [in_range.append(x)]\n", + " [road_log.append(car_locations)]\n", + " one_minute_log.append(in_range)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAAJPCAYAAADxOCSxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzs3W+sbelZGPbnwScuMSQMFtWMA6Z2K1xwlKQ4lUnTVtwm\nQF0UBkfyjEFK5KYpX/oHGjWRx6nUe+6nYFdtilrRDyGgqVUI1w51bYUUTx1fkSgSkGC3ju3p4Eqj\nepzONTgYAlFVE95+OPv6nrvftfbZe693/dlr/37S0Zy9z97r/f+ufZ9Zaz9ZSgkAAAAAuO4r5q4A\nAAAAAMsjaAQAAABARdAIAAAAgIqgEQAAAAAVQSMAAAAAKoJGAAAAAFQGBY0y81/NzI9d+/mNzPzB\nzHx1Zj6XmS9k5ocz87FWFQYAAABgfFlKaXOgzK+IiM9FxJsj4j+NiF8rpbwnM98ZEV9bSnmmSUEA\nAAAAjK7l7WnfERGfKaV8NiKejIhnN88/GxFvbVgOAAAAACNrGTT6voj4qc3vj5dS7m9+vx8Rjzcs\nBwAAAICRNQkaZeYrI+J7IuJ9238rV/e/tbkHDgAAAIBJXDQ6zr8XEf+wlPKrm8f3M/OJUsrLmfma\niPj89hsyUyAJAAAAoLFSSrY4Tqug0ffHw1vTIiI+GBHviIh3b/77ga43tWoEHCozL0spl3PXg/Nj\n7jEn84+5mHvMyfxjLuYec2l5kc7g29My86vi6kuwf+ba0z8cEd+ZmS9ExJ/YPAYAAADgRAy+0qiU\n8tsR8XVbz/2TuAokAQAAAHCCWmZPg1Nyb+4KcLbuzV0Bztq9uSvA2bo3dwU4a/fmrgBn697cFYCh\n8iq52QwFZxbfaQQAAADQTst4iyuNAAAAAKgIGgEAAABQETQCAAAAoCJoBAAAAEBF0AgAAACAiqAR\nAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKgIGgEAAABQETQCAAAAoCJoBAAAAEBF0AgAAACAiqAR\nAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKgIGgEAAABQETQCAAAAoCJoBAAAAEBF0AgAAACAiqAR\nAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKgIGgEAAABQETQCAAAAoCJoBAAAAEBF0AgAAACAiqAR\nAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKgIGgEAAABQETQCAAAAoCJoBAAAAEBF0AgAAACAiqAR\nAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKgIGgEAAABQETQCAAAAoCJoBAAAAEBF0AgAAACAiqAR\nAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKgIGgEAAABQETQCAAAAoCJoBAAAAEBF0AgAAACAiqAR\nAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKgIGgEAAABQETQCAAAAoDI4aJSZj2Xm+zPz05n5qcz8\ntsx8dWY+l5kvZOaHM/OxFpUFAAAAYBotrjT6kYj42VLKt0TEH46I5yPimYh4rpTyhoj4yOYxAAAA\nACciSynHvznzayLiY6WUf3nr+ecj4ttLKfcz84mIuFdK+eat15RSSh5dOAAAAACPaBlvGXql0esj\n4lcz8ycy85cz869l5ldFxOOllPub19yPiMcHlgMAAADAhIYGjS4i4k0R8aOllDdFxG/H1q1o5epS\npuMvZwIAAABgchcD3/9SRLxUSvmlzeP3R8S7IuLlzHyilPJyZr4mIj7f9ebMvLz28F4p5d7A+gAA\nAACcjcy8FRG3Rjn2kO80iojIzJ+PiP+wlPLCJgj0qs2fvlBKeXdmPhMRj5VSntl6n+80AgAAAGio\nZbylRdDoj0TEj0XEKyPi/4qIPxcRr4iIuxHxjRHxYkQ8XUr54tb7BI0AAAAAGlpU0OjoggWNAAAA\nAJpaUvY0AAAAAFZI0AgAAACAiqARAAAAAJWLuSsAJyGz/vKvUrLr+cuIuPPllyzne7uyo65N69fV\nR1eFTNsHfWM1SdG7+7jFGHQdozpO31g8+oZR+mSv+s1o7/otZT7fZMb53krfmERE3I6rPfXLltK2\nnn4ffZ+lV9O959B1NeF+cfAcm2KPGKn9p7aeln7+m8POMVzB+QvOhS/CBgAAAFgJX4QNAAAAwKgE\njQAAAACoCBoBAAAAUBE0AgAAAKAiaAQAAABA5WLuCsA5Gz2d7FLShs+YVvWmPm4xBnul2d2RVvza\nG0bpk6WnAd67fkuZzzc58TTCfePxwO2IuLz+xFLa1lHvvootZe6fk0H70NC1P+HecfA5ZYr9YqT2\nj/4ZprGlnwuntLMvTuVcO6V9PsNtXEbEnc3v5zi3WKcsZe810LbghingAAAAAGgbb3F7GgAAAAAV\nQSMAAAAAKoJGAAAAAFQEjQAAAACoyJ4G10ySWWMpWSlkNNs/G8aI/bL07DN71+8UMoYtZe0NcFBm\ns6W0q6fOXZVb0tw/B03OeceufRnNZDQLGc2uk9HsQH3rtOP5y5DRDIaQPQ0AAABgJWRPAwAAAGBU\ngkYAAAAAVASNAAAAAKgIGgEAAABQETQCAAAAoHIxdwVgUZaQNnzGtKo3pb5tlRp3Z0rgG1KKX3vD\naP2x5JTFB43BEubzTVaQRrhvTB64HVfpfiNiOe3qqXNX5ZYy98/NoH1o6NqfaO/Yez+bep9o3P4l\nn1O6tDrXr8HOvljB+WsyHX11GRF3Nr8fNbdG2KfMfeiWpez377PmBTdMAQcAAABA23iL29MAAAAA\nqAgaAQAAAFARNAIAAACgImgEAAAAQEXQCAAAAIDKxdwVgJMzY4rVm1J7X3fMt+UflVq2+w2j9MXS\nU6HunVb5VNL0TpR2eyw3rZfbcZXyNyKW0a6e+nZVbClz/twMSp0+dD1NtB4XuY81Lmvp55Iup1jn\nseyco6dyfl2Cjr66jIg7m9+Pmlsn/rnhqczy/o7nz3GdwXVZyv7/DmxacMMUcAAAAAC0jbe4PQ0A\nAACAiqARAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKgIGsFAmVm6fvr+NlZZkVn2/hnJzvotwN51\nm7jfjnYKddyhb748+LlcUrs6+nrp8/1cDB6Doet9wv1i0B7WvjJN233K6+lU6z2GnX1x4uesSW31\n0+XQuXUqn2v6bPVBZpan5qr/qfclHCFLmWu9tUsBBwAAAEDbeIsrjQAAAACoCBoBAAAAUBE0AgAA\nAKAiaAQAAABARdAIAAAAgIqgEWetRZrcnWmC+9JyTpiqc+lpjAelkF5QO77sFOp4gO2xuVxquzr6\nfelzf+2a9f3QtT/B3rFXW6fcGxqXdWrryNp/6Ma+WNk5a1Rb/XQ5dG6dyueaHXZ+RpijLTP2pz2H\nNctS5pnPLVPAAQAAANA23uJKIwAAAAAqgkYAAAAAVASNAAAAAKgIGgEAAABQETQCAAAAoHIxdwVg\nNvumwhwxy19XOs4lZBU8uF5dfbmAdjyib7yXVs8b9KVwvR0Rl9efWEK79pwXfW1awlpYs+b9PnQf\nGHEf6W1r55MTzLvGbV3quaTLKdV1bDv7YiXnrEls9dVlRNy59vio+XUKn2t2mPy8uu98nbFf99l7\nhvSbvY01y1L2+3dz84IbpoADAAAAoG28xe1pAAAAAFQEjQAAAACoCBoBAAAAUBE0AgAAAKAiaAQA\nAABARdAIdsjMsv2ztPrsrFNm6fxZolOqa4++8Xnwc7mUdu3R10ub++ds0FiMsaZGXKc718wcc7BR\nW5e+npZevynt7IsTP0dNaqufLlvMrxPv/4M/ww0vcL/PVQvv11b9tv3+p25q94H9Yh9lzbKUeeZz\nyxRwAAAAALSNt7jSCAAAAIDKxdADZOaLEfGbEfHPI+JLpZQ3Z+arI+KnI+JfiogXI+LpUsoXh5YF\nAAAAwDRaXGlUIuJWKeVbSylv3jz3TEQ8V0p5Q0R8ZPMYAAAAgBPR6va07XvlnoyIZze/PxsRb21U\nDgAAAAATaHWl0f+Wmf8gM39g89zjpZT7m9/vR8TjDcoBAAAAYCKDv9MoIv7NUsr/k5n/YkQ8l5nP\nX/9jKaU35WBmXl57eK+Ucq9BfWBSffP7xm+r73rfOWcU7EtN2rBPusaqlJKLG4sdfXH0fKOp3rm0\n/wHazvcR5/B2W29HxOUI5eytUVsHj+HIll6/Ke3si6Xt30u21VeXEXHn2uOj5teJ9//k59R99/6F\n92urfts+ztsi4n31QfPaGw7ql5b7qD2ZpcvMWxFxa5Rjl9K9dx11sMzbEfFbEfEDcfU9Ry9n5msi\n4qOllG/eem2zFHAAAAAAtI23DLo9LTNflZm/b/P7V0XEd0XEJyLigxHxjs3L3hERHxhSDgAAAADT\nGnSlUWa+PiL+583Di4j4n0opfyUzXx0RdyPiGyPixYh4upTyxa33utIIAAAAoKGW8Zamt6cdVLCg\nEQAAAEBTi7k9DQAAAIB1EjQCAAAAoCJoBNsyS+fPOZqgLzKz7POzyHHpqU9n/ZlE7/w5/EBt5ttI\n83a7fZdLWBMN2rn0tbP0+k1pZ18sba9euo7+uhw6x1YwBpOtt337auF92uz813Osy13tP/Bc17Ku\n+xy7xXGXWi5MwXcaAQAAAKyE7zQCAAAAYFSCRgAAAABUBI0AAAAAqAgaAQAAAFARNAIAAACgcjF3\nBYAjdaXybPQN+fumCe190ZyZETvq3lcZGRyn1ze39hqLvnk5ZBwbH7Orfbcj4nLgcZsY0NZB4zaB\npddvSjv7Yow1tFY9fdXVUXvPsxHP23PommtN19y+8/UE+rVFX914fnl44Ny84aD1PtY+enL785H7\n5OjrAWaUpez1b8P2BTdMAQcAAABA23iL29MAAAAAqAgaAQAAAFARNAIAAACgImgEAAAAQEXQCAAA\nAIDKxdwVgFUZOe1rX9rSR4vbkWp1royFO+oiRen8BqXDHSOF94hz98aUxXPOvQF9ufSUxkuv35R2\n9sUY62mNWp9TVtTvo59Tj+mrE+jfof22/f5HzitXB3v0WAee51qP68nuyQM+H/i8CcfLUm78N+g4\nBTdMAQcAAABA23iL29MAAAAAqAgaAQAAAFARNAIAAACgImgEAAAAQEXQCAAAAIDKxdwVgDXpS2Ea\ncS2t55JSz+5RFylK59EkHe4YqetHOGZXWx9JVzznfBuwXpee0njp9Zvbg/6pUmc/oJ/67dgnjjqn\nLOm8eaRJ1tsh+/MY54fGhn7+2H7/2yLiffUBj+qfMcfzpD93DZhXJ93u61awX8G2LKX337jjFtww\nBRwAAAAAbeMtbk8DAAAAoCJoBAAAAEBF0AgAAACAiqARAAAAABVBIwAAAAAqF3NXAOawM1XqklJl\nHlCX1aQqPQHN+rpFyuOR5ut2G6u040uYW0f039LTzFvHu233z09HxNPbL9Jf3Xasl1H3tGvlLNkk\ne8M+e9YJ9OHQvup9f/dBHx5zzz1/jH30pPfmAZ81Trrd1020rpb+GQOOlaV0r6HRC26YAg4AAACA\ntvEWt6cBAAAAUBE0AgAAAKAiaAQAAABARdAIAAAAgIqgEQAAAACVi7krAItzTFrOA9OZriaF6UI1\n799j09UOSHPbf8j6mLcj4rLBsQc7MqXtKaSoPYU6zmm7f748J7fpr9qOddNk3p1ACvc+k6y7Y/bp\nEfb2oVqe93r7vfPJkofOsVPcT0f53DZgbZ5iH/aaaD319dmjxZ5g/8EEspQb1884BTdMAQcAAABA\n23iL29MAAAAAqAgaAQAAAFARNAIAAACgImgEAAAAQEXQCAAAAICKoBHnJ7N0/vS+PEvXz5RVXqPR\n+vWAsT3otQeUf7nE+XJkW5c8963N3bb75fLAve+s7eirpvPuBMdjkjXXol8WNN/H6rPO4x7yM1O9\nT0ZHn13u2RerOj9NtI76+mzyflvQ3gFLkaXMswZapoADAAAAoG28xZVGAAAAAFQEjQAAAACoCBoB\nAAAAUBE0AgAAAKAiaAQAAABA5WLuCgCnoSvl6d7fyN+VqvSQb/Mf+v6OY11GxJ2OP8+W1bEvnesN\n9Rk0LiNaar2WYrt/fjoint5+kf7qtmM/aDbvjlyPc+pLS9103Q3tl4X16xj7VOcxDznAie75k+lo\n/2XU5/OuPplkjUyl5eeincVMP992ltmi3QfuQ6uaN3CkLOWgU1m7ghumgAMAAACgbbzF7WkAAAAA\nVASNAAAAAKgIGgEAAABQETQCAAAAoCJoBAAAAEBF0AhOVGaWrp8DDlCqn8MqMOz9Hce6HNqm1o5s\n46LacM1S67UU1/vlsmvs9Ve3G/qq2bw7wfEYvE/vV8iwubqwuT5Gf3Uec9+fmep8Ujr6ret83v3W\nhZ33h5pgPc3VX71j1bK9ex5rdfMGFi5LmWd9tUwBBwAAAEDbeEuTK40y8xWZ+bHM/NDm8asz87nM\nfCEzP5yZj7UoBwAAAIBptLo97Yci4lMR8eCypWci4rlSyhsi4iObxwAAAACciMFBo8z8hoj47oj4\nsYh4cPnTkxHx7Ob3ZyPirUPLAQAAAGA6La40+qsR8Zci4nevPfd4KeX+5vf7EfF4g3IAAAAAmMig\noFFm/qmI+Hwp5WPx8CqjR5Srb9r2bfYAAAAAJ+Ri4Pv/eEQ8mZnfHRFfGRG/PzPfGxH3M/OJUsrL\nmfmaiPh815sz8/Law3ullHsD6wOL0JX2c+9vr+9LGTrV+3uOdRkRd6pDzpQB8cg2DhqXkSyxTkvz\noI9ux9U8rOiv2g1rpNm86ypn4ePRl5Z5lHV3bP8srF/H2Kc6j3noQXrqMOkYL91WX9yNiLdvvaSv\nX1Z5fmr5Gak69Hzz7qD1NKQ+O/Ym6w7mlZm3IuLWKMe+uhCowYEyvz0i/mIp5Xsy8z0R8YVSyrsz\n85mIeKyU8szW65ulgAMAAACgbbylVfa0Bx5EoH44Ir4zM1+IiD+xeQwAAADAiWh2pdHBBbvSCAAA\nAKCpJV9pBAAAAMAKCBoBAAAAUBE0AgAAAKAiaASHyCzVz5jv23nILNs/l42O3cQRbe5qU18K17Et\nqS5L98jc2/zc1Vf9dqyNZnOuq4wTGJPJ19yhfbSwfm25T/Ueq6+9R/aFfXVLx965b/+ssi9HXGNz\nntf3XltD69NzvFXOlQXT36yNL8IGAAAAWAlfhA0AAADAqASNAAAAAKgIGgEAAABQETQCAAAAoCJo\nBAAAAEBF0IjzNlJq1+00m08tIUXzytIjz5k699RkZrnsSOs8d70Wa8c6aTbvRkwrPabJ19wxfbSg\nfm01Xw5O191orz/bPbVjv9y3X1bZhyPuV3POu4PX1fEFVcez3uYxuN8XdH6BKWUp88z1lingAAAA\nAGgbb3GlEQAAAAAVQSMAAAAAKoJGAAAAAFQEjQAAAACoCBoBAAAAUBE04qx0pdm8XELazJWkR15i\nnZaqmnubtM5z12uxdqyRZnNuxLTSY5p8zbXooxn7eox9qvd4fW08su1nv7929Nvlnn2y2vPTiOto\nrv7qHauWbe041mrnyNodMC9uHOMT/AwAU8hS5lkLLVPAAQAAANA23uJKIwAAAAAqgkYAAAAAVASN\nAAAAAKgIGgEAAABQETQCAAAAoCJoBPtYYArOQ1PDSiO7v7szpgM/OTv6qmn64hMcj8nTNw+dtwuY\n9y37a++U3Q/KOKLtUnRH1W93B56XVtF/I66jufrr4DTlx9Sr4xirnSNrduB8mG2MM8vlVpmdn/+A\nyFLmWQstU8ABAAAA0Dbe4kojAAAAACqCRgAAAABUBI0AAAAAqAgaAQAAAFARNAIAAACgcjF3BWDN\nulKGXv8W+5v+zpXMLLcj4rLrj/qr1pcitpTsS2N71LzrOtbCx6Np+/crsHcsjn7/xH3ccp/qPFbf\ni0vJY9o/+RgvUUcf9DW+r19WdX4aug5vPPw8fbVXuUP3kAZziQU4cA3MuY8+lVnef+3xRyPiVl2R\naefayHsILF2W0vtxbdyCG6aAAwAAAKBtvMXtaQAAAABUBI0AAAAAqAgaAQAAAFARNAIAAACgImgE\nAAAAQOVi7grAlG5KISpV84E6+utuRDytv/rtSH/cLG3ziaaGnTxt9ZBU1Avo45b7Ve+xugvIY9u/\nqjTux+ho/2VE3Nl6bp8+WU1fDk0Jv/PQ85zTDyr30PbfsPZWMy/OwYH76FLm8+242rc6KjLPPBtx\nDwGuZCnd+9XoBTdMAQcAAABA23iL29MAAAAAqAgaAQAAAFARNAIAAACgImgEAAAAQEXQCAAAAIDK\nxdwVANrLzNKZElXGwm470rU2S1+8gBTtx5g0ffPQPlpAH4+VErn3uN2F5bF9cfbpujvafxkRdza/\nH9oXc6XIbmrEdNZLSSG+s9xD2r/Ha89+jZ2KPcd97jW+Xf5PR8TTdWWG12UB59deB6zRm8Zr7vGE\npcpSuveA0QtumAIOAAAAgLbxFrenAQAAAFARNAIAAACgImgEAAAAQEXQCAAAAICKoBEAAAAAlYu5\nKwDnYrK0qGtwQ2rXZimLR0wlPZbZ0sEO7asZ+3rKFNe949P5ZMlj++Xs03Z3tP9uRDx9ZB+sIs3y\niGts6vl20Hgc0u4TSaPOHvYYy7n2yck/7y31s8wNn+Xql+8er7M/78GMspTu9Tx6wQ1TwAEAAADQ\nNt7i9jQAAAAAKoJGAAAAAFQEjQAAAACoCBoBAAAAUBE0AgAAAKByMXcFYE4703cuNYXpXPZIndos\nTfGBaVqXYpZ0sEP7asa+niqtde+49K3xI9a+FN3Ru2ceuy5WmV654XpbQv8cNO8PWVcHrsEl9AUd\nbpjvU4/bdnm3I+Ky64Ut6rDUz5Ajri3nQVivLKV7Px+94IYp4AAAAABoG28ZdHtaZn5lZv5CZn48\nMz+VmX9l8/yrM/O5zHwhMz+cmY+1qCwAAAAA0xh8pVFmvqqU8s8y8yIi/l5E/MWIeDIifq2U8p7M\nfGdEfG0p5Zmt97nSCAAAAKChxVxpFBFRSvlnm19fGRGviIhfj6ug0bOb55+NiLcOLQcAAACA6QwO\nGmXmV2TmxyPifkR8tJTyyYh4vJRyf/OS+xHx+NByAAAAAJjO4OxppZTfjYh/LTO/JiJ+LjP/na2/\nl75v0wcAAABgmQYHjR4opfxGZv6tiPijEXE/M58opbycma+JiM93vSczL689vFdKudeqPjDYUtOl\ndtlR12YpUGdMzT7ELKmYh/bVjH09VcrcznHpe/GDsg/sF+l/o3l65VWmNm+83pY67w6q1yHzZsQU\n3kysY2z6BmaMMdueG7cj4rK78OPLXupnmRWc35ZYp32car1hW2beiohboxx7yBdhZ+bXRcTvlFK+\nmJm/NyJ+LiLuRMS/GxFfKKW8OzOfiYjHfBE2AAAAwLhaxluGXmn0moh4NjO/Iq6+H+m9pZSPZObH\nIuJuZv75iHgxIp4eWA4AAAAAExp0pdGggl1pBAAAANBUy3jL4OxpAAAAAKyPoBEAAAAAFUEjAAAA\nACpDvwgb2EdPSuJmqYcPTHk8t1lTLg/tqxn7eop+60092/nktbKl3T7MAemV9+mr1aYMbrzeljbv\nDhq3Q/rCejwfW2P3VES8f+slY58nbkfEZdcLW32eOfZYrR2wrla7J+8wVpsX0ZdLnpcwAV+EDQAA\nALASvggbAAAAgFEJGgEAAABQETQCAAAAoCJoBAAAAEBF0AgAAACAysXcFYBF2UqpeTci3r71kqO+\nhX7GNO2HmC2t6dD+mbF/p0hV3TsunU8en4L77NNuH5hS96b1sog0wWNrsPaWOu/2rtch86bxHGOh\nFpSaffv4tyPisrvAw8pb6ucaa+xGY+25i+jLpc5LOHFZSvfeOnrBDVPAAQAAANA23uL2NAAAAAAq\ngkYAAAAAVASNAAAAAKgIGgEAAABQETQCAAAAoHIxdwVgURaeqnPydKYHpq5t/v4BpuqrztS1fS/e\np+yO4/W96SwyUDZOn7yIlMBja7SPLbGv9k4VfezeI133uu25NsYe1+3j346Iy+4CDytvqZ9hrKsb\n7b23LVjvuHU+eVpte+Ac5yZERGQpvf+8GbfghingAAAAAGgbb3F7GgAAAAAVQSMAAAAAKoJGAAAA\nAFQEjQAAAACoCBoBAAAAULmYuwKwRpOlTh2a0n7o+weYKm1p51j0vfjI9MaXEXGn83ArzxDZOH31\nGlIO79RwvS2trw5az4emBZeue90OnA9jzf3R0oUfOt+nspB+X7JVt3mEebmKvbevX8798x5nL0vp\n/efTuAU3TAEHAAAAQNt4i9vTAAAAAKgIGgEAAABQETQCAAAAoCJoBAAAAEBF0AgAAACAysXcFYC5\nTZIidGhq0xlT9k6RcvagVMdXFTi8/MxyGY+mSn1bRLxvzVkc95g3h4zvqtMPRxyc2n33oZbVV3vt\nc8e0f8+9aRWpmM/JQtKxH3RuOJFz6k4L6felWvU+0vD88+hhVzBH+tbF5vnLePSz3cOXnFg7YcGy\nlN5/lo1bcMMUcAAAAAC0jbe4PQ0AAACAiqARAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKhczF0B\nmM1YKXdHSpv6aBHzplDtLL/vxcfUK7NcxpmkUL1hvhw61qtOSfxAo7W7xL7aOd7H7C179NXc+wkH\nOGAOjDWuvcdtsS4nOH8e7Ih2LXFvGcuq2zrSfDz5PXePfplkXqz4swAsTZbS+0+9cQtumAIOAAAA\ngLbxFrenAQAAAFARNAIAAACgImgEAAAAQEXQCAAAAICKoBEAAAAAlYu5KwBrMmfazs4Urn0vPqY+\nmeUyIu50Hm5lmRAPTLN707ifdTrXxn25FDtTJh+TBnjHe04+PfM5mTEVde9x+95waHmN0ls3c2Q6\n9HNaT6tu6wjz8VTOPzvt0S+jz4sj1+Ysxvhse0rthz1lKb0fJ8YtuGEKOAAAAADaxlvcngYAAABA\nRdAIAAAAgIqgEQAAAAAVQSMAAAAAKoJGAAAAAFQu5q4ArN1BaZAHpPe8jDpl6KoyFDZO3b6K1LrH\nOrNU1TvrfUxfdLyn78Wn0D9nace4j7k3dM7FvhffVN7S0zqf2T6zr1W3b49074cfcgXn6j36ZfR5\nsfT94rqZ+xQ6AAAYg0lEQVSez7QRDfpkhDnaXcyK1zlnKUvp/bgybsENU8ABAAAA0Dbe4vY0AAAA\nACqCRgAAAABUBI0AAAAAqAgaAQAAAFARNAIAAACgcjF3BWAOvSlcO5888lvne1KGrjJr4IEpTPtS\nka4ite6xBqTDXWO/7UxXe0zK3K333I2It/cdn2Xpmd9dg9ViDJucHyZK69zEgXvPGlNJr7FNXzbC\nXFzNOeeGuT/6vBhw3p9DV3+8LSLeN7S+E+2Xq17nMLIspXu/Gr3ghingAAAAAGgbbxl0e1pmvjYz\nP5qZn8zMf5SZP7h5/tWZ+VxmvpCZH87Mx1pUFgAAAIBpDLrSKDOfiIgnSikfz8yvjoh/GBFvjYg/\nFxG/Vkp5T2a+MyK+tpTyzNZ7XWkEAAAA0NBirjQqpbxcSvn45vffiohPR8TXR8STEfHs5mXPxlUg\nCQAAAIAT0Sx7Wma+LiK+NSJ+ISIeL6Xc3/zpfkQ83qocAAAAAMbXJGi0uTXtb0bED5VS/un1v5Wr\n+9/m+bZtAAAAAI5yMfQAmfl74ipg9N5Sygc2T9/PzCdKKS9n5msi4vM977289vBeKeXe0PrALn1p\nYh9Y7fdsHZjO9KZ+eniIlfbXtoHpYNeSnnhnutpj+mjrPXcj4u19x+e0bI3tZUTc6XhZi/HtnJd9\nL941X6//fakOqPca0kuvZe/sNNIcXMO4R8TOc8okbZwoDXwTmeUy6j32FMZ9eyxvx9X5Yra+PqVx\nhy2ZeSsibo1y7IFfhJ1x9Z1FXyil/IVrz79n89y7M/OZiHjMF2EDAAAAjKtlvGVo0Ojfioifj4j/\nIx7+j713RcQvxtX/NP7GiHgxIp4upXxx672CRgAAAAANLSZoNKhgQSMAAACAplrGW5plTwMAAABg\nPQSNAAAAAKgIGgEAAABQuZi7AjClRaXvHSmN+8NDndF3ho3Ul6fSh73173zyhjZ1HKvvDafSP2wc\nmOJ7rHVx0HztrsBpzbs9+v2U0qSfUl0PNlK67dX02Y7+maSNJ5QO/anM8v6O509h3Cefr1OPa2a5\njIg7HX866nMTnAFfhA0AAACwEr4IGwAAAIBRCRoBAAAAUBE0AgAAAKAiaAQAAABARdAIAAAAgMrF\n3BWAxTkwLfXNhzvtdO7NNOjXU+zLztS1fS/e1Y4d/XeK/cLGgamGx0qF3DuHOp/sKe+E0mHfaI/9\naklp1JdUl1E0Pi8/POxK+m3u88NI49Pcpp6XUadbP4Vxn+xcP9N4brfvdlyN1RjlNjnnwRnJUnr/\n+TJuwQ1TwAEAAADQNt7i9jQAAAAAKoJGAAAAAFQEjQAAAACoCBoBAAAAUJE9Da4ZIzPFojNbjZTR\nbBFt25PsZnQ6YG2MvQaazdHug68n49kDN7RpyvV4Vmu/0Vw69XPKly3pnLD07GZb9buMOrtZxLLn\nwejzdiEZzd4WEe8bqQ69fTjneWrpawcmInsaAAAAwErIngYAAADAqASNAAAAAKgIGgEAAABQETQC\nAAAAoCJoBAAAAEBF0Ag2MrNs/8xdpyG62lO1KbN0/ixMZpbLVnXdcYy1zYHVu2E+7LUGmlTj0ePf\nnWJNncjajYi96jrVWNVVm6fcWQycL6vqqyWcB05sDV9u9clTS63rNaOP5UxjuFe7Gtard+0vaQ5P\nVJdV7YNwgCxlrrXdLgUcAAAAAG3jLa40AgAAAKAiaAQAAABARdAIAAAAgIqgEQAAAAAVQSMAAAAA\nKoJGMKGDUnUuJY3pPrbquZ2at9Vxr/eDtKcLdGDK26nH8MHxL5ewtpaSqniPOixhnZ3Feh84H06+\nj/Zs/yRtXMLa3FNXf1wuvN6TzNUZxnDONbjz/La0uTBT/W4am5PeP2FkWco866FlCjgAAAAA2sZb\nXGkEAAAAQEXQCAAAAICKoBEAAAAAFUEjAAAAACqCRgAAAABUBI1g4+BUm0tOZ7ptq553x0wruqNf\nTj4l9Ck7cr7OmT64M3XwUkyVMniPMpa2pla9zhuM+8n1zxL3jiXvDdd09sHS06HHRHN0hj6Yde11\ntPdy15xYkpnr1zdui943YWWylHnWW8sUcAAAAAC0jbe40ggAAACAiqARAAAAABVBIwAAAAAqgkYA\nAAAAVASNAAAAAKhczF0B4JqudNo9L22efbAvdemmnK7UpjIgNnRD/+9+a/d7Jx2frTpcRsSdqetw\njAH9fuNxrh1jEWO0w9Lrd7QbxuXmt59AvzSYw6Ps763W1oj2avfAOTSmSc7LM7R/tnW3Ve7diHh7\nXx0WPC+aa3x+O4XPk0fPwXOaF5yVLKX7nD56wQ1TwAEAAADQNt7i9jQAAAAAKoJGAAAAAFQEjQAA\nAACoCBoBAAAAUBE0AgAAAKByMXcF4GTtSKs5SzrRnvSgfYXKXnikNaXw3qrLZUTcufb45ObIvim+\n9xjDVacEXro1rbHrGqViHq19C04VffB6XGBbJpmXM7R78vW2Y5/fqy77nidOXUc7x/g8OPe5clD5\nC9wnYKmylO69c/SCG6aAAwAAAKBtvMXtaQAAAABUBI0AAAAAqAgaAQAAAFARNAIAAACgImgEAAAA\nQEXQiPOSWaqfR/6cpetn7jpezl2nU3XDeO9/mAXMi0crdD5zpGsMe9q2qDG6wSnV9UYHjNHNh1pI\nvzRs09XhRmhX4zq2cnRb19SWwwqZvN2TndP2mKMH12Wh876ZHef0qfbDscptctw1jz0sWJYy1+ex\ndingAAAAAGgbb3GlEQAAAACVwUGjzPzxzLyfmZ+49tyrM/O5zHwhMz+cmY8NLQcAAACA6bS40ugn\nIuItW889ExHPlVLeEBEf2TwGAAAA4EQMDhqVUv5uRPz61tNPRsSzm9+fjYi3Di0HAAAAgOmM9Z1G\nj5dS7m9+vx8Rj49UDgAAAAAjuBi7gFJKb0rFzLy89vBeKeXe2PXhzHXNxbGy+G2VdTci3l4VLYNg\npfEYde0/s/b7jvYtrq7H6kuBu92WzesuI+JO58uX2/aTH6t9x+jgw87YLyPs732fXwa3acpz0R4G\njdvC2hIx4rg9Wsgoa6i/uAnadFXQ3u1a27wZqqs/bsfVOe6U2tY31x44as5NvF6mcvKfBViVzLwV\nEbdGOXYpO/eF/Q6S+bqI+FAp5Q9tHj8fEbdKKS9n5msi4qOllG/eek+zFHAAAAAAtI23jHV72gcj\n4h2b398RER8YqRwAAAAARjD4SqPM/KmI+PaI+Lq4+v6i/zIi/pe4uhvnGyPixYh4upTyxa33udII\nAAAAoKGW8ZYmt6cdVbCgEQAAAEBTp3B7GgAAAAAnTNAIAAAAgMrF3BWARetJEdp1nd/Z3265xhTe\nXfZMEzxZeuTWjkiDvDPN8AHHmdo5jdFhh5+4X0ZMxTxaWxaSLrxJ+xaWCnuyPX/Cds/aph3lNKvX\nwubQMbb74m0R8b7tF51wex7YZ3w750Xfi0+oT/pst7fz80vEKtoKx/KdRgAAAAAr4TuNAAAAABiV\noBEAAAAAFUEjAAAAACqCRgAAAABUBI0AAAAAqFzMXQGY1I50tItL7T61kVPmLqp/j2zrotrQZ0Aq\n8L3bt9D0yicxPhGTpWsfLd18XdDo82G0tkw0Fv3FN2zXzG15WI0Z08tfFTbJWpqsTUecl67edtpr\n41A7x+jE2hIxzrhmZtlOJ383Ip5eeF8c6m5mebrrDytrJ0wpS+k+545ecMMUcAAAAAC0jbe4PQ0A\nAACAiqARAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKhczF0BmNQJpl092Ezpr2fNhjhFmvkpNRjD\nQe2aMJX17mpMlDL+GOeS7vuqsKZlrTFFePMxWsC5aslp5o8rZsL9ZKnnpAXMq10OGqOFt+WBUedd\nx7EvI+JOyzLmdOQYz/m5btGfW2CALKX7M+LoBTdMAQcAAABA23iL29MAAAAAqAgaAQAAAFARNAIA\nAACgImgEAAAAQEXQCAAAAIDKxdwVAHZYY1rvmyvSJI3uYtKeNhzDNaX1Xsx8e2DGtN+Tpfy+Kuy0\n2jTDHB1t7ziH9TbRvJt0f28wbqP3/4Tr/RBHtXuhbYmYaN71zLfFnTMPtZJz0t3M8vS1x5cRcafh\n8WGpspTuNTx6wQ1TwAEAAADQNt7i9jQAAAAAKoJGAAAAAFQEjQAAAACoCBoBAAAAUBE0AgAAAKBy\nMXcF4OxMnE52EannR0g1PWu7Go/hqG2ZKX3xItIDT5TiXDrzowpZzz649jU24zq6Kmq5bZpkDCbq\n/30NbvNM66XPZPNuj3Yv4vPaIVZ+TrqMiDtjlgknJEvpXu+jF9wwBRwAAAAAbeMtbk8DAAAAoCJo\nBAAAAEBF0AgAAACAiqARAAAAABVBIwAAAAAqF3NXAFZlhtS4a0o9313ExKnbRxjDU0wlfXMxE4/L\no4VLAX50MTOmab8q7PTaNHGK8CWlAG9X1GnOu0nqPcPnhu5qNG7rAto167y7oZxZP7vd5Mz2hkWP\nBSxEltK9hkYvuGEKOAAAAADaxlvcngYAAABARdAIAAAAgIqgEQAAAAAVQSMAAAAAKoJGAAAAAFQu\n5q4AnJQZU8jOkuJ8orSra0ltPvkYTTAfFzPvJkr1e1XUac27R4uZP31x+6KWmzb7uGImmnfnMkZX\nhQ0qa/T6TzgW/VUYsY0zte/U9oZFpXY/83PSosYCTkCW0r3GRi+4YQo4AAAAANrGW9yeBgAAAEBF\n0AgAAACAiqARAAAAABVBIwAAAAAqgkYAAAAAVC7mrgAsztpT43YXKNX0wUVMnK51pjatdd4tIeXv\nsKJOK9X0zcWsZ294WNS65t2ke96I826ScZlo3XQXPXL7Jv6MdOrzbtbU7vaGjrfPOB5wwrKU7v1k\n9IIbpoADAAAAoG28xe1pAAAAAFQEjQAAAACoCBoBAAAAUBE0AgAAAKAiaAQAAABA5WLuCsCsJk4d\nu4sU2oMKk7r96KLMuyMLOo8xuirsbNMz71/Musboqqj17A1rS0P/sNh1zbu17A2Tjcujhdob9jrk\nhHMMViRL6d5jRi+4YQo4AAAAANrGW0a7PS0z35KZz2fmr2TmO8cqBwAAAID2RrnSKDNfERH/Z0R8\nR0R8LiJ+KSK+v5Ty6WuvcaURAAAAQEOncKXRmyPiM6WUF0spX4qIvxER3ztSWQAAAAA0NlbQ6Osj\n4rPXHr+0eQ4AAACAEzBW0Gieb9cGAAAAoImLkY77uYh47bXHr42rq40ekZmX1x7eK6XcG6k+8NBM\nqXG7nHLa0u5ipDsfUJCUxkcXs64xuirK3jCgMPPuqGLOY4yuimpY1kRteVicvWFAYaO2afJ07vaG\nIw4/8RjBhDLzVkTcGuXYI30R9kVcfRH2n4yIfxwRvxi+CBsAAABgVC3jLaNcaVRK+Z3M/E8i4uci\n4hUR8devB4wAAAAAWLZRrjTaq2BXGgEAAAA01TLeMtYXYQMAAABwwgSNAAAAAKgIGgEAAABQETQC\nAAAAoCJoBAAAAEBF0AgAAACAiqARAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKgIGgEAAABQETQC\nAAAAoCJoBAAAAEBF0AgAAACAiqARAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKgIGgEAAABQETQC\nAAAAoCJoBAAAAEBF0AgAAACAiqARAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKgIGgEAAABQETQC\nAAAAoCJoBAAAAEBF0AgAAACAiqARAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKgIGgEAAABQETQC\nAAAAoCJoBAAAAEBF0AgAAACAiqARAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKgIGgEAAABQETQC\nAAAAoCJoBAAAAEBF0AgAAACAiqARAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKgIGgEAAABQETQC\nAAAAoCJoBAAAAEBF0AgAAACAiqARAAAAABVBIwAAAAAqgkYAAAAAVASNAAAAAKgIGgEAAABQETQC\nAAAAoCJoBAAAAEDl6KBRZj6VmZ/MzH+emW/a+tu7MvNXMvP5zPyu4dUEAAAAYEpDrjT6RET86Yj4\n+etPZuYbI+LtEfHGiHhLRPxoZrqiiUXJzFtz14HzZO4xJ/OPuZh7zMn8Yy7mHmtwdDCnlPJ8KeWF\njj99b0T8VCnlS6WUFyPiMxHx5mPLgZHcmrsCnK1bc1eAs3Zr7gpwtm7NXQHO2q25K8DZujV3BWCo\nMa4A+gMR8dK1xy9FxNePUA4AAAAAI7nY9cfMfC4inuj4018upXzogHLKQbUCAAAAYFZZyrB4TmZ+\nNCL+81LKL28ePxMRUUr54c3j/zUibpdSfmHrfQJJAAAAAI2VUrLFcXZeaXSA65X5YET8ZGb+N3F1\nW9o3RcQvbr+hVQMAAAAAaO/o7zTKzD+dmZ+NiD8WEX8rM/92REQp5VMRcTciPhURfzsi/qMy9HIm\nAAAAACY1+PY0AAAAANZnjOxplcz8rzLz05n5v2fmz2Tm11z727sy81cy8/nM/K5rz//RzPzE5m8/\nMkU9Wb/MfMtmrv1KZr5z7vqwPpn52sz8aGZ+MjP/UWb+4Ob5V2fmc5n5QmZ+ODMfu/aezn0QjpGZ\nr8jMj2XmhzaPzT1Gl5mPZeb7N5/3PpWZ32buMZXNfPrk5t8OP5mZ/4L5xxgy88cz835mfuLacwfP\nNf/W5Rg982/0WMskQaOI+HBE/MFSyh+JiBci4l0REZn5xoh4e0S8MSLeEhE/mpkPvuvof4iIP19K\n+aaI+KbMfMtEdWWlMvMVEfHfx9Vce2NEfH9mfsu8tWKFvhQRf6GU8gfj6vbd/3gzz56JiOdKKW+I\niI9sHvftg1PtzazTD8XVLeIPLiU295jCj0TEz5ZSviUi/nBEPB/mHhPIzNdFxA9ExJtKKX8oIl4R\nEd8X5h/j+Im4mjfXHTLX/FuXIbrm3+ixlkk2yFLKc6WU3908/IWI+IbN798bET9VSvlSKeXFiPhM\nRHxbZr4mIn5fKeXBF2j/jxHx1inqyqq9OSI+U0p5sZTypYj4G3E1B6GZUsrLpZSPb37/rYj4dFwl\nBXgyIp7dvOzZeLinde2Db5600qxGZn5DRHx3RPxYPExSYe4xqs3/1fy3Syk/HhFRSvmdUspvhLnH\nNH4zrv6Hzasy8yIiXhUR/zjMP0ZQSvm7EfHrW08fMtf8W5ejdc2/KWItc0TV/4OI+NnN738gIl66\n9reX4uofV9vPf27zPAzx9RHx2WuPH8w3GMXm/35+a1xt4I+XUu5v/nQ/Ih7f/N63D8Ix/mpE/KWI\n+N1rz5l7jO31EfGrmfkTmfnLmfnXMvOrwtxjAqWUfxIR/3VE/N9xFSz6YinluTD/mM6hc82/dRnL\nKLGWZkGjzX2cn+j4+Z5rr/kvIuL/K6X8ZKty4QC+9Z3JZOZXR8TfjIgfKqX80+t/22SU3DUfzVUO\nlpl/KiI+X0r5WDy8yugR5h4juYiIN0XEj5ZS3hQRvx2b2zMeMPcYS2b+KxHxn0XE6+LqH0NfnZl/\n5vprzD+mssdcg1GMGWu5aHWgUsp37vp7Zv77cXXJ/J+89vTnIuK11x5/Q1xFvT4XDy+revD855pU\nlHO2Pd9eG49GWaGJzPw9cRUwem8p5QObp+9n5hOllJc3l4V+fvN81z5ov+MYfzwinszM746Ir4yI\n35+Z7w1zj/G9FBEvlVJ+afP4/XH1nQovm3tM4F+PiL9fSvlCRERm/kxE/Bth/jGdQ86z/q1Lc2PH\nWqbKnvaWuLpc/ntLKf/vtT99MCK+LzNfmZmvj4hviohfLKW8HBG/ucm8kRHxZyPiA9WB4TD/IK6+\n6Ot1mfnKuPpisA/OXCdWZrNn/fWI+FQp5b+99qcPRsQ7Nr+/Ix7uaZ374FT1ZT1KKX+5lPLaUsrr\n4+pLYP9OKeXPhrnHyDaf2z6bmW/YPPUdEfHJiPhQmHuM7/mI+GOZ+Xs35+DviKtkAOYfUznoPOvf\nurQ0Rayl2ZVGN/jvIuKVEfHc/9/e3aNYFQRhGH4rNDBzNwbuwshEzC66ABNNXYMgiCDCrEBXYKZo\noJEguI3BNjjXxCOIPzMjw/OEJ+qgqKa/bk4df9j9eq11WGt9mJmTtsZ+Wh2OT/qqDtXT6krbNI6X\n57RWLqm11unM3K1etU3WeLLW+njBy+LyuV7dqt7PzNvjt/vVo+pkZu5Un6ubVb/og/A3vteR2uM8\n3KueHy9lPlW32/ZatceZWmu9m5lnbZeDX6s31ePqauqPf2xmXlQ3qmsz86V60J/ts866/Laf1N/D\ntnPGmWYto0cCAAAA8KOLmJ4GAAAAwH9OaAQAAADAjtAIAAAAgB2hEQAAAAA7QiMAAAAAdoRGAAAA\nAOwIjQAAAADYERoBAAAAsPMNqr9UBya4Oz4AAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = traffic_log\n", + "y = one_minute_log\n", + "plt.rcParams['figure.figsize'] = 20, 10\n", + "plt.scatter(x, y, marker = \"_\", c=['r','k'])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##Optimal Speed" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average Speed: 27.61777777777778\n", + "Variance: 81.66279506172839\n", + "Standard Deviation: 9.036746929162529\n", + "Optimal_speed: 36.65452470694031\n" + ] + } + ], + "source": [ + "average_speed = statistics.mean(cars_speed)\n", + "print(\"Average Speed: {}\".format(average_speed))\n", + "var = []\n", + "for x in cars_speed:\n", + " var.append((x - average_speed)**2)\n", + "var = statistics.mean(var)\n", + "print(\"Variance: {}\".format(var))\n", + "stdv = var**(.5)\n", + "print(\"Standard Deviation: {}\".format(stdv))\n", + "optimal_speed = average_speed + stdv\n", + "\n", + "print(\"Optimal_speed: {}\".format(optimal_speed))" + ] + }, + { + "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.4.3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Untitled.ipynb b/Untitled.ipynb new file mode 100644 index 0000000..fb87408 --- /dev/null +++ b/Untitled.ipynb @@ -0,0 +1,687 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 2, 3, 4, 5])" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "list_of_nums = np.array([1,2,3,4,5])\n", + "matrix_of_nums = np.array([[1,2,3],\n", + " [4,5,6],\n", + " [7,8,9]])\n", + "list_of_nums" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 2, 3],\n", + " [4, 5, 6],\n", + " [7, 8, 9]])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix_of_nums" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-1, 1, 3, 5, 7])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list_of_nums * 2 - 3" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1, 8, 27],\n", + " [ 64, 125, 216],\n", + " [343, 512, 729]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix_of_nums ** 3" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2, 4, 6],\n", + " [ 8, 10, 12],\n", + " [14, 16, 18]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix_of_nums + matrix_of_nums" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2, 3, 4],\n", + " [ 6, 7, 8],\n", + " [10, 11, 12]])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix_of_nums + np.array([[1],\n", + " [2],\n", + " [3]])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "ename": "ValueError", + "evalue": "operands could not be broadcast together with shapes (3,3) (3,2) ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m matrix_of_nums + np.array([[1, 2],\n\u001b[1;32m 2\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m [3, 4]])\n\u001b[0m", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (3,3) (3,2) " + ] + } + ], + "source": [ + "matrix_of_nums + np.array([[1, 2],\n", + " [2, 3],\n", + " [3, 4]])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2., 4., inf],\n", + " [ 5., 7., inf],\n", + " [ 8., 10., inf]])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix_of_nums + np.array([1, 2, float('inf')])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9\n", + "2\n", + "(3, 3)\n", + "int64\n" + ] + } + ], + "source": [ + "print(matrix_of_nums.size)\n", + "print(matrix_of_nums.ndim)\n", + "print(matrix_of_nums.shape)\n", + "print(matrix_of_nums.dtype)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52, 55, 58,\n", + " 61, 64, 67, 70, 73, 76, 79, 82, 85, 88, 91, 94, 97])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.arange(10, 100, 3)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_range = np.arange(20)\n", + "my_range" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3, 4],\n", + " [ 5, 6, 7, 8, 9],\n", + " [10, 11, 12, 13, 14],\n", + " [15, 16, 17, 18, 19]])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_range = my_range.reshape((4, 5))\n", + "my_range" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 5, 10, 15],\n", + " [ 1, 6, 11, 16],\n", + " [ 2, 7, 12, 17],\n", + " [ 3, 8, 13, 18],\n", + " [ 4, 9, 14, 19]])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_range.swapaxes(0, 1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[81, 65, 83, 74],\n", + " [24, 99, 20, 50],\n", + " [ 8, 3, 32, 28],\n", + " [68, 71, 20, 39],\n", + " [61, 38, 52, 35]])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nums = np.random.randint(1, 100, (5,4))\n", + "nums" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max: 99\n", + "Min: 3\n", + "Mean: 47.55\n", + "Sum: 951\n" + ] + } + ], + "source": [ + "print(\"Max:\", nums.max())\n", + "print(\"Min:\", nums.min())\n", + "print(\"Mean:\", nums.mean())\n", + "print(\"Sum:\", nums.sum())" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max: [81 99 83 74]\n", + "Min: [ 8 3 20 28]\n", + "Sum: [242 276 207 226]\n", + "Mean: [ 48.4 55.2 41.4 45.2]\n" + ] + } + ], + "source": [ + "print(\"Max:\",nums.max(axis=0))\n", + "print(\"Min:\",nums.min(axis=0))\n", + "print(\"Sum:\",nums.sum(axis=0))\n", + "print(\"Mean:\",nums.mean(axis=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 81, 146, 229, 303],\n", + " [ 24, 123, 143, 193],\n", + " [ 8, 11, 43, 71],\n", + " [ 68, 139, 159, 198],\n", + " [ 61, 99, 151, 186]])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nums.cumsum(axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[29, 3, 44, 13],\n", + " [12, 80, 53, 81],\n", + " [18, 18, 63, 36],\n", + " [51, 85, 20, 1],\n", + " [84, 7, 68, 50]])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nums = np.random.randint(1, 100, (5,4))\n", + "nums" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "12" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nums[2,3]\n", + "nums[1,0]" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 3, 44],\n", + " [80, 53]])" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nums [0:2, 1:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'a': 3, 'b': 1, 'n': 2}\n" + ] + } + ], + "source": [ + "word = \"banana\"\n", + "\n", + "expected_histogram = {\n", + " \"b\": 1,\n", + " \"a\": 3,\n", + " \"n\": 2\n", + "}\n", + "\n", + "def convert_to_histogram(word):\n", + " histogram = {}\n", + " for character in word:\n", + " if character in histogram:\n", + " histogram[character] = histogram[character] + 1\n", + " else:\n", + " histogram[character] = 1\n", + " return histogram\n", + "\n", + "returned_histogram = convert_to_histogram(word)\n", + "print(returned_histogram)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "945.4500000000012\n" + ] + } + ], + "source": [ + "cover_price = 24.95\n", + "discount = .4\n", + "discounted_cover_price = cover_price - (cover_price * discount)\n", + "shipping_cost = 3\n", + "secondary_shipping_cost = .75\n", + "\n", + "def get_shipping_cost(index, shipping_cost, secondary_shipping_cost):\n", + " local_shipping_cost = secondary_shipping_cost\n", + " if index == 0:\n", + " local_shipping_cost = shipping_cost\n", + " return local_shipping_cost\n", + "\n", + "def calculate_total_wholesale_cost(copies):\n", + " total_wholesale_cost = 0\n", + " for index in range(60):\n", + " local_shipping_cost = get_shipping_cost(index, shipping_cost, secondary_shipping_cost)\n", + " total_wholesale_cost += local_shipping_cost\n", + " total_wholesale_cost += discounted_cover_price\n", + " return total_wholesale_cost\n", + "wholesale_cost = calculate_total_wholesale_cost(60)\n", + "print(wholesale_cost)" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2\n" + ] + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "panda_cub_in_snow.jpg", + "text/plain": [ + "" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "Image(\"panda_cub_in_snow.jpg\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "impor seaborn as sns\n", + "%matplotlib inline\n" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "head: rdu-daily-2014.csv: No such file or directory\r\n" + ] + } + ], + "source": [ + "!head rdu-daily-2014.csv" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "rdu_weather = pd.read_csv(\"rdu-daily-2014.csv\")\n", + "rdu_weather.head()\n", + "rdu_weather.describe()" + ] + } + ], + "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.4.3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Untitled1.ipynb b/Untitled1.ipynb new file mode 100644 index 0000000..35a5ec4 --- /dev/null +++ b/Untitled1.ipynb @@ -0,0 +1,68 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "head: complaints_dec_2014.csv: No such file or directory\r\n" + ] + } + ], + "source": [ + "!head complaints_dec_2014.csv" + ] + }, + { + "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.4.3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}