From af8722776fa239ad02916986daa867a6933236fe Mon Sep 17 00:00:00 2001 From: shekhar Date: Thu, 1 Jan 2026 21:54:52 -0500 Subject: [PATCH] fixing the typo --- vectors/LA_vectors_allCode.ipynb | 707 ++++++++++++++++++++++++++++++- 1 file changed, 706 insertions(+), 1 deletion(-) diff --git a/vectors/LA_vectors_allCode.ipynb b/vectors/LA_vectors_allCode.ipynb index 523479b..da9adab 100644 --- a/vectors/LA_vectors_allCode.ipynb +++ b/vectors/LA_vectors_allCode.ipynb @@ -1 +1,706 @@ -{"cells":[{"cell_type":"markdown","metadata":{"id":"ujHJkIX56PzW"},"source":["# COURSE: Linear algebra: theory and implementation\n","## SECTION: Vectors\n","\n","#### Instructor: sincxpress.com\n","##### Course url: https://www.udemy.com/course/linear-algebra-theory-and-implementation/?couponCode=202110"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"LqvDnYFy6PzY"},"outputs":[],"source":["import numpy as np\n","import matplotlib.pyplot as plt"]},{"cell_type":"markdown","metadata":{"id":"EI1QY8Q66PzZ"},"source":["\n","---\n","# VIDEO: Algebraic and geometric interpretations\n","---\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"QJqRiK6s6Pza"},"outputs":[],"source":["\n","# 2-dimensional vector\n","v2 = [ 3, -2 ]\n","\n","# 3-dimensional vector\n","v3 = [ 4, -3, 2 ]\n","\n","# row to column (or vice-versa):\n","v3t = np.transpose(v3)\n","\n","\n","# plot them\n","plt.plot([0,v2[0]],[0,v2[1]])\n","plt.axis('equal')\n","plt.plot([-4, 4],[0, 0],'k--')\n","plt.plot([0, 0],[-4, 4],'k--')\n","plt.grid()\n","plt.axis((-4, 4, -4, 4))\n","plt.show()\n","\n","\n","# plot the 3D vector\n","fig = plt.figure(figsize=plt.figaspect(1))\n","# ax = fig.add_subplot(projection='3d')\n","ax = plt.axes(projection = '3d')\n","ax.plot([0, v3[0]],[0, v3[1]],[0, v3[2]],linewidth=3)\n","\n","# make the plot look nicer\n","ax.plot([0, 0],[0, 0],[-4, 4],'k--')\n","ax.plot([0, 0],[-4, 4],[0, 0],'k--')\n","ax.plot([-4, 4],[0, 0],[0, 0],'k--')\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"gEl0jabJ6Pza"},"source":["\n","---\n","# VIDEO: Vector addition/subtraction\n","---\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"0W41JD2T6Pza"},"outputs":[],"source":["\n","# two vectors in R2\n","v1 = np.array([ 3, -1 ])\n","v2 = np.array([ 2, 4 ])\n","\n","v3 = v1 + v2\n","\n","\n","# plot them\n","plt.plot([0, v1[0]],[0, v1[1]],'b',label='v1')\n","plt.plot([0, v2[0]]+v1[0],[0, v2[1]]+v1[1],'r',label='v2')\n","plt.plot([0, v3[0]],[0, v3[1]],'k',label='v1+v2')\n","\n","plt.legend()\n","plt.axis('square')\n","plt.axis((-6, 6, -6, 6, -6, 6 ))\n","plt.grid()\n","plt.show()\n"]},{"cell_type":"markdown","metadata":{"id":"HOGn5eBm6Pzb"},"source":["\n","---\n","# VIDEO: Vector-scalar multiplication\n","---\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"mRyCDW2d6Pzb"},"outputs":[],"source":["# vector and scalar\n","v1 = np.array([ 3, -1 ])\n","l = 2.3\n","v1m = v1*l # scalar-modulated\n","\n","# plot them\n","plt.plot([0, v1[0]],[0, v1[1]],'b',label='$v_1$')\n","plt.plot([0, v1m[0]],[0, v1m[1]],'r:',label='$\\lambda v_1$')\n","\n","plt.legend()\n","plt.axis('square')\n","axlim = max([max(abs(v1)),max(abs(v1m))])*1.5 # dynamic axis lim\n","plt.axis((-axlim,axlim,-axlim,axlim))\n","plt.grid()\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"o-9CcAY_6Pzb"},"source":["\n","---\n","# VIDEO: Vector-vector multiplication: the dot product\n","---\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"CC9uU__Q6Pzb"},"outputs":[],"source":["## many ways to compute the dot product\n","\n","v1 = np.array([ 1, 2, 3, 4, 5, 6 ])\n","v2 = np.array([ 0, -4, -3, 6, 5 ])\n","\n","# method 1\n","dp1 = sum( np.multiply(v1,v2) )\n","\n","# method 2\n","dp2 = np.dot( v1,v2 )\n","\n","# method 3\n","dp3 = np.matmul( v1,v2 )\n","\n","# method 4\n","dp4 = 0 # initialize\n","\n","# loop over elements\n","for i in range(len(v1)):\n","\n"," # multiply corresponding element and sum\n"," dp4 = dp4 + v1[i]*v2[i]\n","\n","\n","print(dp1,dp2,dp3,dp4)"]},{"cell_type":"markdown","metadata":{"id":"zAz60dFw6Pzc"},"source":["# VIDEO: Dot product properties: associative and distributive"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"ECiO4BV06Pzc"},"outputs":[],"source":["## Distributive property\n","\n","# create random vectors\n","n = 10\n","a = np.random.randn(n)\n","b = np.random.randn(n)\n","c = np.random.randn(n)\n","\n","# the two results\n","res1 = np.dot( a , (b+c) )\n","res2 = np.dot(a,b) + np.dot(a,c)\n","\n","# compare them\n","print([ res1,res2 ])"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"E0p31svY6Pzc"},"outputs":[],"source":["## Associative property\n","\n","# create random vectors\n","n = 5\n","a = np.random.randn(n)\n","b = np.random.randn(n)\n","c = np.random.randn(n)\n","\n","# the two results\n","res1 = np.dot( a , np.dot(b,c) )\n","res2 = np.dot( np.dot(a,b) , c )\n","\n","# compare them\n","print(res1)\n","print(res2)\n","\n","\n","### special cases where associative property works!\n","# 1) one vector is the zeros vector\n","# 2) a==b==c\n"]},{"cell_type":"markdown","metadata":{"id":"KQgxdJI-6Pzc"},"source":["\n","---\n","# VIDEO: Vector length\n","---\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"l7Nrrr2J6Pzc"},"outputs":[],"source":["# a vector\n","v1 = np.array([ 1, 2, 3, 4, 5, 6 ])\n","\n","# methods 1-4, just like with the regular dot product, e.g.:\n","vl1 = np.sqrt( sum( np.multiply(v1,v1)) )\n","\n","# method 5: take the norm\n","vl2 = np.linalg.norm(v1)\n","\n","print(vl1,vl2)"]},{"cell_type":"markdown","metadata":{"id":"UpSiVv8G6Pzc"},"source":["\n","---\n","# VIDEO: The dot product from a geometric perspective\n","---\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"1DsEPu3r6Pzd"},"outputs":[],"source":["\n","# two vectors\n","v1 = np.array([ 2, 4, -3 ])\n","v2 = np.array([ 0, -3, -3 ])\n","\n","# compute the angle (radians) between two vectors\n","ang = np.arccos( np.dot(v1,v2) / (np.linalg.norm(v1)*np.linalg.norm(v2)) )\n","\n","\n","# draw them\n","fig = plt.figure()\n","# ax = fig.add_subplot(projection='3d')\n","ax = plt.axes(projection = '3d')\n","ax.plot([0, v1[0]],[0, v1[1]],[0, v1[2]],'b')\n","ax.plot([0, v2[0]],[0, v2[1]],[0, v2[2]],'r')\n","\n","plt.axis((-6, 6, -6, 6))\n","plt.title('Angle between vectors: %s rad.' %ang)\n","plt.show()\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"kRPC1c556Pzd"},"outputs":[],"source":["## equivalence of algebraic and geometric dot product formulas\n","\n","# two vectors\n","v1 = np.array([ 2, 4, -3 ])\n","v2 = np.array([ 0, -3, -3 ])\n","\n","\n","# algebraic\n","dp_a = np.dot( v1,v2 )\n","\n","# geometric\n","dp_g = np.linalg.norm(v1)*np.linalg.norm(v2)*np.cos(ang)\n","\n","# print dot product to command\n","print(dp_a)\n","print(dp_g)\n"]},{"cell_type":"markdown","metadata":{"id":"BS0B5qrY6Pzd"},"source":["\n","---\n","# VIDEO: Vector Hadamard multiplication\n","---\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"TkQPwBp-6Pzd"},"outputs":[],"source":["\n","# create vectors\n","w1 = [ 1, 3, 5 ]\n","w2 = [ 3, 4, 2 ]\n","\n","w3 = np.multiply(w1,w2)\n","print(w3)\n"]},{"cell_type":"markdown","metadata":{"id":"fioauhFR6Pzd"},"source":["\n","---\n","# VIDEO: Vector outer product\n","---\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"PKLjn1Un6Pzd"},"outputs":[],"source":["\n","v1 = np.array([ 1, 2, 3 ])\n","v2 = np.array([ -1, 0, 1 ])\n","\n","# outer product\n","np.outer(v1,v2)\n","\n","# terrible programming, but helps conceptually:\n","op = np.zeros((len(v1),len(v2)))\n","for i in range(0,len(v1)):\n"," for j in range(0,len(v2)):\n"," op[i,j] = v1[i] * v2[j]\n","\n","print(op)"]},{"cell_type":"markdown","metadata":{"id":"gPJF5SqK6Pzd"},"source":["\n","---\n","# VIDEO: Vector cross product\n","---\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"VpkqUitN6Pzd"},"outputs":[],"source":["# create vectors\n","v1 = [ -3, 2, 5 ]\n","v2 = [ 4, -3, 0 ]\n","\n","# Python's cross-product function\n","v3a = np.cross( v1,v2 )\n","\n","# \"manual\" method\n","v3b = [ [v1[1]*v2[2] - v1[2]*v2[1]],\n"," [v1[2]*v2[0] - v1[0]*v2[2]],\n"," [v1[0]*v2[1] - v1[1]*v2[0]] ]\n","\n","print(v3a,v3b)\n","\n","\n","fig = plt.figure()\n","# ax = fig.add_subplot(projection='3d')\n","ax = plt.axes(projection = '3d')\n","\n","# draw plane defined by span of v1 and v2\n","xx, yy = np.meshgrid(np.linspace(-10,10,10),np.linspace(-10,10,10))\n","z1 = (-v3a[0]*xx - v3a[1]*yy)/v3a[2]\n","ax.plot_surface(xx,yy,z1,alpha=.2)\n","\n","## plot the two vectors\n","ax.plot([0, v1[0]],[0, v1[1]],[0, v1[2]],'k')\n","ax.plot([0, v2[0]],[0, v2[1]],[0, v2[2]],'k')\n","ax.plot([0, v3a[0]],[0, v3a[1]],[0, v3a[2]],'r')\n","\n","\n","ax.view_init(azim=150,elev=45)\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"XuGtENQ26Pzd"},"source":["\n","---\n","# VIDEO: Hermitian transpose (a.k.a. conjugate transpose)\n","---\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"vwaAjpwU6Pzd","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1692279750846,"user_tz":-180,"elapsed":262,"user":{"displayName":"Mike X Cohen","userId":"13901636194183843661"}},"outputId":"0c7fc764-e91b-4dcb-e7bb-c15edb5b9fd8"},"outputs":[{"output_type":"stream","name":"stdout","text":["5.0\n","(-7+24j)\n","(25+0j)\n","[3.+0.j 0.+4.j 5.+2.j 2.-5.j]\n","[3.+0.j 0.+4.j 5.+2.j 2.-5.j]\n","[3.-0.j 0.-4.j 5.-2.j 2.+5.j]\n"]}],"source":["# create a complex number\n","z = complex(3,4)\n","\n","# magnitude\n","print( np.linalg.norm(z) )\n","\n","# by transpose?\n","print( np.transpose(z)*z )\n","\n","# by Hermitian transpose\n","print( np.transpose(z.conjugate())*z )\n","\n","\n","# complex vector\n","v = np.array( [ 3, 4j, 5+2j, complex(2,-5) ] )\n","print( v.T )\n","print( np.transpose(v) )\n","print( np.transpose(v.conjugate()) )"]},{"cell_type":"markdown","metadata":{"id":"LqTJT6Vt6Pze"},"source":["\n","---\n","# VIDEO: Unit vector\n","---\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"TPnVO8HB6Pze"},"outputs":[],"source":["\n","# vector\n","v1 = np.array([ -3, 6 ])\n","\n","# mu\n","mu = 1/np.linalg.norm(v1)\n","\n","v1n = v1*mu\n","\n","# plot them\n","plt.plot([0, v1n[0]],[0, v1n[1]],'r',label='v1-norm',linewidth=5)\n","plt.plot([0, v1[0]],[0, v1[1]],'b',label='v1')\n","\n","# axis square\n","plt.axis('square')\n","plt.axis(( -6, 6, -6, 6 ))\n","plt.grid()\n","plt.legend()\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"iXVxkYB96Pze"},"source":["\n","---\n","# VIDEO: Span\n","---\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"NxSX9z-O6Pze"},"outputs":[],"source":["# set S\n","S1 = np.array([1, 1, 0])\n","S2 = np.array([1, 7, 0])\n","\n","# vectors v and w\n","v = np.array([1, 2, 0])\n","w = np.array([3, 2, 1])\n","\n","# draw vectors\n","fig = plt.figure()\n","# ax = fig.add_subplot(projection='3d')\n","ax = plt.axes(projection = '3d')\n","ax.plot([0, S1[0]],[0, S1[1]],[.1, S1[2]+.1],'r',linewidth=3)\n","ax.plot([0, S2[0]],[0, S2[1]],[.1, S2[2]+.1],'r',linewidth=3)\n","\n","ax.plot([0, v[0]],[0, v[1]],[.1, v[2]+.1],'g',linewidth=3)\n","ax.plot([0, w[0]],[0, w[1]],[0, w[2]],'b')\n","\n","# now draw plane\n","xx, yy = np.meshgrid(range(-15,16), range(-15,16))\n","cp = np.cross(S1,S2)\n","z1 = (-cp[0]*xx - cp[1]*yy)*1./cp[2]\n","ax.plot_surface(xx,yy,z1)\n","\n","plt.show()"]}],"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.7.3"},"colab":{"provenance":[]}},"nbformat":4,"nbformat_minor":0} +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "ujHJkIX56PzW" + }, + "source": [ + "# COURSE: Linear algebra: theory and implementation\n", + "## SECTION: Vectors\n", + "\n", + "#### Instructor: sincxpress.com\n", + "##### Course url: https://www.udemy.com/course/linear-algebra-theory-and-implementation/?couponCode=202110" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "LqvDnYFy6PzY" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EI1QY8Q66PzZ" + }, + "source": [ + "\n", + "---\n", + "# VIDEO: Algebraic and geometric interpretations\n", + "---\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "QJqRiK6s6Pza" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Ignoring fixed x limits to fulfill fixed data aspect with adjustable data limits.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# 2-dimensional vector\n", + "v2 = [ 3, -2 ]\n", + "\n", + "# 3-dimensional vector\n", + "v3 = [ 4, -3, 2 ]\n", + "\n", + "# row to column (or vice-versa):\n", + "v3t = np.transpose(v3)\n", + "\n", + "\n", + "# plot them\n", + "plt.plot([0,v2[0]],[0,v2[1]])\n", + "plt.axis('equal')\n", + "plt.plot([-4, 4],[0, 0],'k--')\n", + "plt.plot([0, 0],[-4, 4],'k--')\n", + "plt.grid()\n", + "plt.axis((-4, 4, -4, 4))\n", + "plt.show()\n", + "\n", + "\n", + "# plot the 3D vector\n", + "fig = plt.figure(figsize=plt.figaspect(1))\n", + "# ax = fig.add_subplot(projection='3d')\n", + "ax = plt.axes(projection = '3d')\n", + "ax.plot([0, v3[0]],[0, v3[1]],[0, v3[2]],linewidth=3)\n", + "\n", + "# make the plot look nicer\n", + "ax.plot([0, 0],[0, 0],[-4, 4],'k--')\n", + "ax.plot([0, 0],[-4, 4],[0, 0],'k--')\n", + "ax.plot([-4, 4],[0, 0],[0, 0],'k--')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gEl0jabJ6Pza" + }, + "source": [ + "\n", + "---\n", + "# VIDEO: Vector addition/subtraction\n", + "---\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "0W41JD2T6Pza" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# two vectors in R2\n", + "v1 = np.array([ 3, -1 ])\n", + "v2 = np.array([ 2, 4 ])\n", + "\n", + "v3 = v1 + v2\n", + "\n", + "\n", + "# plot them\n", + "plt.plot([0, v1[0]],[0, v1[1]],'b',label='v1')\n", + "plt.plot([0, v2[0]]+v1[0],[0, v2[1]]+v1[1],'r',label='v2')\n", + "plt.plot([0, v3[0]],[0, v3[1]],'k',label='v1+v2')\n", + "\n", + "plt.legend()\n", + "plt.axis('square')\n", + "plt.axis((-6, 6, -6, 6))\n", + "plt.grid()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HOGn5eBm6Pzb" + }, + "source": [ + "\n", + "---\n", + "# VIDEO: Vector-scalar multiplication\n", + "---\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "mRyCDW2d6Pzb" + }, + "outputs": [], + "source": [ + "# vector and scalar\n", + "v1 = np.array([ 3, -1 ])\n", + "l = 2.3\n", + "v1m = v1*l # scalar-modulated\n", + "\n", + "# plot them\n", + "plt.plot([0, v1[0]],[0, v1[1]],'b',label='$v_1$')\n", + "plt.plot([0, v1m[0]],[0, v1m[1]],'r:',label='$\\lambda v_1$')\n", + "\n", + "plt.legend()\n", + "plt.axis('square')\n", + "axlim = max([max(abs(v1)),max(abs(v1m))])*1.5 # dynamic axis lim\n", + "plt.axis((-axlim,axlim,-axlim,axlim))\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "o-9CcAY_6Pzb" + }, + "source": [ + "\n", + "---\n", + "# VIDEO: Vector-vector multiplication: the dot product\n", + "---\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "CC9uU__Q6Pzb" + }, + "outputs": [], + "source": [ + "## many ways to compute the dot product\n", + "\n", + "v1 = np.array([ 1, 2, 3, 4, 5, 6 ])\n", + "v2 = np.array([ 0, -4, -3, 6, 5 ])\n", + "\n", + "# method 1\n", + "dp1 = sum( np.multiply(v1,v2) )\n", + "\n", + "# method 2\n", + "dp2 = np.dot( v1,v2 )\n", + "\n", + "# method 3\n", + "dp3 = np.matmul( v1,v2 )\n", + "\n", + "# method 4\n", + "dp4 = 0 # initialize\n", + "\n", + "# loop over elements\n", + "for i in range(len(v1)):\n", + "\n", + " # multiply corresponding element and sum\n", + " dp4 = dp4 + v1[i]*v2[i]\n", + "\n", + "\n", + "print(dp1,dp2,dp3,dp4)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zAz60dFw6Pzc" + }, + "source": [ + "# VIDEO: Dot product properties: associative and distributive" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ECiO4BV06Pzc" + }, + "outputs": [], + "source": [ + "## Distributive property\n", + "\n", + "# create random vectors\n", + "n = 10\n", + "a = np.random.randn(n)\n", + "b = np.random.randn(n)\n", + "c = np.random.randn(n)\n", + "\n", + "# the two results\n", + "res1 = np.dot( a , (b+c) )\n", + "res2 = np.dot(a,b) + np.dot(a,c)\n", + "\n", + "# compare them\n", + "print([ res1,res2 ])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "E0p31svY6Pzc" + }, + "outputs": [], + "source": [ + "## Associative property\n", + "\n", + "# create random vectors\n", + "n = 5\n", + "a = np.random.randn(n)\n", + "b = np.random.randn(n)\n", + "c = np.random.randn(n)\n", + "\n", + "# the two results\n", + "res1 = np.dot( a , np.dot(b,c) )\n", + "res2 = np.dot( np.dot(a,b) , c )\n", + "\n", + "# compare them\n", + "print(res1)\n", + "print(res2)\n", + "\n", + "\n", + "### special cases where associative property works!\n", + "# 1) one vector is the zeros vector\n", + "# 2) a==b==c\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KQgxdJI-6Pzc" + }, + "source": [ + "\n", + "---\n", + "# VIDEO: Vector length\n", + "---\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "l7Nrrr2J6Pzc" + }, + "outputs": [], + "source": [ + "# a vector\n", + "v1 = np.array([ 1, 2, 3, 4, 5, 6 ])\n", + "\n", + "# methods 1-4, just like with the regular dot product, e.g.:\n", + "vl1 = np.sqrt( sum( np.multiply(v1,v1)) )\n", + "\n", + "# method 5: take the norm\n", + "vl2 = np.linalg.norm(v1)\n", + "\n", + "print(vl1,vl2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UpSiVv8G6Pzc" + }, + "source": [ + "\n", + "---\n", + "# VIDEO: The dot product from a geometric perspective\n", + "---\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1DsEPu3r6Pzd" + }, + "outputs": [], + "source": [ + "\n", + "# two vectors\n", + "v1 = np.array([ 2, 4, -3 ])\n", + "v2 = np.array([ 0, -3, -3 ])\n", + "\n", + "# compute the angle (radians) between two vectors\n", + "ang = np.arccos( np.dot(v1,v2) / (np.linalg.norm(v1)*np.linalg.norm(v2)) )\n", + "\n", + "\n", + "# draw them\n", + "fig = plt.figure()\n", + "# ax = fig.add_subplot(projection='3d')\n", + "ax = plt.axes(projection = '3d')\n", + "ax.plot([0, v1[0]],[0, v1[1]],[0, v1[2]],'b')\n", + "ax.plot([0, v2[0]],[0, v2[1]],[0, v2[2]],'r')\n", + "\n", + "plt.axis((-6, 6, -6, 6))\n", + "plt.title('Angle between vectors: %s rad.' %ang)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "kRPC1c556Pzd" + }, + "outputs": [], + "source": [ + "## equivalence of algebraic and geometric dot product formulas\n", + "\n", + "# two vectors\n", + "v1 = np.array([ 2, 4, -3 ])\n", + "v2 = np.array([ 0, -3, -3 ])\n", + "\n", + "\n", + "# algebraic\n", + "dp_a = np.dot( v1,v2 )\n", + "\n", + "# geometric\n", + "dp_g = np.linalg.norm(v1)*np.linalg.norm(v2)*np.cos(ang)\n", + "\n", + "# print dot product to command\n", + "print(dp_a)\n", + "print(dp_g)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BS0B5qrY6Pzd" + }, + "source": [ + "\n", + "---\n", + "# VIDEO: Vector Hadamard multiplication\n", + "---\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "TkQPwBp-6Pzd" + }, + "outputs": [], + "source": [ + "\n", + "# create vectors\n", + "w1 = [ 1, 3, 5 ]\n", + "w2 = [ 3, 4, 2 ]\n", + "\n", + "w3 = np.multiply(w1,w2)\n", + "print(w3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fioauhFR6Pzd" + }, + "source": [ + "\n", + "---\n", + "# VIDEO: Vector outer product\n", + "---\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "PKLjn1Un6Pzd" + }, + "outputs": [], + "source": [ + "\n", + "v1 = np.array([ 1, 2, 3 ])\n", + "v2 = np.array([ -1, 0, 1 ])\n", + "\n", + "# outer product\n", + "np.outer(v1,v2)\n", + "\n", + "# terrible programming, but helps conceptually:\n", + "op = np.zeros((len(v1),len(v2)))\n", + "for i in range(0,len(v1)):\n", + " for j in range(0,len(v2)):\n", + " op[i,j] = v1[i] * v2[j]\n", + "\n", + "print(op)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gPJF5SqK6Pzd" + }, + "source": [ + "\n", + "---\n", + "# VIDEO: Vector cross product\n", + "---\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "VpkqUitN6Pzd" + }, + "outputs": [], + "source": [ + "# create vectors\n", + "v1 = [ -3, 2, 5 ]\n", + "v2 = [ 4, -3, 0 ]\n", + "\n", + "# Python's cross-product function\n", + "v3a = np.cross( v1,v2 )\n", + "\n", + "# \"manual\" method\n", + "v3b = [ [v1[1]*v2[2] - v1[2]*v2[1]],\n", + " [v1[2]*v2[0] - v1[0]*v2[2]],\n", + " [v1[0]*v2[1] - v1[1]*v2[0]] ]\n", + "\n", + "print(v3a,v3b)\n", + "\n", + "\n", + "fig = plt.figure()\n", + "# ax = fig.add_subplot(projection='3d')\n", + "ax = plt.axes(projection = '3d')\n", + "\n", + "# draw plane defined by span of v1 and v2\n", + "xx, yy = np.meshgrid(np.linspace(-10,10,10),np.linspace(-10,10,10))\n", + "z1 = (-v3a[0]*xx - v3a[1]*yy)/v3a[2]\n", + "ax.plot_surface(xx,yy,z1,alpha=.2)\n", + "\n", + "## plot the two vectors\n", + "ax.plot([0, v1[0]],[0, v1[1]],[0, v1[2]],'k')\n", + "ax.plot([0, v2[0]],[0, v2[1]],[0, v2[2]],'k')\n", + "ax.plot([0, v3a[0]],[0, v3a[1]],[0, v3a[2]],'r')\n", + "\n", + "\n", + "ax.view_init(azim=150,elev=45)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XuGtENQ26Pzd" + }, + "source": [ + "\n", + "---\n", + "# VIDEO: Hermitian transpose (a.k.a. conjugate transpose)\n", + "---\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 262, + "status": "ok", + "timestamp": 1692279750846, + "user": { + "displayName": "Mike X Cohen", + "userId": "13901636194183843661" + }, + "user_tz": -180 + }, + "id": "vwaAjpwU6Pzd", + "outputId": "0c7fc764-e91b-4dcb-e7bb-c15edb5b9fd8" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.0\n", + "(-7+24j)\n", + "(25+0j)\n", + "[3.+0.j 0.+4.j 5.+2.j 2.-5.j]\n", + "[3.+0.j 0.+4.j 5.+2.j 2.-5.j]\n", + "[3.-0.j 0.-4.j 5.-2.j 2.+5.j]\n" + ] + } + ], + "source": [ + "# create a complex number\n", + "z = complex(3,4)\n", + "\n", + "# magnitude\n", + "print( np.linalg.norm(z) )\n", + "\n", + "# by transpose?\n", + "print( np.transpose(z)*z )\n", + "\n", + "# by Hermitian transpose\n", + "print( np.transpose(z.conjugate())*z )\n", + "\n", + "\n", + "# complex vector\n", + "v = np.array( [ 3, 4j, 5+2j, complex(2,-5) ] )\n", + "print( v.T )\n", + "print( np.transpose(v) )\n", + "print( np.transpose(v.conjugate()) )" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LqTJT6Vt6Pze" + }, + "source": [ + "\n", + "---\n", + "# VIDEO: Unit vector\n", + "---\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "TPnVO8HB6Pze" + }, + "outputs": [], + "source": [ + "\n", + "# vector\n", + "v1 = np.array([ -3, 6 ])\n", + "\n", + "# mu\n", + "mu = 1/np.linalg.norm(v1)\n", + "\n", + "v1n = v1*mu\n", + "\n", + "# plot them\n", + "plt.plot([0, v1n[0]],[0, v1n[1]],'r',label='v1-norm',linewidth=5)\n", + "plt.plot([0, v1[0]],[0, v1[1]],'b',label='v1')\n", + "\n", + "# axis square\n", + "plt.axis('square')\n", + "plt.axis(( -6, 6, -6, 6 ))\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iXVxkYB96Pze" + }, + "source": [ + "\n", + "---\n", + "# VIDEO: Span\n", + "---\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "NxSX9z-O6Pze" + }, + "outputs": [], + "source": [ + "# set S\n", + "S1 = np.array([1, 1, 0])\n", + "S2 = np.array([1, 7, 0])\n", + "\n", + "# vectors v and w\n", + "v = np.array([1, 2, 0])\n", + "w = np.array([3, 2, 1])\n", + "\n", + "# draw vectors\n", + "fig = plt.figure()\n", + "# ax = fig.add_subplot(projection='3d')\n", + "ax = plt.axes(projection = '3d')\n", + "ax.plot([0, S1[0]],[0, S1[1]],[.1, S1[2]+.1],'r',linewidth=3)\n", + "ax.plot([0, S2[0]],[0, S2[1]],[.1, S2[2]+.1],'r',linewidth=3)\n", + "\n", + "ax.plot([0, v[0]],[0, v[1]],[.1, v[2]+.1],'g',linewidth=3)\n", + "ax.plot([0, w[0]],[0, w[1]],[0, w[2]],'b')\n", + "\n", + "# now draw plane\n", + "xx, yy = np.meshgrid(range(-15,16), range(-15,16))\n", + "cp = np.cross(S1,S2)\n", + "z1 = (-cp[0]*xx - cp[1]*yy)*1./cp[2]\n", + "ax.plot_surface(xx,yy,z1)\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "base", + "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.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}