Monte_Carlo_calculation_of_pi.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Monte Carlo determination of $\\pi$\n",
    "\n",
    "Imagine that we have a circle of radius 1 ($r = 1$), centered at the point $(0, 0)$ in Cartesian coordinates.\n",
    "\n",
    "We can further imagine that circle being enclosed by a square with the same center and with sides of length $2r$, in this case 2.\n",
    "\n",
    "<img src=\"Enclosed_circle.png\" alt=\"Drawing\" style=\"width: 400px;\"/>\n",
    "\n",
    "\n",
    "Given a square with sides of length $2r$, the square's area is\n",
    "\n",
    "$$A_{square} = (2r)^2 = 4r^2$$\n",
    "\n",
    "whereas the area of a circle with radius $r$ is\n",
    "$$A_{circle} = \\pi r^2$$\n",
    "\n",
    "Therefore the ratio of the area of the circle to that of the enclosing square is\n",
    "\n",
    "$$\\frac{A_{circle}}{A_{square}} = \\frac{\\pi r^2}{4r^2} = \\frac{\\pi}{4}$$.\n",
    "\n",
    "By rearranging this expression, we see we can define $\\pi$ as\n",
    "\n",
    "$$\\pi = 4\\frac{A_{circle}}{A_{square}}$$\n",
    "\n",
    "**And *this* suggests a way to calculate $\\pi$!**\n",
    "\n",
    "If we're able to figure out the ratio of the areas of a circle and the smallest square that can hold that circle, we can figure out $\\pi$. And fortunately, this ratio is equal to the probability that a randomly chosen point inside the square also falls inside the circle. \n",
    "\n",
    "This means that we can calculate this ratio (and therefore $\\pi$) using a Monte Carlo simulation by choosing a large number of random points inside a square and tracking how many fall inside the circle.\n",
    "\n",
    "#### Pseudo-code\n",
    "\n",
    "Given the above, our algorithm for determining $\\pi$ looks like this:\n",
    "\n",
    "1. For each of $N$ iterations,\n",
    "    1. Select a random point inside the square depicted above.\n",
    "    1. Determine if the point also falls inside the largest circle that can be enclosed within this square.\n",
    "    1. Keep track of whether or not this point fell inside the circle. At the end of $N$ iterations, you want to know $M$ -- the number of the $N$ random points that fell inside the circle!\n",
    "1. Calculate $\\pi$ as $4\\frac{M}{N}$\n",
    "\n",
    "Note: As you increase the value of $N$, you'll be able to estimate pi with greater accuracy!\n",
    "\n",
    "### Exercise\n",
    "\n",
    "Write a function that calculates $\\pi$ using Julia.\n",
    "\n",
    "Feel free to get started immediately, or to make use of the practice exercises below which have you solve pieces of the problem one at a time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function practice\n",
    "\n",
    "#### Exercise\n",
    "\n",
    "Given variables `x` and `y` defining a point $(x, y)$, write a function `dist(x, y)` that returns the distance of $(x, y)$ from $(0, 0)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise\n",
    "\n",
    "Write a function `myrand` that returns `(x, y)`, where `x` and `y` are pseudo-random numbers uniformly distributed between -1 and +1.\n",
    "\n",
    "*Hint:* The `rand()` function returns a random number between 0 and 1. Passing a collection as the first argument of `rand` will cause `rand` to return a random value from amongst the elements of the collection.\n",
    "\n",
    "Ex. rand(animals) will return one of the strings contained in `animals`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals = [\"cat\", \"dog\", \"bird\"]\n",
    "rand(animals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional practice\n",
    "\n",
    "#### Exercise\n",
    "\n",
    "Given variables `x` and `y` defining a point $(x, y)$, write a conditional statement that prints \"Less than 1!\" if the distance of $(x, y)$ from $(0, 0)$ is less than 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = rand(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise\n",
    "\n",
    "Write a function `inside_circle(x, y)` that takes coordinates/variables `x` and `y` and determines whether the point $(x, y)$ falls inside a circle of radius 1 that is centered at $(0, 0)$. Return `1` if the point falls within the circle and `0` if not.\n",
    "\n",
    "*Hint:* To fall within the circle, the distance of the point to the circle's center should be less than the radius."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loop practice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise\n",
    "\n",
    "Use a loop to generate 100 random points $(x_i, y_i)$ where $-1.0 <= x <= 1.0$ and $-1.0 <= y <= 1.0$. Print the number of times the points fell within a circle of radius 1, centered at $(0, 0)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array practice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise\n",
    "\n",
    "Use an array comprehension to create an array of 100 points in 2D Cartesian space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise\n",
    "\n",
    "Use an array comprehension to create an array of the distances of 100 points in 2D Cartesian space from a point at $(0, 0)$.\n",
    "\n",
    "*Hint:* You may find \"splat\", i.e. `...`, useful here. Adding `...` after a collection passed as an input argument to a function \"opens up\" that collection, passing each of the elements of the collection as inputs to the function. For example, if\n",
    "\n",
    "```\n",
    "a = [1, 2, 3]\n",
    "add_three_things(x, y, z) = x + y + z\n",
    "```\n",
    "then `add_three_things(a)` will give an error, but `add_three_things(a...)` will yield `6`, just as if you had run `add_three_things(a[1], a[2], a[3])`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.0.1",
   "language": "julia",
   "name": "julia-1.0"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.0.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}