LA4DS_ch02.ipynb

{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "name": "LA4DS_ch02.ipynb",
   "provenance": [],
   "collapsed_sections": [],
   "authorship_tag": "ABX9TyOewhvhiRbC6RypIGGdxufO"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Practical Linear Algebra for Data Science\n",
    "## Mike X Cohen (sincxpress.com)\n",
    "### https://www.oreilly.com/library/view/practical-linear-algebra/9781098120603/\n",
    "\n",
    "#### Code for chapter 2"
   ],
   "metadata": {
    "id": "SbGFWGzkd44U"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "tY0IlmddejbI"
   },
   "source": [
    "# import libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "# NOTE: these lines define global figure properties used for publication.\n",
    "import matplotlib_inline.backend_inline\n",
    "matplotlib_inline.backend_inline.set_matplotlib_formats('svg') # display figures in vector format\n",
    "plt.rcParams.update({'font.size':14}) # set global font size"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lILGCfNmeaoR"
   },
   "source": [
    "# Creating vectors"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "9AoQthPKegez"
   },
   "source": [
    "# a vector as a Python list datatype\n",
    "asList = [1,2,3]\n",
    "\n",
    "# same numbers, but as a dimensionless numpy array\n",
    "asArray = np.array([1,2,3])\n",
    "\n",
    "# again same numbers, but now endowed with orientations\n",
    "rowVec = np.array([ [1,2,3] ]) # row\n",
    "colVec = np.array([ [1],[2],[3] ]) # column\n",
    "\n",
    "# Note the use of spacing when defining the vectors; that is not necessary but makes the code more readable."
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "pKu9GCbSeghU"
   },
   "source": [
    "# Check the sizes of the variables\n",
    "print(f'asList:  {np.shape(asList)}') # using np's shape function\n",
    "print(f'asArray: {asArray.shape}') # using a method associated with numpy objects\n",
    "print(f'rowVec:  {rowVec.shape}')\n",
    "print(f'colVec:  {colVec.shape}')"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7vK1qpzpegkN"
   },
   "source": [
    "# Geometry of vectors"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "yQ0gPgH4fBLy"
   },
   "source": [
    "# create a vector\n",
    "v = np.array([-1,2])\n",
    "\n",
    "# plot that vector (and a dot for the tail)\n",
    "plt.arrow(0,0,v[0],v[1],head_width=.5,width=.1)\n",
    "plt.plot(0,0,'ko',markerfacecolor='k',markersize=7)\n",
    "\n",
    "# add axis lines\n",
    "plt.plot([-3,3],[0,0],'--',color=[.8,.8,.8],zorder=-1)\n",
    "plt.plot([0,0],[-3,3],'--',color=[.8,.8,.8],zorder=-1)\n",
    "\n",
    "# make the plot look nicer\n",
    "plt.axis('square')\n",
    "plt.axis([-3,3,-3,3])\n",
    "plt.xlabel('$v_0$')\n",
    "plt.ylabel('$v_1$')\n",
    "plt.title('Vector v in standard position')\n",
    "plt.show()"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "Vf-wu4LtfBOp"
   },
   "source": [
    "# A range of starting positions\n",
    "\n",
    "startPos = [\n",
    "            [0,0],\n",
    "            [-1,-1],\n",
    "            [1.5,-2]\n",
    "            ]\n",
    "\n",
    "\n",
    "# create a new figure\n",
    "fig = plt.figure(figsize=(6,6))\n",
    "\n",
    "for s in startPos:\n",
    "\n",
    "  # plot that vector (and a dot for the tail)\n",
    "  # note that plt.arrow automatically adds an offset to the third/fourth inputs\n",
    "  plt.arrow(s[0],s[1],v[0],v[1],head_width=.5,width=.1,color='black')\n",
    "  plt.plot(s[0],s[1],'ko',markerfacecolor='k',markersize=7)\n",
    "\n",
    "  # indicate the vector in its standard position\n",
    "  if s==[0,0]:\n",
    "    plt.text(v[0]+.1,v[1]+.2,'\"Standard pos.\"')\n",
    "\n",
    "\n",
    "# add axis lines\n",
    "plt.plot([-3,3],[0,0],'--',color=[.8,.8,.8],zorder=-1)\n",
    "plt.plot([0,0],[-3,3],'--',color=[.8,.8,.8],zorder=-1)\n",
    "\n",
    "# make the plot look nicer\n",
    "plt.axis('square')\n",
    "plt.axis([-3,3,-3,3])\n",
    "plt.xlabel('$v_0$')\n",
    "plt.ylabel('$v_1$')\n",
    "plt.title('Vector $\\mathbf{v}$ in various locations')\n",
    "plt.savefig('Figure_02_01.png',dpi=300) # write out the fig to a file\n",
    "plt.show()"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RmDpBhPLfBRx"
   },
   "source": [
    "# Adding vectors"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "9na0binQg4tg"
   },
   "source": [
    "# Using 2D vectors here instead of 3D vectors in the book to facilitate visualization\n",
    "v = np.array([1,2])\n",
    "w = np.array([4,-6])\n",
    "vPlusW = v+w\n",
    "\n",
    "# print out all three vectors\n",
    "print(v)\n",
    "print(w)\n",
    "print(vPlusW)\n",
    "\n",
    "# Note that here we don't need to worry about vector orientation (row vs. column), \n",
    "# so for simplicity the vectors are created orientationless."
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "6WUKBXsCALJm"
   },
   "source": [
    "# Where's the code to generate Figure 3-2? \n",
    "# It's exercise 0!"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TGxmt6X3Cj6w"
   },
   "source": [
    "# Subtracting vectors"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "bqZj44Z3Cmrx"
   },
   "source": [
    "# Same v and w as above for comparison\n",
    "vMinusW = v-w\n",
    "\n",
    "# print out all three vectors\n",
    "print(v)\n",
    "print(w)\n",
    "print(vMinusW)"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "wMHKSzKFCc_3"
   },
   "source": [
    "# Code for Figure 3-2 is part of Exercise 0."
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_kSQSRE-fBUp"
   },
   "source": [
    "# Vector-scalar multiplication"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "stq0frvmihiN"
   },
   "source": [
    "# a scalar\n",
    "s = -1/2\n",
    "\n",
    "# a vector\n",
    "b = np.array([3,4])\n",
    "\n",
    "# print them\n",
    "print(b*s)\n",
    "\n",
    "# Question: Does vector b need to be a numpy array? What happens if it's a list?"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "# Scalar-vector addition\n",
    "s = 3.5\n",
    "\n",
    "print(v)\n",
    "print(s+v)"
   ],
   "metadata": {
    "id": "jgNODDx_ltdn"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "WXEjiVKJihk8"
   },
   "source": [
    "# plot\n",
    "plt.plot([0,b[0]],[0,b[1]],'m--',linewidth=3,label='b')\n",
    "plt.plot([0,s*b[0]],[0,s*b[1]],'k:',linewidth=3,label='sb')\n",
    "\n",
    "plt.grid()\n",
    "plt.axis('square')\n",
    "plt.axis([-6,6,-6,6])\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "VI1nLhJyihns"
   },
   "source": [
    "# Effects of different scalars\n",
    "\n",
    "# a list of scalars:\n",
    "scalars = [ 1, 2, 1/3, 0, -2/3 ]\n",
    "\n",
    "baseVector = np.array([ .75,1 ])\n",
    "\n",
    "# create a figure\n",
    "fig,axs = plt.subplots(1,len(scalars),figsize=(12,3))\n",
    "i = 0 # axis counter\n",
    "\n",
    "for s in scalars:\n",
    "\n",
    "  # compute the scaled vector\n",
    "  v = s*baseVector\n",
    "\n",
    "  # plot it\n",
    "  axs[i].arrow(0,0,baseVector[0],baseVector[1],head_width=.3,width=.1,color='k',length_includes_head=True)\n",
    "  axs[i].arrow(.1,0,v[0],v[1],head_width=.3,width=.1,color=[.75,.75,.75],length_includes_head=True)\n",
    "  axs[i].grid(linestyle='--')\n",
    "  axs[i].axis('square')\n",
    "  axs[i].axis([-2.5,2.5,-2.5,2.5])\n",
    "  axs[i].set(xticks=np.arange(-2,3), yticks=np.arange(-2,3))\n",
    "  axs[i].set_title(f'$\\sigma$ = {s:.2f}')\n",
    "  i+=1 # update axis counter\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('Figure_02_03.png',dpi=300)\n",
    "plt.show()\n"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KcF07aOdihqE"
   },
   "source": [
    "# Vector transpose"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "-EEhEycVwXNO"
   },
   "source": [
    "# Row vector\n",
    "r = np.array([ [1,2,3] ])\n",
    "\n",
    "# orientationless array\n",
    "l = np.array([1,2,3])"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "576musu6wXV1"
   },
   "source": [
    "# print out the vector, its transpose, and its double-transpose\n",
    "print(r), print(' ')\n",
    "\n",
    "# Transpose the row vector\n",
    "print(r.T), print(' ')\n",
    "\n",
    "# double-transpose\n",
    "print(r.T.T)"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "Mx6I2nH0wXZF"
   },
   "source": [
    "# Same for the orientationless array\n",
    "print(l), print(' ')\n",
    "print(l.T), print(' ')\n",
    "print(l.T.T)"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "XuYbMcdXwXb-"
   },
   "source": [
    ""
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "# The dot product is distributive"
   ],
   "metadata": {
    "id": "toCvM6BReALV"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# just some random vectors...\n",
    "v = np.array([ 0,1,2 ])\n",
    "w = np.array([ 3,5,8 ])\n",
    "u = np.array([ 13,21,34 ])\n",
    "\n",
    "# two ways to comptue\n",
    "res1 = np.dot( v, w+u )\n",
    "res2 = np.dot( v,w ) + np.dot( v,u )\n",
    "\n",
    "# show that they are equivalent\n",
    "res1,res2"
   ],
   "metadata": {
    "id": "zlM0uJIceELT"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    ""
   ],
   "metadata": {
    "id": "OqSuPgvHeANu"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VnF9n7PDwXgN"
   },
   "source": [
    "# Solutions to code exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Exercise 1"
   ],
   "metadata": {
    "id": "0Ia7D2RuEPCY"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# The vectors\n",
    "v = np.array([1,2])\n",
    "w = np.array([4,-6])\n",
    "vPlusW = v+w\n",
    "\n",
    "\n",
    "# now plot all three vectors\n",
    "plt.figure(figsize=(6,6))\n",
    "\n",
    "a1 = plt.arrow(0,0,v[0],v[1],head_width=.3,width=.1,color='k',length_includes_head=True)\n",
    "a2 = plt.arrow(v[0],v[1],w[0],w[1],head_width=.3,width=.1,color=[.5,.5,.5],length_includes_head=True)\n",
    "a3 = plt.arrow(0,0,vPlusW[0],vPlusW[1],head_width=.3,width=.1,color=[.8,.8,.8],length_includes_head=True)\n",
    "\n",
    "\n",
    "# make the plot look a bit nicer\n",
    "plt.grid(linestyle='--',linewidth=.5)\n",
    "plt.axis('square')\n",
    "plt.axis([-6,6,-6,6])\n",
    "plt.legend([a1,a2,a3],['v','w','v+w'])\n",
    "plt.title('Vectors $\\mathbf{v}$, $\\mathbf{w}$, and $\\mathbf{v+w}$')\n",
    "plt.savefig('Figure_02_02a.png',dpi=300) # write out the fig to a file\n",
    "plt.show()"
   ],
   "metadata": {
    "id": "Jzlps2LlEQRb"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "# vector difference\n",
    "vMinusW = v-w\n",
    "\n",
    "\n",
    "# now plot all three vectors\n",
    "plt.figure(figsize=(6,6))\n",
    "\n",
    "a1 = plt.arrow(0,0,v[0],v[1],head_width=.3,width=.1,color='k',length_includes_head=True)\n",
    "a2 = plt.arrow(0,0,w[0],w[1],head_width=.3,width=.1,color=[.5,.5,.5],length_includes_head=True)\n",
    "a3 = plt.arrow(w[0],w[1],vMinusW[0],vMinusW[1],head_width=.3,width=.1,color=[.8,.8,.8],length_includes_head=True)\n",
    "\n",
    "\n",
    "# make the plot look a bit nicer\n",
    "plt.grid(linestyle='--',linewidth=.5)\n",
    "plt.axis('square')\n",
    "plt.axis([-6,6,-6,6])\n",
    "plt.legend([a1,a2,a3],['v','w','v-w'])\n",
    "plt.title('Vectors $\\mathbf{v}$, $\\mathbf{w}$, and $\\mathbf{v-w}$')\n",
    "plt.savefig('Figure_02_02b.png',dpi=300)\n",
    "plt.show()"
   ],
   "metadata": {
    "id": "bFk5NUHeEjVe"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    ""
   ],
   "metadata": {
    "id": "aEyAijHeEQZi"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Exercise 2"
   ],
   "metadata": {
    "id": "5lhI6njFMIv0"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "# the function\n",
    "def normOfVect(v):\n",
    "  return np.sqrt(np.sum(v**2))\n",
    "\n",
    "# test it on a unit-norm vector\n",
    "w = np.array([0,0,1])\n",
    "print( normOfVect(w) )\n",
    "\n",
    "# non-unit-norm vector, and confirm using np.linalg.norm\n",
    "w = np.array([1,2,3])\n",
    "print( normOfVect(w),np.linalg.norm(w) )"
   ],
   "metadata": {
    "id": "2IBYC8qKp_4w"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    ""
   ],
   "metadata": {
    "id": "VsA3W7EZO3KC"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Exercise 3"
   ],
   "metadata": {
    "id": "8ki-fdMqPEGj"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "# define function\n",
    "def createUnitVector(v):\n",
    "  # get vector norm\n",
    "  mu = np.linalg.norm(v)\n",
    "  # return unit vector\n",
    "  return v / mu\n",
    "\n",
    "\n",
    "# test on a unit vector\n",
    "w = np.array([0,1,0])\n",
    "print( createUnitVector(w) )\n",
    "\n",
    "# test on a non-unit vector that is easy to confirm\n",
    "w = np.array([0,3,0])\n",
    "print( createUnitVector(w) )\n",
    "\n",
    "# test on a non-unit vector\n",
    "w = np.array([13,-5,7])\n",
    "uw = createUnitVector(w)\n",
    "print( uw ), print(' ')\n",
    "# confirm the vectors' norms\n",
    "print( np.linalg.norm(w),np.linalg.norm(uw) )\n",
    "\n",
    "# what happens with the zeros vector?\n",
    "print('\\n\\n\\n') # just some spaces\n",
    "createUnitVector( np.zeros((4,1)) )"
   ],
   "metadata": {
    "id": "mRKCY5NAqDnB"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    ""
   ],
   "metadata": {
    "id": "WuM2gunEO68_"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Exercise 4"
   ],
   "metadata": {
    "id": "dDtSlk5RRyT0"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# define the function\n",
    "def createMagVector(v,mag):\n",
    "  # get vector norm\n",
    "  mu = np.linalg.norm(v)\n",
    "  # return scaled vector\n",
    "  return mag * v / mu\n",
    "\n",
    "# test on a vector that is easy to confirm\n",
    "w = np.array([1,0,0])\n",
    "mw = createMagVector(w,4)\n",
    "print( mw )\n",
    "\n",
    "# confirm the vectors' norms\n",
    "print( np.linalg.norm(w),np.linalg.norm(mw) )\n"
   ],
   "metadata": {
    "id": "ar0fVeCdqGXd"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    ""
   ],
   "metadata": {
    "id": "2CK7U4qxO-Fd"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Exercise 5"
   ],
   "metadata": {
    "id": "PLaa7qtQK2Lh"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# the row vector to transpose\n",
    "v = np.array([[1,2,3]])\n",
    "\n",
    "# initialize the column vector\n",
    "vt = np.zeros((3,1))\n",
    "\n",
    "# direct implementation of the formula using a for loop\n",
    "for i in range(v.shape[1]):\n",
    "  vt[i,0] = v[0,i]\n",
    "\n",
    "# confirm!\n",
    "print(v), print(' ')\n",
    "print(vt)\n",
    "\n",
    "# Note about data types: The two vectors actually have different data types\n",
    "#  (ints vs. floats). That happened because I defined v using ints while the default type\n",
    "#  for np.zeros is float. You can match data types in several ways, including: \n",
    "#  (1) write 3. instead of 3 when creating v; (2) use dtype=np.float as an optional input."
   ],
   "metadata": {
    "id": "_bDlky_EqJmV"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    ""
   ],
   "metadata": {
    "id": "p267dm8cPHnL"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Exercise 6"
   ],
   "metadata": {
    "id": "WG4o7KMwK2Oe"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# some vector\n",
    "c = np.random.randn(5)\n",
    "\n",
    "# squared norm as dot product with itself\n",
    "sqrNrm1 = np.dot(c,c)\n",
    "\n",
    "# squared norm via our function from exercise 1\n",
    "sqrNrm2 = normOfVect(c)**2\n",
    "\n",
    "# print both to confirm they're the same\n",
    "print( sqrNrm1 )\n",
    "print( sqrNrm2 )"
   ],
   "metadata": {
    "id": "TixOP_P-qMVg"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    ""
   ],
   "metadata": {
    "id": "3fMvZGNrPZgx"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Exercise 7"
   ],
   "metadata": {
    "id": "uNFCPFrWK2Rv"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# dimensionality\n",
    "n = 11\n",
    "\n",
    "# some random column vectors\n",
    "a = np.random.randn(n,1)\n",
    "b = np.random.randn(n,1)\n",
    "\n",
    "# dot products both ways\n",
    "atb = np.sum(a*b)\n",
    "bta = np.sum(b*a)\n",
    "\n",
    "# they're equal if their difference is 0\n",
    "atb - bta\n",
    "\n",
    "# For an extra challenge, see what happens when you use np.dot() to compute the dot products."
   ],
   "metadata": {
    "id": "Nm42fqcaqOi6"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Exercise 8"
   ],
   "metadata": {
    "id": "peki_RfFegnb"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# the vectors a and b\n",
    "a = np.array([1,2])\n",
    "b = np.array([1.5,.5])\n",
    "\n",
    "# compute beta\n",
    "beta = np.dot(a,b) / np.dot(a,a)\n",
    "\n",
    "# compute the projection vector (not explicitly used in the plot)\n",
    "projvect = b - beta*a\n",
    "\n",
    "\n",
    "# draw the figure\n",
    "plt.figure(figsize=(4,4))\n",
    "\n",
    "# vectors\n",
    "plt.arrow(0,0,a[0],a[1],head_width=.2,width=.02,color='k',length_includes_head=True)\n",
    "plt.arrow(0,0,b[0],b[1],head_width=.2,width=.02,color='k',length_includes_head=True)\n",
    "\n",
    "# projection vector\n",
    "plt.plot([b[0],beta*a[0]],[b[1],beta*a[1]],'k--')\n",
    "\n",
    "# projection on a\n",
    "plt.plot(beta*a[0],beta*a[1],'ko',markerfacecolor='w',markersize=13)\n",
    "\n",
    "# make the plot look nicer\n",
    "plt.plot([-1,2.5],[0,0],'--',color='gray',linewidth=.5)\n",
    "plt.plot([0,0],[-1,2.5],'--',color='gray',linewidth=.5)\n",
    "\n",
    "# add labels\n",
    "plt.text(a[0]+.1,a[1],'a',fontweight='bold',fontsize=18)\n",
    "plt.text(b[0],b[1]-.3,'b',fontweight='bold',fontsize=18)\n",
    "plt.text(beta*a[0]-.35,beta*a[1],r'$\\beta$',fontweight='bold',fontsize=18)\n",
    "plt.text((b[0]+beta*a[0])/2,(b[1]+beta*a[1])/2+.1,r'(b-$\\beta$a)',fontweight='bold',fontsize=18)\n",
    "\n",
    "# some finishing touches\n",
    "plt.axis('square')\n",
    "plt.axis([-1,2.5,-1,2.5])\n",
    "plt.show()"
   ],
   "metadata": {
    "id": "xhsmQq4sqQ-e"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    ""
   ],
   "metadata": {
    "id": "nM9xPKX5Sepk"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Exercise 9"
   ],
   "metadata": {
    "id": "sZM4JqfVajCq"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# generate random R2 vectors (note: no orientation here! we don't need it for this exercise)\n",
    "t = np.random.randn(2)\n",
    "r = np.random.randn(2)\n",
    "\n",
    "# the decomposition\n",
    "t_para = r * (np.dot(t,r) / np.dot(r,r))\n",
    "t_perp = t - t_para\n",
    "\n",
    "# confirm that the two components sum to the target\n",
    "print(t)\n",
    "print( t_para+t_perp )\n",
    "\n",
    "# confirm orthogonality (dot product must be zero!)\n",
    "print( np.dot(t_para,t_perp) )\n",
    "# Note about this result: Due to numerical precision errors, \n",
    "#   you might get a result of something like 10^-17, which can be interpretd as zero.\n",
    "\n",
    "\n",
    "\n",
    "# draw them!\n",
    "plt.figure(figsize=(6,6))\n",
    "\n",
    "# draw main vectors\n",
    "plt.plot([0,t[0]],[0,t[1]],color='k',linewidth=3,label=r'$\\mathbf{t}$')\n",
    "plt.plot([0,r[0]],[0,r[1]],color=[.7,.7,.7],linewidth=3,label=r'$\\mathbf{r}$')\n",
    "\n",
    "# draw decomposed vector components\n",
    "plt.plot([0,t_para[0]],[0,t_para[1]],'k--',linewidth=3,label=r'$\\mathbf{t}_{\\|}$')\n",
    "plt.plot([0,t_perp[0]],[0,t_perp[1]],'k:',linewidth=3,label=r'$\\mathbf{t}_{\\perp}$')\n",
    "\n",
    "plt.axis('equal')\n",
    "plt.legend()\n",
    "plt.savefig('Figure_02_08.png',dpi=300)\n",
    "plt.show()"
   ],
   "metadata": {
    "id": "VaxGL2QUqZFn"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Exercise 10"
   ],
   "metadata": {
    "id": "vSS3N5NdiAlo"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# Replace t_para in the previous exercise with the line below:\n",
    "t_para = r * (np.dot(t,r) / np.dot(t,t))"
   ],
   "metadata": {
    "id": "C6NG78lhqbwq"
   },
   "execution_count": null,
   "outputs": []
  }
 ]
}