{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "91a4b01c",
   "metadata": {},
   "source": [
    "# storing data in py5 with variables\n",
    "\n",
    "When you begin using py5 for more advanced programs and visual output, including sketches that have their own internal \"logic\", you start working with a surprising amount of data. Even when you're only drawing basic shapes, you have to decide where they're positioned, what colors to apply to them, and how they're sized. For the sake of not having to repeat yourself, and for making your code easier to read and understand, you can store these kinds of data in *variables* that can be used repeatedly.\n",
    "\n",
    "## variables\n",
    "\n",
    "Variables in programming are basically just placeholder names for information. It's a lot like using letters in algebra -- you can name a variable and store pretty much anything you like in it, whether that's numerical values, hex codes, mathematical formulas or something else entirely. If you're using the same values over and over in your code, or you need to have more control over changing a value as your program runs, variables are the way to go. \n",
    "\n",
    "We're going to be utilizing the *print* function to look at the data stored in different variables. First, let's take a look at some of the variables that already exist in py5; they are *built-in*. See what the following code spits out..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e11fb170",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "600\n",
      "400\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=600x400>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(600, 400)\n",
    "background('#004477')\n",
    "\n",
    "print(width)\n",
    "print(height)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2f6646d",
   "metadata": {},
   "source": [
    "We set the width and height of the window to 600 and 400 pixels using `size()`, and py5 has built-in variables for the width and height of the window. By printing those variables, we were able to quickly see what they were set to (or what information was stored in them). \n",
    "\n",
    "Of course, you don't have to use the system's built-in variables. Creating your own variable is called *declaring* it. Storing information in that variable is called *assigning*. You can even declare and assign a variable at the same time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9fa88e7e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=600x400>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(600, 400)\n",
    "background('#004477')\n",
    "\n",
    "x = 1 # Declaring a variable called x and assigning 1 to it\n",
    "print(x) # You can imagine what this will do"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "851968ab",
   "metadata": {},
   "source": [
    "You can name variables anything you like, with some exceptions. Some variables, like `width` and `height`, are already taken by py5, and clashing with them will cause problems. Variable names cannot start with a number, or contain a space, hyphen or special symbol.\n",
    "\n",
    "```\n",
    "playerlives = 3  # correct\n",
    "playerLives = 3  # correct\n",
    "player_lives = 3 # correct\n",
    "5playerlives = 3 # incorrect\n",
    "player lives = 3 # incorrect\n",
    "player-lives = 3 # incorrect \n",
    "player&live$ = 3 # incorrect\n",
    "```\n",
    "\n",
    "You'll see many variables in other development environments using camelCase, where the first letter is lowercase and subsequent words are capitalized. py5 (and much of Python coding) prefers to use underscores to separate words in functions and variables. Whatever method you use, use it consistently to avoid confusion. \n",
    "\n",
    "After you declare and assign variables, you can go ahead and use them as arguments for functions. Try adding three more variables, and using them to draw a `rect()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b33df397",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=600x400>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(600, 400)\n",
    "background('#004477')\n",
    "\n",
    "x = 1 # Declaring a variable called x and assigning 1 to it\n",
    "y = 30\n",
    "w = 20\n",
    "h = w\n",
    "rect(x,y, w,h)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b32c4e5c",
   "metadata": {},
   "source": [
    "<img src='images/variables/rect.png'>\n",
    "\n",
    "We created a variable, *h*, and in the same line gave it the value we already assigned to *w* - so the width and height are the same, and we've drawn a square. Because we're using variables, if you wanted to change any of those arguments in your `rect()`, you could just change them in your variable assignments, without touching the `rect()` function at all. This becomes really important when you re-use the same variables throughout your code! \n",
    "\n",
    "## doing math with your variables\n",
    "\n",
    "Variables that store a number can do all the things numbers do - like add, subtract, multiply and divide. Multiplication uses an asterisk (\\*), and division uses a forward slash (/). Try adding these lines to your code:\n",
    "\n",
    "```\n",
    "print(x + 2)       # displays 3\n",
    "print(x - 2)       # displays -1\n",
    "print(x * 5)       # displays 5\n",
    "print(4 / 2)       # displays 2\n",
    "```\n",
    "\n",
    "What will this next line spit out?\n",
    "\n",
    "```\n",
    "print(1 + 2 * 3)   # displays ???\n",
    "```\n",
    "\n",
    "It displays a 7 (and not a 9, as you would expect, if you simply did each operation in order) because py5 follows the [order of operations](https://en.wikipedia.org/wiki/Order_of_operations) you may vaguely recall from previous schooling. Whether you call it BEDMAS, PEMDAS, or BODMAS, it works here, too. Since brackets/parenthesis are always checked first, if you need your maths to go a little differently you can always cheat the system by adding some:\n",
    "\n",
    "```\n",
    "print(1 + 2 * 3)   # displays 7\n",
    "print((1 + 2) * 3) # displays 9\n",
    "```\n",
    "\n",
    "These are all whole numbers, which in the world of programming are usually called *integers*. You'll also find references to *floating-point numbers* or *floats*, which are just numbers with a decimal point (like 1.5). In fact, Python used to always return an integer from dividing other integers, rounding down to the nearest whole number. You can see this old behavior by adding a second slash to your division:\n",
    "\n",
    "```\n",
    "print(3 / 2)   # prints 1.5\n",
    "print(3 // 2)  # prints 1\n",
    "```\n",
    "\n",
    "And, of course, don't try to divide by zero... you'll get a special error for that."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f88f2536",
   "metadata": {},
   "source": [
    "## modulo\n",
    "\n",
    "You may not have encountered the modulo operator before, but it's very useful in this course and deserves its own introduction. Modulo (represented by the percentage sign, %) calculates the *remainder* of a division operation. For example, 2 / 5 is 2.5 - but if we're just talking about how many times 5 can be divided into whole numbers, that's 2, and you will have a leftover (remainder) of 1 that can't be evenly divided among two people. Modulo is a shortcut to figuring out that remainder.\n",
    "\n",
    "```\n",
    "print(5.0 / 2)     # displays 2.5\n",
    "print(5.0 % 2)     # displays 1\n",
    "```\n",
    "\n",
    "One way modulo can be useful is quickly determining if any number is odd or even, without having to have human eyes on it:\n",
    "\n",
    "```\n",
    "print(7 % 2)       # displays 1, therefore 7 is odd\n",
    "print(6 % 2)       # displays 0, therefore 6 is even\n",
    "```\n",
    "\n",
    "If a modulo operation results in 0, you can know that something has been divided up perfectly. This will become very useful when you begin trying to draw things in rows and columns - using modulo will let you write instructions for py5 that can trigger every *x* steps, no matter what *x* is, since any multiple of a number will have the same modulo result as that number. \n",
    "\n",
    "## image reveal task\n",
    "\n",
    "Here's another challenge. Let's give you a series of instructions and see if you can use them to draw a particular symbol. What is the symbol? You won't know until you try it out... Here's some code to start you off."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3420ab5e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=600x740>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(600, 740)\n",
    "background('#004477')\n",
    "no_fill()\n",
    "stroke('#FFFFFF')\n",
    "stroke_weight(3)\n",
    "\n",
    "xco = 400\n",
    "yco = 440"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b5caacb",
   "metadata": {},
   "source": [
    "You'll be given six steps, and following them will reveal the correct shape. To make things a little easier, the first step will also give you the code to use. You'll have to figure out the next five yourself!\n",
    "\n",
    "1. Draw a line beginning at an x-coordinate of half the display window width, and y-coordinate of a third of the window height. The endpoint must have an x/y-coordinate equal to xco & yco.\n",
    "\n",
    "```\n",
    "line(width/2,height/3, xco,yco)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bf90593",
   "metadata": {},
   "outputs": [],
   "source": [
    "size(600, 740)\n",
    "background('#004477')\n",
    "no_fill()\n",
    "stroke('#FFFFFF')\n",
    "stroke_weight(3)\n",
    "\n",
    "xco = 400\n",
    "yco = 440\n",
    "\n",
    "# Step 1\n",
    "line(width/2,height/3, xco,yco)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f75adc36",
   "metadata": {},
   "source": [
    "<img src=\"images/variables/arithmetic-operators-symbol-reveal.png\">\n",
    "\n",
    "*(See how that worked? To get half of width, you just use width/2, and so on. Break each instruction down into pieces and you'll figure it out quickly.)*\n",
    "\n",
    "2. Draw a centred ellipse with a width that's an eleventh of the display window width, and a height that's a fourteenth of the window height. \n",
    "\n",
    "3. Draw a centred ellipse with a width that's a nineteenth of the display window width, and a height that's a twenty-second of the window height. \n",
    "\n",
    "4. Draw a line beginning at an x/y-coordinate equal to xco & yco respectively. The endpoint must have an x-coordinate of the display window width minus xco, and a y-coordinate equal to yco. \n",
    "\n",
    "5. Draw a line beginning at an x-coordinate of the display window width minus xco, and y-coordinate equal to yco. The endpoint must have an x-coordinate of half the display window width, and a y-coordinate of a third of the window height. \n",
    "\n",
    "6. Draw a centred ellipse with a width that's a fifth of the display window width, and height that's a twelfth of the display window height. \n",
    "\n",
    "*(A clue: if this seems like a conspiracy, you're on the right track.)*\n",
    "\n",
    "## disk space analyser task\n",
    "\n",
    "Here's one last challenge. Before we get to the task at hand, let's introduce the `arc()` function. This is used to draw elliptical arcs - and it's best to try it out to understand how it works. \n",
    "\n",
    "Breaking the `arc()` down across multiple lines will make it a little easier to examine its parts. Here are its required arguments. \n",
    "\n",
    "```\n",
    "arc(\n",
    "  x_coordinate, y_coordinate,\n",
    "  width, height,\n",
    "  start_angle, end_angle\n",
    ")\n",
    "```\n",
    "\n",
    "We use *radians* to measure where an arc ends and begins. Let's start with an arc with a starting angle of zero radians and an ending angle of two radians:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9d751d9b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=600x700>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(600,700)\n",
    "background('#004477')\n",
    "stroke('#FFFFFF')\n",
    "stroke_weight(3)\n",
    "no_fill()\n",
    "\n",
    "arc(width/2,height/2, 200,200, 0,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d519e89a",
   "metadata": {},
   "source": [
    "<img src=\"images/variables/arithmetic-arc.png\">\n",
    "\n",
    "We started at zero radians, and our arc is being drawn clockwise. You may notice 2 radians is... well, a little more than a quarter of a way around the circle, which can feel quite unhelpful. Rather than trying to strictly remember exactly how much a single radian is, it can be better to remember that halfway around a circle is *pi* radians - that funny number starting with 3.1415. This animated diagram from Wikipedia is also helpful:\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/4/4e/Circle_radians.gif\">\n",
    "\n",
    "*Lucas V. Barbosa [Public domain], from [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:Circle_radians.gif)*\n",
    "\n",
    "py5 actually has a built-in understanding of how much *pi* is. Anywhere you want to use pi, type `PI`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9901975b",
   "metadata": {},
   "outputs": [],
   "source": [
    "size(600,700)\n",
    "background('#004477')\n",
    "stroke('#FFFFFF')\n",
    "stroke_weight(3)\n",
    "no_fill()\n",
    "\n",
    "arc(width/2,height/2, 200,200, 0,2)\n",
    "arc(width/2,height/2, 300,300, 0,PI) # half-circle"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d38ed507",
   "metadata": {},
   "source": [
    "<img src=\"images/variables/pi.png\">\n",
    "\n",
    "You can of course use this in mathematical operations too - a complete circle is PI\\*2 radians. However, there's also a special name for the mathematical concept of PI\\*2, which is called *tau*, and py5 has a built-in variable for that, too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "944e457a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=600x700>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(600,700)\n",
    "background('#004477')\n",
    "stroke('#FFFFFF')\n",
    "stroke_weight(3)\n",
    "no_fill()\n",
    "\n",
    "arc(width/2,height/2, 200,200, 0,2)\n",
    "arc(width/2,height/2, 300,300, 0,PI)  # half-circle\n",
    "arc(width/2,height/2, 400,400, 0,TAU) # full-circle"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "601ee0fb",
   "metadata": {},
   "source": [
    "<img src=\"images/variables/arithmetic-arcs.png\">\n",
    "\n",
    "Of course, this means that, instead of worrying about calculating radians, you could just know `TAU / 4` will always be a fourth of a circle, and so on. This is a case where being able to do arithmetic with variables is really useful!\n",
    "\n",
    "Many functions have optional arguments. In the case of `arc()`, there is a final MODE variable that can change the way the arc appears. If you want to close off the arc, so it looks like a slice of pie, you add one last argument called... PIE. We'll also take a look at another built-in variable here, HALF_PI. HALF_PI is, of course, the same as PI/2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8f0d5c57",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=600x700>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(600,700)\n",
    "background('#004477')\n",
    "stroke('#FFFFFF')\n",
    "stroke_weight(3)\n",
    "no_fill()\n",
    "\n",
    "arc(width/2,height/2, 200,200, 0,2)\n",
    "arc(width/2,height/2, 300,300, 0,PI)  # half-circle\n",
    "arc(width/2,height/2, 400,400, 0,TAU) # full-circle\n",
    "arc(width/2,height/2, 350,350, 3.4,TAU - HALF_PI, PIE) # a pie slice!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5409fcfe",
   "metadata": {},
   "source": [
    "<img src=\"images/variables/arithmetic-arc-pie.png\">\n",
    "\n",
    "This brings us to the next task. You may have seen *disk usage analysers* that break up the data on a hard drive into a funny pie charts or ring charts. One example is the Linux [GNOME Disk Usage Analyzer](https://en.wikipedia.org/wiki/Disk_Usage_Analyzer). Using what you know about arcs and drawing shapes in general, you'll be trying to recreate the image below:\n",
    "\n",
    "<img src=\"images/variables/arithmetic-disk-space-analyser.png\">\n",
    "\n",
    "Remember that you can cover shapes with other shapes to create that \"donut hole\" in the center, and don't worry about adding the text or even perfectly matching the colors. This is more about grasping arcs and using variables like PI, HALF_PI and TAU!"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "formats": "ipynb,md:myst"
  },
  "kernelspec": {
   "display_name": "py5bot",
   "language": "python",
   "name": "py5bot"
  },
  "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.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}