{ "cells": [ { "cell_type": "markdown", "id": "0d38eab6-bff0-4243-9a86-0d5c7278681c", "metadata": {}, "source": [ "# Working with Vectors in Sage" ] }, { "cell_type": "markdown", "id": "3d04f269-03ed-4b3d-a406-04f68776fb0a", "metadata": {}, "source": [ "## Find the angle and radius of a vector in component form." ] }, { "cell_type": "code", "execution_count": 2, "id": "a04f588f-ae21-4231-95b9-027cae7da5f5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "For the position vector <3,4>, the angle with the x axis is 0.93 radians or 53.13 degrees\n" ] } ], "source": [ "from sympy import deg\n", "angle_rad = N(atan(4/3))\n", "angle_deg = N(deg(angle_rad))\n", "\n", "# Vector <3,4>, angle\n", "print(\"For the position vector <3,4>, the angle with the x axis is {0:.2f} radians or {1:.2f} degrees\".format(angle_rad, angle_deg))" ] }, { "cell_type": "code", "execution_count": 3, "id": "cc7f3091-3b73-45f8-bd93-fed5fc936725", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The radius of the position vector <3, 4> is 5\n" ] } ], "source": [ "# For the radius, simply use the pythagorean theorem: works for \n", "\n", "r = sqrt(3**2 + 4**2)\n", "print(\"The radius of the position vector <3, 4> is \", r)" ] }, { "cell_type": "markdown", "id": "563c767d-303e-448d-9f99-17a74bdac232", "metadata": {}, "source": [ "Try a problem (Moer 11.1, Question 5)\n", "\n", "Given a vector $\\vec{u} = \\langle 2, -2\\rangle$, find the magnitude and the angle (in radians):\n", "\n", "Magnitude is $\\sqrt{2^2 + 2^2} = \\sqrt{8} = 2 \\sqrt{2}$ $\\tan\\theta = \\frac{b}{a} = \\tan-\\frac{2}{2}$\n", "\n", "Angle = $\\frac{7pi}{4}$\n", "\n", "And Moer says we're good!" ] }, { "cell_type": "code", "execution_count": 4, "id": "75ae2c49-4b0c-48f8-8cca-08566d0583b0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-1/4*pi\n" ] }, { "data": { "image/png": "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", "text/plain": [ "Graphics object consisting of 1 graphics primitive" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# No help!\n", "print(atan(-1))\n", "\n", "# plot it -- better!\n", "v1 = vector((2, -2))\n", "plot(v1)" ] }, { "cell_type": "markdown", "id": "15f8f0fb-e8f2-4124-9955-e74f295d35ee", "metadata": {}, "source": [ "# From \"polar form to component form\n", "\n", "Given a vector $\\vec{v}$ with an magnititude $\\|\\vec{v}\\|$ making an angle $\\theta$ with the positive x axis, then:\n", "\n", "$$\n", "\\begin{align}\n", "\\boldsymbol{\\vec{v} = \\langle\\|\\vec{v}\\|\\cos\\theta, |\\vec{v}\\|\\sin\\theta\\rangle = |\\vec{v}\\| \\langle\\cos\\theta, \\sin\\theta\\rangle}\n", "\\end{align}\n", "$$\n", "\n", "Here let's work a problem with that, Moer #11.1, Question 4\n", "\n", "A vector with magnitude 10 points in a direction 340 degrees counterclockwise from the positive x axis." ] }, { "cell_type": "code", "execution_count": 5, "id": "26ebdb8d-7f1a-4ae4-81bb-ca6f8d34b7b7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "17/9*pi\n", "Answer is <9.4, -3.42>\n" ] } ], "source": [ "# Get degrees in radians:\n", "from sympy import rad\n", "angle = rad(340)\n", "print(angle)\n", "horiz = round((N(cos(angle)) * 10), 2)\n", "vert = round((N(sin(angle)) * 10), 2)\n", "print(\"Answer is <{0}, {1}>\".format(horiz, vert))\n" ] }, { "cell_type": "markdown", "id": "079f5dc0-7c82-46ac-9682-89d83ec49a87", "metadata": {}, "source": [ "Check if it makes sense visually (spoiler alert, Moer marked it correct)." ] }, { "cell_type": "code", "execution_count": 6, "id": "d8abb597-4eb6-4941-bcdc-95aa67a921b2", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "Graphics object consisting of 1 graphics primitive" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "p = plot(vector((horiz, vert)))\n", "p.show(aspect_ratio=1, xmin=-4, xmax=12, ymin=-12, ymax=4)" ] }, { "cell_type": "markdown", "id": "8794f089-3670-4438-953b-d477380b6f18", "metadata": {}, "source": [ "# Finding unit vector in a given direction\n", "\n", "Given a vector $\\vec{v} = \\langle u,v \\rangle$\n", "\n", "1. Find the magnitiude, $\\|\\vec{v}\\|$\n", "2. Then find our new vector with scalar multiplication: vector $\\vec{u} = \\frac{1}{\\|\\vec{v}\\|} \\cdot \\vec{v}$\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "cab33796-3522-4fa1-a835-624aab7b94cb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Terms: -4 2\n", "2*sqrt(5)\n", "1/10*sqrt(5)\n", "1\n", "1\n" ] } ], "source": [ "# Do Moer 11.1 Q8: \n", "# Find the unit vector in the direction of <−4, 2>\n", "# My answer differed from what I found by hand, but only because of \n", "# Sage moving the radical to the numerator.\n", "\n", "v1 = vector((-4,2))\n", "print(\"Terms: \", v1[0], v1[1])\n", "magnitude = sqrt((v1[0])**2 + (v1[1])**2)\n", "print(magnitude)\n", "inverse = 1/magnitude\n", "print(inverse)\n", "v2 = inverse * v1\n", "v2\n", "\n", "\n", "# Check magnitude of result:\n", "v2_mag = sqrt((v2[0])**2 + (v2[1])**2)\n", "print(v2_mag)\n", "\n", "# Check answer done by hand\n", "v3 = vector((-2/sqrt(5), 1/sqrt(5)))\n", "v3_mag = sqrt((v3[0])**2 + (v3[1])**2)\n", "print(v3_mag)\n" ] }, { "cell_type": "markdown", "id": "741b8f50-905e-4263-8186-fdbd782aa666", "metadata": {}, "source": [ "### Do Moer 11.1 Q8 by hand \n", "Find the unit vector in the direction of <−4, 2>\n", "\n", "$\\sqrt{20} = 2 \\sqrt{5}$\n", "\n", "$\\frac{1}{2 \\sqrt{5}} \\cdot -4 = \\frac{-2}{\\sqrt{5}}$ \n", "\n", "$\\frac{1}{2 \\sqrt{5}} \\cdot 2 = \\frac{1}{\\sqrt{5}}$ \n", "\n", "So the unit vecor is as shown below:\n", "\n", "$$\n", "\\begin{align}\n", "\\langle - \\frac{2}{\\sqrt{5}}. \\frac{1}{\\sqrt{5}} \\rangle\n", "\\end{align}\n", "$$\n", "\n" ] }, { "cell_type": "markdown", "id": "0c0620f3-3337-49ff-8ea7-178132adb43e", "metadata": {}, "source": [ "## Instantiating vectors in Sage, finding dot product and cross product." ] }, { "cell_type": "code", "execution_count": 8, "id": "52f68e46-f607-48c0-bc6e-4a05bf77dc0b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n", "Dot product of V1 and V10: 26\n", "Cross product of V1 and V10: (8, -4, 0)\n" ] } ], "source": [ "V1 = vector([1,2,3])\n", "\n", "# Can instantiate using tuple or list, among other iterables.\n", "V10 = vector([1,2,7])\n", "V11 = vector((1,2,7))\n", "print(V10 == V11)\n", "\n", "print(\"Dot product of V1 and V10: \", V1 * V10)\n", "print(\"Cross product of V1 and V10: \", V1.cross_product(V10))" ] }, { "cell_type": "code", "execution_count": 9, "id": "1ff7b94a-1a32-41f8-923f-9a8c0049bbce", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n" ], "text/plain": [ "Graphics3d Object" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Lets get a simple plot going:\n", "V1 = vector([1,2,3])\n", "V2 = vector([2,0, 4])\n", "origin = point((0,0), color='black', size=30)\n", "pl = plot(V1) + plot(V2) + origin\n", "pl.show(aspect_ratio=1, xmax=10, xmin=-5, ymax=10, ymin=-5, zmax=10, zmin=-5)" ] }, { "cell_type": "code", "execution_count": 10, "id": "fb363128-621b-4758-bceb-0fef999f8f74", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n" ], "text/plain": [ "Graphics3d Object" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Here we asked Gemini to refine it to exclude the box but get our standard axis lines showing:\n", "\n", "# 1. Define your vectors and origin\n", "V1 = vector([1, 2, 3])\n", "V2 = vector([2, 0, 4])\n", "origin_point = point((0, 0, 0), color='black', size=30) # Corrected to 3D\n", "\n", "# 2. Create the plots for your vectors\n", "plot_v1 = plot(V1, color='blue', legend_label='V1 = [1, 2, 3]')\n", "plot_v2 = plot(V2, color='red', legend_label='V2 = [2, 0, 4]')\n", "\n", "# 3. Define and plot the axes manually\n", "axis_len = 5 # How long to draw the axes\n", "label_offset = 0.3 # How far to put the label from the arrowhead\n", "\n", "# Create arrows for X, Y, Z axes\n", "x_axis = arrow((0, 0, 0), (axis_len, 0, 0), color='black', width=1.5)\n", "y_axis = arrow((0, 0, 0), (0, axis_len, 0), color='black', width=1.5)\n", "z_axis = arrow((0, 0, 0), (0, 0, axis_len), color='black', width=1.5)\n", "\n", "# Create 3D text labels for the axes\n", "x_label = text3d(\"x\", (axis_len + label_offset, 0, 0), color='black', fontsize=14)\n", "y_label = text3d(\"y\", (0, axis_len + label_offset, 0), color='black', fontsize=14)\n", "z_label = text3d(\"z\", (0, 0, axis_len + label_offset), color='black', fontsize=14)\n", "\n", "# 4. Combine all the plot objects\n", "pl = plot_v1 + plot_v2 + origin_point + x_axis + y_axis + z_axis + x_label + y_label + z_label\n", "\n", "# 5. Show the final plot\n", "# The key is frame=False\n", "pl.show(frame=False, aspect_ratio=1)" ] }, { "cell_type": "code", "execution_count": 11, "id": "d7931251-c7bf-4b32-86ce-6f2dc16131e8", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n" ], "text/plain": [ "Graphics3d Object" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Or refinied again:\n", "# 1. Define your vectors\n", "V1 = vector([1, 2, 3])\n", "V2 = vector([2, 0, 4])\n", "origin_point = point((0, 0, 0), color='black', size=30)\n", "\n", "# 2. Calculate vector lengths for labels\n", "len_v1 = V1.norm().n(digits=3) # Get numerical approximation\n", "len_v2 = V2.norm().n(digits=3)\n", "\n", "# 3. Create vector plots (now with thickness and new labels)\n", "plot_v1 = plot(V1, color='blue', width=4, \n", " legend_label=f'V1 = [1, 2, 3] (Length: {len_v1})')\n", "plot_v2 = plot(V2, color='red', width=4, \n", " legend_label=f'V2 = [2, 0, 4] (Length: {len_v2})')\n", "\n", "# 4. Define and plot the axes\n", "axis_len = 5 # How long to draw the axes\n", "label_offset = 0.3 # How far to put the 'x, y, z' label\n", "\n", "x_axis = arrow((0, 0, 0), (axis_len, 0, 0), color='black', width=1.0)\n", "y_axis = arrow((0, 0, 0), (0, axis_len, 0), color='black', width=1.0)\n", "z_axis = arrow((0, 0, 0), (0, 0, axis_len), color='black', width=1.0)\n", "\n", "x_label = text3d(\"x\", (axis_len + label_offset, 0, 0), color='black', fontsize=14)\n", "y_label = text3d(\"y\", (0, axis_len + label_offset, 0), color='black', fontsize=14)\n", "z_label = text3d(\"z\", (0, 0, axis_len + label_offset), color='black', fontsize=14)\n", "\n", "# 5. --- NEW: Add ticks and number labels ---\n", "tick_offset = 0.3 # How far to put number labels from the axis\n", "tick_size = 15 # Size of the tick mark points\n", "\n", "# Use sum() to create a single plot object from a generator\n", "x_ticks = sum(point((i, 0, 0), color='black', size=tick_size) for i in range(1, axis_len + 1))\n", "y_ticks = sum(point((0, i, 0), color='black', size=tick_size) for i in range(1, axis_len + 1))\n", "z_ticks = sum(point((0, 0, i), color='black', size=tick_size) for i in range(1, axis_len + 1))\n", "\n", "x_tick_labels = sum(text3d(str(i), (i, -tick_offset, 0), color='black', fontsize=10) for i in range(1, axis_len + 1))\n", "y_tick_labels = sum(text3d(str(i), (tick_offset, i, 0), color='black', fontsize=10) for i in range(1, axis_len + 1))\n", "z_tick_labels = sum(text3d(str(i), (0, tick_offset, i), color='black', fontsize=10) for i in range(1, axis_len + 1))\n", "\n", "\n", "# 6. Combine ALL the plot objects\n", "pl = plot_v1 + plot_v2 + origin_point\n", "pl += x_axis + y_axis + z_axis + x_label + y_label + z_label\n", "pl += x_ticks + y_ticks + z_ticks\n", "pl += x_tick_labels + y_tick_labels + z_tick_labels\n", "\n", "# 7. Show the final plot\n", "pl.show(frame=False, aspect_ratio=1)\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "d45abd6c-8d5f-46cc-aea3-bdf4c75465f4", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "Graphics object consisting of 3 graphics primitives" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Another example (thanks to Gemini):\n", "\n", "# 1. Define vectors\n", "v1 = vector([3, 4])\n", "v2 = vector([-2, 2])\n", "\n", "# 2. Create plot objects for each vector\n", "p_v1 = plot(v1, color='blue', legend_label='v1 = (3, 4)')\n", "p_v2 = plot(v2, color='orange', legend_label='v2 = (-2, 2)')\n", "\n", "# 3. Add an origin point\n", "origin = point((0,0), color='black', size=30)\n", "\n", "# 4. Combine and show\n", "# (aspect_ratio=1 ensures x and y axes are scaled equally)\n", "(p_v1 + p_v2 + origin).show(aspect_ratio=1)" ] }, { "cell_type": "code", "execution_count": 17, "id": "b6f1c056-d77e-44d2-9d58-63c2d3acf162", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(8.41421356237310, -9.65685424949238)\n" ] }, { "data": { "text/plain": [ "12.8083497715031" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Solve a problem, 11.1 q9 -- enterered rounded answers in Moer, it's correct!\n", "# A person starts walking from home and walks:\n", "# 4 miles East\n", "# 5 miles Southeast\n", "# 4 miles South\n", "# 3 miles Southwest\n", "# 3 miles East\n", "# Have to find total miles (easy) and displacement vector and ||displacement vector||\n", "\n", "southeast = 7*pi/4\n", "southwest = 5*pi/4\n", "\n", "# Solve # 11.1 q 9:\n", "v1 = vector((4, 0))\n", "v2 = vector([N(5*cos(southeast)), N(5*sin(southeast))])\n", "v3 = vector((0, -4))\n", "v4 = vector([N(3*cos(southwest)), N(3*sin(southwest))])\n", "v5 = vector((3, 0))\n", "\n", "displacement = v1 + v2 + v3 + v4 + v5\n", "print(displacement)\n", "sqrt(displacement[0]**2 + displacement[1]**2)" ] }, { "cell_type": "code", "execution_count": 18, "id": "7ffadf9b-d82f-4416-8003-d34770c534e2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5.65685424949238" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "N((4*sqrt(2)))" ] }, { "cell_type": "markdown", "id": "2034d444-e253-455f-b82d-797668c96b90", "metadata": {}, "source": [ "$\\vec{v} = \\langle-1,2\\rangle\\quad\\quad\\vec{u} = \\langle1,1\\rangle\\quad\\quad \\vec{u} + \\vec{v} = \\langle0, 3\\rangle$\n", "\n", "$\\vec{w} = \\langle6, -3\\rangle$\n", "\n", "If a and b are scalars, then $a\\vec{u} + b\\vec{v} = \\vec{w}$ \n", "\n", "So $a \\cdot \\langle1,1\\rangle + b\\cdot \\langle-1,2\\rangle = \\langle6, -3\\rangle$\n", "\n", "So system of equations to solve is: \n", "\n", "$$\n", "\\begin{alignat*}{2}\n", "a - b &= 6 \\\\\n", "a + 2b &= -3\n", "\\\\\n", "\\therefore\n", "\\\\\n", "a &= b + 6 \\\\\n", "b + 6 + 2b &= -3\\\\\n", "3b &= -9\\\\\n", "b&=\\boxed{-3} \\\\\n", "a&=\\boxed{3}\n", "\\end{alignat*}\n", "$$\n" ] }, { "cell_type": "markdown", "id": "590d7a2c-983d-4876-baa8-87f127550643", "metadata": {}, "source": [ "# Magnitude, Distance, Midpoints\n", "\n", "Note that the distance formula between two points (x,y,z) and $(x_1, y_1, z_1)$\n", "is effectively the same as the magnitude formula, i.e., \n", "\n", "$\\sqrt{(x - x_1)^2 + (y - y_1)^2 + (z - z_1)^2}$\n", "\n", "The midpoint formula for the two points would be:\n", "\n", "$\\langle \\frac{x+x_1}{2}, \\frac{y+y_1}{2}, \\frac{z+z_1}{2}\\rangle$" ] }, { "cell_type": "code", "execution_count": 19, "id": "308cc0c0-4171-4cbc-b8aa-d32c7a9615e4", "metadata": {}, "outputs": [], "source": [ "def magnitude_list(l: list):\n", " \"\"\"return the Euclidean length of a point specified as a list of scalars\"\"\"\n", " square_sum = 0\n", " for i in l:\n", " square_sum += i**2\n", " return sqrt(square_sum)\n", "\n", "# But see the vector.norm() method, which will give you the same thing!\n", "\n", "def magnitude(v: vector):\n", " \"\"\"return the Euclidean length of a vector\"\"\"\n", " l = v.list()\n", " return magnitude_list(l)\n", "\n", "# Note we could also implement distance between two points \n", "# doing the subtraction in that fn and calling magnitude_list\n", "# from sympy import Point3D\n", "# p = Point3D([1,2,3])\n", "# print(p)\n", "\n", "V = vector((1,2,3))\n", "assert magnitude(V) == sqrt(14)\n", "assert magnitude(V) == V.norm()" ] }, { "cell_type": "markdown", "id": "bc0292bf-1a30-47ba-a25c-d0876626affd", "metadata": {}, "source": [ "## Implicit Plots of 3D Surfaces\n", "\n", "For implicit plotting, we used https://c3d.libretexts.org/CalcPlot3D/index.html, selecting \"implicit surface\" from the dropdown. This is easier to set up than SageMath.\n", "\n", "The cell below is commented out because it throws off Jupyter's scrolling somewhat" ] }, { "cell_type": "code", "execution_count": 20, "id": "5cae0671-8409-48c4-b097-75531e521639", "metadata": {}, "outputs": [], "source": [ "# x = var('x')\n", "# y = var('y')\n", "# z = var('z')\n", "\n", "# equation = (x-2)**2 + y**2 + z**2 == 36\n", "# implicit_plot3d(equation, (x,-8, 8), (y,-8,8), (z,-8, 8))" ] }, { "cell_type": "code", "execution_count": 21, "id": "b52a9eaa-402f-433f-9c87-303031cb8358", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(-1, 11, -6)" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Checking a solution gotten by hand:\n", "a = vector((-3, 3, -2))\n", "b = vector((-1, -4, 2))\n", "a - 2*b" ] }, { "cell_type": "code", "execution_count": 22, "id": "8324a329-b2f0-4443-8cee-1a59dc451c69", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(12, -18, -4)" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Checking a solution gotten by hand:\n", "a = vector((3, -3, -1))\n", "b = vector((3, -5, -1))\n", "a + 3*b" ] }, { "cell_type": "markdown", "id": "8e73582b-8314-4c8f-a87a-6f8a0a4882d8", "metadata": {}, "source": [ "## The Dot Product\n", "\n", "The dot product gives us information about the angle $\\theta$ between two vectors.\n", "\n", "$$\n", "\\begin{alignat*}{2}\n", "&\\vec{V1} \\cdot \\vec{V2} = 0 &\\quad\\quad \\theta = \\frac{pi}{2} \\\\\n", "&\\vec{V1} \\cdot \\vec{V2} \\gt 0 &\\quad\\quad \\theta \\lt \\frac{pi}{2} \\\\\n", "&\\vec{V1} \\cdot \\vec{V2} \\lt 0 &\\quad\\quad \\theta \\gt \\frac{pi}{2} \\\\\n", "\\end{alignat*}\n", "$$\n", "\n", "The dot product is related to the angle as follows:\n", "\n", "$$\n", "\\begin{align*}\n", "\\vec{v} \\cdot \\vec{w} &= \\|\\vec{v}\\| \\|\\vec{w}\\| \\cos \\theta \\\\ \\\\\n", "\\cos \\theta &= \\frac{\\vec{v} \\cdot \\vec{w}}{\\|\\vec{v}\\| \\|\\vec{w}\\|}\n", "\\end{align*}\n", "$$" ] }, { "cell_type": "code", "execution_count": 23, "id": "8554a0cd-b3f3-4b8d-b88b-cdcde05070f0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.89902877949431" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "N(acos(-35/(10*sqrt(13))))" ] }, { "cell_type": "code", "execution_count": 24, "id": "12cf872f-395e-4e8e-9174-652e8e016af4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-35\n", "sqrt(26)\n", "5*sqrt(2)\n", "5.09901951359278\n", "5.09901951359279\n", "-7/52*sqrt(26)*sqrt(2)\n" ] } ], "source": [ "a = vector((4,-1,-3))\n", "b = vector((-5,0,5))\n", "print(a*b)\n", "print(a.norm())\n", "print(b.norm())\n", "print(N(sqrt(26)))\n", "print(N(sqrt(2) * sqrt(13)))\n", "lhs = a*b / (a.norm() * b.norm())\n", "print(lhs)" ] }, { "cell_type": "code", "execution_count": 25, "id": "611332a3-c5d1-4bc7-9bc5-ce24455692dd", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-0.970725343394151\n", "-0.970725343394151\n" ] } ], "source": [ "print(N(-7/52*sqrt(26)*sqrt(2) ))\n", "print(N(a*b/(10*sqrt(13))))" ] }, { "cell_type": "code", "execution_count": 26, "id": "6d22830a-5a1b-40e4-8573-dee329a8d7f9", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2.89902877949431 approx = arccos(-174.730561810947/pi)\n" ] } ], "source": [ "from sympy import deg\n", "theta_radians = acos(-0.970725343394151)\n", "theta_degrees = (acos(deg(-0.970725343394151)))\n", "print(theta_radians, \" approx = \", theta_degrees)\n" ] }, { "cell_type": "code", "execution_count": 27, "id": "78fdf928-314a-448f-ac26-943dd845face", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n" ], "text/plain": [ "Graphics3d Object" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "origin = point((0,0), color='black', size=30)\n", "pl = plot(a, color=\"red\") + plot(b, color=\"blue\") + origin\n", "pl.show(aspect_ratio=1)" ] }, { "cell_type": "code", "execution_count": 28, "id": "a2f5d361-a333-490c-885c-83724e50cdc9", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n" ] } ], "source": [ "# Checking an answer. Are these two vectors orthogonal?\n", "\n", "a = vector((2, -2, 3))\n", "b = vector((4, -1, -10/3))\n", "\n", "print(a * b)" ] }, { "cell_type": "markdown", "id": "72d4d2c4-dff4-497e-8205-e869062c063d", "metadata": {}, "source": [ "## Projection of vectors\n", "\n", "A vector projection is a kind of \"shadow that one vector casts onto another. When we want to find the projection of $\\vec{b}$ onto $\\vec{a}$, we write it as $\\text{proj}_{\\vec{a}}{\\vec{b}}$.\n", "\n", "Here is the formula to use:\n", "\n", "$$\n", "\\begin{align}\n", "\\boldsymbol{\n", "\\text{proj}_{\\vec{w}}\\vec{v} = \\left( \\frac{\\vec{v}\\cdot\\vec{w}}{\\|\\vec{w}\\|^2} \\right) \n", "\\vec{w}}\n", "\\end{align}\n", "$$\n", "\n", "The following problem, (11.4 Question 6), finds the projection $\\vec{b}$ onto $\\vec{a}$" ] }, { "cell_type": "code", "execution_count": 29, "id": "962d5798-a64c-444c-9436-cfa00fb0f4f3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(72/17, 0, -18/17)" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A = vector((4, 0, -1))\n", "B = vector ((5,0,2))\n", "\n", "\n", "def get_projection_b_onto_a(b, a):\n", " \"\"\"project b onto a\"\"\"\n", " return (b*a)/(a.norm()**2) * a\n", "\n", "get_projection_b_onto_a(B, A)" ] }, { "cell_type": "markdown", "id": "42c37abb-25b5-4326-928e-7c132731c4d6", "metadata": {}, "source": [ "11.4 question 7.\n", "Find the angle of intersection, in radians, of two functions that intersect at (-2,3).\n", "\n", "The functions are $f(x) = x^2 + 2x + 3$ and $g(x) = -5x - 7$\n", "\n", "First, we need to find the derivatives, to get our slopes as something we can represent as vectors. \n", "\n", "$$\n", "\\begin{align}\n", "f^{\\prime}(x) = 2x + 2 \\\\\n", "g^{\\prime}(x) = -5\n", "\\end{align}\n", "$$\n", "\n", "Find the slope of tangent line for $f(x)$:\n", "\n", "\n", "$$\n", "\\begin{align}\n", "(y - 3) = -2(x - (-2)) \\\\\n", "y - 3 = -2x -4 \\\\\n", "y = -2x - 1 \\\\\n", "\\end{align}\n", "$$\n", "\n", "The slope is -2 at $f(x)$ = -2. (For confirmation, see https://www.desmos.com/calculator/5ftj0x5ccz)\n", "\n", "$g(x)$ is linear, so the slope is -5 wherever you go.\n", "\n", "Next, per the video, we need to create two vectors, lets call them $\\vec{F}$ and $\\vec{G}$ We can read these off the graph. \n", "\n", "For $\\vec{F}$, we can take (-2,3) to the point (0,-1). Subtracting we have the position vector, (-2,4)\n", "\n", "For vector $\\vec{G}$, we can take the points (-2,3) to the points (0, -7). Subtracting we get a position vector (-2, 10). \n", "\n", "Next, as we documented above, we'll need to use the formula below to find the angle begween the vectors.\n", "\n", "$$\n", "\\begin{align}\n", "\\cos \\theta &= \\frac{\\vec{v} \\cdot \\vec{w}}{\\|\\vec{v}\\| \\|\\vec{w}\\|}\n", "\\end{align}\n", "$$\n", "\n", "Earlier, however, we didn't stop to implement that formula in Sage. Let's do so now, and use it to find our angle between our two vectors, $\\vec{F} = (-2,4)$ and $\\vec{G} = (-2,10)$\n" ] }, { "cell_type": "code", "execution_count": 30, "id": "1c98e265-e105-4851-8d4e-264882ebb12b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Raw angle: arccos(11/130*sqrt(26)*sqrt(5))\n", "Evaluated: 0.266252049150925\n", "In degree: 15.2551187030578\n" ] } ], "source": [ "def get_angle_between_vectors(v: vector, w: vector):\n", " \"\"\"returns the angle between two vectors in radians.\"\"\"\n", " cos_theta = (v*w)/(v.norm() * w.norm())\n", " return acos(cos_theta)\n", "\n", "F = vector((-2, 4))\n", "G = vector((-2, 10))\n", "print(\"Raw angle: \", get_angle_between_vectors(F, G))\n", "print(\"Evaluated: \", N(get_angle_between_vectors(F, G)))\n", "print(\"In degree: \", N(deg((get_angle_between_vectors(F, G)))))" ] }, { "cell_type": "markdown", "id": "6cf1c48f-b123-4865-8994-0a4687477462", "metadata": {}, "source": [ "## 3D Vector Cross Products\n", "\n", "Earlier we used the ```vector.cross_product``` method in Sage to find a cross-product. Let's review how to do it without sage. \n", "\n", "There is an unmemorizable formula for the vector cross-product, but fortunately, we can also think about it in terms of the determinant of a 3x3 matrix based on a and b. We use the regular multiplication symbol for the cross-product:\n", "\n", "$$\n", "\\begin{align}\n", "\\vec{a} \\times \\vec{b} = \\det{\\begin{vmatrix}\n", "i & j & k \\\\\n", "a_1 & a_2 & a_3 \\\\\n", "b_1 & b_2 & b_3 \\\\\n", "\\end{vmatrix}}\n", "= &\\left(\\det{\\begin{vmatrix}\n", "a_2 & a_3 \\\\\n", "b_2 & b_3 \\\\\n", "\\end{vmatrix}} \\cdot i\\right) - \\left(\\det{\\begin{vmatrix}\n", "a_1 & a_3 \\\\\n", "b_1 & b_3 \\\\\n", "\\end{vmatrix}} \\cdot j\\right) + \n", "\\left(\\det{\\begin{vmatrix}\n", "a_1 & a_2 \\\\\n", "b_1 & b_2 \\\\\n", "\\end{vmatrix}}\n", "\\cdot k\\right)\\\\ \n", "\\end{align}\n", "$$\n", "\n", "The first thirty-eight minutes or so of [this video](https://www.youtube.com/watch?v=qqfhgStQ-cA) provides a good treatment of the details of how we got that formula in terms of three 2x2 matrices. " ] }, { "cell_type": "markdown", "id": "79e6ee24-1f0e-4467-9bbd-ba4e7cde2870", "metadata": {}, "source": [ "Let's use this method to solve 11.5, question 3, which asks us to find the cross-product $\\vec{u} \\times \\vec{b}$ where:\n", "\n", "$\\vec{u} = 6i + 9j + 6k$\n", "\n", "$\\vec{v} = \\langle4, -8, 5\\rangle$\n", "\n", "Solving for\n", "\n", "$$\n", "\\begin{align}\n", "\\det{\\begin{vmatrix}\n", "i & j & k \\\\\n", "6 & 9 & 6 \\\\\n", "4 & -8 & 5\\\\\n", "\\end{vmatrix}}\n", "\\end{align}\n", "$$\n", "\n", "gives us:\n", "\n", "$$\n", "\\begin{align}\n", "& [(45) - (-48)]i - [(30)-(24)]j + [(-48) -(36)]k \\\\\n", "\\\\\n", "= &\\;\\boxed{\\langle 93, -6, -84\\rangle}\n", "\\end{align}\n", "$$\n", "\n", "Now, since doing this manually is error-prone as heck, let's check our result using Sage. \n" ] }, { "cell_type": "code", "execution_count": 31, "id": "c62dccaf-fc2c-442b-8e78-e562e21c2269", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(93, -6, -84)" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "u = vector((6, 9, 6))\n", "v = vector((4, -8, 5))\n", "u.cross_product(v)" ] }, { "cell_type": "markdown", "id": "bd7a838e-8f69-44a4-bb41-bfd46ecbfa05", "metadata": {}, "source": [ "Sure enough, I had a sign error in the middle term, since corrected." ] }, { "cell_type": "markdown", "id": "b3672228-9047-49e4-824e-b5aa2594177a", "metadata": {}, "source": [ "## Some Properties of the Cross Product\n", "\n", "1. The cross product is a vector that is orthogonal to both of the original two vectors. Since they are orthogonal, the dot product will be zero." ] }, { "cell_type": "code", "execution_count": 32, "id": "877d64f3-4009-4e1f-8c66-6ee95223bddb", "metadata": {}, "outputs": [], "source": [ "u = vector((3, 6, 9))\n", "v = vector((4, -8, -1))\n", "w = u.cross_product(v)\n", "\n", "# Show w is orthogonal to both u and v\n", "assert w * u == 0\n", "assert w * v == 0" ] }, { "cell_type": "markdown", "id": "706bdc52-7aa1-4b10-ab60-11230fce56db", "metadata": {}, "source": [ "2. If we consider two vectors as forming two sides of a parallelogram, then the magnitude of the cross product is equal to the area of this parallelogram. If theta is the angle between them, then we may find this area using the [parallelogram area formula](https://en.wikipedia.org/wiki/Parallelogram)\n", "\n", "$$\n", "\\begin{align}\n", "|\\vec{A}\\times\\vec{B}| = |\\vec{A}| \\cdot |\\vec{B}| \\cdot \\sin\\theta\n", "\\end{align}\n", "$$" ] }, { "cell_type": "code", "execution_count": 33, "id": "1348f6f0-401c-4d37-b137-0ef40a5b9f10", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "9*sqrt(101)\n", "9*sqrt(101)\n" ] } ], "source": [ "# Show that a cross product represents the \n", "# area of a parallelogram between two vectors.\n", "\n", "u = vector((3,6,9))\n", "v = vector((4, -8, -1))\n", "w = u.cross_product(v)\n", "\n", "# get_angle_between_vectors defined earlier in this notebook.\n", "theta = get_angle_between_vectors(u, v)\n", "print(w.norm())\n", "print((u.norm() * v.norm() * sin(theta)).simplify())\n", "assert (w.norm() == u.norm() * v.norm() * sin(theta))" ] }, { "cell_type": "markdown", "id": "0f338447-bce3-4710-ac68-abda3a16c295", "metadata": {}, "source": [ "3. The cross product is \"anti-commutative\". That is, if we reverse the order of the vectors, we get the negation of the cross-product." ] }, { "cell_type": "code", "execution_count": 34, "id": "fcb78df0-badc-4f29-a473-b54ac3707541", "metadata": {}, "outputs": [], "source": [ "u = vector((3, 2, 1))\n", "v = vector((4, 3, -1))\n", "assert (u.cross_product(v) == - v.cross_product(u))" ] }, { "cell_type": "code", "execution_count": 35, "id": "aba6b22d-a399-45c2-b2ba-3e2767b3e84e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "7.34846922834953" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "u = vector(RR, (3, 2, -4))\n", "v = vector(RR, (-6, 6, -4))\n", "w = vector(RR, (0,-2,-2))\n", "\n", "z = u.cross_product(w)\n", "z.norm() * 1/2" ] }, { "cell_type": "code", "execution_count": 36, "id": "741529d2-ff4d-4715-a19b-cbeab5b9cb81", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "sqrt(673)" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "P = vector((3, 2, -4))\n", "Q = vector((-6, 6, -4))\n", "R = vector((0, -2, -2))\n", "\n", "PQ = Q-P\n", "PR = R-P\n", "\n", "(PQ.cross_product(PR)).norm() * 1/2" ] }, { "cell_type": "markdown", "id": "8f8b208a-0718-4a66-a043-4b7b29739b29", "metadata": {}, "source": [ "PQ = <(-6 -3), (6-4), (-4 -(-4)> = <-9, 4, 0>\n", "PR = <(0 - 3), (-2 -2), (-2) - (-4)> = <-3, -4, 2>" ] }, { "cell_type": "code", "execution_count": 37, "id": "3f7ff289-7a25-471f-8fb7-04bedce68c3f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "45.8693797647189" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pq = vector(RR, (-9, 2, 0))\n", "pr = vector(RR, (-3, -4, 2))\n", "\n", "pq.cross_product(pr).norm()" ] }, { "cell_type": "markdown", "id": "1b7c471c-b78c-4b9f-951d-3f379b7c4e3c", "metadata": {}, "source": [ "# Triple Scalar Product\n", "\n", "This is used to find the volume of a parallepiped (a lopsided cube, i.e., a paralellogram in 3D).\n", "\n", "Formally we use $V = | u \\cdot (v \\times w)|$ (That's an abslolute value -- result will be scalar)\n", "\n", "\n", "$$\n", "\\begin{align}\n", "u \\cdot (v \\times w) = \\begin{vmatrix}\n", "u_1 & u_2 & u3 \\\\\n", "v_1 & v_2 & v_3 \\\\\n", "w_1 & w_2 & w_3\n", "\\end{vmatrix}\n", "\\end{align}\n", "$$\n", "\n", "So you'd work it like a 3D determinant cross product. (The order doesn't matter of the three terms)." ] }, { "cell_type": "code", "execution_count": 38, "id": "884579e4-c72f-4644-a79f-f338edcfd527", "metadata": {}, "outputs": [], "source": [ "a = vector([3, 5, -1])\n", "b = vector([0, 1, 4])\n", "c = vector([2, 3, 1])" ] }, { "cell_type": "code", "execution_count": 39, "id": "fd7ce10a-6e1a-4e89-9340-7b6d3618b19d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "9" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a * b.cross_product(c)" ] }, { "cell_type": "code", "execution_count": 40, "id": "4cfe4e79-b411-4bb1-bd8b-95fe13bf1a1b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "9" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b * c.cross_product(a)" ] }, { "cell_type": "code", "execution_count": 41, "id": "c2d10098-bd05-46c7-9c4e-da7514767bbb", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-9" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a * c.cross_product(b)" ] }, { "cell_type": "markdown", "id": "6470d009-25f2-472c-b1e7-ef63e5e25e6f", "metadata": {}, "source": [ "## Finding the equation of a plane given 3 points\n", "\n", "11.6 Q 4. \"Find a plane through the points (-8,-5,3), (-4,6,1), (3,4,-2)\"\n", "\n", "We need to find a normal vector to the plane as a first step. Let's call these vectors, a, b & c, respectively. Then:" ] }, { "cell_type": "code", "execution_count": 42, "id": "ac81ed3f-8d4a-4c2b-9b3a-8498287f060c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(37.0000000000000, 2.00000000000000, 85.0000000000000)" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = vector(RR, [-8,-5,3])\n", "b = vector(RR, [-4,6,1])\n", "c = vector(RR, [3,4,-2])\n", "\n", "bc = c - b\n", "ba = a - b\n", "\n", "normal_vector = ba.cross_product(bc)\n", "normal_vector" ] }, { "cell_type": "markdown", "id": "ef181be0-291c-4dee-959c-493c6d212cb5", "metadata": {}, "source": [ "Next, we use the Point-Normal equation to find the equation of the plane.\n", "\n", "## Equation of a Plane (Point - Normal Form)\n", "\n", "The plane containing the point $(x_1, y_1, z_1)$ and having a normal vector $\\vec{n} = \\langle a, b, c \\rangle$ has equation:\n", "\n", "$$\\boldsymbol{a(x - x_1) + b(y - y_1) + c(z - z_1) = 0}$$\n", "\n", "Or a, b, and c terms are given by the components of our normal vector. Meanwhile, we can use any point in the plane as the terms of our $x_1, y_1, z_1$. We'll use point b.\n", "\n", "Given that, our equation is $37(x - (-4)) + 2(y - 6) + 85(z - 1) = 0$, and simplifying we have $37(x +4) + 2(y - 6) + 85(z - 1) = 0$\n", "\n", "[Checking it graphically on Desmos](https://www.desmos.com/3d/fm6wbveeqf), it is correct.\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "73aa9901-d006-46d3-9a8c-2a875f240b42", "metadata": {}, "source": [ "## Finding the intersection of two planes:\n", "\n", "In exercise 11.6 question 5, we're asked to find the equation of a line where two planes intersect. The planes are $-4y\\ +\\ 5z\\ =\\ -7$ and $-9x\\ -7y\\ -4z\\ =\\ -25$, and they are [graphed here](https://www.desmos.com/3d/qcyywxvipn). The [associated video](https://moer.maricopa.edu/assessment/watchvid.php?url=http%3A%2F%2Fyoutu.be%2FPlcZDfKv2_Q) tells us to find the normal vector for each plane, and then the cross product of those two normal vectors will give us the direction vector of their intersection. Then given a point on that vector, we can figure out the equation.\n", "\n", "The Point-Normal equation from the last cell means we can read off our normal vector components from the coefficients of each term. So we have two normal vectors:\n", "\n", "$$\n", "\\begin{align}\n", "\\vec{n_1} &= \\langle0, -4, 5\\rangle \\\\\n", "\\vec{n_2} &= \\langle-9, -7, -4\\rangle\n", "\\end{align}\n", "$$\n", "\n", "\n", "Their cross-product (see below), is $\\langle51, -45, -36\\rangle$\n", "\n", "Note we're asked to find a parametric equation based on $x(t) = 51t$ Copying our point normal equation from above, we have: \n", "\n", "$$\\boldsymbol{a(x - x_1) + b(y - y_1) + c(z - z_1) = 0}$$\n", "\n", "So we want to find three points $P(0, , )$. For points y and z, we have a system of equations:\n", "\n", "$$\n", "\\begin{align}\n", "4y + 5z = -7 \\\\\n", "-7y - 4z = -25\n", "\\end{align}\n", "$$\n", "\n", "We solve it in a code cell below using Sage. $y =3, z = 1$ \n", "\n", "Multiplying row two by $\\frac{5}{4}$ gives $-\\frac{35}{4}y - 5z = - \\frac{125}{4}$\n", "\n", "Subtracting \n", "\n", "\n", "\n", "So at this point we have a point, $P$ on the line, and $P = \\left(0, 3, 1\\right)$ and a direction vector, $\\langle51, -45, -36\\rangle$\n", "\n", "So we have\n", "\n", "$$\n", "\\begin{align}\n", "x &= 0 + 51t \\\\\n", "y &= 3 -45t \\\\\n", "z &= 1 - 36t\n", "\\end{align}\n", "$$" ] }, { "cell_type": "code", "execution_count": 43, "id": "3df5f865-fc97-4502-a0a7-5fc038c16ad5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(51, -45, -36) (-51, 45, 36)\n" ] } ], "source": [ "# Get the cross product for exercise below:\n", "n1 = vector([0, -4, 5])\n", "n2 = vector([-9, -7, -4])\n", "print(n1.cross_product(n2), n2.cross_product(n1))" ] }, { "cell_type": "code", "execution_count": 44, "id": "7c424439-9246-436a-b606-03de2a6a4296", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3, 1)" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Use sage to solve the system of \n", "M = Matrix(QQ, [[-4, 5], [-7, -4]])\n", "M\n", "V = vector(QQ, [-7, -25])\n", "M.solve_right(V)" ] }, { "cell_type": "code", "execution_count": 45, "id": "6c089635-9733-4c66-bdfb-f067ec37baff", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "87/10" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "simplify(-174/-20)" ] } ], "metadata": { "kernelspec": { "display_name": "SageMath 10.7", "language": "sage", "name": "sagemath-10.7" }, "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.3" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": {}, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }