0- Python warmup.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>MIT 8.02 ESG </h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Preliminary warmup - not graded </h1>\n",
    "\n",
    "<h2> 0.  Using an on-line notebook </h2>\n",
    "\n",
    "On-line notebooks are composed of \"markdown\" (text) cells, such as the part that you are reading now, and \"code\" cells, such as the one below. Code cells are grey boxes preceeded by <font color=\"light blue\"><b>In [ ] :</b></font>.\n",
    "\n",
    "You can work on this notebook on-line, or if you have experience with Jupyter and the proper Python installation, you can download it from the tab above (look for the left button as shown below) and work on it locally.\n",
    "\n",
    "<img src=\"images/download.png\" width=200 />\n",
    "\n",
    "<b><font color=\"red\">WARNING: if you are working on-line, remember to save your work by clicking on the CLOUD with the arrow pointing down (find in the tab above the middle button in the figure below). If you close the tab you will lose your work! If you saved it, you can load the notebook again and recover your work by clicking on the the cloud with the arrow pointing up (right button in the figure above).</font></b>\n",
    "\n",
    "If you are working on-line, start by clicking on the code cell below (the contour will change color) and then on <font color=\"light blue\"><b> Run </b></font> in the top menu to execute it. This will start a new session. If you are working locally, skip this cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from new_session import *\n",
    "start_session()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the  sections 1 to 7 you will learn some basic syntax in Python, the programming language used in these simulations. If you are already familiar with Python you can go to section 8."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> 1.  Indentation:</h2>\n",
    "\n",
    "Indentation is mandatory in Python to define the blocks of statements. The number of spaces must be uniform in a block of code. </font><b> When you uncomment a line (as we will ask below and in the problems), be sure the indentation (= the number of spaces) is consistent with the rest of the block</b></font> .\n",
    "\n",
    "<h2> 2.  Basic operations:</h2>\n",
    "\n",
    "<h3> a) Addition, subtraction, multiplication and division</h3>  \n",
    "\n",
    "You can type simple operations in the cells.  The example below shows: 2+3.Click on the code cell, and then \n",
    "\n",
    " click <font color=\"blue\"><b>Run</b></font> in the top menu: the output will appear in a new cell  below, identified by <b><font color=\"red\">Out[ ] = </font></b>.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2+3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can delete 2+3 and enter other statements. Try for example:  5-7, 6/2, 3*4, 6%2, 6/5. Always click Run to see the output and make sense of it.\n",
    "\n",
    "\n",
    "<h3> b) Exponentiation:</h3>\n",
    "\n",
    "This one is tricky!!  For $2^3$ type 2**3 and run it!\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> 3. Storing information in variables</h2>\n",
    "\n",
    "Variables provide a way to associate names with objects.\n",
    "<ul>\n",
    "\n",
    "<li>Example 1: The statement <b>a = 5.2</b>  binds the float (the data type used to represent real numbers) <b>5.2</b> to the variable <b>a</b>.</li>\n",
    "\n",
    "<li>Example 2: The statement <b>b = \"Hello MIT\"</b> binds the string <b>Hello MIT</b> to the variable <b>b</b>. </li>\n",
    "</ul>\n",
    "\n",
    "<b>Note 1:</b> the quotation marks are used to identify the object as a string, an object used to represent characters.\n",
    "\n",
    "<b>Note 2:</b> upper and lowercase letters are different in Python! If you define <b>a = 5.2</b>, you are not binding A to the same value.\n",
    "\n",
    "<h2> 4. Print statement </h2>\n",
    "\n",
    "The <b>print( ) function </b> shows as output anything you put in between the parenthesis. Let's try this function. Type in the cell below:\n",
    "\n",
    "<ul>   \n",
    "    <li><b>a = 5.2</b></li>\n",
    "    <li><b>b = \"Hello MIT\"</b></li>    \n",
    "</ul>\n",
    "\n",
    "Click <b>Run</b>: nothing happens! \n",
    "\n",
    "If you want to know what is stored in the variables <b>a</b> and <b>b</b> just use the print( ) function typing in the cell the following statements:\n",
    "\n",
    "<ul> \n",
    "    <li><b>print(a)</b></li>\n",
    "    <li><b>print(b)</b></li>\n",
    "</ul>\n",
    "    \n",
    "and run it again.\n",
    "You can also be more explicit by adding some text to describe what you are printing. <b> Note:</b> you must put the text between quotation marks as follows:\n",
    "\n",
    "<ul> \n",
    "    <li><b>print( \"This is what I stored in a:\", a )</b></li>\n",
    "</ul>\n",
    "\n",
    "Also, note that we separate the two arguments inside the parenthesis by a comma.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> 5. Storing information in a list.</h3>\n",
    "\n",
    "A list is an ordered sequence of values, where each value is identified by an index.\n",
    "Lists are written by enclosing a comma-separated list of elements within square parentheses.\n",
    "\n",
    "Example: Store the integer numbers 2, -3, and 8 in the list call MyList\n",
    " \n",
    "<ul>\n",
    "    <li><b>MyList = [ 2, -3, 8]</b></li>\n",
    "</ul>\n",
    "\n",
    "You can print to the screen all the list by typing:\n",
    "<ul>\n",
    "    <li><b>print( MyList )</b></li>\n",
    "</ul>\n",
    "\n",
    "You can also print the elements of the list. In Python, the index of a list starts at 0. In this example, MyList has a length of 3 so the index starts at 0 and ends at 2. Check it by typing:\n",
    "\n",
    "<ul>\n",
    "    <li>print(\"The first element of MyList is:\" , MyList[ 0 ] )</li>\n",
    "    <li>print(\"The second element of MyList is:\" , MyList[ 1 ] )</li>\n",
    "    <li>print(\"The third element of MyList is:\" , MyList[ 2 ] )</li>\n",
    "</ul>\n",
    "\n",
    "Click <b>Run</b>.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> 6. Adding explanatory text to your code </h3>\n",
    "\n",
    "Anything preceeded by the hash symbol # is a \"comment\", meaning that it is not interpreted by Python. See an example below:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NewList = [1,2,3,4]  # Here is my new list\n",
    "\n",
    "#I will print the 3rd element of the list and I will NOT print the 1st element\n",
    "\n",
    "print(\"The 3rd element\", NewList[2])\n",
    "#print(\"The 1st element\", NewList[0]))\n",
    "print(\"Note that nothing behind the # is executed\")\n",
    "\n",
    "# Do not forget to Click Run\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>7. Functions in Python  </h3>\n",
    "\n",
    "Python comes with a large library of functions, print( ) is one of them. You can also write your own function!</font><b> We will not ask you to write a function, just to modify what is in the body: be careful with indentation when you do so!</b></font>\n",
    "\n",
    "A function is a generic piece of code that can be used repeatedly. It takes a number of parameters, then it executes the code in the body of the function  until either a return statement is encountered, in which case the value of the expression following the return becomes the value of the function invocation, or there are no more statements to execute, in which case the function returns the value None. \n",
    "\n",
    "We now write as an example a function that has a number as input parameter and that returns a value equal to the square of the number. We will call this function square( ). The syntax is explained in the cell below. To use the function you need to call it with actual parameter/s, as show in the example. \n",
    "    \n",
    "</font><b>Notice the indentation. We do not define x inside the function: x is passed to it when we call it.\n",
    "The body assumes that x is known </b></font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(x): # name of function (list of formal parameters)\n",
    "    \"\"\"This function returns the square of a float or integer x\"\"\" # This is a docstring, it provides\n",
    "    # documentation about the function\n",
    "    return x**2  # body of the function\n",
    "\n",
    "z = square(6) # call the function binding the actual parameter 6 to the formal parameter x\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Self-check. Now try to run the cell below: what happens? How would you fix it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(x): # name of function (list of formal parameters)\n",
    "    \"\"\"This function returns the square of a float or integer x\"\"\" # This is a docstring, it provides\n",
    "    # documentation about the function\n",
    "return x**2  # body of the function\n",
    "\n",
    "z = square(6) # call the function binding the actual parameter 6 to the formal parameter x\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> 8. Visualizing vectors and unit vectors </h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For visualizations, we will mostly use  the VPython package (called vpython when imported). In this section, for example you will learn how to visualize vectors and unit vectors. Here, and in the problems you have to solve, we provide you with a code that is mostly ready to use, with functions that we wrote for you. You just need to fill in a few lines and run it. The code below guides you to write a function that has a 3D vector as argument \n",
    "$$\\vec{\\mathbf{V}} = (v_x,v_y,v_x).$$ \n",
    "It  returns the components of the relative unit vector \n",
    "$$\\hat{\\mathbf{u}} = (u_x,u_y,u_x) = \\frac{\\vec V}{|\\vec V|}.$$ \n",
    "There are libraries (including VPython) with methods that would do all these calculations for us, but here the goal is to make you reflect on the nature of vectors, so you will be asked to code some parts \"from scratch\". \n",
    "Complete the parts where it says FILL IN and run it. DO NOT CHANGE THE NAMES OF VARIABLES. We wrote manual tests to check your work: compare the output you get with the expected ouput written in the comments below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from vpython import *  #Here we're importing all the vpython package \n",
    "\n",
    "def unit_vector(V):\n",
    "    \"\"\"The function takes the following  input:\n",
    "    V = [v_x,v_y,v_z], a list of the x,y & z components of a vector V of non-zero length \n",
    "    It returns [u_x,u_y,u_z], a list the x,y & z components of the unit vector in the direction of V.\"\"\"\n",
    "    # First: calculate the magnitude of the vector \n",
    "    # Hint 1: use sqrt( ) for square root, the function provided by vptyhon\n",
    "    # Reminder 1: x**2 for x^2. \n",
    "    # Reminder  2: the input V is an orderered sequence of values with indexes starting from zero. \n",
    "    # V is passed to the function, you do not want to define it inside it, or you will\n",
    "    # bind it to a specific value.\n",
    "    # So, assume V is given. If you want  the first element v_x, you must type V[0].\n",
    "\n",
    "    \n",
    "    #magnitude = FILL IN \n",
    "    \n",
    "    \n",
    "    # Second: calculate the components of the unit vector\n",
    "    # Remember, the unit vector is given by a vector divided by its magnitude\n",
    "    \n",
    "    #u_x = FILL IN\n",
    "    #u_y = FILL IN\n",
    "    #u_z = FILL IN\n",
    "    \n",
    "    \n",
    "    \n",
    "    return ([u_x,u_y,u_z]) # return the components of the unit vector as a list\n",
    "\n",
    "# Basic manual tests. Do you get the expected output?\n",
    "\n",
    "print(unit_vector([3,0,0])) # Expected output: [1.0, 0.0, 0.0]\n",
    "print(unit_vector([0,3,0])) # Expected output: [0.0, 1.0, 0.0]\n",
    "print(unit_vector([0,0,3])) # Expected output: [0.0, 1.0, 0.0]\n",
    "a = unit_vector([1,1,0])\n",
    "print(a) # Expected output: [0.7071067811865475, 0.7071067811865475, 0.0]\n",
    "print(sqrt(a[0]**2 + a[1]**2 + a[2]**2)) # Expected output: close to 1, due numerical to approximations (analytically it is 1)\n",
    "b = unit_vector([1,2,3])\n",
    "print(b) # Expected output: [0.2672612419124244, 0.5345224838248488, 0.8017837257372732]\n",
    "print(sqrt(b[0]**2 + b[1]**2 + b[2]**2)) # Expected output: close to 1 (analytically it is 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now run the cell below: it defines the function draw_vector to draw a vector and relative unit vector as graphical objects. Read only the docstring (in red). You do not need to read and understand the body of the function, but you are welcome to do so!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_vector(V):\n",
    "    \"\"\"The function takes the following  input:\n",
    "    V = [v_x,v_y,v_z], a list of the x,y & z components of a vector V of non-zero length\n",
    "    and it creates a canvas representing the vector in green and the relative unit vector in red\n",
    "    Both vectors have the tail in the center of the canvas, at position (0,0,0)\"\"\"\n",
    "    scene = canvas()\n",
    "    Varrow = arrow(pos = vector(0,0,0), axis = vector(V[0], V[1],V[2]), shaftwidth = 0.05, color = color.green)\n",
    "    u = unit_vector(V)  # Call the function unit_vector on the instance vector V\n",
    "    uarrow = arrow(pos = vector(0,0,0), axis = vector(u[0], u[1],u[2]), shaftwidth=0.07, color = color.red)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, call the draw_vector function for some test cases to visualize vectors and unit vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Call draw_vector on the following vectors:\n",
    "\n",
    "# [3,0,0] expect a vector pointing to the right\n",
    "# [0,3,0] expect a vector pointing up\n",
    "# [0,0,3] expect a vector pointing out of the screen\n",
    "# [1,1,0] expect a vector pointing diagonally up-right\n",
    "# Each unit vector is aligned with the relative vector.\n",
    "\n",
    "\n",
    "# FILL IN\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}