Annotating YouTubes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Annotating Public Resources Using I-Python Notebook\n",
    "============================\n",
    "<h2>A Linear Algebra Example</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"400\"\n",
       "            height=\"300\"\n",
       "            src=\"https://www.youtube.com/embed/3Md5KCCQX-0\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.YouTubeVideo at 0x104efe390>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo(\"3Md5KCCQX-0\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yes, you may embed Youtubes in your I-Python Notebooks, meaning you may follow up on a presentation with some example interactive code (or static code for display purposes).\n",
    "\n",
    "Consider the Khan Academy video above.  He's looking for eigenvectors of a matrix and follows some time-worn and trusted algebraic techniques.\n",
    "\n",
    "NumPy and SciPy come with their own linear algebra components.  NumPy's matrix object will transpose, for example, and below we test the example Hermitian matrix [from Wikipedia](https://en.wikipedia.org/wiki/Hermitian_matrix), proving it obey's the definition of Hermitian in equalling it's own conjugate transpose.\n",
    "\n",
    "*A* and *A.H* may not look the same at first glance, but remember the zero terms (e.g. 0.j) don't matter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "[[ 2.+0.j  2.+1.j  4.+0.j]\n",
      " [ 2.-1.j  3.+0.j  0.+1.j]\n",
      " [ 4.+0.j -0.-1.j  1.+0.j]]\n",
      "A.H\n",
      "[[ 2.-0.j  2.+1.j  4.-0.j]\n",
      " [ 2.-1.j  3.-0.j -0.+1.j]\n",
      " [ 4.-0.j  0.-1.j  1.-0.j]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from scipy import linalg\n",
    "\n",
    "#  https://en.wikipedia.org/wiki/Hermitian_matrix\n",
    "A = np.matrix('2, 2+1j, 4; 2-1j, 3, 1j; 4, -1j, 1')\n",
    "assert (A == A.H).all()  # expect True\n",
    "print(\"A\", A, sep='\\n')\n",
    "print(\"A.H\", A.H, sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's return to Khan's example.  He actually starts his solution in an earlier video, defining matrix *A* and seeking eigenvalues as a first step...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"400\"\n",
       "            height=\"300\"\n",
       "            src=\"https://www.youtube.com/embed/11dNghWC4HI\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.YouTubeVideo at 0x104243208>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "YouTubeVideo(\"11dNghWC4HI\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eigenvalues  : -3.0 3.0 3.0\n",
      "Eigenvector 1: [-0.81649658  0.40824829  0.40824829]\n",
      "Eigenvector 2: [ 0.57735027  0.57735027  0.57735027]\n",
      "Eigenvector 3: [-0.27602622 -0.89708523  0.34503278]\n"
     ]
    }
   ],
   "source": [
    "A  = np.array(\n",
    "    [[-1, 2, 2],\n",
    "     [2, 2, -1], \n",
    "     [2, -1, 2]])    # ordinary numpy Array\n",
    "M_A = np.matrix(A)   # special matrix version\n",
    "la, v = linalg.eig(A)                  # get eigenvalues la and eigenvectors v\n",
    "l1, l2, l3 = list(map(lambda c: c.real, la))\n",
    "print(\"Eigenvalues  :\", l1, l2, l3)\n",
    "print(\"Eigenvector 1:\", v[:,0])\n",
    "print(\"Eigenvector 2:\", v[:,1])\n",
    "print(\"Eigenvector 3:\", v[:,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course the SciPy docs comes with [it's own documentation](http://docs.scipy.org/doc/scipy/reference/tutorial/linalg.html#eigenvalues-and-eigenvectors) on how the eigen-stuff is found.\n",
    "\n",
    "Are the above solutions and Khan's really the same?\n",
    "\n",
    "We may show that the 2nd and 3rd solutions obey the rule: \n",
    "\n",
    "*{a * [1/2, 0, 1] + b * [1/2, 1, 0], a,b both floats}*\n",
    "\n",
    "per Khan's algebraic solution. \n",
    "\n",
    "To show this, divide through by x in [x,y,z] to get [1.0, 3.2500000543426637, -1.2500000181142212] i.e. ratios [4.0, 13.0, -5.0]. So a=-5, b=13 in Khan's equation of the eigenspace (back to top video).  Likewise [1, 1, 1] (same ratios as Eigenvector 2) is obtained with a = b = 1.\n",
    "\n",
    "Now say you want to prove that the original matrix, applied to any of the above eigenvectors, simply scales each one by some linear amount (the definition of an eigenvector):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scaling E1\n",
      "[[-3.]\n",
      " [-3.]\n",
      " [-3.]]\n",
      "Scaling E2\n",
      "[[ 3.]\n",
      " [ 3.]\n",
      " [ 3.]]\n",
      "Scaling E3\n",
      "[[ 3.]\n",
      " [ 3.]\n",
      " [ 3.]]\n"
     ]
    }
   ],
   "source": [
    "eigen1 = v[:,0].reshape(3, 1)\n",
    "print(\"Scaling E1\", (M_A * eigen1)/eigen1,  sep=\"\\n\")  # show the scale factor\n",
    "eigen2 = v[:,1].reshape(3, 1)\n",
    "print(\"Scaling E2\", (M_A * eigen2)/eigen2,  sep=\"\\n\")  # show the scale factor\n",
    "eigen3 = v[:,2].reshape(3, 1)\n",
    "print(\"Scaling E3\", (M_A * eigen3)/eigen3,  sep=\"\\n\")  # show the scale factor"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}