Pi.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Pi.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mJ9WKrZIb0iq"
      },
      "source": [
        "#**Making Art, Games, and More with Pi and Python**\r\n",
        "---  \r\n",
        "\\\r\n",
        "*Michael D'Argenio  \r\n",
        "mjdargen@gmail.com  \r\n",
        "https://dargen.io  \r\n",
        "https://github.com/mjdargen  \r\n",
        "Created: March 13, 2021*  \r\n",
        "\r\n",
        "\\\r\n",
        "Celebrate Pi Day by making art, music, games with Pi using Python. In this Google Colaboratory Notebook, you will explore what Pi is, how it's used, and some fun applications."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h0l-nzBeBoIq"
      },
      "source": [
        "# 0. Install Dependencies and Download Files\r\n",
        "*Before we get to the fun, run the cell below to install all of the dependencies and download the necessary files*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gVGY7iJWBjPl"
      },
      "source": [
        "# install dependencies\r\n",
        "!apt update &> /dev/null\r\n",
        "!apt install libasound2-dev portaudio19-dev libportaudio2 libportaudiocpp0 ffmpeg &> /dev/null\r\n",
        "!pip3 install chord &> /dev/null\r\n",
        "!pip3 install pyaudio &> /dev/null\r\n",
        "\r\n",
        "# clone repo with text files and utility functions\r\n",
        "!git clone https://github.com/mjdargen/pi.git\r\n",
        "!mkdir ./output\r\n",
        "\r\n",
        "# import libraries\r\n",
        "import math\r\n",
        "import datetime\r\n",
        "from chord import Chord\r\n",
        "import plotly.express as px\r\n",
        "from PIL import Image\r\n",
        "import pyaudio\r\n",
        "import numpy as np\r\n",
        "from scipy import signal\r\n",
        "from scipy.io import wavfile\r\n",
        "from IPython.display import Audio\r\n",
        "import requests\r\n",
        "from bs4 import BeautifulSoup\r\n",
        "\r\n",
        "# read in 1 million decimal digits\r\n",
        "with open('./pi/pi_dec_1m.txt', 'r') as f:\r\n",
        "    dec_pi = f.read()\r\n",
        "\r\n",
        "# read in 1 million hexadecimal digits\r\n",
        "with open('./pi/pi_hex_1m.txt', 'r') as f:\r\n",
        "    hex_pi = f.read()\r\n",
        "\r\n",
        "# get list of values after decimal point\r\n",
        "dec_digits = [int(num) for num in dec_pi[2:]]\r\n",
        "hex_digits = [int(num, 16) for num in hex_pi[2:]]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c-Oc1sYn5SUB"
      },
      "source": [
        "# 1. What is π?\r\n",
        "\r\n",
        "Pi (π) is an irrational number. An irrational number means that the number cannot be represented as a common fraction and that its decimal representation goes on forever and never settles on a repeating pattern. That means we do not know, nor will we ever know the true value of pi.\r\n",
        "\r\n",
        "Pi is also a transcendental number which means it is a number that is not the root of a non-zero polynomial with rational coefficients. This essentially means that the number is non-algebraic. The best known transcendental numbers are π and e.\r\n",
        "\r\n",
        "Determining a value for pi has been a competitive game that has stretched on for ages as described in [this timeline](https://en.wikipedia.org/wiki/Chronology_of_computation_of_%CF%80). To date, Timothy Mullican currently holds the record for computing 50 trillion digits of pi which took 303 days using an algorithm called [\"y-cruncher\" developed by Alexander Yee](http://www.numberworld.org/y-cruncher/).\r\n",
        "\r\n",
        "Despite not knowing the true value of pi, it is still a very important number that we use daily. It is defined as the ratio of a circle's circumference to its diameter; however, its uses extend far behind basic geometry. You can watch this (relatively older) [Numberphile video](https://www.youtube.com/watch?v=yJ-HwrOpIps) diving into pi in more detail.\r\n",
        "\r\n",
        "Pi is the most infamous number. It is the only number with a widely-recognized holiday - Pi Day on March 14th. In this notebook, we will explore various aspects of pi and try to have some fun with the number."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7Ext2XlAz_pQ"
      },
      "source": [
        "print(math.pi)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VhZDe1x7GeNA"
      },
      "source": [
        "# 2. How old are you in terms of π?\r\n",
        "Determine how old you are in terms of pi. Input your birthday in the fields below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n-KpKVxfGdeL"
      },
      "source": [
        "# Bithday = input(\"Enter your Birthday (YYYY-MM-DD): \")\r\n",
        "Bithday = '1970-01-01'  #@param {type: \"date\"}\r\n",
        "bday = datetime.datetime.strptime(Bithday, '%Y-%m-%d')\r\n",
        "today = datetime.datetime.now()\r\n",
        "diff = today - bday\r\n",
        "days = round(diff.days / math.pi)\r\n",
        "years = round(diff.days / math.pi / 365.2422)\r\n",
        "print(f\"You are {years}π years old or {days}π days old.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JX8hjphK5bD7"
      },
      "source": [
        "# 3. Approximating π\r\n",
        "Approximate pi using a specified number of summation terms. We will be using the [Leibniz formula](https://en.wikipedia.org/wiki/Leibniz_formula_for_%CF%80) for approximating π. It is an infinite alternating series that slowly converges towards pi as described by the formula below.  \r\n",
        "\r\n",
        "$\\\\π = \\sum_{k=0}^{n} (-1)^{k} \\frac{4}{2k+1}$\r\n",
        "\r\n",
        "To use the program, specify how many terms (n) you would like to use to approximate pi. The program will spit out the resulting approximation.  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cq-V-One0L5F"
      },
      "source": [
        "# prompt user to input a number\r\n",
        "n = int(input(\"How many terms to approximate pi? \"))\r\n",
        "pi = 0.0\r\n",
        "# set the range for the number of terms to compute\r\n",
        "for i in range(0, n):\r\n",
        "    # odd term - subtract\r\n",
        "    if i % 2:\r\n",
        "        pi -= 4.0 / (2 * i + 1)\r\n",
        "    # even term - add\r\n",
        "    else:\r\n",
        "        pi += 4.0 / (2 * i + 1)\r\n",
        "print(f\"Pi Approximation: {pi}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uv0pclTC5nV2"
      },
      "source": [
        "# 4. One Million Digits of π\r\n",
        "\r\n",
        "View the first one million decimal digits of pi and the first one million hexadecimal digits of pi. After running the cells below, click the 'x' near the output window to clear the cell. Displaying millions of characters can burden your browser and slowdown the notebook."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BYfS7QxKGX_X"
      },
      "source": [
        "# print 1 million decimal digits of pi\r\n",
        "print(dec_pi)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7cQvPa9dEsuO"
      },
      "source": [
        "# print 1 million hexadecimal digits of pi\r\n",
        "print(hex_pi)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i7wpMRxZHeh2"
      },
      "source": [
        "# 5. Plot Distribution of the Digits of π\r\n",
        "In the cell below, we are going to further inspect the first one million decimal and hexadecimal digits of pi. We will plot the distribution of the digits of pi to figure out if there are digits that occur more in the first one million digits of pi.\r\n",
        "\r\n",
        "The first plot will be the decimal digits of pi and the second plot will be the hexadecimal digits of pi. The diagrams are also written to the \"output\" folder as an interactive html webpage that can be downloaded in the file tab on the left."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ai4zvqhWD9bJ"
      },
      "source": [
        "# decimal distribution\r\n",
        "dec_dist = {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0}\r\n",
        "for num in dec_digits:\r\n",
        "    dec_dist[num] += 1\r\n",
        "\r\n",
        "# hexadecimal distribution\r\n",
        "hex_dist = {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0,\r\n",
        "            10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0}\r\n",
        "for num in hex_digits:\r\n",
        "    hex_dist[num] += 1\r\n",
        "\r\n",
        "# plot bar charts\r\n",
        "# decimal\r\n",
        "fig = px.bar(x=list(dec_dist.keys()),\r\n",
        "             y=list(dec_dist.values()),\r\n",
        "             text=list(dec_dist.values()))\r\n",
        "fig.update_layout(title=\"Decimal Number Distribution of 1 Million Digits of Pi\",\r\n",
        "                  xaxis_title=\"Decimal Numbers\",\r\n",
        "                  yaxis_title=\"Number of Occurrences\",\r\n",
        "                  xaxis=dict(tickmode='linear', dtick=1))\r\n",
        "min, max = int(1000000 / 10 - 1000000 * .001), int(1000000 / 10 + 1000000 * .001)\r\n",
        "fig.update_yaxes(range=[min, max])\r\n",
        "fig.update_traces(texttemplate='%{text:,}', textposition='outside')\r\n",
        "fig.show()\r\n",
        "fig.write_html(\"./output/dec_dist.html\")\r\n",
        "print()\r\n",
        "# hexademical\r\n",
        "fig = px.bar(x=list(hex_dist.keys()),\r\n",
        "             y=list(hex_dist.values()),\r\n",
        "             text=list(hex_dist.values()))\r\n",
        "fig.update_layout(title=\"Hexadecimal Number Distribution of 1 Million Digits of Pi\",\r\n",
        "                  xaxis_title=\"Hexadecimal Numbers\",\r\n",
        "                  yaxis_title=\"Number of Occurrences\",\r\n",
        "                  xaxis=dict(tickmode='linear', dtick=1))\r\n",
        "min, max = int(1000000 / 16 - 1000000 * .001), int(1000000 / 16 + 1000000 * .001)\r\n",
        "fig.update_yaxes(range=[min, max])\r\n",
        "fig.update_traces(texttemplate='%{text:,}', textposition='outside')\r\n",
        "fig.show()\r\n",
        "fig.write_html(\"./output/hex_dist.html\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gOHe2HwRIQlC"
      },
      "source": [
        "# 6. π Chord Diagram\r\n",
        "\r\n",
        "A chord diagram is a special type of diagram that shoes edges or arcs from nodes on a circular plot. In this case, we are showing the progression of the digits of pi. The nodes represent each possible value of a digit (0-9 for decimal and 0-15 for hexadecimal). The arcs or edges represent transitions from one digit to the next. For example, the first digits after the decimal point for pi are \"14159\". We would start at 1 and draw an arc to 4, then draw an arc from 4 to 1, then an arc from 1 to 5, then an arc from 5 to 9, and so on.\r\n",
        "\r\n",
        "The first diagram shows the chord diagram for the first one million decimal digits of pi. The second diagram shows the chord diagram for the first one million hexadecimal digits of pi. The diagrams are also written to the \"output\" folder as an interactive html webpage that can be downloaded in the file tab on the left."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tm1uCSjMIPkw"
      },
      "source": [
        "# decimal chord diagram\r\n",
        "# create 2D list 10 x 10\r\n",
        "dec_chord = []\r\n",
        "# initialize\r\n",
        "for i in range(10):\r\n",
        "    dec_chord.append([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\r\n",
        "# loop through and add edges\r\n",
        "for idx, num in enumerate(dec_digits[:-1]):\r\n",
        "    dec_chord[num][dec_digits[idx+1]] += 1\r\n",
        "\r\n",
        "# hexadecimal chord diagram\r\n",
        "# create 2D list 16 x 16\r\n",
        "hex_chord = []\r\n",
        "# initialize\r\n",
        "for i in range(16):\r\n",
        "    hex_chord.append([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\r\n",
        "# loop through and add edges\r\n",
        "for idx, num in enumerate(hex_digits[:-1]):\r\n",
        "    hex_chord[num][hex_digits[idx+1]] += 1\r\n",
        "\r\n",
        "# plot chord diagrams\r\n",
        "# decimal\r\n",
        "fig = Chord(dec_chord, [str(n) for n in list(range(10))])\r\n",
        "fig.show()\r\n",
        "fig.to_html(\"./output/decimal_chord.html\")\r\n",
        "# hexadecimal\r\n",
        "fig = Chord(hex_chord, [str(n) for n in list(range(16))])\r\n",
        "fig.show()\r\n",
        "fig.to_html(\"./output/hexadecimal_chord.html\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8ZEOhmxw7aF1"
      },
      "source": [
        "# 7. Snake - Pi Version\r\n",
        "Play the Pi version of Snake! I modified snake so the snake appears as various segments of π. Instead of eating food, the snake is trying to eat the decimal digits of pi in sequential order. See how many digits of pi you can eat!  \r\n",
        "\r\n",
        "**Note:** This code won't run properly in Google Colab, so I am embedding a repl.it project here. View the source code [here](https://repl.it/@MichaelDArgenio/PiSnake). This project was originally forked from [@LorenzoCampos](https://repl.it/@LorenzoCampos) and tweaked to make the pi version. Run the cell below to show and play the embedded game.\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8-yZOAkxYH0k"
      },
      "source": [
        "from IPython.display import IFrame\r\n",
        "IFrame(src='https://repl.it/@MichaelDArgenio/PiSnake?lite=false',\r\n",
        "       frameborder='0', width='800', height='800')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u2W4_3gIQr2f"
      },
      "source": [
        "# 8. Binary Pixel Image of π\r\n",
        "\r\n",
        "Pi can also be represented as a binary number. In order to do this, I take the first million hexadecimal digits and convert it to a binary number byte by byte. To visualize this information, I will represent the first 1 million hexadecimal digits as a 2000x2000 monochrome black/white image. The zeros are represented by a black pixel and the ones are represented as a white pixel.\r\n",
        "\r\n",
        "See the full image below. It may appear as a solid white image for a minute as the image will take a little while to load in the Colab output window. The image is also saved in the \"output\" window and can be downloaded in the file tab on the left.\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gz8Xv9lcQumi"
      },
      "source": [
        "# splits string 2 characters at a time converts to hex\r\n",
        "temp = hex_pi[2:]\r\n",
        "hex = [int(c+temp[idx*2+1], 16) for idx, c in enumerate(temp[::2])]\r\n",
        "binary = [str(bin(h)[2:].zfill(8)) for h in hex]\r\n",
        "binary = ''.join(binary)\r\n",
        "\r\n",
        "IMAGE_WIDTH = 2000\r\n",
        "IMAGE_HEIGHT = 2000\r\n",
        "\r\n",
        "# create empty b/w image\r\n",
        "img = Image.new('1', (IMAGE_WIDTH, IMAGE_HEIGHT))\r\n",
        "pixels = img.load()  # load pixels\r\n",
        "\r\n",
        "# loop through pixels one by one\r\n",
        "for i in range(img.size[0]):  # columns\r\n",
        "    for j in range(img.size[1]):  # rows\r\n",
        "        # 0 - black, 1 - white\r\n",
        "        idx = i * 1000 + j\r\n",
        "        pixels[i, j] = int(binary[idx])\r\n",
        "\r\n",
        "# image size\r\n",
        "size = (IMAGE_WIDTH*25, IMAGE_HEIGHT*25)\r\n",
        "# resize image\r\n",
        "img = img.resize(size)\r\n",
        "# save image\r\n",
        "img.save('./output/binary_pi.png')\r\n",
        "print(\"It may look white for a minute, because it takes a little while to load.\")\r\n",
        "img"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I-sBniGIWCT9"
      },
      "source": [
        "# 9. Making Music with π\r\n",
        "\r\n",
        "We can even make music with pi. The script below uses numpy to compute the waveforms and scipy to write to a .wav file. I kept some of the code in [piaudio.py](https://github.com/mjdargen/pi/blob/main/piaudio.py) to keep from cluttering the notebook. This file is responsible for mapping the string note representations to specific frequencies and constructing the selected waveform for each note based on the duration and the BPM.\r\n",
        "\r\n",
        "Try playing along with the `notes` dictionary to see what sort of cool sounds you can make with pi. Map certain digit values to keys on the keyboard. Must write the notes in the following format shown below. You can also specify what type of waveform you want by supplying the `waveform` argument to the `play_note()` function. It can either be `sinusoid`, `triangle`, `sawtooth`, or `square`.\r\n",
        "\r\n",
        "Determine whether you want to use the decimal digits or the hexadecimal digits of pi by using either line 20 or line 22. By default, the script below only uses the first 100 digits of pi. Using the full one million digits of pi would take way too long to execute.\r\n",
        "\r\n",
        "A play window will show up in the output window to preview the audio. You can also download the .wav file. The audio is also saved in the \"output\" window and can be downloaded in the file tab on the left.  \r\n",
        "\r\n",
        "Note format explained: \r\n",
        "* Must start with: `NOTE_` \r\n",
        "* First letter is the note: A-G\r\n",
        "* If there is an \"S\", means sharp (no flats)\r\n",
        "* Number is octave on the keyboard, 0-lowest, 8-highest"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2NFdpu1aWDqp"
      },
      "source": [
        "# import functions from script in git repo\n",
        "import sys\n",
        "sys.path.insert(1, './pi')\n",
        "from piaudio import play_note\n",
        "\n",
        "# dictionary of notes; format:\n",
        "#   first letter is the note\n",
        "#   if there is an \"S\", means sharp\n",
        "#   number is octave on the keyboard, 0-lowest, 8-highest\n",
        "notes = {0: 'NOTE_C4', 1: 'NOTE_D4', 2: 'NOTE_E4', 3: 'NOTE_F4',\n",
        "         4: 'NOTE_G4', 5: 'NOTE_A4', 6: 'NOTE_B4', 7: 'NOTE_C5',\n",
        "         8: 'NOTE_D5', 9: 'NOTE_E5', 10: 'NOTE_F5', 11: 'NOTE_G5',\n",
        "         12: 'NOTE_A5', 13: 'NOTE_B5', 14: 'NOTE_C6', 15: 'REST'}\n",
        "BPM = 120   # beats per minute\n",
        "fs = 44100  # sampling rate\n",
        "\n",
        "prev = 15\n",
        "song = np.ndarray([])\n",
        "# generate tones based on digits of pi\n",
        "for num in dec_digits[:100]:\n",
        "# or try hex digits\n",
        "# for num in hex_digits[:100]:\n",
        "    if num == prev:\n",
        "        num = 15\n",
        "    prev = num\n",
        "    song = play_note(song, BPM, notes[num], 8, waveform='sinusoid')\n",
        "\n",
        "# write to file\n",
        "song = song * .5  # adjust volume\n",
        "song = (song * float(2 ** 15 - 1)).astype(np.int16)\n",
        "wavfile.write(\"./output/pi.wav\", fs, song)\n",
        "Audio(\"./output/pi.wav\", autoplay=False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qM8bKhfYbsx-"
      },
      "source": [
        "# 10. Art with π & Processing\r\n",
        "\r\n",
        "[Processing](https://processing.org/) is a flexible software sketchbook and a language for learning how to code within the context of the visual arts. It is a free graphical library and IDE. It is built in Java; however, there is also a [Python mode](https://py.processing.org/).\r\n",
        "\r\n",
        "You can't run Processing code in Google Colaboratory. You will need to download Processing and install the Python Mode add-on. Follow this [Getting Started guide](https://py.processing.org/tutorials/gettingstarted/).\r\n",
        "\r\n",
        "This Processing script parses the first 10,000 decimal digits of pi and represents them as circles. The color of the circles indicates the numerical value of that digit.\r\n",
        "\r\n",
        "See the graphic generated below. You can also download the graphic [here](https://raw.githubusercontent.com/mjdargen/pi/main/output/pi.png). I provide the code to generate the graphic below. You can also view/download the script from my GitHub repo [here](https://github.com/mjdargen/pi/blob/main/pi.pyde).\r\n",
        "\r\n",
        "![Pi Graphic](https://raw.githubusercontent.com/mjdargen/pi/main/output/pi.png)\r\n",
        "\r\n",
        "```\r\n",
        "# Creates a graphic representing the digits of pi with colors\r\n",
        "\r\n",
        "# 100 rows x 100 columns\r\n",
        "rows = 100\r\n",
        "row_width = 1500\r\n",
        "row_sep = 20\r\n",
        "circle_size = 15\r\n",
        "# calculate width and height\r\n",
        "w = row_width + (row_width // 4)\r\n",
        "h = (rows - 1) * row_sep + (row_width // 4)\r\n",
        "\r\n",
        "colors = ['#f5453b', '#ff8a29', '#f6f34e', '#bb1b86', '#b5d2a1',\r\n",
        "          '#d11638', '#ffffff', '#6a4a3c', '#52bd97', '#d2f301']\r\n",
        "\r\n",
        "def setup():\r\n",
        "    # open file\r\n",
        "    with open('pi_dec_1m.txt', 'r') as f:\r\n",
        "        dec_pi = f.read()[2:]\r\n",
        "    dec_pi = [int(n) for n in dec_pi]\r\n",
        "    \r\n",
        "    # setup image\r\n",
        "    size(w, h)\r\n",
        "    global img\r\n",
        "    img = createImage(w, h, ARGB)\r\n",
        "    \r\n",
        "    # increase density\r\n",
        "    pixelDensity(2)\r\n",
        "    \r\n",
        "    # set background color\r\n",
        "    background(0)\r\n",
        "    \r\n",
        "    # start the drawing based on line width \r\n",
        "    x_start = row_width/8\r\n",
        "    y_start = row_width/8\r\n",
        "    \r\n",
        "    # write header\r\n",
        "    textFont(createFont(\"Courier New\", 120))\r\n",
        "    textAlign(CENTER, TOP)\r\n",
        "    fill(255)\r\n",
        "    text('Pi', w//2, row_width//32)\r\n",
        "    \r\n",
        "    # write legend for number colors\r\n",
        "    for i in range(10):\r\n",
        "        textFont(createFont(\"Courier New\", 48))\r\n",
        "        fill(colors[i])\r\n",
        "        text(i, x_start//2, y_start + row_sep*i*3)\r\n",
        "    \r\n",
        "    # for every row, 100 lines\r\n",
        "    for i in range(rows):\r\n",
        "        # for every circle in row, 100 circles\r\n",
        "        for j in range(row_width//15):\r\n",
        "            \r\n",
        "            # coordinates are center point of circle\r\n",
        "            x = x_start + j*15\r\n",
        "            y = y_start + (i*row_sep)\r\n",
        "            \r\n",
        "            # draw circle\r\n",
        "            c = colors[dec_pi[i*100+j]]\r\n",
        "            fill(c)\r\n",
        "            circle(x, y, circle_size)\r\n",
        "    \r\n",
        "    # save image\r\n",
        "    save(\"pi.png\")\r\n",
        "    # no loop function necessary\r\n",
        "    noLoop()\r\n",
        "    \r\n",
        "def draw():\r\n",
        "    image(img, 0, 0)\r\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eQZLIYpqKm6B"
      },
      "source": [
        "# 11. Using π to find Kevin Bacon\r\n",
        "\r\n",
        "*This script shows how we can essentially use the digits of pi as a pseudo-random number generator for an algorithm.*\r\n",
        "\r\n",
        "Below we are going to explore the [Six Degrees of Kevin Bacon](https://en.wikipedia.org/wiki/Six_Degrees_of_Kevin_Bacon) using pi. Six Degrees of Kevin Bacon is a game / thought experiment that is an example of \"six degrees of separation\". The idea behind \"six degrees of separation\" is that any two people are (on average) six or fewer social connections away from each other. As a dumb way to explore this, we will load a random Wikipedia page and follow the links on that page until we arrive on Kevin Bacon's Wikipedia page.  \r\n",
        "\r\n",
        "We use the [random Wikipedia page](https://en.wikipedia.org/wiki/Special:Random) as our starting point. From there, the script gets a list of all valid Wikipedia pages linked on a single page. Then the script uses the hexadecimal digits of pi in sequential order to determine which one of the Wikipedia pages we visit next.  \r\n",
        "\r\n",
        "The script below can take a long time to execute depending upon how many pages it needs to visit until we find Kevin Bacon's Wikipedia page. The minimal number of pages I've needed to visit so far has been 2,254 pages.\r\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UuIfz9NTKrBs"
      },
      "source": [
        "# returns a list of all valid other wikipages linked on the page\r\n",
        "def get_all_wikipages(url):\r\n",
        "    # get url and soup it up\r\n",
        "    page = requests.get(url)\r\n",
        "    # soup = BeautifulSoup(page.text, 'lxml')\r\n",
        "    soup = BeautifulSoup(page.content, 'html.parser')\r\n",
        "\r\n",
        "    # get all links\r\n",
        "    links = []\r\n",
        "    for link in soup.find_all('a'):\r\n",
        "        links.append(link.get('href'))\r\n",
        "\r\n",
        "    # get only valid wiki pages\r\n",
        "    links = [link for link in links if link is not None]\r\n",
        "    links = [link for link in links if '/wiki/' == link[:6] and ':' not in link]\r\n",
        "    wiki_pages = [link for link in links if 'Main_Page' not in link]\r\n",
        "    return wiki_pages\r\n",
        "\r\n",
        "\r\n",
        "# start with random page\r\n",
        "url = \"https://en.wikipedia.org/wiki/Special:Random\"\r\n",
        "\r\n",
        "# for all values of pi\r\n",
        "found = False\r\n",
        "for idx, num in enumerate(hex_digits):\r\n",
        "    # get all links on wikipage for new url\r\n",
        "    wiki_pages = get_all_wikipages(url)\r\n",
        "    # try to find kevin bacon\r\n",
        "    for pg in wiki_pages:\r\n",
        "        if 'Kevin_Bacon' in pg:\r\n",
        "            found = True\r\n",
        "            break\r\n",
        "    if found:\r\n",
        "        break\r\n",
        "    # get new url based on next digit of pi num, ensure no index errors\r\n",
        "    try:\r\n",
        "        page = wiki_pages[len(wiki_pages) // 16 * num + num]\r\n",
        "    except IndexError:\r\n",
        "        try:\r\n",
        "            page = wiki_pages[num]\r\n",
        "        except IndexError:\r\n",
        "            page = wiki_pages[-1]\r\n",
        "    url = 'https://en.wikipedia.org' + page\r\n",
        "    # print(url)  # if you want to print every url tried\r\n",
        "\r\n",
        "if found:\r\n",
        "    print(f\"Found Kevin Bacon at the {idx} digit of Pi.\")\r\n",
        "else:\r\n",
        "    print(\"Never found Kevin Bacon.\")\r\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}