part 5 - object oriented programming and bouncing balls.ipynb

{
 "metadata": {
  "name": "part 5 - object oriented programming and bouncing balls"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Best way to learn Python part 5 - OOP and bouncing balls!\n",
      "\n",
      "We'll be using the matplotlib animation framework, so please don't use `inline` mode. Instead, start up like this:\n",
      "\n",
      "    ipython notebook --pylab"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# activate Python 3 default behaviour for print() function\n",
      "# and integer division (4/3 = 1.333...)\n",
      "from __future__ import print_function\n",
      "from __future__ import division"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Classes encapsulate data and behaviour that belong together"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "\n",
      "class Circle(object):\n",
      "    def __init__(self, radius, centre):\n",
      "        self.radius = radius\n",
      "        self.centre = centre\n",
      "        \n",
      "    def circumference(self):\n",
      "        return 2.0 * math.pi * self.radius\n",
      "        \n",
      "    def area(self):\n",
      "        return math.pi * self.radius ** 2\n",
      "    \n",
      "    def point_inside(self, xy):\n",
      "        dist_x = xy[0] - self.centre[0]\n",
      "        dist_y = xy[1] - self.centre[1]\n",
      "        dist = math.hypot(dist_x, dist_y)\n",
      "        \n",
      "        if dist < self.radius:\n",
      "            return True\n",
      "        else:\n",
      "            return False\n",
      "        \n",
      "        \n",
      "        \n",
      "c1 = Circle(2, (0,0))\n",
      "print c1.circumference()\n",
      "print c1.area()\n",
      "c1.point_inside((1,1))\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "12.5663706144\n",
        "12.5663706144\n"
       ]
      },
      {
       "output_type": "pyout",
       "prompt_number": 30,
       "text": [
        "True"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Inheritance\n",
      "\n",
      "If there's an *is a* relationship between two classes, you can consider creating an inheritance relationship.\n",
      "\n",
      "In this case, a `Circle` definitely *is a* `Shape`, so we factor out functionality common to all shapes, namely their position."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "\n",
      "class Shape(object):\n",
      "    def __init__(self, position):\n",
      "        self.position = position\n",
      "\n",
      "class Circle(Shape):\n",
      "    \n",
      "    def __init__(self, radius, centre):\n",
      "        self.radius = radius\n",
      "        super(Circle, self).__init__(centre)\n",
      "        \n",
      "        \n",
      "    def circumference(self):\n",
      "        return 2.0 * math.pi * self.radius\n",
      "        \n",
      "    def area(self):\n",
      "        return math.pi * self.radius ** 2\n",
      "    \n",
      "    def point_inside(self, xy):\n",
      "        dist_x = xy[0] - self.position[0]\n",
      "        dist_y = xy[1] - self.position[1]\n",
      "        \n",
      "        dist = math.hypot(dist_x, dist_y)\n",
      "        \n",
      "        if dist < self.radius:\n",
      "            return True\n",
      "        else:\n",
      "            return False\n",
      "        \n",
      "    \n",
      "c1 = Circle(1.0, (0.5, 1.0))\n",
      "c2 = Circle(1.5, (-0.5, 2.0))\n",
      "c3 = Circle(0.5, (0,0))\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 31
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# 2D Bouncing Ball Physics!\n",
      "\n",
      "**This example, like all matplotlib animations, doesn't work in inline mode.**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# when we're in pylab mode, the next two imports are not necessary\n",
      "# we do it here for correctness sake, iow your code will also run without pylab mode\n",
      "import numpy as np\n",
      "import matplotlib.pyplot as plt\n",
      "\n",
      "import matplotlib.animation as animation\n",
      "\n",
      "# gravitational acceleration on Earth in m*s^-2\n",
      "g = 9.80665\n",
      "#g = 1.6249\n",
      "# acceleration vector due to g\n",
      "ag = np.array((0,-g))\n",
      "# coefficient of restitution (ratio of velocity after and before bounce)\n",
      "# see http://en.wikipedia.org/wiki/Coefficient_of_restitution\n",
      "cor = 0.95\n",
      "\n",
      "# bounds of the room\n",
      "xlim = (0,30)\n",
      "ylim = (0,20)\n",
      "\n",
      "# position of the ball\n",
      "xy = np.array((3.0,18.0))\n",
      "# velocity of the ball\n",
      "v = np.array((0.2,0.3))\n",
      "\n",
      "# 1 millisecond delta t\n",
      "delta_t = 0.001\n",
      "\n",
      "fig = plt.figure()\n",
      "ax = fig.add_subplot(111, autoscale_on=False, xlim=xlim, ylim=ylim)\n",
      "ax.grid()\n",
      "\n",
      "scatter, = ax.plot([], [], 'o', color='green', markersize=20)\n",
      "\n",
      "def init():\n",
      "    return []\n",
      "\n",
      "def animate(t):\n",
      "    # t is time in seconds\n",
      "    global xy, v\n",
      "    \n",
      "    if xy[0] <= xlim[0]:\n",
      "        # hit the left wall, reflect x component\n",
      "        v[0] = cor * np.abs(v[0])\n",
      "        \n",
      "    elif xy[0] >= xlim[1]:\n",
      "        v[0] = - cor * np.abs(v[0])\n",
      "        \n",
      "    if xy[1] <= ylim[0]:\n",
      "        v[1] = cor * np.abs(v[1])\n",
      "        \n",
      "    elif xy[1] >= ylim[1]:\n",
      "        v[1] = - cor * np.abs(v[1])\n",
      "    \n",
      "    # delta t is 0.1\n",
      "    delta_v = delta_t * ag\n",
      "    v += delta_v\n",
      "    \n",
      "    xy += v\n",
      "    \n",
      "    xy[0] = np.clip(xy[0], xlim[0], xlim[1])\n",
      "    xy[1] = np.clip(xy[1], ylim[0], ylim[1])\n",
      "\n",
      "    scatter.set_data(xy)\n",
      "    # have to return an iterable\n",
      "    return scatter,\n",
      "\n",
      "# interval in milliseconds\n",
      "# we're watching in slow motion (delta t is shorter than interval)\n",
      "ani = animation.FuncAnimation(fig, animate, np.arange(0,100,delta_t), init_func=init, interval=10, blit=True)\n",
      "\n",
      "plt.show()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 32
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Multiply all the balls!\n",
      "\n",
      "**This example, like all matplotlib animations, doesn't work in inline mode.**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# when we're in pylab mode, the next two imports are not necessary\n",
      "# we do it here for correctness sake, iow your code will also run without pylab mode\n",
      "import numpy as np\n",
      "import matplotlib.pyplot as plt\n",
      "\n",
      "import matplotlib.animation as animation\n",
      "\n",
      "# gravitational acceleration on Earth in m*s^-2\n",
      "g = 9.80665\n",
      "#g = 1.6249\n",
      "# acceleration vector due to g\n",
      "ag = np.array((0,-g))\n",
      "# coefficient of restitution (ratio of velocity after and before bounce)\n",
      "# see http://en.wikipedia.org/wiki/Coefficient_of_restitution\n",
      "cor = 0.95\n",
      "\n",
      "# bounds of the room\n",
      "xlim = (0,30)\n",
      "ylim = (0,20)\n",
      "\n",
      "# 1 millisecond delta t\n",
      "delta_t = 0.001\n",
      "\n",
      "fig = plt.figure()\n",
      "ax = fig.add_subplot(111, autoscale_on=False, xlim=xlim, ylim=ylim)\n",
      "ax.grid()\n",
      "\n",
      "# in Python 2.7 we have to derive from object to have new-style classes\n",
      "# in Python 3 this is still valid, but not necessary, as all classes are new-style\n",
      "class Ball(object):\n",
      "    \n",
      "    def __init__(self, xy, v):\n",
      "        \"\"\"\n",
      "        :param xy: Initial position.\n",
      "        :param v: Initial velocity.\n",
      "        \"\"\"\n",
      "        self.xy = np.array(xy)\n",
      "        self.v = np.array(v)\n",
      "        \n",
      "        self.scatter, = ax.plot([], [], 'o', markersize=20)\n",
      "        \n",
      "    def update(self):\n",
      "        if self.xy[0] <= xlim[0]:\n",
      "            # hit the left wall, reflect x component\n",
      "            self.v[0] = cor * np.abs(self.v[0])\n",
      "            \n",
      "        elif self.xy[0] >= xlim[1]:\n",
      "            self.v[0] = - cor * np.abs(self.v[0])\n",
      "            \n",
      "        if self.xy[1] <= ylim[0]:\n",
      "            # hit the left wall, reflect y component\n",
      "            self.v[1] = cor * np.abs(self.v[1])\n",
      "            \n",
      "        elif self.xy[1] >= ylim[1]:\n",
      "            self.v[1] = - cor * np.abs(self.v[1])\n",
      "        \n",
      "        # delta t is 0.1\n",
      "        delta_v = delta_t * ag\n",
      "        self.v += delta_v\n",
      "        \n",
      "        self.xy += self.v\n",
      "        \n",
      "        self.xy[0] = np.clip(self.xy[0], xlim[0], xlim[1])\n",
      "        self.xy[1] = np.clip(self.xy[1], ylim[0], ylim[1])\n",
      "        \n",
      "        self.scatter.set_data(self.xy)\n",
      "        \n",
      "        \n",
      "\n",
      "balls = [Ball((3.0,18.0), (0.2,0.3)), Ball((4.0,17.0), (-0.2,0.1)), Ball((1.0,19.0), (-0.3,0.5))]\n",
      "\n",
      "def init():\n",
      "    return []\n",
      "\n",
      "def animate(t):\n",
      "    # t is time in seconds\n",
      "    global xy, v\n",
      "\n",
      "    for ball in balls:\n",
      "        ball.update()\n",
      "    \n",
      "    # have to return an iterable\n",
      "    return [ball.scatter for ball in balls]\n",
      "\n",
      "# interval in milliseconds\n",
      "# we're watching in slow motion (delta t is shorter than interval)\n",
      "ani = animation.FuncAnimation(fig, animate, np.arange(0,100,delta_t), init_func=init, interval=10, blit=True)\n",
      "\n",
      "plt.show()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 33
    }
   ],
   "metadata": {}
  }
 ]
}