TEST1_Python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please note the area of the polygon given by the ordered coordinates,  [(0, 0), (2, 0), (2, 2), (0, 2)] is:  4.0 square units according to Green's Theorem Area! Yay! Thank you!\n",
      "\n",
      "\n",
      "#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#\n",
      "\n",
      "Please note the area of the polygon given by the ordered coordinates,  [(2, 1), (2, 2), (3, 2)] is:  0.5 square units according to Green's Theorem Area! Yay! Thank you!\n",
      "\n",
      "\n",
      "#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#\n",
      "\n",
      "Please note the area of the polygon given by the ordered coordinates,  [(2, 2), (3, 2), (2, 1)] is:  0.5 square units according to Green's Theorem Area! Yay! Thank you!\n",
      "\n",
      "\n",
      "#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#\n",
      "\n",
      "Please note the area of the polygon given by the ordered coordinates,  [(3, 2), (2, 2), (2, 1)] is:  0.5 square units according to Green's Theorem Area! Yay! Thank you!\n",
      "\n",
      "\n",
      "#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#\n",
      "\n",
      "Please note the area of the polygon given by the ordered coordinates,  [(0, 0), (3, 4), (0, 4), (3, 0)] is:  0.0 square units according to Green's Theorem Area! Yay! Thank you!\n",
      "\n",
      "\n",
      "#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#\n",
      "\n",
      "Please note the area of the polygon given by the ordered coordinates,  [(0, 0), (3, 4), (0, 4), (2, 6), (0, 4), (3, 0)] is:  0.0 square units according to Green's Theorem Area! Yay! Thank you!\n",
      "\n",
      "\n",
      "#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#\n",
      "\n",
      "Please note the area of the polygon given by the ordered coordinates,  [(0, 0), (3, 4), (0, 4), (2, 0), (4, 0), (3, 0)] is:  2.0 square units according to Green's Theorem Area! Yay! Thank you!\n",
      "\n",
      "\n",
      "#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#\n",
      "\n",
      "Please enter 3 or more (x,y) coordinates!\n",
      "Please note the area of the polygon given by the ordered coordinates,  [(2, 1), (3, 4)] is:  0.0 square units according to Green's Theorem Area! Yay! Thank you!\n",
      "\n",
      "\n",
      "#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#\n",
      "\n",
      "Please note the area of the polygon given by the ordered coordinates,  [(2, 1), (3, 1), (4, 1)] is:  0.0 square units according to Green's Theorem Area! Yay! Thank you!\n",
      "\n",
      "\n",
      "#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#\n",
      "\n",
      "Please note the area of the polygon given by the ordered coordinates,  [(2, 1), (2, 4), (2, 6), (3, 4)] is:  2.5 square units according to Green's Theorem Area! Yay! Thank you!\n",
      "\n",
      "\n",
      "#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#\n",
      "\n",
      "Please note the area of the polygon given by the ordered coordinates,  [(2, 1), (2, 4), (2, 6), (3, 4), (9, 8)] is:  9.5 square units according to Green's Theorem Area! Yay! Thank you!\n",
      "\n",
      "\n",
      "#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#\n",
      "\n",
      "Please note the area of the polygon given by the ordered coordinates,  [(0, 14), (2, 0), (2, 3), (0, 2), (9, 5), (8, 7)] is:  49.5 square units according to Green's Theorem Area! Yay! Thank you!\n",
      "\n",
      "\n",
      "#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#YAY SO FAR! :)\n",
    "\n",
    "\n",
    "#coordinateValues = []\n",
    "def polygarea(coords):\n",
    "    \"\"\"\n",
    "    Please describe the function. \n",
    "    \n",
    "    Please note that for xy coordinates in the positive ++ quadrant (quadrant 1), Green's Theorem returns Positive area ONLY if the vertices are numbered clockwise around the perimeter.  That is, sketching the polygon should be done in a clockwise way. \n",
    "    If it is done in a counter-clockwise ordering sketch, then the computed area will be negative. \n",
    "    \n",
    "    For example:\n",
    "    polygarea([(2, 2), (3,2), (2,1)]) yields a negative area: -1\n",
    "    polygarea([(3, 2), (2,2), (2,1)]) yields a positive area: 1\n",
    "    \n",
    "\n",
    "    In both cases, the set of points are the same.  However the computed area is different based on the order. Please note that here, for this function, Saniya (based upon Professor Pilcher's formula) is using the absolute value, so that no matter what the area returned will ALWAYS be positive :).  No need to worry about clockwise or counterclockwise here...please order polygon sides as ye like, but in consecutive edge order:)\n",
    "    Please note these characteristics of a polygon:\n",
    "        Sides do NOT intersect. \n",
    "        Closed figure\n",
    "        All edges are straight lines. \n",
    "        \n",
    "    Please note that here Saniya has put the comments in terms of this general example (given by Professor Pilcher)\n",
    "     of this square with these coordinates:  (0, 0), (2,0), (2,2), (0,2). \n",
    "     Please note that the coordinates should be entered in the order in which the polygon should be created.  All coordinates should be unique.  The first set of coordinates essentially becomes interpreted as the last set of coordinates as well since the figure needs to close. \n",
    "     Therefore, for these coordinates: (0, 0), (2,0), (2,2), (0,2), the program will go from: (0,0) to (2,0) to (2,2) to (0,2), and finally back to (0,0).\n",
    "     \n",
    "     Please note that when entering the coordinates in the polygarea function, please enter them in this form:\n",
    "     polygarea([(x1,y1), (x2,y2), (x3,y3),...(xn,yn)]).\n",
    "     That is for example the 2 by 2 square formed by these points: (0, 0), (2,0), (2,2), (0,2) will have an area of: (2)(2)= 4 units squared.\n",
    "    Hence, the function: polygarea([(0, 0), (2,0), (2,2), (0,2)]) should yield a 4. \n",
    "    \n",
    "    Please note that in the comments, oftentimes ye will see \"print\" commented out and this is since Saniya would test the code values for different parts.  It is helpful to still include these comments so that the reader can understand Saniya's thought processes. \n",
    "    Please note that Saniya humbly then tested the results obtained with (X,Y) polygon area calculators on the web to see how the results compared and those matched. \n",
    "    \"\"\"\n",
    "    CoordsList = [num for elem in coords for num in elem]   # flatten a list using a listcomp with two 'for'\n",
    "    # please note the source of this code idea is: #https://docs.python.org/2/tutorial/datastructures.html\n",
    "    # we thus get: [0, 0, 2, 0, 2, 2, 0, 2]\n",
    "    #then, we please assign this to a vector: \n",
    "\n",
    "\n",
    "    # even index elements go to the x matrix.  Even though 0 is NOT even, the elements 2, 4, etc. are! \n",
    "    # odd index elements go to the y matrix. \n",
    "\n",
    "    LengthCoordsList = len(CoordsList)\n",
    "    #print(LengthCoordsList) #8 here\n",
    "\n",
    "    if LengthCoordsList == 4:\n",
    "        print(\"Please enter 3 or more (x,y) coordinates!\")\n",
    "\n",
    "    NumOfCoordinatesN = (LengthCoordsList)/(2) #please note that this is the value for n\n",
    "    #print(NumOfCoordinatesN)  #here, this would yield 4 since there are 4 coordinates! :)\n",
    "    xlist = []\n",
    "    ylist = []\n",
    "\n",
    "    xlistForPosTerms = []  #please remove the last element here for the xlist\n",
    "    xlistForNegTerms = []\n",
    "\n",
    "    i = 0\n",
    "\n",
    "    while i < LengthCoordsList:\n",
    "        NewXvalue = CoordsList[i]\n",
    "        xlist.append(NewXvalue)\n",
    "        xlistForPosTerms.append(NewXvalue)\n",
    "        xlistForNegTerms.append(NewXvalue)\n",
    "\n",
    "        i = i + 2\n",
    "    firstxValue = CoordsList[0]\n",
    "    xlist.append(firstxValue)  #please note that we want to join the coordinates of the figure in the order they are given and so we must go back to square 1 (pun intended), which is the 1st point given.  We are closing the figure. \n",
    "    xlistForNegTerms.append(firstxValue) \n",
    "\n",
    "    #print(xlist)  #the 1st and last element will correspond to the same x,y pair...here we are closing the figure and the x component goes to the xlist.\n",
    "    #print(xlistForPosTerms, \"POS and misses last element\")  \n",
    "    #print(xlistForNegTerms, \"NEG\")\n",
    "\n",
    "\n",
    "\n",
    "    j = 1  #here, the y values start at index 1 and go on to index 3, 5, ... etc. \n",
    "#the same concept applies to creating the vectors of y values. \n",
    "    ylistForPosTerms = []\n",
    "    ylistForNegTerms = []\n",
    "    while j < LengthCoordsList:\n",
    "        NewYvalue = CoordsList[j]\n",
    "        ylist.append(NewYvalue) \n",
    "        ylistForPosTerms.append(NewYvalue) \n",
    "        ylistForNegTerms.append(NewYvalue) \n",
    "        j = j + 2\n",
    "    #adding on the last element, which should be the same as the 1st element. \n",
    "    firstyValue = CoordsList[1]\n",
    "    ylist.append(firstyValue)\n",
    "    ylistForPosTerms.append(firstyValue)\n",
    "\n",
    "    #print(ylistForPosTerms, \"POS\")  \n",
    "    #print(ylist)\n",
    "    #print(ylistForNegTerms, \"NEG and misses last element\")\n",
    "\n",
    "\n",
    "    #defensive programming:  just in case, please note\n",
    "    if len(xlist) != len(ylist):\n",
    "        print(\"Please note that there is a problem with the coordinate values you have entered! Please make sure you have specified both an x and y coordinate for each x,y pair.\")\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    #print(CoordsList, \"CoordsList\")\n",
    "    #print(4 + 5)\n",
    "\n",
    "    #to the xlist we will additionally append the 1st element at the end since Greens Theorem goes back to the start. \n",
    "\n",
    "    # Please note: An index of x 1 greater than y leads to negative term like:  -x2y1, -x3y2, -x4y3, -x5y4\n",
    "\n",
    "\n",
    "    maxIndex = len(xlist) #here, please note that this is 5. \n",
    "\n",
    "\n",
    "    #print(maxIndex, \"maxIndex\")\n",
    "\n",
    "    # Please note: An index of x 1 less than y leads to a positive term like:  x1y2, x2y3, x3y4, x4y5\n",
    "\n",
    "\n",
    "    maxIndex = len(xlist) \n",
    "    #print(maxIndex, \"maxIndex\")\n",
    "    \n",
    "    #here, we please try to find the positive terms like x1y2, x2y3, x3y4, x4y5, etc. \n",
    "\n",
    "\n",
    "    # Green's Theorem involves summing these values to get some net number...then dividing that net number by 2 yields the Area\n",
    "\n",
    "\n",
    "\n",
    "    #***Below, please note that we please try to find the positive terms like x1y2, x2y3, x3y4, x4y5, etc. \n",
    "\n",
    "    #please note that the pop function is of the form:  list.pop(index), where index is the position of the element in the list that we want to remove. \n",
    "    #the pop function pops off that given element with that index position in the original list.  It gets rid of that value.  \n",
    "    indexLastElement = len(xlist) - 1  #please note that the indexing begins at 0.  Therefore, a list of 5 elements will go up to index 4.  Hence, we please subtract 1 from the # of elements (given by len(xlist)) to get the maximum index. \n",
    "    #print(indexLastElement)\n",
    "\n",
    "\n",
    "    #xlist.pop(indexLastElement)\n",
    "    #print(xlistForPosTerms)\n",
    "    #print(xlistForPosTerms, \"xlistposterms\")\n",
    "\n",
    "    #please remove the 1st element here for the ylist.  Please note that this 1st element always has the index of 0. \n",
    "\n",
    "\n",
    "\n",
    "    ylistForPosTerms.pop(0)  #please note this is removing the 1st term from the ylist. \n",
    "    #print(ylistForPosTerms, \"ylistposterms\")\n",
    "\n",
    "\n",
    "    #now, please note that these are the 2 new lists: \n",
    "\n",
    "    #xlistForPosTerms = [0, 2, 2, 0] -->  values are x1, x2, x3, and x4 respectively (From the original xlist)\n",
    "    # ylistForPosTerms = [0, 2, 2, 0]  --> values are y2, y3, y4, and y5 respectively (From the original ylist)\n",
    "\n",
    "    #Now, when we multiply respective elements in xlistForPosTerms with the corresponding ones in ylistForPosTerms, we essentially will get: \n",
    "    # a list with:  [x1y2, x2y3, x3y4, x4y5,..., etc.] \n",
    "\n",
    "    xlistMultylistPosValues = []  # Please note that this creates an empty list that will ultimately have x1y2, x2y3, x3y4, x4y5, etc. \n",
    "\n",
    "    for k in range(0, len(xlistForPosTerms)):\n",
    "        xlistMultylistPosValues.append(xlistForPosTerms[k] * ylistForPosTerms[k])\n",
    "\n",
    "    #print(xlistMultylistPosValues) #[0, 4, 4, 0]\n",
    "\n",
    "    #Then to get the sum of all the positive values, please note that we will just use the sum(list) function and that adds together ALL of the terms in the list. \n",
    "\n",
    "    sumPositivexyvalues = sum(xlistMultylistPosValues)\n",
    "    #print(sumPositivexyvalues)\n",
    "\n",
    "    #hence, sumPositivexyvalues = x1y2 + x2y3 + x3y4 + x4y5 + ... etc.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    #***Below, please note that we now please try to find the negative terms like x2y1, x3y2, x4y3, x5y4, etc. \n",
    "\n",
    "    # indexLastElement gives us the maximum index in the ylist (and xlist).  \n",
    "    #Here, we want to please remove the 1st element from the xlist and the last element from the ylist. \n",
    "\n",
    "\n",
    "    #Please remove the 1st element from the xlist: \n",
    "\n",
    "    #print(xlistForNegTerms, \"xlistnegtermsbefore\")\n",
    "    xlistForNegTerms.pop(0)\n",
    "\n",
    "    #print(xlistForNegTerms, \"xlistnegterms now\")\n",
    "    #xlistForNegTerms.append()\n",
    "\n",
    "\n",
    "    #print(ylistForNegTerms, \"ylistnegterms\")\n",
    "\n",
    "    xlistMultylistNegValues = []  #creates an empty list that we will use to please store the elements: x2y1, x3y2, x4y3, x5y4, etc.\n",
    "    for g in range(0, len(xlistForNegTerms)):  #xlistForNegTerms has the terms x2, x3, x4, x5,...  while ylistForNegTerms has the terms y1, y2, y3, y4, etc...\n",
    "        xlistMultylistNegValues.append(xlistForNegTerms[g] * ylistForNegTerms[g])\n",
    "\n",
    "    #print(xlistMultylistNegValues, \"xmulty neg terms\")\n",
    "\n",
    "\n",
    "\n",
    "    #Then to get the sum of all the negative values, please note that we will just use the sum(list) function and that adds together ALL of the terms in the list. \n",
    "\n",
    "    sumNegativexyvalues = sum(xlistMultylistNegValues)\n",
    "    #print(sumNegativexyvalues)\n",
    "\n",
    "    #hence, sumNegativexyvalues = x2y1 + x3y2 + x4y3 + x5y4 + ... etc.\n",
    "\n",
    "    #Please note that since the sumNegativexyvalues should be negative, we multiply it by negative 1 to get or subtract it from the sumPositivexyvalues to get:\n",
    "\n",
    "    SumWithinBracketsGreensTheorem = sumPositivexyvalues - sumNegativexyvalues\n",
    "    #print(SumWithinBracketsGreensTheorem, \"= sum within brackets using Green's Theorem\")\n",
    "\n",
    "    #Please note that manually, we found Green's area returned a negative value as well.  \n",
    "    # We please convert this sum in brackets into a positive value since we please take the absolute value here. \n",
    "    \n",
    "    \n",
    "    if SumWithinBracketsGreensTheorem < 0:\n",
    "        PositiveSumWithinBracketsGreensTheorem = -1 * SumWithinBracketsGreensTheorem\n",
    "    else:\n",
    "        PositiveSumWithinBracketsGreensTheorem = SumWithinBracketsGreensTheorem\n",
    "    \n",
    "    #print(PositiveSumWithinBracketsGreensTheorem, \"= Absolute Value of Brackets of Green's Theorem\")\n",
    "    \n",
    "    #Please note that now that we found the inner bracket area, we have to multiply this by (1/2) to get the final area as per Green's Theorem. \n",
    "    GreensTheoremArea = (1/2)*(PositiveSumWithinBracketsGreensTheorem) \n",
    "    print(\"Please note the area of the polygon given by the ordered coordinates, \", coords, \"is: \", GreensTheoremArea, \"square units according to Green's Theorem Area! Yay! Thank you!\")\n",
    "    print(\"\")\n",
    "    print(\"\")\n",
    "    print(\"#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#\")\n",
    "    print(\"\")\n",
    "    \n",
    "polygarea([(0, 0), (2,0), (2,2), (0,2)])\n",
    "\n",
    "polygarea([(2, 1), (2,2), (3,2)])\n",
    "\n",
    "polygarea([(2, 2), (3,2), (2,1)])\n",
    "polygarea([(3, 2), (2,2), (2,1)])\n",
    "\n",
    "\n",
    "polygarea([(0,0), (3, 4), (0,4), (3,0)])\n",
    "\n",
    "polygarea([(0,0), (3, 4), (0,4), (2,6), (0,4), (3,0)])\n",
    "\n",
    "polygarea([(0,0), (3, 4), (0,4), (2,0), (4,0), (3,0)])\n",
    "\n",
    "polygarea([(2,1), (3, 4)])\n",
    "\n",
    "polygarea([(2,1), (3, 1), (4, 1)])\n",
    "polygarea([(2,1), (2, 4), (2, 6), (3,4)])\n",
    "\n",
    "polygarea([(2,1), (2, 4), (2, 6), (3,4), (9, 8)])\n",
    "polygarea([(0,14), (2,0), (2,3), (0,2), (9, 5), (8,7)])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please note that the perimeter of the polygon with the ordered coordinates: [(0, 2), (3, 4), (5, 6)] is:  12.837102637643028 units. Thank you!\n",
      "Please note that the perimeter of the polygon with the ordered coordinates: [(0, 0), (2, 0), (2, 2), (0, 2)] is:  8.0 units. Thank you!\n",
      "Please note that the perimeter of the polygon with the ordered coordinates: [(0, 14), (2, 0), (2, 3), (0, 2), (9, 5), (8, 7)] is:  41.73125037197032 units. Thank you!\n"
     ]
    }
   ],
   "source": [
    "#YAY SO FAR! :)\n",
    "\n",
    "\n",
    "#coordinateValues = []\n",
    "def polygperim(coords):\n",
    "    \"\"\"\n",
    "    Please describe the function. \n",
    "    Please note that this function will compute the perimeter of a polygon. \n",
    "    Created by Saniya Khullar\n",
    "\n",
    "\n",
    "\n",
    "    Please note these characteristics of a polygon:\n",
    "        Sides do NOT intersect. \n",
    "        Closed figure\n",
    "        All edges are straight lines. \n",
    "        \n",
    "        \n",
    "     Please note that here Saniya has put the comments in terms of this general example (given by Professor Pilcher)\n",
    "     of this square with these coordinates:  (0, 0), (2,0), (2,2), (0,2). \n",
    "     Please note that the coordinates should be entered in the order in which the polygon should be created.  All coordinates should be unique.  The first set of coordinates essentially becomes interpreted as the last set of coordinates as well since the figure needs to close. \n",
    "     Therefore, for these coordinates: (0, 0), (2,0), (2,2), (0,2), the program will go from: (0,0) to (2,0) to (2,2) to (0,2), and finally back to (0,0).\n",
    "     \n",
    "     Please note that when entering the coordinates in the polygperim() function, please enter them in this form:\n",
    "     polygperim([(x1,y1), (x2,y2), (x3,y3),...(xn,yn)]).\n",
    "     That is for example the 2 by 2 square formed by these points: (0, 0), (2,0), (2,2), (0,2) will have a total perimeter of: (2) + (2) + (2) + (2) = 8 units.\n",
    "    Hence, the function: polygperim([(0, 0), (2,0), (2,2), (0,2)]) should yield an 8.\n",
    "    \n",
    "    The distance between the sets of coordinates is calculated using the distance formula:  distance = squareroot(((x2-x1)^(2)) + ((y2-y1)^(2)))\n",
    "    \n",
    "    \n",
    "    \n",
    "    Please note that in the comments, oftentimes ye will see \"print\" commented out and this is since Saniya would test the code values for different parts.  It is helpful to still include these comments so that the reader can understand Saniya's thought processes. \n",
    "    Please note that Saniya humbly then tested the results obtained with (X,Y) polygon area calculators on the web (like www.pages.towson.edu) to see how the results compared and those matched. \n",
    "        \n",
    "    \n",
    "    \n",
    "    Thank you so much!\n",
    "    \"\"\"\n",
    "    CoordsList = [num for elem in coords for num in elem]   # flatten a list using a listcomp with two 'for'\n",
    "    # please note the source of this code idea is: #https://docs.python.org/2/tutorial/datastructures.html\n",
    "    # we thus get: [0, 0, 2, 0, 2, 2, 0, 2]\n",
    "    #then, we please assign this to a vector: \n",
    "\n",
    "\n",
    "    # even index elements go to the x matrix.  Even though 0 is NOT even, the elements 2, 4, etc. are! \n",
    "    # odd index elements go to the y matrix. \n",
    "\n",
    "    LengthCoordsList = len(CoordsList)\n",
    "    #print(LengthCoordsList) #8 here\n",
    "\n",
    "    if LengthCoordsList == 4:\n",
    "        print(\"Please enter 3 or more (x,y) coordinates!\")\n",
    "\n",
    "    NumOfCoordinatesN = (LengthCoordsList)/(2) #please note that this is the value for n\n",
    "    #print(NumOfCoordinatesN)  #here, this would yield 4 since there are 4 coordinates! :)\n",
    "    xlist = []\n",
    "    ylist = []\n",
    "\n",
    "    xlistPerim1 = []  #please remove the last element here for the xlist\n",
    "    xlistPerim2 = []\n",
    "\n",
    "    i = 0\n",
    "\n",
    "    while i < LengthCoordsList:\n",
    "        NewXvalue = CoordsList[i]\n",
    "        xlist.append(NewXvalue)\n",
    "        xlistPerim1.append(NewXvalue)\n",
    "        xlistPerim2.append(NewXvalue)\n",
    "\n",
    "        i = i + 2\n",
    "    firstxValue = CoordsList[0]\n",
    "    xlist.append(firstxValue)  #please note that we want to join the coordinates of the figure in the order they are given and so we must go back to square 1 (pun intended), which is the 1st point given.  We are closing the figure. \n",
    "    xlistPerim1.append(firstxValue) \n",
    "    xlistPerim2.append(firstxValue) \n",
    "\n",
    "    \n",
    "    #print(xlist)  #the 1st and last element will correspond to the same x,y pair...here we are closing the figure and the x component goes to the xlist.\n",
    "    #print(xlistPerim1, \"Term 1, x1\")  \n",
    "    #print(xlistPerim2, \"Term 2, x2\")\n",
    "\n",
    "\n",
    "    #   xlistPerim1 = [0, 2, 2, 0, 0]\n",
    "    #xlistPerim2 = [0, 2, 2, 0, 0]\n",
    "\n",
    "\n",
    "    #print(xlistPerim1, \"xlistPerim1 before\")\n",
    "    #print(xlistPerim2, \"xlistPerim2 before\")\n",
    "\n",
    "    #ylistPerim1 = [0, 0, 2, 2, 0]\n",
    "    #ylistPerim2 = [0, 0, 2, 2, 0]\n",
    "\n",
    "    \n",
    "\n",
    "    j = 1  #here, the y values start at index 1 and go on to index 3, 5, ... etc. \n",
    "\n",
    "    ylistPerim1 = []\n",
    "    ylistPerim2 = []\n",
    "    while j < LengthCoordsList:\n",
    "        NewYvalue = CoordsList[j]\n",
    "        ylist.append(NewYvalue) \n",
    "        ylistPerim1.append(NewYvalue) \n",
    "        ylistPerim2.append(NewYvalue) \n",
    "        j = j + 2\n",
    "    #adding on the last element, which should be the same as the 1st element. \n",
    "    firstyValue = CoordsList[1]\n",
    "    ylist.append(firstyValue)\n",
    "    ylistPerim1.append(firstyValue)\n",
    "    ylistPerim2.append(firstyValue)\n",
    "\n",
    "    \n",
    "    #print(ylistPerim1, \"ylistPerim1 before\")  \n",
    "    #print(ylist)\n",
    "    #print(ylistPerim2, \"ylistPerim2 before\")\n",
    "\n",
    "    #print(ylistPerim1, \"ylistPerim1 before\")\n",
    "    #print(ylistPerim2, \"xlistPerim2 before\")\n",
    "\n",
    "\n",
    "    len(xlist)\n",
    "    len(ylist)\n",
    "    #defensive programming:  just in case, please note\n",
    "    if len(xlist) != len(ylist):\n",
    "        print(\"Please note that there is a problem with the coordinate values you have entered! Please make sure you have specified both an x and y coordinate for each x,y pair.\")\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    #print(CoordsList, \"CoordsList\")\n",
    "\n",
    "    #to the xlist we will additionally append the 1st element at the end since Greens Theorem goes back to the start. \n",
    "\n",
    "    # Please note: An index of x 1 greater than y leads to negative term like:  -x2y1, -x3y2, -x4y3, -x5y4\n",
    "\n",
    "\n",
    "    maxIndex = len(xlist) #here, please note that this is 5.\n",
    "    \n",
    "    #polygarea([(0,0), (3, 4), (0,4), (3,0)])\n",
    "\n",
    "    \n",
    "    \n",
    "    #first step is to go in 2's and get the difference between the 2 positions, x2-x1, for instance, stored in a new list. \n",
    "    #Then, we will ultimately get these values squared. \n",
    "\n",
    "\n",
    "    numOfLoopings = len(xlistPerim1) - 1\n",
    "    #print(numOfLoopings) #please note here that this should be 4. \n",
    "\n",
    "\n",
    "    #x2 - x1 is term2 - term 1, for instance. \n",
    "\n",
    "    #xlistPerimTerm1  #this will have the term 1 values.  Here, we please remove the last value from the list of x values. \n",
    "    maxPerimIndex = len(xlistPerim1) - 1\n",
    "    #print(maxPerimIndex)\n",
    "    #xlistPerim1\n",
    "    xlistPerim1.pop(maxPerimIndex)\n",
    "    #print(xlistPerim1, \"xlistPerim1 after\")\n",
    "\n",
    "    #for the 2nd term, we please get rid of the 1st term. \n",
    "    xlistPerim2.pop(0)\n",
    "    #print(xlistPerim2, \"xlistPerim2 after\")\n",
    "\n",
    "\n",
    "\n",
    "    #ylistPerimTerm1  #this will have the term 1 values.  Here, we please remove the last value from the list of y values. \n",
    "    maxPerimIndexY = len(ylistPerim1) - 1\n",
    "    #print(maxPerimIndexY, \"maxPerimIndexY\")\n",
    "    #ylistPerim1\n",
    "    ylistPerim1.pop(maxPerimIndexY)\n",
    "    #print(ylistPerim1, \"ylistPerim1 after\")\n",
    "\n",
    "    #for the 2nd term, we please get rid of the 1st term. \n",
    "    ylistPerim2.pop(0)\n",
    "    #print(ylistPerim2, \"ylistPerim2 after\")\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    #subtractionXValue = xlistPerim2 - xlistPerim1\n",
    "    #print(subtractionXValue)\n",
    "    #squareValueXDifference = (subtractionXValue) ** (2) #please note that ** helps us square terms\n",
    "\n",
    "    distance = 0\n",
    "\n",
    "    index = 0\n",
    "    xdiffList = []\n",
    "    ydiffList = []\n",
    "\n",
    "    while index < len(xlistPerim2):\n",
    "        xdiff = xlistPerim2[index] - xlistPerim1[index]\n",
    "        xdiffList.append(xdiff)\n",
    "        ydiff = ylistPerim2[index] - ylistPerim1[index]\n",
    "        ydiffList.append(ydiff)\n",
    "        index = index + 1\n",
    "    #print(xdiffList)  #[2, 0, -2, 0]\n",
    "    #print(ydiffList)  #[0, 2, 0, -2]\n",
    "\n",
    "\n",
    "    squaringIndex = 0\n",
    "\n",
    "    #please note that we now square these difference terms so that we get:  ((x2 - x1)^2), ((x3 - x2)^2), ((y2 - y1)^2, ((y3 - y2)^2,...\n",
    "    #we start by creating empty lists \n",
    "    xsquarediffList = [] #  we will soon fill up this empty list with the terms (x2 - x1)^2), ((x3 - x2)^2), ....\n",
    "    ysquarediffList = []  #  we will soon fill up this empty list with the terms (y2 - y1)^2), ((y3 - y2)^2), ....\n",
    "    addedtermsList = [] #we will soon fill up this list with the terms: (x2 - x1)^2) + (y2 - y1)^2) , ((x3 - x2)^2) + ((y3 - y2)^2), etc. \n",
    "    while squaringIndex < len(xdiffList):  #we will essentially have as many terms in the squared difference lists as there are terms to begin with. \n",
    "        xsquarediff = (xdiffList[squaringIndex]) ** (2) #please note that ** helps us square terms\n",
    "        ysquarediff = (ydiffList[squaringIndex]) ** (2) #please note that ** helps us square terms\n",
    "        newAddedTerm = xsquarediff + ysquarediff  #this takes the current value for (xm - xn)^2) and adds it to the respective value for (ym - yn)^2) and then adds that to this new list. \n",
    "        xsquarediffList.append(xsquarediff) # the append function allows us to add the new computed value, xsquarediff, to the list  xsquarediffList\n",
    "        ysquarediffList.append(ysquarediff)  # the append function allows us to add the new computed value, ysquarediff, to the list  ysquarediffList\n",
    "        addedtermsList.append(newAddedTerm) # the append function allows us to add the new computed value, newAddedTerm, to the list  addedtermsList\n",
    "        squaringIndex = squaringIndex + 1 #we please increment the squaringIndex by 1 to signify that we have just run through 1 loop and it will determine if we can still go through more loops or if we should now exit the loop (as we have the total # of terms that we should have)\n",
    "\n",
    "    #print(xsquarediffList)\n",
    "    #print(ysquarediffList)\n",
    "    #print(addedtermsList)\n",
    "\n",
    "\n",
    "    #Now that we have calculated the squared terms, we will take the respective square root of the sum of the terms: ((x2 - x1)^2) + ((y2-y1)^2)\n",
    "\n",
    "    #[4, 4, 4, 4]\n",
    "    PeriIndex = 0\n",
    "    distanceIntervals = []\n",
    "    while PeriIndex < len(xsquarediffList):\n",
    "        sqrtdistance = (addedtermsList[PeriIndex]) ** (0.5)  #please note that raising a value to the 0.5 exponent is equivalent to taking the square root of that number. \n",
    "        distanceIntervals.append(sqrtdistance)  #we are just going through the respective terms in the list x2 - x1)^2) + (y2 - y1)^2) , ((x3 - x2)^2) + ((y3 - y2)^2), etc.  and are taking the square root of each of these terms and are adding it into the new list, distanceIntervals. \n",
    "        #This is essentially the distance formula. \n",
    "        PeriIndex = PeriIndex + 1  #We increment the PeriIndex by 1 and are going through the loop again. \n",
    "    \n",
    "    #print(distanceIntervals)    \n",
    "\n",
    "    TotalDistance = sum(distanceIntervals)\n",
    "    print(\"Please note that the perimeter of the polygon with the ordered coordinates:\", coords, \"is: \", TotalDistance, \"units. Thank you!\")\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "polygperim([(0, 2), (3,4), (5, 6)])\n",
    "polygperim([(0,0), (2,0), (2,2), (0,2)])\n",
    "polygperim([(0,14), (2,0), (2,3), (0,2), (9, 5), (8,7)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "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
}