intro_lecture3_2020.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "lecture3_2020.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1iIYo7TP4I6p",
        "colab_type": "text"
      },
      "source": [
        "# Lecture 3: NumPy, Ideal Gas simulation + making a video"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6D1MRrF3Q1wR",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "8pcgeRjpaRX0"
      },
      "source": [
        "## Debugging:\n",
        "\n",
        "The following examples run without error messages, but they do not give the expected result!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "5L9oUo_ZaRX4",
        "colab": {}
      },
      "source": [
        "# Define a function\n",
        "def square(x):\n",
        "    y = x * x\n",
        "\n",
        "# Set k to square of four\n",
        "k = square(4.0)\n",
        "\n",
        "# Should print \"k is 16.0\", shouldn't it?\n",
        "print(\"k is\", k)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "weFkW_FW5rd4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def make_sum(n):\n",
        "\n",
        "  k = 0.0\n",
        "  for i in range(n):\n",
        "\n",
        "    k = k + i\n",
        "\n",
        "    return k\n",
        "\n",
        "\n",
        "for i in range(20):\n",
        "  print(i, make_sum(i))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J0R0p6w3Toos",
        "colab_type": "text"
      },
      "source": [
        "## Question from yesterday: Precision of Python code?\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w5VBIt_KT66v",
        "colab_type": "text"
      },
      "source": [
        "Python floats (i.e. decimal numbers) have 64-bit precision, so only this many numbers exist:\n",
        "\n",
        "$$ 2^{64} = 1.8446744 \\cdot 10^{19} $$\n",
        "\n",
        "Same as Fortran (double precision), C++ (double), etc."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O6lLembTT539",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "1.0 - 1e-8                  # = 1 - 1*10^-8"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q4b8KjhyPadP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "0.1 + 0.2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F2Y3EzRITt0T",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "1.0 - 0.9999999999    # 10x 9s"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9sgSSnCGT0UG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "1.0 - 0.99999999999999999   # 17x 9s"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GRK-lxbiVhaz",
        "colab_type": "text"
      },
      "source": [
        "About 14-16 significant digits!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bSK5vkKsJNhm",
        "colab_type": "text"
      },
      "source": [
        "Printing a large number:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MqppncbbJMvw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = 12345678901234567890.0\n",
        "\n",
        "# Formatted output with 25 places\n",
        "print(\"{:35.10f}\".format(x))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6rDI5jxIUX2D",
        "colab_type": "text"
      },
      "source": [
        "Integers (whole numbers and zero) have arbitrary precision, i.e. *unlimited* significant digits."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "59gqYjGlXK8v",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "99 + 1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X2WKay47VZqh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "9999999999999999999999999999999999999999999999999999999999999999 + 1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WRSAF1TxMD1o",
        "colab_type": "text"
      },
      "source": [
        "*   Most other programming languages us 32-bit integers by default: $2^{32} = 4,294,967,296$\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QW9QRwvd7Fp5",
        "colab_type": "text"
      },
      "source": [
        "## Part 1: What is NumPy and NumPy arrays?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AgBLePmj6mmf",
        "colab_type": "text"
      },
      "source": [
        "What is NumPy? besides `np.exp()`, `np.cos()` etc?\n",
        "\n",
        "\n",
        "*   NumPy is a python package for math and algebra in python\n",
        "\n",
        "*   You import NumPy with the following line:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AyLXkgCU6mqO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_DNPHptg7bWf",
        "colab_type": "text"
      },
      "source": [
        "The core of NumPy is the so-called \"numpy arrays\". \n",
        "\n",
        "They behave very similarly to Pythons lists, but they can be used in for much more advanced mathematical operations."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e4lDC5FM7lT-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# a is a list\n",
        "a = [0.0, 1.0, 2.0, 3.0, 4.0]\n",
        "b = np.asarray(a)\n",
        "\n",
        "# b = np.asarray([0.0, 1.0, 2.0, 3.0, 4.0])\n",
        "\n",
        "print(\"a is\", a)\n",
        "print(\"b is\", b)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R6ibuhDC8_vS",
        "colab_type": "text"
      },
      "source": [
        "They \"look\", but have very different properties. For example, what happens when you add the array to itself?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8neFPJnx8_1v",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Print a list added to a list\n",
        "print(a + a)\n",
        "\n",
        "# Print a numpy array added to a numpy array\n",
        "print(b + b)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I8OitDOx_i-z",
        "colab_type": "text"
      },
      "source": [
        "Element-wise operations"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o2H3z5umL8yV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "b = np.asarray([0.0, 1.0, 2.0, 3.0, 4.0])\n",
        "c = np.asarray([0.0, 10.0, 20, 30.0, 40.0])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nR9bJox-LzP4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(b*c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gg1-WG3pLzSq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(b-c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mluvTLLQLzWM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(b/c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CFvbhYfILzX_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(b**2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nMf5SaayMTSB",
        "colab_type": "text"
      },
      "source": [
        "Can you explain what the following does:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AarMghb5LzaV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(np.sqrt(a))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xo5seFpdR1Ll",
        "colab_type": "text"
      },
      "source": [
        "## Q: \"Ok, so why is this useful?\": Matrices, Linear algebra, etc!\n",
        "\n",
        "Consider adding the following equations, where a, b, and c are vectors:\n",
        "\n",
        "$\\mathbf{c} = \\mathbf{a} + \\mathbf{b}$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7DuZu_kqR1i-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = [0.0, 1.0, 2.0, 3.0, 4.0]\n",
        "b = [0.0, 10.0, 20, 30.0, 40.0]\n",
        "\n",
        "c = []\n",
        "for i in range(5):\n",
        "\n",
        "  val = a[i] + b[i]\n",
        "\n",
        "  c.append(val)\n",
        "\n",
        "print(c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AAVNcYY5R1sF",
        "colab_type": "text"
      },
      "source": [
        "With NumPy:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OFCJgtTXR2BA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = np.asarray(a)\n",
        "b = np.asarray(b)\n",
        "\n",
        "c = a + b\n",
        "\n",
        "print(c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sg08w6vn_jLw",
        "colab_type": "text"
      },
      "source": [
        "## Making NumPy arrays:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2N1bRWWHxak7",
        "colab_type": "text"
      },
      "source": [
        "You can make lists of numbers for example using the function np.arange() function:\n",
        "\n",
        "`np.arange([start], stop, [step]`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zY7NSu4F_jR-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Numbers from 0-9\n",
        "np.arange(10)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O-9SsU7DxR9Y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Numbers from 10-20\n",
        "np.arange(10,21)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AWyGsUvSxSI9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Numbers from 0-100 in steps of 10\n",
        "np.arange(0, 101, 10)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qYZuYbAeypk5",
        "colab_type": "text"
      },
      "source": [
        "Doesn't have to be integers!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AE3i1BiQysGt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Numbers from 0-0.9 in steps of 0.1\n",
        "np.arange(0, 1, 0.1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O0M-9UxOxSTZ",
        "colab_type": "text"
      },
      "source": [
        "Write your own below!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JcBf_nkX_jfF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DGFeraks_jju",
        "colab_type": "text"
      },
      "source": [
        "## Making Arrays of Random numbers\n",
        "\n",
        "The module `np.random` contains lots of functions to generate random numbers: [Link](https://numpy.org/doc/1.18/reference/random/index.html)\n",
        "\n",
        "For example you can use the `np.random.random()` function to make random matrices."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nGz1fbmU-0D2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Random number between 0-1\n",
        "x = np.random.random()\n",
        "\n",
        "print(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bfl77rPr_jpV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Make a (random) 3 x 4 matrix\n",
        "np.random.random(size=(3,4))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BYfm14-4_j2L",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# For reproducibility\n",
        "np.random.seed(42) # Any number you like\n",
        "np.random.random(size=(5,5))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HEgdjrLh--dB",
        "colab_type": "text"
      },
      "source": [
        "**Note:** Other functions exist too, for example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fRPric8z_CxI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Normal distrbution centered on 0 with standard deviation 1\n",
        "np.random.normal()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s1I8zqvR_NhT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Random integer from 1 to 72\n",
        "np.random.randint(1, 72)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QT1FF3X0TPVm",
        "colab_type": "text"
      },
      "source": [
        "## Matrices and vectors algebra with NumPy\n",
        "\n",
        "Numpy is excellent for handling matrices and vectors, and carrying out algebraic operations,\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t_rFV_gwBf1k",
        "colab_type": "text"
      },
      "source": [
        "### Vector operations:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qfnc1JCMBfMe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "np.random.seed(2012)\n",
        "a = np.random.random(size=(3))\n",
        "b = np.random.random(size=(3))\n",
        "\n",
        "print(a)\n",
        "print(b)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vRWVwNWZBoVV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Element-wise sum\n",
        "c = a + b\n",
        "print(c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q2fRa901Bogg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Dot-product\n",
        "c = np.dot(a, b)\n",
        "print(c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Aj0Vf3P5B4es",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Element-wise product\n",
        "c = a * b\n",
        "print(c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "osI5LrPGB_3m",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Outer product\n",
        "c = np.outer(a, b)\n",
        "print(c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "McTrwuH-BomQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Scaling:\n",
        "c = a * 10.0\n",
        "print(c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nw_p_3OaBcjJ",
        "colab_type": "text"
      },
      "source": [
        "## Matrix multiplication:\n",
        "\n",
        "For example, we have matrices `A` and `B`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wVUq81SkTPqX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "np.random.seed(2012)\n",
        "A = np.random.randint(10, size=(3,3))\n",
        "B = np.random.randint(10, size=(3,3))\n",
        "print(\"A\")\n",
        "print(A)\n",
        "print(\"B\")\n",
        "print(B)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DB9CQ1uGAOOi",
        "colab_type": "text"
      },
      "source": [
        "Matrix multiplication:\n",
        "\n",
        "$$C = AB$$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g6tN7F5GAOXS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "C = np.matmul(A,B)\n",
        "print(C)\n",
        "\n",
        "## Or \n",
        "print()\n",
        "\n",
        "C = A @ B\n",
        "print(C)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GiAytAwzAwLD",
        "colab_type": "text"
      },
      "source": [
        "**Element-wise** multiplication: (hadamard product)\n",
        "\n",
        "$$C = A \\circ B$$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QXJsQVxjAwPQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "C = A * B\n",
        "print(C)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5YM1myr6Emzh",
        "colab_type": "text"
      },
      "source": [
        "#### Also: Special cases for `np.dot()`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bU31c6ggGBrL",
        "colab_type": "text"
      },
      "source": [
        "`np.dot()` can also do matrix multiplication!\n",
        "\n",
        "https://numpy.org/doc/stable/reference/generated/numpy.dot.html"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w-OPiShqFvC3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "np.random.seed(666)\n",
        "\n",
        "M = np.random.randint(10, size=(10,10))\n",
        "v = np.random.randint(10, size=(10))\n",
        "\n",
        "# Matrix-Vector\n",
        "print(np.matmul(M, v))\n",
        "print(np.dot(M, v))\n",
        "\n",
        "print()\n",
        "\n",
        "# Vector-Matrix\n",
        "print(np.matmul(v, M))\n",
        "print(np.dot(v, M))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UWTExBXk_kUn",
        "colab_type": "text"
      },
      "source": [
        "## Numpy slice notation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TzSQDU5nFu5y",
        "colab_type": "text"
      },
      "source": [
        "Suppose we have an array, a"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aZl0cSGT_kxS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "np.random.seed(2020)\n",
        "a = np.random.randint(10, size=(10,10))\n",
        "print(a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QPvdEROxIF9q",
        "colab_type": "text"
      },
      "source": [
        "Different examples of Numpy slice-notation:\n",
        "\n",
        "The general syntax is \n",
        "\n",
        "`array[row]`\n",
        "\n",
        "or\n",
        "\n",
        "`array[row, column]`\n",
        "\n",
        "Special notation:\n",
        "\n",
        "*   `n` = what is in index n\n",
        "*   `:n` = up to n\n",
        "*   `n:` = n and onwards\n",
        "*   `:` = everything\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PBGd1SjWJpOx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Get row 3\n",
        "a[3]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NZ3WHpfnJy8M",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Get column 3\n",
        "a[:, 3]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T7QfxVkVIJMe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# First a[:5]five rows, \"up to 5\"\n",
        "a[:5]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oONdjMdvIJlq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# First five rows \"from 5 and onwards\"\n",
        "a[5:]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "czbxXl_HIJwt",
        "colab_type": "text"
      },
      "source": [
        "The general syntax is `array[row, column]`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TYzSa7q4WNg2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Everything\n",
        "a[:, :]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1vS90KgDIJ5s",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Last 5 rows\n",
        "a[:, 5:]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DwpCJuf--3w4",
        "colab_type": "text"
      },
      "source": [
        "## Lots of other stuff!\n",
        "\n",
        "NumPy Manual: https://docs.scipy.org/doc/numpy/reference/index.html\n",
        "\n",
        "For example: Eigenvalues"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W1IjmEp--4WH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "eigen_vals, eigen_vecs = np.linalg.eig(a)\n",
        "\n",
        "print(eigen_vals)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "elK2kW2i4JUn",
        "colab_type": "text"
      },
      "source": [
        "## Demonstration: Simulation of a gas (non-interacting particles):\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bdXhC_KqBVwz",
        "colab_type": "text"
      },
      "source": [
        "![alt text](https://www.saburchill.com/physics/images_thermal_physics/kinetic_theory_03.jpg)\n",
        "\n",
        "In this exercise we will simulate a simple gas consisting of non-interaction particles.\n",
        "\n",
        "If we describe a position of a particle in the as as $X$, when we can use Newton's laws to simulate movement:\n",
        "\n",
        "$$\n",
        "X(t+\\Delta t) = X(t) + \\Delta t \\cdot V_x(t)\n",
        "$$\n",
        "\n",
        "where $\\Delta t$ is a small timestep and $V_x$ is the velocity."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pDHJtUz5E1gK",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qv5j4KMEFbnq",
        "colab_type": "text"
      },
      "source": [
        "First, we need to create some initial positions and velocities:\n",
        "\n",
        "For example from NumPy's `np.random.random` function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ufz2VB2kFjDJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "print(np.random.random())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ubzAeZMYCbtM",
        "colab_type": "text"
      },
      "source": [
        "Everything is in 2D, so lets get some *random* $x$- and $y$-coordinates and velocities for the particles"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "thosbJGUBVL_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n_particles = 5 # Any number you like \n",
        "\n",
        "X = np.random.random(n_particles)\n",
        "Y = np.random.random(n_particles)\n",
        "\n",
        "Vx = np.random.random(n_particles)\n",
        "Vy = np.random.random(n_particles)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8zQwwaQNOMER",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(X)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "04-r-_i1Gakj",
        "colab_type": "text"
      },
      "source": [
        "Now, lets implement the time evolution without Numpy:\n",
        "\n",
        "$$\n",
        "X(t+\\Delta t) = X(t) + \\Delta t \\cdot V_x(t)\n",
        "$$\n",
        "\n",
        "First let set some variables for the simulation:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SqLY5F_pGay3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dt = 0.01\n",
        "n_steps = 100"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vqrC3L2bDJUd",
        "colab_type": "text"
      },
      "source": [
        "Lets program the equation:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pp82MM3OI5nz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for n in range(n_steps):\n",
        "\n",
        "  for i in range(n_particles):\n",
        "\t  X[i] = X[i] + Vx[i] * dt\n",
        "\t  Y[i] = Y[i] + Vy[i] * dt\n",
        "\n",
        "  #X = X + Vx * dt\n",
        "  #Y = Y + Vy * dt\n",
        "  print(X, Y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ANNM5c-RDRC7",
        "colab_type": "text"
      },
      "source": [
        "The same using Numpy notation:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SoUyYdqzDPhS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for n in range(n_steps):\n",
        "\n",
        "  X = X + Vx * dt\n",
        "  Y = Y + Vy * dt\n",
        "  \n",
        "  print(X, Y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rDfPb1WVDc-D",
        "colab_type": "text"
      },
      "source": [
        "## Making a video of the gas simulation\n",
        "\n",
        "We will use a too called `md_video` written by Dr. Jimmy Kromann."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WNf7u0OnHeqc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!rm md_video.py\n",
        "!wget https://www.dropbox.com/s/rsj7yb6a3r62wq5/md_video.py #2> /dev/null\n",
        "\n",
        "import md_video as video\n",
        "\n",
        "from matplotlib import rc\n",
        "rc('animation', html='jshtml')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ANaG8oE_Hgwg",
        "colab_type": "text"
      },
      "source": [
        "Rewriting everything from above, for compactness: I should have written a function, right?*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N-CLm-UTHg4L",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n_particles = 50 # Any number you like \n",
        "\n",
        "X = np.random.random(n_particles) - 0.5\n",
        "Y = np.random.random(n_particles) - 0.5\n",
        "\n",
        "Vx = np.random.random(n_particles) - 0.5\n",
        "Vy = np.random.random(n_particles) - 0.5\n",
        "\n",
        "# Simulation options\n",
        "dt = 0.01\n",
        "n_steps = 500\n",
        "\n",
        "# We want to save the fames in this empty list of lists\n",
        "frames = [[],[]]\n",
        "\n",
        "# Run the simulation\n",
        "for n in range(n_steps):\n",
        "\n",
        "  X = X + Vx * dt\n",
        "  Y = Y + Vy * dt\n",
        "\n",
        "  # Append the X and Y positions to \"frames\"\n",
        "  frames[0].append(X)\n",
        "  frames[1].append(Y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PmlBNdIgIc3N",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Compiles the animation\n",
        "anim = video.save(frames, box_width=1.0)\n",
        "\n",
        "# Runs the animation\n",
        "anim"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}