{"id":402,"date":"2024-02-25T14:28:12","date_gmt":"2024-02-25T19:28:12","guid":{"rendered":"https:\/\/pressbooks.bccampus.ca\/businessanalytics\/chapter\/vectors_ai-3\/"},"modified":"2024-02-25T17:28:40","modified_gmt":"2024-02-25T22:28:40","slug":"vectors_ai-3","status":"publish","type":"chapter","link":"https:\/\/pressbooks.bccampus.ca\/businessanalytics\/chapter\/vectors_ai-3\/","title":{"raw":"What is a Vector?","rendered":"What is a Vector?"},"content":{"raw":"

Vectors<\/h1>\r\n

Updated Feb 2024<\/h5>\r\nA vector is something which has magnitude or length and direction. It is used to describe a variety of things. We can also view a vector as an ordered n-tuple, ie, [latex](a, b, c)[\/latex], or as a set of directions.\r\n

Vectors in two dimensions<\/h2>\r\nIn two dimensions, a vector is an ordered pair of real numbers, [latex](a,b)[\/latex]<\/span> or [latex]\\binom{a}{b}[\/latex] (expressed vertically. We use\u201carrow\u201d notation to show that this has direction - as opposed to being a point. When we draw this, it has an arrow:\r\n\r\n\\[\\vec{v} = \\binom{1}{2}, \\,\\, \\vec{w} = \\binom{3}{1}\\]<\/span>\r\n
\r\n
\r\n<\/span><\/code><\/pre>\r\n
## This is a Python cell; see how we create vectors:<\/span><\/span> <\/span>\r\n## We need a library, NumPy has the best math-y stuff<\/span><\/span>\r\nimport<\/span> numpy as<\/span> np<\/span> <\/span>\r\n## Define a Vector<\/span><\/span>\r\n## note that I've used 2 sets of brackets: the square ones define a list INSIDE of the function<\/span><\/span>\r\nv =<\/span> np.array([1<\/span>,2<\/span>])<\/span> <\/span>\r\nw =<\/span> np.array([3<\/span>,1<\/span>])<\/span> <\/span> <\/span>\r\nprint<\/span>(\"v = \"<\/span>, v, \" and w = \"<\/span>, w)<\/span><\/code><\/div>\r\n
<\/code><\/pre>\r\n \r\n
<\/code><\/pre>\r\n<\/div>\r\n
v =  [1 2]  and w =  [3 1]<\/code><\/pre>\r\n
<\/h2>\r\n
Visualizing:<\/h2>\r\nUsually vectors look like arrows coming out from [latex](0,0)[\/latex]\r\n
\r\n
\r\n
## Don't worry a lot about graphing, but know that matplotlib is a pretty good tool, and lets us plot our math stuff nicely<\/span><\/span>\r\n## matplotlib also makes stats visualizations!<\/span><\/span>\r\n<\/span>\r\n## Why plt?  I dunno... tradition<\/span><\/span>\r\nimport<\/span> matplotlib.pyplot as<\/span> plt <\/span>\r\n<\/span>\r\n<\/span>\r\n# Creating plot <\/span><\/span>\r\n## Tells Python to dray a blue arrow from (0,0) to (1,2)<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, v[0<\/span>], v[1<\/span>], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n<\/span>\r\n<\/span>\r\n## and the red line is w<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, w[0<\/span>], w[1<\/span>], color=<\/span>'r'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n<\/span>\r\nplt.axis('equal'<\/span>)<\/span>\r\nplt.title('Vectors on a Plane'<\/span>) <\/span>\r\n<\/span>\r\nplt.xticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\nplt.yticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\n<\/span>\r\n<\/span>\r\n# Show plot with grid <\/span><\/span>\r\nplt.grid() <\/span>\r\nplt.show() <\/span><\/code><\/pre>\r\n<\/div>\r\n<\/div>\r\n
\"\"
<\/figcaption><\/figure>\r\nBut they don\u2019t need to start at [latex](0,0)[\/latex]! Think of them as a set of instructions, saying \u201cfrom any begining point, go [latex]a[\/latex]<\/span> steps to the right, and [latex]b[\/latex]<\/span> steps up.\r\n\r\nIn this plot, I have the second (red) vector start where the first one ends.\r\n\r\nIn the next plot, the blue vector is repeated a bunch of times\u2026.\r\n
\r\n
\r\n
<\/span>\r\n# Creating plot <\/span><\/span>\r\n## Tells Python to dray a blue arrow from (0,0) to (1,2)<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, v[0<\/span>], v[1<\/span>], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n<\/span>\r\n#plt.quiver(X, Y, 1,2, color='g', units='xy', scale= 1) <\/span><\/span>\r\n<\/span>\r\n<\/span>\r\n## and the red line starts where the blue one ends.<\/span><\/span>\r\nplt.quiver(v[0<\/span>], v[1<\/span>], w[0<\/span>], w[1<\/span>], color=<\/span>'r'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n<\/span>\r\nplt.axis('equal'<\/span>)<\/span>\r\nplt.title('Vectors can start anywhere'<\/span>) <\/span>\r\n<\/span>\r\nplt.xticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\nplt.yticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\n<\/span>\r\n<\/span>\r\n# Show plot with grid <\/span><\/span>\r\nplt.grid() <\/span>\r\nplt.show() <\/span><\/code><\/pre>\r\n<\/div>\r\n<\/div>\r\n
\"\"<\/figure>\r\n
\r\n
<\/span><\/code><\/pre>\r\n
# Creating plot\r\n<\/span><\/span> ## Tells Python to dray a blue arrow from (0,0) to (1,2)<\/span><\/span>\r\nplt.quiver([0<\/span>,1<\/span>,3<\/span>], [0<\/span>,-<\/span>1<\/span>,2<\/span>], [v[0<\/span>],v[0<\/span>],v[0<\/span>]], [v[1<\/span>], v[1<\/span>], v[1<\/span>]], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>)\r\n<\/span>\r\nplt.axis('equal'<\/span>)<\/span>\r\nplt.title('Vectors can start anywhere'<\/span>) <\/span><\/code><\/code><\/code>plt.xticks(range<\/span>(-<\/span>10<\/span>,10<\/span>))plt.yticks(range<\/span>(-<\/span>10<\/span>,10<\/span>))<\/span><\/span><\/code><\/code><\/span> # Show plot with grid\r\n<\/span><\/span>plt.grid()<\/code><\/span>\r\nplt.show()<\/code> <\/span>\r\n\r\n<\/div>\r\n
<\/code><\/pre>\r\n<\/div>\r\n
\"\"<\/figcaption><\/figure>\r\n
Other Vector Spaces<\/h2>\r\nWe can put these vectors anywhere - in particular, we can add dimensions, to make vectors work for us, making 3 dimensional, or even 27 dimensional vectors. You saw some really big ones in Neural Networks, where each dimension is a feature. Anyways!\r\n
Operations with Vectors.<\/h2>\r\n
Scaling<\/h5>\r\nWe can multiply a vector by a scaler (or constant), by multiplying\r\neach component by the same constant:\r\n\r\n\\[c\\binom{a}{b} =\\binom{ca}{cb}\\]<\/span>\r\n\r\nSo:\r\n\r\n\\[-2\\binom{1}{2}=\\binom{-2}{-4}\\]<\/span>\r\n
Adding:<\/h6>\r\nAdd two vectors, by adding the components:\r\n\r\n\\[\\binom{a}{b}+\\binom{c}{d} =\\binom{a+c}{b+d}\\]<\/span>\r\n\r\nOr,\r\n\r\n\\[\\binom{1}{2}+\\binom{3}{1} =\r\n\\binom{4}{3}\\]<\/span>\r\n\r\nThis creates a vector that goes one direction, then the next.\r\n\r\nCheck out some math:\r\n
\r\n
\r\n
## Remember our v and w?<\/span><\/span>\r\n<\/span>\r\nv =<\/span> np.array([1<\/span>,2<\/span>])<\/span>\r\nw =<\/span> np.array([3<\/span>,1<\/span>])<\/span>\r\n<\/span>\r\nprint<\/span>(\"Multipling v by -2 gives \"<\/span>, -<\/span>2<\/span>*<\/span>v)<\/span>\r\n<\/span>\r\n#Graphically: <\/span><\/span>\r\n<\/span>\r\n## Tells Python to dray a blue arrow from (0,0) to (1,2)<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, v[0<\/span>], v[1<\/span>], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n## and the red line is w<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, -<\/span>2<\/span>*<\/span>v[0<\/span>], -<\/span>2<\/span>*<\/span>v[1<\/span>], color=<\/span>'r'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n## and the sum<\/span><\/span>\r\n<\/span>\r\nplt.axis('equal'<\/span>)<\/span>\r\nplt.title('Multiplication!'<\/span>) <\/span>\r\n<\/span>\r\nplt.xticks(range<\/span>(-<\/span>5<\/span>,5<\/span>))<\/span>\r\nplt.yticks(range<\/span>(-<\/span>5<\/span>,5<\/span>))<\/span>\r\n<\/span>\r\n<\/span>\r\n# Show plot with grid <\/span><\/span>\r\nplt.grid() <\/span>\r\nplt.show() <\/span><\/code><\/pre>\r\n<\/div>\r\n<\/div>\r\n
Multipling v by -2 gives  [-2 -4]<\/code><\/pre>\r\n
\"\"<\/figcaption><\/figure>\r\n
\r\n
\r\n
<\/span>\r\n## add<\/span><\/span>\r\nz =<\/span> v+<\/span>w<\/span>\r\n<\/span>\r\nprint<\/span>(\"The sum of v and w is \"<\/span>,z)<\/span>\r\n<\/span>\r\n##Graphically:<\/span><\/span>\r\n<\/span>\r\n## Tells Python to dray a blue arrow from (0,0) to (1,2)<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, v[0<\/span>], v[1<\/span>], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n## and the red line is w<\/span><\/span>\r\nplt.quiver(v[0<\/span>], v[1<\/span>], w[0<\/span>], w[1<\/span>], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n## and the sum<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, z[0<\/span>], z[1<\/span>], color=<\/span>'r'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n<\/span>\r\n<\/span>\r\nplt.axis('equal'<\/span>)<\/span>\r\nplt.title('Adding makes sense geometrically!'<\/span>) <\/span>\r\n<\/span>\r\nplt.xticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\nplt.yticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\n<\/span>\r\n<\/span>\r\n# Show plot with grid <\/span><\/span>\r\nplt.grid() <\/span>\r\nplt.show() <\/span><\/code><\/pre>\r\n<\/div>\r\n<\/div>\r\n
The sum of v and w is  [4 3]<\/code><\/pre>\r\n
\"\"<\/figure>\r\n
\r\n
\r\n
## order doesn't matter - that's important:<\/span><\/span>\r\n<\/span>\r\n<\/span>\r\n## add<\/span><\/span>\r\nz =<\/span> w+<\/span>v<\/span>\r\n<\/span>\r\nprint<\/span>(\"Whe I flip the order, the sum is still \"<\/span>,z)<\/span>\r\n<\/span>\r\n##Graphically:<\/span><\/span>\r\n<\/span>\r\n## Tells Python to dray a blue arrow from (0,0) to (1,2)<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, w[0<\/span>], w[1<\/span>], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n## and the red line is w<\/span><\/span>\r\nplt.quiver(w[0<\/span>], w[1<\/span>], v[0<\/span>], v[1<\/span>], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n## and the sum<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, z[0<\/span>], z[1<\/span>], color=<\/span>'r'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n<\/span>\r\n<\/span>\r\nplt.axis('equal'<\/span>)<\/span>\r\nplt.title('Adding in the other order!'<\/span>) <\/span>\r\n<\/span>\r\nplt.xticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\nplt.yticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\n<\/span>\r\n<\/span>\r\n# Show plot with grid <\/span><\/span>\r\nplt.grid() <\/span>\r\nplt.show() <\/span><\/code><\/pre>\r\n<\/div>\r\n<\/div>\r\n
Whe I flip the order, the sum is still  [4 3]<\/code><\/pre>\r\n
\"png\"
\"\"<\/figcaption><\/figure>\r\n
Getting super fancy:<\/h2>\r\nI can combine these:\r\n\r\n$$5 \\binom{1}{2} - 3\\binom{3}{1} =\\binom{5-9}{10 - 3} = \\binom{-4}{7}$$<\/span>\r\n
\r\n
\r\n
## It's pretty easy to do this in Python.<\/span><\/span>\r\n<\/span>\r\n5<\/span>*<\/span>v-<\/span>3<\/span>*<\/span>w<\/span><\/code><\/pre>\r\n<\/div>\r\n<\/div>\r\n
array([-4,  7])<\/code><\/pre>\r\n
Coordinate Representations<\/h2>\r\nRemember [latex]\\vec(v) = \\binom{1}{2}[\/latex] <\/span>And how I said it was a set of directions? One step to the right, 2 steps up. We can write this using special vectors called Basis Vectors<\/strong>.\r\n\r\n\\[\\binom{1}{2} = 1 \\binom{1}{0}+ 2\\binom{0}{1}\\]<\/span>\r\n\r\n[latex]\\binom{1}{0}[\/latex] and $[latex]\\binom{0}{1}[\/latex] are basis vectors, which means that every 2-dimensional vector is a linear combination of there two.\r\n\r\nBut, there\u2019s nothing actually that special about them. What do I mean? I can actually make any set of 2 vectors into a basis, as long as one isn\u2019t a scaler multiple of the other. This is a trick that will come in handy later on.\r\n
Magnitude<\/h2>\r\nWe said that vectors have magnitude (length) and direction. We say that the length of the vector is the length of the line segment, and we can use Pythagorus. We use 2 lines (or one line) around a vector to show that we\u2019re looking for it\u2019s length.\r\n\r\n\\[ \\left| \\binom{a}{b}\\right| =\\sqrt{a^2+b^2}\\]<\/span>\r\n\r\nOr:\r\n\r\n\\[\\left|\\binom{3}{4}\\right| =\\sqrt{3^2+4^2}=\\sqrt{25}=5\\]<\/span>\r\n\r\nThis also works in other dimensions:\r\n\r\n$$\\left|\\begin{pmatrix}1\\\\2\\\\\r\n3\\end{pmatrix}\\right|=\\sqrt{1^2+2^2+3^2} = \\sqrt{14}\\approx\r\n3.7417$$<\/span>\r\n\r\nIn linear algebra, we call this a Norm<\/strong>, and in\r\nMachine Learning, it\u2019s called the L2 Norm<\/strong>.\r\n
\r\n
\r\n
## This is much easier to do in python than to typeset the math!<\/span><\/span>\r\n<\/span>\r\n## let's get some linear algebra things:<\/span><\/span>\r\n<\/span>\r\nfrom<\/span> numpy.linalg import<\/span> *<\/span><\/span>\r\n<\/span>\r\na =<\/span> np.array([3<\/span>,4<\/span>])<\/span>\r\nnorm_a=<\/span>norm(a)<\/span>\r\n<\/span>\r\nprint<\/span>(\"The magnitude of vector \"<\/span>, a, \"is \"<\/span>, norm_a)<\/span>\r\n<\/span>\r\nb =<\/span> np.array([1<\/span>,2<\/span>,3<\/span>])<\/span>\r\nnorm_b=<\/span>norm(b)<\/span>\r\n<\/span>\r\nprint<\/span>(\"The magnitude of vector \"<\/span>, b, \"is \"<\/span>, norm_b)<\/span><\/code><\/pre>\r\n<\/div>\r\n<\/div>\r\n
The magnitude of vector  [3 4] is  5.0\r\nThe magnitude of vector  [1 2 3] is  3.7416573867739413<\/code><\/pre>\r\n
The Dot Product<\/h2>\r\nWe\u2019ve seen that we can add the vectors. and multiply a vector by a scaler. This leads to the question: Is there some form of multiplication between vectors? The answer is\u2026. kind of.\r\n\r\nIn fact, there are two different kinds of multiplication-type operations: the dot product: (\u20d7<\/em>v<\/em>)\u2005\u22c5\u2005(\u20d7<\/em>w<\/em>) <\/span>and The cross product: (\u20d7<\/em>v<\/em>)\u2005\u00d7\u2005(\u20d7<\/em>w<\/em>)<\/span>.\r\n
Definition:<\/h6>\r\nThe dot product is:\r\n\r\n$$\\begin{pmatrix}a\\\\b\\end{pmatrix}\\cdot\r\n\\begin{pmatrix}c\\\\d\\end{pmatrix} = ac+ bd$$<\/span>\r\n\r\nThis function takes in two vectors, and outputs a scaler (constant\r\nnumber), for example:\r\n\r\n$$\\begin{pmatrix}1\\\\2\\end{pmatrix}\\cdot\r\n\\begin{pmatrix}3\\\\1\\end{pmatrix} = (1)(3)+ (2)(1) =5$$<\/span>\r\n
\r\n
\r\n
## this is again, easy in Python!<\/span><\/span>\r\n<\/span>\r\nnp.dot(v,w)<\/span>\r\n<\/span>\r\n## And also for bigger arrays!<\/span><\/span>\r\n<\/span>\r\nv1 =<\/span> np.array([1<\/span>,2<\/span>,3<\/span>,4<\/span>])<\/span>\r\nv2 =<\/span> np.array([4<\/span>,-<\/span>2<\/span>,3<\/span>,0<\/span>])<\/span>\r\n<\/span>\r\nv3=<\/span> np.dot(v1, v2)<\/span>\r\n<\/span>\r\nprint<\/span>(v1, \" dot \"<\/span>, v2, \" equals \"<\/span>, v3)<\/span><\/code><\/pre>\r\n<\/div>\r\n<\/div>\r\n
[1 2 3 4]  dot  [ 4 -2  3  0]  equals  9<\/code><\/pre>\r\nMathematically, the dot product is (kind of sort of) looking at the angle between the two vectors:\r\n\r\n(\u20d7<\/em>v<\/em>)\u2005\u22c5\u2005(\u20d7<\/em>w<\/em>)\u2004=\u2004|(\u20d7<\/em>v<\/em>)||(\u20d7<\/em>w<\/em>)|cos\u2006\u03b8<\/em><\/span>\r\n\r\nWhere \u03b8<\/em><\/span> is the angle between the two vectors. What we really get out of this is:\r\n\r\nIf (\u20d7<\/em>v<\/em>)\u2005\u22c5\u2005(\u20d7<\/em>w<\/em>)\u2004=\u20040<\/span>, than the two lines are perpendicular. That\u2019s useful!\r\n
The Cross Product for completeness<\/h2>\r\nThe dot product is an operation which takes two vectors and returns a scalar. The Cross product is an operation which takes two vectors and\r\nreturn another vector. It is defined specifically for 3-dimensional\r\nvectors\r\n\r\nThe Cross Product:\r\n\r\n$$\\begin{pmatrix}a\\\\b\\\\c\\end{pmatrix}\\times\r\n\\begin{pmatrix}d\\\\e\\\\f\\end{pmatrix} =\r\n\\begin{pmatrix}bf-ec\\\\cd-af\\\\ae-bd\\end{pmatrix}$$<\/span>\r\n\r\nHopefully, you look at that and think \u201cGee, I hope Python has a Cross Product function, because I don\u2019t want to do that.\u201d You would be correct.\r\n\r\nIn three dimensions, a\u20d7<\/em>\u2005\u00d7\u2005b\u20d7<\/em><\/span> is\r\northogonal<\/strong> ( perpendicular) to both a\u20d7<\/em><\/span> and b\u20d7<\/em><\/span>.\r\n\r\n
\r\n
\r\n
## It's just np.cross<\/span><\/span>\r\n<\/span>\r\nv1 =<\/span> np.array([1<\/span>,2<\/span>,3<\/span>])<\/span>\r\nv2 =<\/span> np.array([4<\/span>,-<\/span>2<\/span>,3<\/span>])<\/span>\r\n<\/span>\r\nv3 =<\/span> np.cross(v1,v2)<\/span>\r\n<\/span>\r\nprint<\/span>(v1, \" cross \"<\/span>, v2,\" equals \"<\/span>, v3)<\/span>\r\n<\/span><\/code><\/pre>\r\n<\/div>\r\n<\/div>\r\n\r\n
[1 2 3]  cross  [ 4 -2  3]  equals  [ 12   9 -10]<\/code><\/pre>\r\n
\r\n
norm(v1-<\/span>v2,1<\/span>)<\/span><\/code><\/pre>\r\n<\/div>\r\n
7.0<\/code><\/pre>\r\n
\r\n
?norm<\/span><\/code><\/pre>\r\n<\/div>\r\n
\r\n
<\/code><\/pre>\r\n<\/div>","rendered":"
Vectors<\/h1>\n
Updated Feb 2024<\/h5>\n
A vector is something which has magnitude or length and direction. It is used to describe a variety of things. We can also view a vector as an ordered n-tuple, ie, [latex](a, b, c)[\/latex], or as a set of directions.<\/p>\n
Vectors in two dimensions<\/h2>\n
In two dimensions, a vector is an ordered pair of real numbers, [latex](a,b)[\/latex]<\/span> or [latex]\\binom{a}{b}[\/latex] (expressed vertically. We use\u201carrow\u201d notation to show that this has direction – as opposed to being a point. When we draw this, it has an arrow:<\/p>\n
\\[\\vec{v} = \\binom{1}{2}, \\,\\, \\vec{w} = \\binom{3}{1}\\]<\/span><\/p>\n
\n
\r\n<\/span><\/code><\/pre>\n
## This is a Python cell; see how we create vectors:<\/span><\/span> <\/span>
\n## We need a library, NumPy has the best math-y stuff<\/span><\/span>
\nimport<\/span> numpy as<\/span> np<\/span> <\/span>
\n## Define a Vector<\/span><\/span>
\n## note that I've used 2 sets of brackets: the square ones define a list INSIDE of the function<\/span><\/span>
\nv =<\/span> np.array([1<\/span>,2<\/span>])<\/span> <\/span>
\nw =<\/span> np.array([3<\/span>,1<\/span>])<\/span> <\/span> <\/span>
\nprint<\/span>(\"v = \"<\/span>, v, \" and w = \"<\/span>, w)<\/span><\/code><\/div>\n
<\/code><\/pre>\n
 <\/p>\n
<\/code><\/pre>\n<\/div>\n
v =  [1 2]  and w =  [3 1]<\/code><\/pre>\n
<\/h2>\n
Visualizing:<\/h2>\n
Usually vectors look like arrows coming out from [latex](0,0)[\/latex]<\/p>\n
\n
\n
## Don't worry a lot about graphing, but know that matplotlib is a pretty good tool, and lets us plot our math stuff nicely<\/span><\/span>\r\n## matplotlib also makes stats visualizations!<\/span><\/span>\r\n<\/span>\r\n## Why plt?  I dunno... tradition<\/span><\/span>\r\nimport<\/span> matplotlib.pyplot as<\/span> plt <\/span>\r\n<\/span>\r\n<\/span>\r\n# Creating plot <\/span><\/span>\r\n## Tells Python to dray a blue arrow from (0,0) to (1,2)<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, v[0<\/span>], v[1<\/span>], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n<\/span>\r\n<\/span>\r\n## and the red line is w<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, w[0<\/span>], w[1<\/span>], color=<\/span>'r'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n<\/span>\r\nplt.axis('equal'<\/span>)<\/span>\r\nplt.title('Vectors on a Plane'<\/span>) <\/span>\r\n<\/span>\r\nplt.xticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\nplt.yticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\n<\/span>\r\n<\/span>\r\n# Show plot with grid <\/span><\/span>\r\nplt.grid() <\/span>\r\nplt.show() <\/span><\/code><\/pre>\n<\/div>\n<\/div>\n
\"\"
<\/figcaption><\/figure>\n
But they don\u2019t need to start at [latex](0,0)[\/latex]! Think of them as a set of instructions, saying \u201cfrom any begining point, go [latex]a[\/latex]<\/span> steps to the right, and [latex]b[\/latex]<\/span> steps up.<\/p>\n
In this plot, I have the second (red) vector start where the first one ends.<\/p>\n
In the next plot, the blue vector is repeated a bunch of times\u2026.<\/p>\n
\n
\n
<\/span>\r\n# Creating plot <\/span><\/span>\r\n## Tells Python to dray a blue arrow from (0,0) to (1,2)<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, v[0<\/span>], v[1<\/span>], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n<\/span>\r\n#plt.quiver(X, Y, 1,2, color='g', units='xy', scale= 1) <\/span><\/span>\r\n<\/span>\r\n<\/span>\r\n## and the red line starts where the blue one ends.<\/span><\/span>\r\nplt.quiver(v[0<\/span>], v[1<\/span>], w[0<\/span>], w[1<\/span>], color=<\/span>'r'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n<\/span>\r\nplt.axis('equal'<\/span>)<\/span>\r\nplt.title('Vectors can start anywhere'<\/span>) <\/span>\r\n<\/span>\r\nplt.xticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\nplt.yticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\n<\/span>\r\n<\/span>\r\n# Show plot with grid <\/span><\/span>\r\nplt.grid() <\/span>\r\nplt.show() <\/span><\/code><\/pre>\n<\/div>\n<\/div>\n
\"\"<\/figure>\n
\n
<\/span><\/code><\/pre>\n
# Creating plot
\n<\/span><\/span> ## Tells Python to dray a blue arrow from (0,0) to (1,2)<\/span><\/span>
\nplt.quiver([0<\/span>,1<\/span>,3<\/span>], [0<\/span>,-<\/span>1<\/span>,2<\/span>], [v[0<\/span>],v[0<\/span>],v[0<\/span>]], [v[1<\/span>], v[1<\/span>], v[1<\/span>]], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>)
\n<\/span>
\nplt.axis('equal'<\/span>)<\/span>
\nplt.title('Vectors can start anywhere'<\/span>) <\/span><\/code><\/code><\/code>plt.xticks(range<\/span>(–<\/span>10<\/span>,10<\/span>))plt.yticks(range<\/span>(-<\/span>10<\/span>,10<\/span>))<\/span><\/span><\/code><\/code><\/span> # Show plot with grid
\n<\/span><\/span>plt.grid()<\/code><\/span>
\nplt.show()<\/code> <\/span><\/p>\n<\/div>\n
<\/code><\/pre>\n<\/div>\n
\"\"<\/figcaption><\/figure>\n
Other Vector Spaces<\/h2>\n
We can put these vectors anywhere – in particular, we can add dimensions, to make vectors work for us, making 3 dimensional, or even 27 dimensional vectors. You saw some really big ones in Neural Networks, where each dimension is a feature. Anyways!<\/p>\n
Operations with Vectors.<\/h2>\n
Scaling<\/h5>\n
We can multiply a vector by a scaler (or constant), by multiplying
\neach component by the same constant:<\/p>\n
\\[c\\binom{a}{b} =\\binom{ca}{cb}\\]<\/span><\/p>\n
So:<\/p>\n
\\[-2\\binom{1}{2}=\\binom{-2}{-4}\\]<\/span><\/p>\n
Adding:<\/h6>\n
Add two vectors, by adding the components:<\/p>\n
\\[\\binom{a}{b}+\\binom{c}{d} =\\binom{a+c}{b+d}\\]<\/span><\/p>\n
Or,<\/p>\n
\\[\\binom{1}{2}+\\binom{3}{1} =
\n\\binom{4}{3}\\]<\/span><\/p>\n
This creates a vector that goes one direction, then the next.<\/p>\n
Check out some math:<\/p>\n
\n
\n
## Remember our v and w?<\/span><\/span>\r\n<\/span>\r\nv =<\/span> np.array([1<\/span>,2<\/span>])<\/span>\r\nw =<\/span> np.array([3<\/span>,1<\/span>])<\/span>\r\n<\/span>\r\nprint<\/span>(\"Multipling v by -2 gives \"<\/span>, -<\/span>2<\/span>*<\/span>v)<\/span>\r\n<\/span>\r\n#Graphically: <\/span><\/span>\r\n<\/span>\r\n## Tells Python to dray a blue arrow from (0,0) to (1,2)<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, v[0<\/span>], v[1<\/span>], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n## and the red line is w<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, -<\/span>2<\/span>*<\/span>v[0<\/span>], -<\/span>2<\/span>*<\/span>v[1<\/span>], color=<\/span>'r'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n## and the sum<\/span><\/span>\r\n<\/span>\r\nplt.axis('equal'<\/span>)<\/span>\r\nplt.title('Multiplication!'<\/span>) <\/span>\r\n<\/span>\r\nplt.xticks(range<\/span>(-<\/span>5<\/span>,5<\/span>))<\/span>\r\nplt.yticks(range<\/span>(-<\/span>5<\/span>,5<\/span>))<\/span>\r\n<\/span>\r\n<\/span>\r\n# Show plot with grid <\/span><\/span>\r\nplt.grid() <\/span>\r\nplt.show() <\/span><\/code><\/pre>\n<\/div>\n<\/div>\n
Multipling v by -2 gives  [-2 -4]<\/code><\/pre>\n
\"\"<\/figcaption><\/figure>\n
\n
\n
<\/span>\r\n## add<\/span><\/span>\r\nz =<\/span> v+<\/span>w<\/span>\r\n<\/span>\r\nprint<\/span>(\"The sum of v and w is \"<\/span>,z)<\/span>\r\n<\/span>\r\n##Graphically:<\/span><\/span>\r\n<\/span>\r\n## Tells Python to dray a blue arrow from (0,0) to (1,2)<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, v[0<\/span>], v[1<\/span>], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n## and the red line is w<\/span><\/span>\r\nplt.quiver(v[0<\/span>], v[1<\/span>], w[0<\/span>], w[1<\/span>], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n## and the sum<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, z[0<\/span>], z[1<\/span>], color=<\/span>'r'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n<\/span>\r\n<\/span>\r\nplt.axis('equal'<\/span>)<\/span>\r\nplt.title('Adding makes sense geometrically!'<\/span>) <\/span>\r\n<\/span>\r\nplt.xticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\nplt.yticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\n<\/span>\r\n<\/span>\r\n# Show plot with grid <\/span><\/span>\r\nplt.grid() <\/span>\r\nplt.show() <\/span><\/code><\/pre>\n<\/div>\n<\/div>\n
The sum of v and w is  [4 3]<\/code><\/pre>\n
\"\"<\/figure>\n
\n
\n
## order doesn't matter - that's important:<\/span><\/span>\r\n<\/span>\r\n<\/span>\r\n## add<\/span><\/span>\r\nz =<\/span> w+<\/span>v<\/span>\r\n<\/span>\r\nprint<\/span>(\"Whe I flip the order, the sum is still \"<\/span>,z)<\/span>\r\n<\/span>\r\n##Graphically:<\/span><\/span>\r\n<\/span>\r\n## Tells Python to dray a blue arrow from (0,0) to (1,2)<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, w[0<\/span>], w[1<\/span>], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n## and the red line is w<\/span><\/span>\r\nplt.quiver(w[0<\/span>], w[1<\/span>], v[0<\/span>], v[1<\/span>], color=<\/span>'b'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n## and the sum<\/span><\/span>\r\nplt.quiver(0<\/span>, 0<\/span>, z[0<\/span>], z[1<\/span>], color=<\/span>'r'<\/span>, units=<\/span>'xy'<\/span>, scale=<\/span>1<\/span>) <\/span>\r\n<\/span>\r\n<\/span>\r\nplt.axis('equal'<\/span>)<\/span>\r\nplt.title('Adding in the other order!'<\/span>) <\/span>\r\n<\/span>\r\nplt.xticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\nplt.yticks(range<\/span>(-<\/span>1<\/span>,5<\/span>))<\/span>\r\n<\/span>\r\n<\/span>\r\n# Show plot with grid <\/span><\/span>\r\nplt.grid() <\/span>\r\nplt.show() <\/span><\/code><\/pre>\n<\/div>\n<\/div>\n
Whe I flip the order, the sum is still  [4 3]<\/code><\/pre>\n
\"png\"
\"\"<\/figcaption><\/figure>\n
Getting super fancy:<\/h2>\n
I can combine these:<\/p>\n
$$5 \\binom{1}{2} – 3\\binom{3}{1} =\\binom{5-9}{10 – 3} = \\binom{-4}{7}$$<\/span><\/p>\n
\n
\n
## It's pretty easy to do this in Python.<\/span><\/span>\r\n<\/span>\r\n5<\/span>*<\/span>v-<\/span>3<\/span>*<\/span>w<\/span><\/code><\/pre>\n<\/div>\n<\/div>\n
array([-4,  7])<\/code><\/pre>\n
Coordinate Representations<\/h2>\n
Remember [latex]\\vec(v) = \\binom{1}{2}[\/latex] <\/span>And how I said it was a set of directions? One step to the right, 2 steps up. We can write this using special vectors called Basis Vectors<\/strong>.<\/p>\n
\\[\\binom{1}{2} = 1 \\binom{1}{0}+ 2\\binom{0}{1}\\]<\/span><\/p>\n
[latex]\\binom{1}{0}[\/latex] and $[latex]\\binom{0}{1}[\/latex] are basis vectors, which means that every 2-dimensional vector is a linear combination of there two.<\/p>\n
But, there\u2019s nothing actually that special about them. What do I mean? I can actually make any set of 2 vectors into a basis, as long as one isn\u2019t a scaler multiple of the other. This is a trick that will come in handy later on.<\/p>\n
Magnitude<\/h2>\n
We said that vectors have magnitude (length) and direction. We say that the length of the vector is the length of the line segment, and we can use Pythagorus. We use 2 lines (or one line) around a vector to show that we\u2019re looking for it\u2019s length.<\/p>\n
\\[ \\left| \\binom{a}{b}\\right| =\\sqrt{a^2+b^2}\\]<\/span><\/p>\n
Or:<\/p>\n
\\[\\left|\\binom{3}{4}\\right| =\\sqrt{3^2+4^2}=\\sqrt{25}=5\\]<\/span><\/p>\n
This also works in other dimensions:<\/p>\n
$$\\left|\\begin{pmatrix}1\\\\2\\\\
\n3\\end{pmatrix}\\right|=\\sqrt{1^2+2^2+3^2} = \\sqrt{14}\\approx
\n3.7417$$<\/span><\/p>\n
In linear algebra, we call this a Norm<\/strong>, and in
\nMachine Learning, it\u2019s called the L2 Norm<\/strong>.<\/p>\n
\n
\n
## This is much easier to do in python than to typeset the math!<\/span><\/span>\r\n<\/span>\r\n## let's get some linear algebra things:<\/span><\/span>\r\n<\/span>\r\nfrom<\/span> numpy.linalg import<\/span> *<\/span><\/span>\r\n<\/span>\r\na =<\/span> np.array([3<\/span>,4<\/span>])<\/span>\r\nnorm_a=<\/span>norm(a)<\/span>\r\n<\/span>\r\nprint<\/span>(\"The magnitude of vector \"<\/span>, a, \"is \"<\/span>, norm_a)<\/span>\r\n<\/span>\r\nb =<\/span> np.array([1<\/span>,2<\/span>,3<\/span>])<\/span>\r\nnorm_b=<\/span>norm(b)<\/span>\r\n<\/span>\r\nprint<\/span>(\"The magnitude of vector \"<\/span>, b, \"is \"<\/span>, norm_b)<\/span><\/code><\/pre>\n<\/div>\n<\/div>\n
The magnitude of vector  [3 4] is  5.0\r\nThe magnitude of vector  [1 2 3] is  3.7416573867739413<\/code><\/pre>\n
The Dot Product<\/h2>\n
We\u2019ve seen that we can add the vectors. and multiply a vector by a scaler. This leads to the question: Is there some form of multiplication between vectors? The answer is\u2026. kind of.<\/p>\n
In fact, there are two different kinds of multiplication-type operations: the dot product: (\u20d7<\/em>v<\/em>)\u2005\u22c5\u2005(\u20d7<\/em>w<\/em>) <\/span>and The cross product: (\u20d7<\/em>v<\/em>)\u2005\u00d7\u2005(\u20d7<\/em>w<\/em>)<\/span>.<\/p>\n
Definition:<\/h6>\n
The dot product is:<\/p>\n
$$\\begin{pmatrix}a\\\\b\\end{pmatrix}\\cdot
\n\\begin{pmatrix}c\\\\d\\end{pmatrix} = ac+ bd$$<\/span><\/p>\n
This function takes in two vectors, and outputs a scaler (constant
\nnumber), for example:<\/p>\n
$$\\begin{pmatrix}1\\\\2\\end{pmatrix}\\cdot
\n\\begin{pmatrix}3\\\\1\\end{pmatrix} = (1)(3)+ (2)(1) =5$$<\/span><\/p>\n
\n
\n
## this is again, easy in Python!<\/span><\/span>\r\n<\/span>\r\nnp.dot(v,w)<\/span>\r\n<\/span>\r\n## And also for bigger arrays!<\/span><\/span>\r\n<\/span>\r\nv1 =<\/span> np.array([1<\/span>,2<\/span>,3<\/span>,4<\/span>])<\/span>\r\nv2 =<\/span> np.array([4<\/span>,-<\/span>2<\/span>,3<\/span>,0<\/span>])<\/span>\r\n<\/span>\r\nv3=<\/span> np.dot(v1, v2)<\/span>\r\n<\/span>\r\nprint<\/span>(v1, \" dot \"<\/span>, v2, \" equals \"<\/span>, v3)<\/span><\/code><\/pre>\n<\/div>\n<\/div>\n
[1 2 3 4]  dot  [ 4 -2  3  0]  equals  9<\/code><\/pre>\n
Mathematically, the dot product is (kind of sort of) looking at the angle between the two vectors:<\/p>\n
(\u20d7<\/em>v<\/em>)\u2005\u22c5\u2005(\u20d7<\/em>w<\/em>)\u2004=\u2004|(\u20d7<\/em>v<\/em>)||(\u20d7<\/em>w<\/em>)|cos\u2006\u03b8<\/em><\/span><\/p>\n
Where \u03b8<\/em><\/span> is the angle between the two vectors. What we really get out of this is:<\/p>\n
If (\u20d7<\/em>v<\/em>)\u2005\u22c5\u2005(\u20d7<\/em>w<\/em>)\u2004=\u20040<\/span>, than the two lines are perpendicular. That\u2019s useful!<\/p>\n
The Cross Product for completeness<\/h2>\n
The dot product is an operation which takes two vectors and returns a scalar. The Cross product is an operation which takes two vectors and
\nreturn another vector. It is defined specifically for 3-dimensional
\nvectors<\/p>\n
The Cross Product:<\/p>\n
$$\\begin{pmatrix}a\\\\b\\\\c\\end{pmatrix}\\times
\n\\begin{pmatrix}d\\\\e\\\\f\\end{pmatrix} =
\n\\begin{pmatrix}bf-ec\\\\cd-af\\\\ae-bd\\end{pmatrix}$$<\/span><\/p>\n
Hopefully, you look at that and think \u201cGee, I hope Python has a Cross Product function, because I don\u2019t want to do that.\u201d You would be correct.<\/p>\n
In three dimensions, a\u20d7<\/em>\u2005\u00d7\u2005b\u20d7<\/em><\/span> is
\northogonal<\/strong> ( perpendicular) to both a\u20d7<\/em><\/span> and b\u20d7<\/em><\/span>.<\/p>\n
\n
\n
## It's just np.cross<\/span><\/span>\r\n<\/span>\r\nv1 =<\/span> np.array([1<\/span>,2<\/span>,3<\/span>])<\/span>\r\nv2 =<\/span> np.array([4<\/span>,-<\/span>2<\/span>,3<\/span>])<\/span>\r\n<\/span>\r\nv3 =<\/span> np.cross(v1,v2)<\/span>\r\n<\/span>\r\nprint<\/span>(v1, \" cross \"<\/span>, v2,\" equals \"<\/span>, v3)<\/span>\r\n<\/span><\/code><\/pre>\n<\/div>\n<\/div>\n
[1 2 3]  cross  [ 4 -2  3]  equals  [ 12   9 -10]<\/code><\/pre>\n
\n
norm(v1-<\/span>v2,1<\/span>)<\/span><\/code><\/pre>\n<\/div>\n
7.0<\/code><\/pre>\n
\n
?norm<\/span><\/code><\/pre>\n<\/div>\n
\n
<\/code><\/pre>\n<\/div>\n","protected":false},"author":883,"menu_order":11,"template":"","meta":{"pb_show_title":"on","pb_short_title":"","pb_subtitle":"","pb_authors":[],"pb_section_license":""},"chapter-type":[],"contributor":[],"license":[],"class_list":["post-402","chapter","type-chapter","status-publish","hentry"],"part":102,"_links":{"self":[{"href":"https:\/\/pressbooks.bccampus.ca\/businessanalytics\/wp-json\/pressbooks\/v2\/chapters\/402","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/pressbooks.bccampus.ca\/businessanalytics\/wp-json\/pressbooks\/v2\/chapters"}],"about":[{"href":"https:\/\/pressbooks.bccampus.ca\/businessanalytics\/wp-json\/wp\/v2\/types\/chapter"}],"author":[{"embeddable":true,"href":"https:\/\/pressbooks.bccampus.ca\/businessanalytics\/wp-json\/wp\/v2\/users\/883"}],"version-history":[{"count":8,"href":"https:\/\/pressbooks.bccampus.ca\/businessanalytics\/wp-json\/pressbooks\/v2\/chapters\/402\/revisions"}],"predecessor-version":[{"id":416,"href":"https:\/\/pressbooks.bccampus.ca\/businessanalytics\/wp-json\/pressbooks\/v2\/chapters\/402\/revisions\/416"}],"part":[{"href":"https:\/\/pressbooks.bccampus.ca\/businessanalytics\/wp-json\/pressbooks\/v2\/parts\/102"}],"metadata":[{"href":"https:\/\/pressbooks.bccampus.ca\/businessanalytics\/wp-json\/pressbooks\/v2\/chapters\/402\/metadata\/"}],"wp:attachment":[{"href":"https:\/\/pressbooks.bccampus.ca\/businessanalytics\/wp-json\/wp\/v2\/media?parent=402"}],"wp:term":[{"taxonomy":"chapter-type","embeddable":true,"href":"https:\/\/pressbooks.bccampus.ca\/businessanalytics\/wp-json\/pressbooks\/v2\/chapter-type?post=402"},{"taxonomy":"contributor","embeddable":true,"href":"https:\/\/pressbooks.bccampus.ca\/businessanalytics\/wp-json\/wp\/v2\/contributor?post=402"},{"taxonomy":"license","embeddable":true,"href":"https:\/\/pressbooks.bccampus.ca\/businessanalytics\/wp-json\/wp\/v2\/license?post=402"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}