Lect_0621b.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lecture 06-21-2021 -- Part b\n",
    "\n",
    "## Today we will cover\n",
    " - Brief history of python\n",
    " - Python's place in the family of programming languages\n",
    " - Basic variables (integer, float, string)\n",
    " - Conversions between the basic variable types\n",
    " - Boolean variables\n",
    " - \"Collection\" data types\n",
    "    - lists\n",
    "    - tuples\n",
    "    - sets\n",
    "    - dictionaries\n",
    " - Operators\n",
    " - Control statements\n",
    " - Functions\n",
    " \n",
    "## Today's homework will be:\n",
    "1. Write a function to compute the square root of a positive number.\n",
    "2. Write a function to compute prime numbers.\n",
    "\n",
    "\n",
    " \n",
    "For more detail on python please see the Purdue DataMine web link: <a href=\"https://thedatamine.github.io/the-examples-book/python.html\" target=\"_blank\">Data Mine on Python</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "   \n",
    "Function are blocks of code that run when called. \n",
    "\n",
    "- Can pass parameters to a function. \n",
    "- A function can return a value.\n",
    "\n",
    "Functions allow code to be more readable by allowing the hiding of details of an operation that may not be central to the understanding of the overall algorithm. Sometimes, this is called encapsulation. For example, perhaps we want to solve some sort of geometric problem, such as finding the height of a tree from the angle of the sun and the length of the shadow cast on the ground. The height calculation will involve intermediate calculations of trigonometric functions of the angle (e.g., sine, cosine, tangent). These sorts of intermediate calculations are naturally left to functions in python and other programming languages.\n",
    "\n",
    "In addition, functions ...\n",
    "\n",
    "- Assist in divide and conquer problem solving.\n",
    "- Allow to reuse the function code in other parts of a larger program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30.0\n",
      "13.0\n"
     ]
    }
   ],
   "source": [
    "# Example function to compute area capacity of a tractor + implement.\n",
    "# From Prof. Buckmaster's planter-optimizer_B.xlsx example.\n",
    "\n",
    "def width_from_rows_spacing(Nrows,Wper):\n",
    "    return Nrows*Wper/12\n",
    "\n",
    "def area_capacity(speed,width,fieldefficiency):\n",
    "    return speed*width*fieldefficiency/8.25\n",
    "\n",
    "width = width_from_rows_spacing(12,30)\n",
    "\n",
    "print(width)\n",
    "\n",
    "print(area_capacity(5.5,width,0.65))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A Need for a Function ...\n",
    "\n",
    "A few years ago I used a pair of smart phone apps to log cell phone strength while I was working wheat harvest. These apps were called `NetMonitor` and `NetworkCell`. When opened in Excel the file looked like ...\n",
    "\n",
    "<img align=\"left\" src='Figs/ImageOfCSV.png' width=\"800\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I manually grabbed the first line of the file above and saved it below as a single text string in the string variable `headstring` ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The first line of the cell phone log file\n",
    "headstring = 'report;sys_time;sim_state;net_op_name;net_op_code;roaming;net_type;call_state;data_state;data_act;data_rx;data_tx;gsm_neighbors;umts_neighbors;lte_neighbors;rssi_strongest;tech;mcc;mnc;lac_tac;node_id;cid;psc_pci;rssi;rsrq;rssnr;slev;gps;accuracy;lat;long;band;arfcn;bts_psc_pci;bts_band;bts_arfcn;site_name;site_lat;site_long;cell_name;azimuth;height;tilt_mech;tilt_el;'       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "\n",
      "report;sys_time;sim_state;net_op_name;net_op_code;roaming;net_type;call_state;data_state;data_act;data_rx;data_tx;gsm_neighbors;umts_neighbors;lte_neighbors;rssi_strongest;tech;mcc;mnc;lac_tac;node_id;cid;psc_pci;rssi;rsrq;rssnr;slev;gps;accuracy;lat;long;band;arfcn;bts_psc_pci;bts_band;bts_arfcn;site_name;site_lat;site_long;cell_name;azimuth;height;tilt_mech;tilt_el;\n"
     ]
    }
   ],
   "source": [
    "print(type(headstring))\n",
    "print()\n",
    "print(headstring)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second line of the log file was captured and placed below as the string variable `datastring` ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The second line of the cell phone log file\n",
    "datastring = '0;20190708155136;READY;Verizon Wireless;311480;0;LTE;IDLE;CONNECTED;INOUT;2609703;771758;0;0;1;-76;LTE;311;480;55423;942108;2;62;-68;-7;226;4;1;3;39.71412349;-91.42606194;700;5230;null;null;null;null;;;null;null;null;null;null;'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "\n",
      "0;20190708155136;READY;Verizon Wireless;311480;0;LTE;IDLE;CONNECTED;INOUT;2609703;771758;0;0;1;-76;LTE;311;480;55423;942108;2;62;-68;-7;226;4;1;3;39.71412349;-91.42606194;700;5230;null;null;null;null;;;null;null;null;null;null;\n"
     ]
    }
   ],
   "source": [
    "print(type(datastring))\n",
    "print()\n",
    "print(datastring)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The first step to making sense of my cell phone log data might be to ...\n",
    "\n",
    "Make a function which would parse the individual items, in order that I could line them up later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining my new function ...\n",
    "def my_parse(string_in):\n",
    "    out_list = []\n",
    "    current = ''\n",
    "    for x in string_in:\n",
    "        if x == ';':\n",
    "            out_list.append(current)\n",
    "            current = ''\n",
    "        else:\n",
    "            current = current + x\n",
    "    if current != '':\n",
    "        out_list.append(current)\n",
    "    return out_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['How do', ' you', ' do?', ' My name is:', ' Sue.']\n"
     ]
    }
   ],
   "source": [
    "# Try it on a short string or two ...\n",
    "print(my_parse('How do; you; do?; My name is:; Sue.'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['How do', '', ' you', ' do?', ' My name is:', '', ' Sue.']\n"
     ]
    }
   ],
   "source": [
    "print(my_parse('How do;; you; do?; My name is:;; Sue.'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "44\n",
      "['report', 'sys_time', 'sim_state', 'net_op_name', 'net_op_code', 'roaming', 'net_type', 'call_state', 'data_state', 'data_act', 'data_rx', 'data_tx', 'gsm_neighbors', 'umts_neighbors', 'lte_neighbors', 'rssi_strongest', 'tech', 'mcc', 'mnc', 'lac_tac', 'node_id', 'cid', 'psc_pci', 'rssi', 'rsrq', 'rssnr', 'slev', 'gps', 'accuracy', 'lat', 'long', 'band', 'arfcn', 'bts_psc_pci', 'bts_band', 'bts_arfcn', 'site_name', 'site_lat', 'site_long', 'cell_name', 'azimuth', 'height', 'tilt_mech', 'tilt_el']\n"
     ]
    }
   ],
   "source": [
    "# Calling my new function on headstring ...\n",
    "mylist = my_parse(headstring)\n",
    "\n",
    "print(type(mylist))\n",
    "print(len(mylist))\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "44\n",
      "['0', '20190708155136', 'READY', 'Verizon Wireless', '311480', '0', 'LTE', 'IDLE', 'CONNECTED', 'INOUT', '2609703', '771758', '0', '0', '1', '-76', 'LTE', '311', '480', '55423', '942108', '2', '62', '-68', '-7', '226', '4', '1', '3', '39.71412349', '-91.42606194', '700', '5230', 'null', 'null', 'null', 'null', '', '', 'null', 'null', 'null', 'null', 'null']\n"
     ]
    }
   ],
   "source": [
    "# Calling my new function on datastring ...\n",
    "mylist2 = my_parse(datastring)\n",
    "\n",
    "print(type(mylist2))\n",
    "print(len(mylist2))\n",
    "print(mylist2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now to line the values in the two lists up we could ...\n",
    "\n",
    "Use a dictionary structure of key-value pairs ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'accuracy': '3',\n",
       " 'arfcn': '5230',\n",
       " 'azimuth': 'null',\n",
       " 'band': '700',\n",
       " 'bts_arfcn': 'null',\n",
       " 'bts_band': 'null',\n",
       " 'bts_psc_pci': 'null',\n",
       " 'call_state': 'IDLE',\n",
       " 'cell_name': 'null',\n",
       " 'cid': '2',\n",
       " 'data_act': 'INOUT',\n",
       " 'data_rx': '2609703',\n",
       " 'data_state': 'CONNECTED',\n",
       " 'data_tx': '771758',\n",
       " 'gps': '1',\n",
       " 'gsm_neighbors': '0',\n",
       " 'height': 'null',\n",
       " 'lac_tac': '55423',\n",
       " 'lat': '39.71412349',\n",
       " 'long': '-91.42606194',\n",
       " 'lte_neighbors': '1',\n",
       " 'mcc': '311',\n",
       " 'mnc': '480',\n",
       " 'net_op_code': '311480',\n",
       " 'net_op_name': 'Verizon Wireless',\n",
       " 'net_type': 'LTE',\n",
       " 'node_id': '942108',\n",
       " 'psc_pci': '62',\n",
       " 'report': '0',\n",
       " 'roaming': '0',\n",
       " 'rsrq': '-7',\n",
       " 'rssi': '-68',\n",
       " 'rssi_strongest': '-76',\n",
       " 'rssnr': '226',\n",
       " 'sim_state': 'READY',\n",
       " 'site_lat': '',\n",
       " 'site_long': '',\n",
       " 'site_name': 'null',\n",
       " 'slev': '4',\n",
       " 'sys_time': '20190708155136',\n",
       " 'tech': 'LTE',\n",
       " 'tilt_el': 'null',\n",
       " 'tilt_mech': 'null',\n",
       " 'umts_neighbors': '0'}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is called list comprehension .... explain more on this later\n",
    "JVKdict = {mylist[i]: mylist2[i] for i in range(len(mylist))}\n",
    "\n",
    "print(type(JVKdict))\n",
    "JVKdict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### I wonder where I was that day ...\n",
    "\n",
    "Look at `sys_time` and at `lat` and `long`. Could type into a google map ...\n",
    "\n",
    "<a href=\"https://www.google.com/maps/\" target=\"_blank\">Google Map</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HW Problem 1: Computing the square root\n",
    "\n",
    "Create a function that \n",
    "\n",
    "1. takes two parameters: a positive number and a tolerance.\n",
    "and\n",
    "2. returns the square root of the positive number to within the tolerance specified.\n",
    "\n",
    "You may google \"square root algorithms\" or some such, or check out the so-called Babylonian method.\n",
    "See:\n",
    "<a href=\"https://en.wikipedia.org/wiki/Methods_of_computing_square_roots\" target=\"_blank\">Wikipedia</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HW Problem 2: Sieve of Eratosthenes\n",
    "\n",
    "Sift the Twos and Sift the Threes,\n",
    "The Sieve of Eratosthenes.\n",
    "When the multiples sublime,\n",
    "The numbers that remain are Prime.\n",
    "\n",
    "Here in words is the algorithm. n is an integer greater than 2. The algorithm finds all the primes less than or equal to n. Remember that 1 is not a prime (on a technicality), 2 is a prime and the only even prime, 3 is prime, etc.\n",
    "\n",
    "1. Create a list of consecutive integers from 2 to n: (2, 3, 4, ..., n)\n",
    "2. Let p = 2 to start. p is prime.\n",
    "3. Remove all the multiples 2p, 3p, 4p, etc. from the list\n",
    "4. Find the next largest number in the new list and call it p. This number will be prime.\n",
    "5. Repeat steps 3 and 4 until all the numbers in the list have either been marked as prime or removed.\n",
    "\n",
    "Notice that the algorithm does not need to check for any p's greater than the square root of n (hence you could use the square root function created in problem 1 to limit the search here).\n",
    "\n",
    "There is a Wikipedia page and many youtube links of interest: <a href=\"\n",
    "https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes\" target=\"_blank\">Sieve of Eratosthenes</a>"
   ]
  },
  {
   "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.5.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}