From 10d394e8ecc58c60ad1518b7f0a197ceed58d673 Mon Sep 17 00:00:00 2001 From: rdukewiesenb <68960154+rdukewiesenb@users.noreply.github.com> Date: Mon, 17 Aug 2020 14:36:21 -0400 Subject: [PATCH 1/3] Created using Colaboratory --- ..._131_Vectors_and_Matrices_Assignment.ipynb | 530 ++++++++++++++++++ 1 file changed, 530 insertions(+) create mode 100644 module1/LS_DS_131_Vectors_and_Matrices_Assignment.ipynb diff --git a/module1/LS_DS_131_Vectors_and_Matrices_Assignment.ipynb b/module1/LS_DS_131_Vectors_and_Matrices_Assignment.ipynb new file mode 100644 index 00000000..a9932fce --- /dev/null +++ b/module1/LS_DS_131_Vectors_and_Matrices_Assignment.ipynb @@ -0,0 +1,530 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Copy of LS_DS_131_Vectors_and_Matrices_Assignment.ipynb", + "provenance": [], + "collapsed_sections": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yXA3GwWhY9KL", + "colab_type": "text" + }, + "source": [ + "# Part 1 - Scalars and Vectors\n", + "\n", + "For the questions below it is not sufficient to simply provide answer to the questions, but you must solve the problems and show your work using python (the NumPy library will help a lot!) Translate the vectors and matrices into their appropriate python representations and use numpy or functions that you write yourself to demonstrate the result or property. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oNOTv43_Zi9L", + "colab_type": "text" + }, + "source": [ + "## 1.1 Create a two-dimensional vector and plot it on a graph" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "XNqjzQzrkVG7", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "unKFT619lk3e", + "colab_type": "text" + }, + "source": [ + "## 1.2 Create a three-dimensional vecor and plot it on a graph" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "atUEd3T6llKm", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b7qFxbKxZmI2", + "colab_type": "text" + }, + "source": [ + "## 1.3 Scale the vectors you created in 1.1 by $5$, $\\pi$, and $-e$ and plot all four vectors (original + 3 scaled vectors) on a graph. What do you notice about these vectors? " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ah6zMSLJdJwL", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "outputId": "b1ccb836-02b8-4d42-a7db-6c34f010f6c6" + }, + "source": [ + "from math import e, pi\n", + "print(e)\n", + "print(pi)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "2.718281828459045\n", + "3.141592653589793\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "3qpwDlzXkVf5", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wrgqa6sWimbH", + "colab_type": "text" + }, + "source": [ + "## 1.4 Graph vectors $\\vec{a}$ and $\\vec{b}$ and plot them on a graph\n", + "\n", + "\\begin{align}\n", + "\\vec{a} = \\begin{bmatrix} 5 \\\\ 7 \\end{bmatrix}\n", + "\\qquad\n", + "\\vec{b} = \\begin{bmatrix} 3 \\\\4 \\end{bmatrix}\n", + "\\end{align}" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "I1BGXA_skV-b", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QN6RU_3gizpw", + "colab_type": "text" + }, + "source": [ + "## 1.5 find $\\vec{a} - \\vec{b}$ and plot the result on the same graph as $\\vec{a}$ and $\\vec{b}$. Is there a relationship between vectors $\\vec{a} \\thinspace, \\vec{b} \\thinspace \\text{and} \\thinspace \\vec{a-b}$" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "68sWHIOPkXp5", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1ZPVuJAlehu_", + "colab_type": "text" + }, + "source": [ + "## 1.6 Find $c \\cdot d$\n", + "\n", + "\\begin{align}\n", + "\\vec{c} = \\begin{bmatrix}7 & 22 & 4 & 16\\end{bmatrix}\n", + "\\qquad\n", + "\\vec{d} = \\begin{bmatrix}12 & 6 & 2 & 9\\end{bmatrix}\n", + "\\end{align}\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "2_cZQFCskYNr", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cLm8yokpfg9B", + "colab_type": "text" + }, + "source": [ + "## 1.7 Find $e \\times f$\n", + "\n", + "\\begin{align}\n", + "\\vec{e} = \\begin{bmatrix} 5 \\\\ 7 \\\\ 2 \\end{bmatrix}\n", + "\\qquad\n", + "\\vec{f} = \\begin{bmatrix} 3 \\\\4 \\\\ 6 \\end{bmatrix}\n", + "\\end{align}" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ku-TdCKAkYs8", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-TN8wO2-h53s", + "colab_type": "text" + }, + "source": [ + "## 1.8 Find $||g||$ and then find $||h||$. Which is longer?\n", + "\n", + "\\begin{align}\n", + "\\vec{g} = \\begin{bmatrix} 1 \\\\ 1 \\\\ 1 \\\\ 8 \\end{bmatrix}\n", + "\\qquad\n", + "\\vec{h} = \\begin{bmatrix} 3 \\\\3 \\\\ 3 \\\\ 3 \\end{bmatrix}\n", + "\\end{align}" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "-5VKOMKBlgaA", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "njrWIMS-ZAoH", + "colab_type": "text" + }, + "source": [ + "# Part 2 - Matrices" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GjkcAVIOmOnn", + "colab_type": "text" + }, + "source": [ + "## 2.1 What are the dimensions of the following matrices? Which of the following can be multiplied together? See if you can find all of the different legal combinations.\n", + "\\begin{align}\n", + "A = \\begin{bmatrix}\n", + "1 & 2 \\\\\n", + "3 & 4 \\\\\n", + "5 & 6\n", + "\\end{bmatrix}\n", + "\\qquad\n", + "B = \\begin{bmatrix}\n", + "2 & 4 & 6 \\\\\n", + "\\end{bmatrix}\n", + "\\qquad\n", + "C = \\begin{bmatrix}\n", + "9 & 6 & 3 \\\\\n", + "4 & 7 & 11\n", + "\\end{bmatrix}\n", + "\\qquad\n", + "D = \\begin{bmatrix}\n", + "1 & 0 & 0 \\\\\n", + "0 & 1 & 0 \\\\\n", + "0 & 0 & 1\n", + "\\end{bmatrix}\n", + "\\qquad\n", + "E = \\begin{bmatrix}\n", + "1 & 3 \\\\\n", + "5 & 7\n", + "\\end{bmatrix}\n", + "\\end{align}" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Z69c-uPtnbIx", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lMOlCoM3ncGa", + "colab_type": "text" + }, + "source": [ + "## 2.2 Find the following products: CD, AE, and BA. What are the dimensions of the resulting matrices? How does that relate to the dimensions of their factor matrices?" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "zhKwiSItoE2F", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "p2jmaGLgoFPN", + "colab_type": "text" + }, + "source": [ + "## 2.3 Find $F^{T}$. How are the numbers along the main diagonal (top left to bottom right) of the original matrix and its transpose related? What are the dimensions of $F$? What are the dimensions of $F^{T}$?\n", + "\n", + "\\begin{align}\n", + "F = \n", + "\\begin{bmatrix}\n", + "20 & 19 & 18 & 17 \\\\\n", + "16 & 15 & 14 & 13 \\\\\n", + "12 & 11 & 10 & 9 \\\\\n", + "8 & 7 & 6 & 5 \\\\\n", + "4 & 3 & 2 & 1\n", + "\\end{bmatrix}\n", + "\\end{align}" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Wl3ElwgLqaAn", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "13ik2LEEZLHn", + "colab_type": "text" + }, + "source": [ + "# Part 3 - Square Matrices" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sDBAPUwfp7f7", + "colab_type": "text" + }, + "source": [ + "## 3.1 Find $IG$ (be sure to show your work) 😃\n", + "\n", + "You don't have to do anything crazy complicated here to show your work, just create the G matrix as specified below, and a corresponding 2x2 Identity matrix and then multiply them together to show the result. You don't need to write LaTeX or anything like that (unless you want to).\n", + "\n", + "\\begin{align}\n", + "G= \n", + "\\begin{bmatrix}\n", + "13 & 14 \\\\\n", + "21 & 12 \n", + "\\end{bmatrix}\n", + "\\end{align}" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ZnqvZBOYqar3", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DZ_0XTDQqpMT", + "colab_type": "text" + }, + "source": [ + "## 3.2 Find $|H|$ and then find $|J|$.\n", + "\n", + "\\begin{align}\n", + "H= \n", + "\\begin{bmatrix}\n", + "12 & 11 \\\\\n", + "7 & 10 \n", + "\\end{bmatrix}\n", + "\\qquad\n", + "J= \n", + "\\begin{bmatrix}\n", + "0 & 1 & 2 \\\\\n", + "7 & 10 & 4 \\\\\n", + "3 & 2 & 0\n", + "\\end{bmatrix}\n", + "\\end{align}\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "5QShhoXyrjDS", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2gZl1CFwrXSH", + "colab_type": "text" + }, + "source": [ + "## 3.3 Find $H^{-1}$ and then find $J^{-1}$" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "nyX6De2-rio1", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Vvd4Pe86rjhW", + "colab_type": "text" + }, + "source": [ + "## 3.4 Find $HH^{-1}$ and then find $J^{-1}J$. Is $HH^{-1} == J^{-1}J$? Why or Why not? \n", + "\n", + "Please ignore Python rounding errors. If necessary, format your output so that it rounds to 5 significant digits (the fifth decimal place)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "V0iTO4McYjtk", + "colab_type": "text" + }, + "source": [ + "# Stretch Goals: \n", + "\n", + "A reminder that these challenges are optional. If you finish your work quickly we welcome you to work on them. If there are other activities that you feel like will help your understanding of the above topics more, feel free to work on that. Topics from the Stretch Goals sections will never end up on Sprint Challenges. You don't have to do these in order, you don't have to do all of them. \n", + "\n", + "- Write a function that can calculate the dot product of any two vectors of equal length that are passed to it.\n", + "- Write a function that can calculate the norm of any vector\n", + "- Prove to yourself again that the vectors in 1.9 are orthogonal by graphing them. \n", + "- Research how to plot a 3d graph with animations so that you can make the graph rotate (this will be easier in a local notebook than in google colab)\n", + "- Create and plot a matrix on a 2d graph.\n", + "- Create and plot a matrix on a 3d graph.\n", + "- Plot two vectors that are not collinear on a 2d graph. Calculate the determinant of the 2x2 matrix that these vectors form. How does this determinant relate to the graphical interpretation of the vectors?\n", + "\n" + ] + } + ] +} \ No newline at end of file From db62ba27d5e2f8b04795013c550d04448f6fa5ea Mon Sep 17 00:00:00 2001 From: rdukewiesenb <68960154+rdukewiesenb@users.noreply.github.com> Date: Mon, 17 Aug 2020 22:19:53 -0400 Subject: [PATCH 2/3] yay! --- ..._131_Vectors_and_Matrices_Assignment.ipynb | 1013 ++++++++++++++++- 1 file changed, 967 insertions(+), 46 deletions(-) diff --git a/module1/LS_DS_131_Vectors_and_Matrices_Assignment.ipynb b/module1/LS_DS_131_Vectors_and_Matrices_Assignment.ipynb index a9932fce..e4df4d4f 100644 --- a/module1/LS_DS_131_Vectors_and_Matrices_Assignment.ipynb +++ b/module1/LS_DS_131_Vectors_and_Matrices_Assignment.ipynb @@ -36,6 +36,24 @@ "For the questions below it is not sufficient to simply provide answer to the questions, but you must solve the problems and show your work using python (the NumPy library will help a lot!) Translate the vectors and matrices into their appropriate python representations and use numpy or functions that you write yourself to demonstrate the result or property. " ] }, + { + "cell_type": "code", + "metadata": { + "id": "rD74vXW788a-", + "colab_type": "code", + "colab": {} + }, + "source": [ + "# Import\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import math\n", + "from mpl_toolkits.mplot3d import Axes3D" + ], + "execution_count": 39, + "outputs": [] + }, { "cell_type": "markdown", "metadata": { @@ -54,11 +72,57 @@ "colab": {} }, "source": [ - "" + "blue = [.05, .14]\n", + "green = [.5, .8]\n", + "# these are where the vectors end on the graph" ], - "execution_count": null, + "execution_count": 113, "outputs": [] }, + { + "cell_type": "code", + "metadata": { + "id": "7kO7yTcn7Of9", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 286 + }, + "outputId": "1ead9b98-a457-429d-d5d5-a5883535358d" + }, + "source": [ + "plt.arrow(0, 0, .05, .14, head_width=0.01, head_length=0.05, color=\"blue\")\n", + "plt.arrow(0, 0, .5, .8, head_width=0.01, head_length=0.05, color=\"green\")" + ], + "execution_count": 114, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 114 + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD8CAYAAAB0IB+mAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAdxElEQVR4nO3de5zOdf7/8cfLjPMxDMkxpbBlVVPpm44otMt2YFM6rWiLDlQbtbdO35voIG3xVXROJ2xbWvpJB1valJGKCENiCOMsM4Yxr98f12wmi7lmXNf1uQ7P++3mNtfhfV3Xs3czz/nM5/pc74+5OyIikvwqBB1ARERiQ4UvIpIiVPgiIilChS8ikiJU+CIiKUKFLyKSIkotfDN73sw2mNnCg9xvZvakmWWb2bdmdnLkY4qIyOEKZwv/RaDrIe7vBrQq/jcAGHf4sUREJNJKLXx3/wTYfIghPYGXPWQOUMfMGkUqoIiIREZ6BJ6jMbC6xPWc4tt+2n+gmQ0g9FcA1atXP6V169YReHkRkdQxb968je6eUZ7HRqLww+bu44HxAJmZmZ6VlRXLlxcRSXhm9mN5HxuJo3TWAE1LXG9SfJuIiMSRSBT+VODq4qN1OgDb3P2/dueIiEiwSt2lY2avA+cC9c0sB7gPqAjg7k8D04HuQDaQB1wXrbAiIlJ+pRa+u/cp5X4HBkYskYiIRIU+aSsikiJU+CIiKUKFLyKSIlT4IiIpQoUvIpIiVPgiIilChS8ikiJU+CIiKUKFLyKSIlT4IiIpQoUvIpIiVPgiIilChS8ikiJU+CIiKUKFLyKSIlT4IiIpQoUvIpIiVPgiIilChS8ikiJU+CIiKUKFLyKSIlT4IiIpQoUvIpIiVPgiIilChS8ikiJU+CIiKUKFLyKSIlT4IiIpQoUvUkZTFk1h0sJJQccQKTMVvkiY3J0HZj1A78m9SU9LDzqOSJnpu1YkDAWFBfR9qy9TFk9h4KkDuaTNJUFHEikzFb5IKTbs3MAFr1zAN+u/oV3Ddoy+cHTQkUTKRYUvcggLNyyk08ud2Ji3kZqVavLPPv+kYlrFoGOJlIv24YscxLSl0+jwbAc27NxA5bTKTLpsEk1rNw06lki5qfBF9uPuPPbvx+g1uRc79+ykWsVq3HL6LXRt1TXoaCKHJazCN7OuZrbEzLLNbOgB7m9mZh+b2Xwz+9bMukc+qkj07dm7h2vfvpb7Zt1HfmE+6RXSObHBiQw/f3jQ0UQOW6n78M0sDRgLdAFygLlmNtXdF5UY9ldgkruPM7O2wHSgRRTyikTNtl3buHDihXy7/lvyC/MBqFmpJu9c/g5pFdICTidy+MLZwj8NyHb3Fe6+G3gD6LnfGAdqFV+uDayNXESR2NiwcwNf/fQVuwp3AVA1vSpvX/42DWs0DDiZSGSEc5ROY2B1ies5wOn7jbkfeN/MbgaqA50P9ERmNgAYANCsWbOyZhWJqr2+lz1FewBom9GWfif14+zmZwecSiRyInVYZh/gRXcfZWZnAK+Y2QnuXlRykLuPB8YDZGZmeoReW+SwrdiygjZj2wCQd3ceVStWDTiRSOSFs0tnDVDyWLQmxbeV1A+YBODunwNVgPqRCCgSbTnbczjmyWMA2DFsh8peklY4hT8XaGVmR5tZJeByYOp+Y1YBnQDMrA2hws+NZFCRaFj/83qajg5tz2y9ays1KtUIOJFI9JRa+O5eCAwCZgCLCR2N852ZPWhmPYqH3Q70N7NvgNeBa91du2wkrm3K28SRo44MXf7LJmpXqR1wIpHoCmsfvrtPJ3SoZcnb7i1xeRFwZmSjiUTP1l1bqf9oaK/j+jvWU7dq3YATiUSfPmkrKWdHwQ6OePgIAHIG59CgeoOAE4nEhgpfUkrenjxqjQx9ZOSHW3+gca3GAScSiR0VvqSMgsICqj9UHYAlg5bQok6LYAOJxJgKX1LCnr17qDK8CgDf/vlbjqt3XMCJRGJPhS9Jb2/RXmqPDB2B8+X1X3JiwxMDTiQSDBW+JLUiL6LJ6CbkF+bzybWfcGrjU4OOJBIYFb4kLXenzdg2rPt5He/3fZ+zmp8VdCSRQKnwJSm5Ox2e68DSTUt5q/dbdDmmS9CRRAKnwpekdOHEC/lyzZdMvHgiF7e5OOg4InFBhS9Jp/fk3sxcMZNxF43jynZXBh1HJG6o8CWpDHh3AJMXTebRLo/y58w/Bx1HJK6o8CVp3PH+HUz4agL3nn0vd/zPHUHHEYk7KnxJCg/+60FGfT6K2zrcxgPnPRB0HJG4pMKXhPfEnCe4b9Z9/Kn9nxh94eig44jELRW+JLRnv3qWwTMGc3Hri3mu53NBxxGJayp8SVivL3id/u/25/yjz+fvvf8edByRuKfCl4Q09fupXPHWFZzS6BQ+uOoDzCzoSCJxT4UvCeeDFR/Q882eHFv3WOb2n6uyFwmTCl8SymerPqPLK13IqJbBkkFLVPYiZaDCl4Qxb+08Or7QkcpplVl7+1oqmL59RcpCPzGSEBZuWEjmhEwAtg/bTnqF9IATiSQeFb7EvWWblnHiuNBJS/LvyadSWqWAE4kkJhW+xLUft/7IcWNCpyPcefdOqqRXCTiRSOJS4UvcWrtjLS3+1gKA7UO3U61itWADiSQ4Fb7EpdyduTR+vDEAW+7aQs3KNQNOJJL4VPgSdzbnb6bBYw0AyL0zlzpV6gScSCQ5qPAlrmwv2E69R+oB8NPtP1G/Wv2AE4kkDxW+xI2du3dSe2RtAFbdtoojaxwZcCKR5KLCl7iQvyefGiNqAJB9czZNazcNOJFI8lHhS+B2791NtYdCR+AsumkRx9Q9JuBEIslJhS+BKiwqpOrwqgDMv2E+bTLaBJxIJHmp8CUwe4v2kvFoBkVexOf9Pqf9ke2DjiSS1FT4EogiL6Llky3ZumsrH139ER2adAg6kkjSU+FLzLk77Z9uz6ptq5h2xTTOO/q8oCOJpISwCt/MuprZEjPLNrOhBxnT28wWmdl3ZvZaZGNKsnB3zn7xbBZsWMCkyybRvVX3oCOJpIxS15g1szRgLNAFyAHmmtlUd19UYkwrYBhwprtvMbMG0Qosia3nGz2ZvWo2L/R8gV6/6RV0HJGUEs4W/mlAtruvcPfdwBtAz/3G9AfGuvsWAHffENmYkgyueusq3l36Lk91e4pr218bdByRlBNO4TcGVpe4nlN8W0nHAceZ2WdmNsfMuh7oicxsgJllmVlWbm5u+RJLQho0fRATF0zkofMfYtBpg4KOI5KSIvWmbTrQCjgX6ANMMLP/WvHK3ce7e6a7Z2ZkZETopSXe3f3h3YydO5a7zryLYWcNCzqOSMoKp/DXACU/596k+LaScoCp7r7H3X8AlhL6BSApbuTskYyYPYKbMm9iZOeRQccRSWnhFP5coJWZHW1mlYDLgan7jXmb0NY9Zlaf0C6eFRHMKQlo7JdjGfbhMK488UrGXjQ26DgiKa/Uwnf3QmAQMANYDExy9+/M7EEz61E8bAawycwWAR8Dd7r7pmiFlvj30tcvMei9QXRv1Z2Jl0wMOo6IAObugbxwZmamZ2VlBfLaEl1TFk2h1+RenNn0TD697lPMLOhIIknDzOa5e2Z5HqtP2kpEvbfsPXpN7sUJGSeo7EXijApfIuZfK/9F99e607RWU7658RuVvUicUeFLRHyR8wXnvnQutSvX5odbf6CC6VtLJN7op1IO2zfrvqHDc6HVLnPvzCWtQlrAiUTkQFT4cli+3/g97Z8JrWO/655dVEyrGHAiETkYFb6U24otK2gzNnSGqry786icXjngRCJyKCp8KZec7Tkc82To3LM7hu2gasWqAScSkdKo8KXM1v28jqajQ6ttbL1rKzUq1Qg4kYiEQ4UvZbIxbyONRjUCYNNfNlG7Su2AE4lIuFT4Eratu7aS8WholdP1d6ynbtW6AScSkbJQ4UtYdhTs4IiHjwAgZ3AODarrpGYiiUaFL6XK25NHrZG1AFh560oa19r//DcikghU+HJIBYUFVH+oOgBLBi2heZ3mAScSkfJS4ctB7dm7hyrDqwCw4MYFHFfvuIATicjhUOHLARUWFf6yG2du/7mc0OCEgBOJyOFS4ct/KfIimjzehF2Fu/j0uk/JPKpcS2+LSJxR4cuvuDutx7Rm/c71vN/3fTo26xh0JBGJEBW+/MLdOe3Z01i2eRn/+OM/6HJMl6AjiUgEqfAFCJV9l1e6kLU2i1cveZU/tP5D0JFEJMJU+AJA78m9+fCHDxn/u/FcceIVQccRkShQ4QvXT72eKYunMOqCUfQ/pX/QcUQkSlT4KW7IjCE8N/857j/nfoacMSToOCISRSr8FPbArAcYPWc0gzsM5r5z7ws6johEmQo/RY3+fDT3/+t++p3Uj8cvfDzoOCISAyr8FDRh3gSGvD+ES9tcyrM9ng06jojEiAo/xby24DUG/HMAnY7uxORek4OOIyIxpMJPIe98/w5XvnUlpzQ6hZlXzcTMgo4kIjGkwk8RM5fP5A9v/oFWdVsxt/9clb1IClLhp4DZq2ZzwcQLaFC9Ad8P+l5lL5KiVPhJbt7aeZz1wllUTqvMmiFrqGD6Xy6SqvTTn8QWblhI5oTQ0sY7hu0gvUJ6wIlEJEgq/CS1bNMyThx3IgD59+RTMa1iwIlEJGgq/CS0cutKjhsTOh3hzrt3UiW9SsCJRCQeqPCTzNodazn6b0cDsH3odqpVrBZwIhGJFyr8JLJh5wYaP94YgC13baFm5ZoBJxKReBJW4ZtZVzNbYmbZZjb0EOMuNTM3M50ENcY252+m4WMNAci9M5c6VeoEnEhE4k2phW9macBYoBvQFuhjZm0PMK4mcCvwRaRDyqFt27WNeo/UA+Cn23+ifrX6AScSkXgUzhb+aUC2u69w993AG0DPA4z7X+BhYFcE80kpdu7eSZ2HQ1vzq25bxZE1jgw4kYjEq3AKvzGwusT1nOLbfmFmJwNN3X3aoZ7IzAaYWZaZZeXm5pY5rPxa/p58aoyoAcDyW5bTtHbTgBOJSDw77DdtzawC8Dhwe2lj3X28u2e6e2ZGRsbhvnRKKygsoNpDoSNwFg9cTMsjWgacSETiXTiFvwYouenYpPi2/6gJnADMMrOVQAdgqt64jZ7CokKqDq8KwPwb5tO6fuuAE4lIIgin8OcCrczsaDOrBFwOTP3Pne6+zd3ru3sLd28BzAF6uHtWVBKnuL1Fe6n/SH0cZ06/ObQ/sn3QkUQkQZRa+O5eCAwCZgCLgUnu/p2ZPWhmPaIdUPYp8iJa/K0F2wq28fE1H3N6k9ODjiQiCSSs1bTcfTowfb/b7j3I2HMPP5bsz91p/3R7crbnMP2K6Zzb4tygI4lIgtEnbROAu3PWC2exYMMCJveaTLdW3YKOJCIJSIWfAH7/+u/5bPVnvNjzRS5re1nQcUQkQanw41zft/oybdk0xnQbwzXtrwk6jogkMBV+HLtp2k28uuBVRnQawcDTBgYdR0QSnAo/Tg37YBjjssYx9MyhDO140PXqRETCpsKPQyM+HcHIz0Yy8NSBjOg8Iug4IpIkVPhxZsyXY7j7o7vp264vY7qPCTqOiCQRFX4cefHrF7n5vZu5qNVFvHLxK0HHEZEko8KPE5O/m8x171xHx2YdebfPu0HHEZEkpMKPA9OXTaf3lN60a9COT679BDMLOpKIJCEVfsBmrZzFRa9dRNNaTZn/5/kqexGJGhV+gObkzOG8l86jTuU6/HDrD1Qw/e8QkehRwwTk63Vfc8ZzZ2AYuX/JJa1CWtCRRCTJqfADsDh3MSc9cxIAu/66i/QKYS1aKiJyWFT4MbZ883La/l9bAPLvyadSWqWAE4lIqlDhx9Dqbas59qljAfh52M9USa8ScCIRSSUq/BhZ9/M6mj3RDIBtQ7dRvVL1gBOJSKpR4cfAxryNNBrVCIBNf9lErcq1Ak4kIqlIhR9lW3dtJePRDADW37GeulXrBpxIRFKVCj+KdhTs4IiHjwBgzZA1NKjeIOBEIpLKVPhRkrcnj1ojQ7tuVt66kqNqHhVwIhFJdSr8KNhVuIvqD4XelF06aCnN6zQPOJGIiAo/4nbv3U3V4VUBWHDjAlrVaxVwIhGREBV+BBUWFVJrRGg3Tlb/LE5ocELAiURE9lHhR0iRF3HUqKMo2FvA7Otmc8pRpwQdSUTkV1T4EeDuHD/meHLzcpl51UzObHZm0JFERP6LCv8wuTuZEzLJ3pzN2398m84tOwcdSUTkgFT4h8Hd6fxKZ7766Steu+Q1erbuGXQkEZGDUuEfhssmX8ZHP3zEhN9PoM+JfYKOIyJySCr8cur3Tj/eWvwWoy8czfUnXx90HBGRUqnwy2HwjME8//XzPHDuA9zW4bag44iIhEWFX0b3z7qfJ+Y8we1n3M6959wbdBwRkbCp8Mtg1L9H8cC/HuD6k67nsQseCzqOiEiZqPDD9HTW09wx8w4ua3sZE3pMCDqOiEiZhVX4ZtbVzJaYWbaZDT3A/UPMbJGZfWtmH5pZUq0W9uq3r3LjtBvp0rILk3tNDjqOiEi5lFr4ZpYGjAW6AW2BPmbWdr9h84FMd28HTAEeiXTQoLz9/dv0/UdfTj3qVGb0nRF0HBGRcgtnC/80INvdV7j7buAN4FefMHL3j909r/jqHKBJZGMG4/3l73PxmxdzfL3j+eL6LzCzoCOJiJRbOIXfGFhd4npO8W0H0w9470B3mNkAM8sys6zc3NzwUwbg0x8/5cKJF3JkjSNZNHCRyl5EEl5E37Q1s75AJvDoge539/HununumRkZGZF86YjKWpvF2S+eTdX0qqwevJoKpve2RSTxpYcxZg3QtMT1JsW3/YqZdQbuAc5x94LIxCuboiIoKICqVcv/HAvWL+DUCacCsG3oNtIrhDNFIiLxL5xN17lAKzM72swqAZcDU0sOMLOTgGeAHu6+IfIxw/PII9ClS/kfv3TTUto93Q6AXffsomJaxQglExEJXqmF7+6FwCBgBrAYmOTu35nZg2bWo3jYo0ANYLKZfW1mUw/ydFEzdy7ccw/06FH62ANZuXUlx485HoCdd++kcnrlCKYTEQmeuXsgL5yZmelZWVkRea7t2+H442H9evjpJ2jYsGyPX7N9DU1Ghw4s2j50OzUr14xILhGRSDOzee6eWZ7HJvy7ke5wzTWwbh2cf37Zy37Dzg2/lP2Wu7ao7EUkaSV84b/wArz/PlSvDrfcUrbHbs7fTMPHQr8hNt65kTpV6kQhoYhIfEjowl+yBG6+GfLyIC0NunUL/7Hbdm2j3iP1AFh3+zrqVasXpZQiIvEhYQu/oCD0Bm1+PqSnw3XXQcUwD6r5effP1Hk4tDW/evBqGtYo434gEZEElLCFf+utsHp1aB9+xYpwww3hPS5/Tz41R4T20y+/ZTlNaiXFKhAiIqVKyMJ/9114+eXQ1j1Ay5bQpk3pjysoLKDaQ9UAWDxwMS2PaBnFlCIi8SXhCn/7dujTZ1/Zh/tm7Z69e6gyvAoAX9/wNa3rt45iShGR+JNwhV+jBlx8ceiyWWg5hcsvP/Rj9hbt/eUN2jn95vDbI38b5ZQiIvEn4RaKqVABvv8+dHndulDh16p18PFFXkTzJ5qzY/cOZl0zi9ObnB6boCIicSbhCj87G7KyYMQIaNDg0GPdnXbj2rFmxxqmXzGdc1qcE5uQIiJxKOF26fzmN6Gvd9556HHuTscXOvJd7ndM6TWFbq3KcJC+iEgSSqjCnz0bdu+GKVNCH7Q6lIteu4h/r/43L/3hJS5te2lsAoqIxLGEKXx3OOus0OVLLjn02Cv/fiXvZb/HmO5juPq3V0c/nIhIAkiYwp84MfR17tzQ0TkHc9O0m3ht4WuM7DSSgacOjE04EZEEkBCFv2cPXH011KsHmYdYFPSumXcxLmscd3e8m7s63hW7gCIiCSAhCv+++0Jf5807+JjhnwznkX8/wqBTBzG80/DYBBMRSSBxX/jbt4cOwTz/fGje/MBjnvriKf768V+5qt1VPNX9qdgGFBFJEHFf+FdeGfr6978f+P4X5r/ALf/vFn5/3O95+eKXYxdMRCTBxHXhr1kD//wn3HYb1DnAuUkmfTeJP039E2c3P5t3Ln8n9gFFRBJIXBf+GWeEvj788H/fN23pNP445Y/8tuFvmXXNLOxQh+6IiEj8Fv4334TWu3/mGahU6df3ffzDx/zu9d/RvHZzvrrhK5W9iEgY4rbw27cPfe3f/9e3f776c85/+XzqVKnD8luWU8Hi9j9BRCSuxGVbTpsW+vrBB7/+kNX8n+bzP8//D2mWRu6duaRVKGV9BRER+UXcFX5REfzud6HLnTrtu31x7mJOHn8yAHn35JFeIeEW+hQRCVTcFf6TT4a+Ll6877blm5fT9v/aApB/Tz6V0iod4JEiInIocVX4+fkweHBoCeTWxWcgXL1tNcc+dSwAPw/7mSrpVQJMKCKSuOKq8P9zbtoPPwx9XffzOpo90QyAbUO3Ub1S9YCSiYgkvrgp/E2b4NlnQycob9gQNuZtpNGoRgBs/stmalU+xHkMRUSkVHFT+N2KT0g1YQJsyd9CxqMZAGy4YwNHVD0iwGQiIskhLgo/Ozu0zv3w4VCUvoO6j9QFYM2QNWRUzwg4nYhIcoiLwv/PeWpvHpJHrZGhXTc/3vYjR9U8KsBUIiLJJfDC/+yz0HlqX31zF7UeDr0pu+zmZTSr3SzgZCIiySXQwneHjh2BtN1cubgqAAtvXMixdY8NMpaISFIKtPAnTgQqFJJ+b00A5g2Yx28a/CbISCIiSSuwwneHq68pwu5oRKHvZvZ1szm50clBxRERSXphFb6ZdTWzJWaWbWZDD3B/ZTN7s/j+L8ysRWnPuXYtcHMrvNpGZl41kzObnVnm8CIiEr5SC9/M0oCxQDegLdDHzNruN6wfsMXdjwVGAwc4ZcmvrStcDHVX8M4f36Fzy85lTy4iImUSzhb+aUC2u69w993AG0DP/cb0BF4qvjwF6GSlnZWkYh7Pdn2dHq17lDGyiIiURzhrDDcGVpe4ngOcfrAx7l5oZtuAesDGkoPMbAAwoPhqwfUd+iy8nj7lyZ1s6rPfXKUwzcU+mot9NBf7HF/eB8Z0UXl3Hw+MBzCzLHfPjOXrxyvNxT6ai300F/toLvYxs6zyPjacXTprgKYlrjcpvu2AY8wsHagNbCpvKBERibxwCn8u0MrMjjazSsDlwNT9xkwFrim+fBnwkbt75GKKiMjhKnWXTvE++UHADCANeN7dvzOzB4Esd58KPAe8YmbZwGZCvxRKM/4wcicbzcU+mot9NBf7aC72KfdcmDbERURSQ+CLp4mISGyo8EVEUkTUCz8ayzIkqjDmYoiZLTKzb83sQzNrHkTOWChtLkqMu9TM3MyS9pC8cObCzHoXf298Z2avxTpjrITxM9LMzD42s/nFPyfdg8gZbWb2vJltMLOFB7nfzOzJ4nn61szCW4jM3aP2j9CbvMuBlkAl4Bug7X5jbgKeLr58OfBmNDMF9S/MuTgPqFZ8+cZUnovicTWBT4A5QGbQuQP8vmgFzAeOKL7eIOjcAc7FeODG4sttgZVB547SXJwNnAwsPMj93YH3AAM6AF+E87zR3sKPzrIMianUuXD3j909r/jqHEKfeUhG4XxfAPwvoXWZdsUyXIyFMxf9gbHuvgXA3TfEOGOshDMXDtQqvlwbWBvDfDHj7p8QOuLxYHoCL3vIHKCOmTUq7XmjXfgHWpah8cHGuHsh8J9lGZJNOHNRUj9Cv8GTUalzUfwnalN3nxbLYAEI5/viOOA4M/vMzOaYWdeYpYutcObifqCvmeUA04GbYxMt7pS1T4AYL60g4TGzvkAmcE7QWYJgZhWAx4FrA44SL9IJ7dY5l9BffZ+Y2YnuvjXQVMHoA7zo7qPM7AxCn/85wd2Lgg6WCKK9ha9lGfYJZy4ws87APUAPdy+IUbZYK20uagInALPMbCWhfZRTk/SN23C+L3KAqe6+x91/AJYS+gWQbMKZi37AJAB3/xyoQmhhtVQTVp/sL9qFr2UZ9il1LszsJOAZQmWfrPtpoZS5cPdt7l7f3Vu4ewtC72f0cPdyLxoVx8L5GXmb0NY9Zlaf0C6eFbEMGSPhzMUqoBOAmbUhVPi5MU0ZH6YCVxcfrdMB2ObuP5X2oKju0vHoLcuQcMKci0eBGsDk4vetV7l70p0wIMy5SAlhzsUM4AIzWwTsBe5096T7KzjMubgdmGBmgwm9gXttMm4gmtnrhH7J1y9+v+I+oCKAuz9N6P2L7kA2kAdcF9bzJuFciYjIAeiTtiIiKUKFLyKSIlT4IiIpQoUvIpIiVPgiIilChS8ikiJU+CIiKeL/A+8GjUtEXvpEAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, { "cell_type": "markdown", "metadata": { @@ -74,13 +138,51 @@ "metadata": { "id": "atUEd3T6llKm", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 466 + }, + "outputId": "62b79e90-f944-47c2-c326-fe9b40a73a29" }, "source": [ - "" + "c = [1, 4, 7]\n", + "d = [3, 5.5, 0]\n", + "e = [2, 5, 8]\n", + "\n", + "# one spot in the matrix for each axis\n", + "vectors = np.array([[0, 0, 0, 1, 4, 7],\n", + " [0, 0, 0, 3, 5.5, 0],\n", + " [0, 0, 0, 2, 5, 8]])\n", + "\n", + "X, Y, Z, U, V, W = zip(*vectors)\n", + "fig = plt.figure(figsize=(10, 8))\n", + "ax = fig.add_subplot(111, projection='3d')\n", + "ax.quiver(X, Y, Z, U, V, W, length=1)\n", + "ax.set_xlim(0, 10)\n", + "ax.set_ylim(0, 10)\n", + "ax.set_zlim(0, 10)\n", + "ax.set_xlabel('X Axis')\n", + "ax.set_ylabel('Y Axis')\n", + "ax.set_zlabel('Z Axis')\n", + "ax.set(facecolor=\"pink\")\n", + "plt.show()" ], - "execution_count": null, - "outputs": [] + "execution_count": 99, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] }, { "cell_type": "markdown", @@ -99,16 +201,16 @@ "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 52 + "height": 51 }, - "outputId": "b1ccb836-02b8-4d42-a7db-6c34f010f6c6" + "outputId": "4dcd365c-89de-418e-c598-04620b5f24a7" }, "source": [ "from math import e, pi\n", "print(e)\n", "print(pi)" ], - "execution_count": null, + "execution_count": 10, "outputs": [ { "output_type": "stream", @@ -125,13 +227,94 @@ "metadata": { "id": "3qpwDlzXkVf5", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 281 + }, + "outputId": "2dafd416-8aee-41be-b729-16c0359fee6a" }, "source": [ - "" + "# Scaling 'blue' by 5, π and -e\n", + "blue = [.05, .14]\n", + "\n", + "# multiply by scalar\n", + "\n", + "yellow = np.multiply(5, blue)\n", + "pink = np.multiply(math.pi, blue)\n", + "orange = np.multiply(-0.05, blue)\n", + "\n", + "# plot scaled vectors\n", + "plt.arrow(0, 0, blue[0], blue[1], head_width=0.02, head_length=0.05, color=\"blue\")\n", + "plt.arrow(0, 0, yellow[0], yellow[1], head_width=0.02, head_length=0.05, color=\"yellow\")\n", + "plt.arrow(0, 0, pink[0], pink[1], head_width=0.02, head_length=0.05, color=\"pink\")\n", + "plt.arrow(0, 0, orange[0], orange[1], head_width=0.02, head_length=0.05, color=\"orange\")\n", + "plt.xlim(-0.5, 1)\n", + "plt.ylim(-0.5, 1)\n", + "plt.title(\"Scaling 'blue' by 5, π and -e\")\n", + "plt.show()" ], - "execution_count": null, - "outputs": [] + "execution_count": 117, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "QaphJRhYVOhL", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 281 + }, + "outputId": "702bf405-6eea-4380-b7f7-c8cccedae880" + }, + "source": [ + "# Scaling 'green' by 5, π and -e\n", + "green = [.5, .8]\n", + "\n", + "teal = np.multiply(5, green) \n", + "grey = np.multiply(math.pi, green) \n", + "navy = np.multiply(-0.5, green) \n", + "\n", + "plt.arrow(0, 0, green[0], green[1], head_width=0.02, head_length=0.05, color=\"green\")\n", + "plt.arrow(0, 0, teal[0], teal[1], head_width=0.02, head_length=0.05, color=\"#48c9b0\")\n", + "plt.arrow(0, 0, grey[0], grey[1], head_width=0.02, head_length=0.05, color=\"#bdbdbd\")\n", + "plt.arrow(0, 0, navy[0], navy[1], head_width=0.02, head_length=0.05, color=\"#34495e\")\n", + "plt.xlim(-1, 1)\n", + "plt.ylim(-1, 1)\n", + "plt.title(\"Scaling 'green' by 5, π and -e\")\n", + "plt.show()\n", + "\n" + ], + "execution_count": 125, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] }, { "cell_type": "markdown", @@ -154,13 +337,38 @@ "metadata": { "id": "I1BGXA_skV-b", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 281 + }, + "outputId": "1f731f88-53f6-48f4-d7a8-bc8ba72c6c75" }, "source": [ - "" + "a = np.array([5, 7])\n", + "b = np.array([3, 4])\n", + "\n", + "a_line = plt.arrow(0, 0, 5, 7, head_width=.02, head_length=.5, color=\"pink\")\n", + "b_line = plt.arrow(0, 0, 3, 4, head_width=.02, head_length=.5, color=\"purple\")\n", + "plt.title(\"Graphing Vectors A and B\")\n", + "plt.legend([a_line, b_line], ['Vector A', 'Vector B'])\n", + "plt.show()" ], - "execution_count": null, - "outputs": [] + "execution_count": 147, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] }, { "cell_type": "markdown", @@ -177,13 +385,66 @@ "metadata": { "id": "68sWHIOPkXp5", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "425e88ef-606c-4869-944f-1b17720b17fa" }, "source": [ - "" + " a-b" ], - "execution_count": null, - "outputs": [] + "execution_count": 146, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([2, 3])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 146 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "KoFcl5lVi3k2", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 281 + }, + "outputId": "6844e2b0-7014-484b-87d5-92573127b4a2" + }, + "source": [ + "ab_line = plt.arrow(0, 0, 2, 3, head_width=.02, head_length=.5, color=\"#ec407a\")\n", + "a_line = plt.arrow(0, 0, 5, 7, head_width=.02, head_length=.5, color=\"pink\")\n", + "b_line = plt.arrow(0, 0, 3, 4, head_width=.02, head_length=.5, color=\"purple\")\n", + "plt.title(\"Plotting Vectors A, B and AB\")\n", + "plt.legend([a_line, b_line, ab_line], ['Vector A', 'Vector B', 'Vector AB'])\n", + "plt.show()" + ], + "execution_count": 148, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] }, { "cell_type": "markdown", @@ -206,14 +467,89 @@ "metadata": { "id": "2_cZQFCskYNr", "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 51 + }, + "outputId": "2715d528-5d2c-42c3-e9fa-ee82e2d5e176" + }, + "source": [ + "# dot product -- not multiplication!!\n", + "# need to use np.array() for this to work\n", + "\n", + "c = np.array([7, 22, 4, 16])\n", + "d = np.array([12, 6, 2, 9])\n", + "\n", + "print((c*d).sum())\n", + "np.sqrt((c*d).sum())" + ], + "execution_count": 155, + "outputs": [ + { + "output_type": "stream", + "text": [ + "368\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "19.183326093250876" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 155 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "awNwUbJBkwdB", + "colab_type": "code", "colab": {} }, "source": [ - "" + "c ⋅ d = 19.18" ], "execution_count": null, "outputs": [] }, + { + "cell_type": "code", + "metadata": { + "id": "WG2hxeMVqfdt", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "76f34266-80b8-4e3f-a38e-46dde3d0d7b1" + }, + "source": [ + "# other way to find dot product\n", + "np.vdot(c,d)" + ], + "execution_count": 170, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "368" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 170 + } + ] + }, { "cell_type": "markdown", "metadata": { @@ -235,10 +571,44 @@ "metadata": { "id": "ku-TdCKAkYs8", "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "93d47231-2abd-4e9c-b22a-7412b6306dc3" + }, + "source": [ + "# cross product -- not multiplication!!\n", + "\n", + "e = np.array([5, \n", + " 7, \n", + " 2])\n", + "f = np.array([3,\n", + " 4,\n", + " 6])\n", + "\n", + "print(np.cross(e,f))" + ], + "execution_count": 158, + "outputs": [ + { + "output_type": "stream", + "text": [ + "[ 34 -24 -1]\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "b1rgNwZSmTHs", + "colab_type": "code", "colab": {} }, "source": [ - "" + "# e × f = [34, -24, -1]" ], "execution_count": null, "outputs": [] @@ -264,13 +634,91 @@ "metadata": { "id": "-5VKOMKBlgaA", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 51 + }, + "outputId": "2f347a57-742c-4b99-be3f-07216cd873b3" }, "source": [ - "" + "# find the norm of g \n", + "g = np.array([1,\n", + " 1,\n", + " 1,\n", + " 8])\n", + "\n", + "print(np.sqrt((g**2).sum()))\n", + "np.linalg.norm(g)\n", + "\n", + "\n" ], - "execution_count": null, - "outputs": [] + "execution_count": 180, + "outputs": [ + { + "output_type": "stream", + "text": [ + "8.18535277187245\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "8.18535277187245" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 180 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "IlCuVlnjnMLO", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 51 + }, + "outputId": "a17bfdbd-c38a-4b60-c357-5bc3ab509050" + }, + "source": [ + "# Find the norm of h\n", + "\n", + "h = np.array([3,\n", + " 3,\n", + " 3,\n", + " 3])\n", + "\n", + "print(np.sqrt((h**2).sum()))\n", + "np.linalg.norm(h)" + ], + "execution_count": 185, + "outputs": [ + { + "output_type": "stream", + "text": [ + "6.0\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "6.0" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 185 + } + ] }, { "cell_type": "markdown", @@ -324,10 +772,153 @@ "metadata": { "id": "Z69c-uPtnbIx", "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "2859cdca-53c2-4e4c-e246-8db538af4d0b" + }, + "source": [ + "A = np.array([[1, 2],\n", + " [3, 4],\n", + " [5, 6]])\n", + " \n", + "print(\"Dimensions: (3, 2)\")" + ], + "execution_count": 209, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Dimensions: (3, 2)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "PDoTP26t5xPg", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "9b3c1122-db86-4319-b735-a4838ddc5048" + }, + "source": [ + "B = np.array([2, 4, 6])\n", + "\n", + "print(\"Dimensions: (1, 3)\")" + ], + "execution_count": 208, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Dimensions: (1, 3)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "EKlZ1q0M5zl6", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "b2542aec-2b97-4b70-b2bf-6b13b9ec5093" + }, + "source": [ + "C = np.array([[9, 6, 3],\n", + " [4, 7, 11]])\n", + "\n", + "print(\"Dimensions: (2, 3)\")" + ], + "execution_count": 207, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Dimensions: (2, 3)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uZ_RvT6e50St", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "11e7a4d1-520f-4f84-b6d3-5be887a118cd" + }, + "source": [ + "# Matrix D is an identity matrix\n", + "D = np.array([[1, 0, 0],\n", + " [0, 1, 0],\n", + " [0, 0, 1]])\n", + "\n", + "print(\"Dimensions: (3,3)\")" + ], + "execution_count": 206, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Dimensions: (3,3)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "KxggKNY454DB", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "158fbdea-5726-43a6-a01d-bf78393e0843" + }, + "source": [ + "E = np.array([[1, 3],\n", + " [5, 7]])\n", + "\n", + "print(\"Dimensions: (2,2)\")" + ], + "execution_count": 203, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Dimensions: (2,2)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "p_w-5_UG6Qcm", + "colab_type": "code", "colab": {} }, "source": [ - "" + "# Matricies that can be multiplied together:\n", + "# A and C" ], "execution_count": null, "outputs": [] @@ -345,16 +936,105 @@ { "cell_type": "code", "metadata": { - "id": "zhKwiSItoE2F", + "id": "KV6zp9xj7KXB", "colab_type": "code", "colab": {} }, "source": [ - "" + "# In each combination, the matricies do not have the same dimensions, so it's an illegal multiplication" ], "execution_count": null, "outputs": [] }, + { + "cell_type": "code", + "metadata": { + "id": "zhKwiSItoE2F", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 163 + }, + "outputId": "ec85bddd-52a6-494c-941e-1dbef738035a" + }, + "source": [ + "(C*D)" + ], + "execution_count": 192, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m(\u001b[0m\u001b[0mC\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mD\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (2,3) (3,3) " + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "hIZV6RZY7HsQ", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 163 + }, + "outputId": "d85992e0-7041-486c-c1eb-2c4aaca0e4a8" + }, + "source": [ + "(A*E)" + ], + "execution_count": 194, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mE\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (3,2) (2,2) " + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "hLXT_2lM6-oB", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 316 + }, + "outputId": "5f4349fe-175e-4469-ba71-fdf587f279d3" + }, + "source": [ + "np.cross(A,E)" + ], + "execution_count": 193, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcross\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mE\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mcross\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/numpy/core/numeric.py\u001b[0m in \u001b[0;36mcross\u001b[0;34m(a, b, axisa, axisb, axisc, axis)\u001b[0m\n\u001b[1;32m 1550\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1551\u001b[0m \u001b[0;31m# Create the output array\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1552\u001b[0;31m \u001b[0mshape\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbroadcast\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m...\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m...\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1553\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m3\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1554\u001b[0m \u001b[0mshape\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: shape mismatch: objects cannot be broadcast to a single shape" + ] + } + ] + }, { "cell_type": "markdown", "metadata": { @@ -381,13 +1061,39 @@ "metadata": { "id": "Wl3ElwgLqaAn", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 119 + }, + "outputId": "5537cb86-97f7-427f-cdb6-767b93c35068" }, "source": [ - "" + "# In the transposed matrix, the numbers continue to run along the main diagonal.\n", + "F = np.array([[20, 19, 18, 17],\n", + " [16, 15, 14, 13],\n", + " [12, 11, 10, 9],\n", + " [8, 7, 6, 5],\n", + " [4, 3, 2, 1]])\n", + "\n", + "print(\"Dimensions F: (5,4)\")\n", + "print(\"Dimensions F.T: (4,5)\")\n", + "print(F.T)" ], - "execution_count": null, - "outputs": [] + "execution_count": 210, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Dimensions F: (5,4)\n", + "Dimensions F.T: (4,5)\n", + "[[20 16 12 8 4]\n", + " [19 15 11 7 3]\n", + " [18 14 10 6 2]\n", + " [17 13 9 5 1]]\n" + ], + "name": "stdout" + } + ] }, { "cell_type": "markdown", @@ -424,13 +1130,68 @@ "metadata": { "id": "ZnqvZBOYqar3", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 51 + }, + "outputId": "0c340371-3ca6-468b-f400-cefd666f49ee" }, "source": [ - "" + "# Inversing Matrix G\n", + "G = np.array([[13, 14],\n", + " [21, 12]])\n", + "\n", + "IG = np.linalg.inv(G)\n", + "IG" ], - "execution_count": null, - "outputs": [] + "execution_count": 222, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[-0.08695652, 0.10144928],\n", + " [ 0.15217391, -0.0942029 ]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 222 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "zP5SgrBy9SJC", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 51 + }, + "outputId": "9fec28d5-234b-48d0-96cc-6971dbffd054" + }, + "source": [ + "# Mutliplying Matrices G and IG\n", + "G*IG" + ], + "execution_count": 223, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[-1.13043478, 1.42028986],\n", + " [ 3.19565217, -1.13043478]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 223 + } + ] }, { "cell_type": "markdown", @@ -462,13 +1223,76 @@ "metadata": { "id": "5QShhoXyrjDS", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "b17b7417-f005-4649-a45a-25ee1ecc7e14" }, "source": [ - "" + "# Finding the determinant of H\n", + "# determinant for a (2,2) = ad - bc\n", + "\n", + "H = np.array([[12, 11],\n", + " [7, 10]])\n", + "\n", + "H_det = np.linalg.det(H)\n", + "H_det" ], - "execution_count": null, - "outputs": [] + "execution_count": 240, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "43.000000000000014" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 240 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "mDkPdlHxA1cy", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "04ebaffc-57dd-4606-a649-31e96951f070" + }, + "source": [ + "# Finding the determinant of J\n", + "# determinant for a (3,3) = aei +\n", + "# will need to break this matrix up into sub-matrices\n", + "\n", + "J = np.array([[0, 1, 2],\n", + " [7, 10, 4],\n", + " [3, 2, 0]])\n", + "\n", + "J_det = np.linalg.det(J)\n", + "J_det" + ], + "execution_count": 241, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "-19.999999999999996" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 241 + } + ] }, { "cell_type": "markdown", @@ -485,13 +1309,32 @@ "metadata": { "id": "nyX6De2-rio1", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 102 + }, + "outputId": "3eb013a6-0ed1-4c0a-bf81-d63e07c2926b" }, "source": [ - "" + "IH = np.linalg.inv(H)\n", + "print(IH)\n", + "IJ = np.linalg.inv(J)\n", + "print(IJ)" ], - "execution_count": null, - "outputs": [] + "execution_count": 243, + "outputs": [ + { + "output_type": "stream", + "text": [ + "[[ 0.23255814 -0.25581395]\n", + " [-0.1627907 0.27906977]]\n", + "[[ 0.4 -0.2 0.8 ]\n", + " [-0.6 0.3 -0.7 ]\n", + " [ 0.8 -0.15 0.35]]\n" + ], + "name": "stdout" + } + ] }, { "cell_type": "markdown", @@ -505,6 +1348,84 @@ "Please ignore Python rounding errors. If necessary, format your output so that it rounds to 5 significant digits (the fifth decimal place)." ] }, + { + "cell_type": "code", + "metadata": { + "id": "kYU4BIY9CXz6", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 51 + }, + "outputId": "311b20ee-951a-4f8f-c6cb-707b0f56d873" + }, + "source": [ + "IHH = (IH*H)\n", + "IHH" + ], + "execution_count": 245, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 2.79069767, -2.81395349],\n", + " [-1.13953488, 2.79069767]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 245 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tGYIsPUjWOZ1", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 68 + }, + "outputId": "fabc7dcf-31a0-4352-d8e5-acaff2079bca" + }, + "source": [ + "IJJ = (IJ*J)\n", + "IJJ" + ], + "execution_count": 247, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 0. , -0.2, 1.6],\n", + " [-4.2, 3. , -2.8],\n", + " [ 2.4, -0.3, 0. ]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 247 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "nKJIFIBvW-UN", + "colab_type": "code", + "colab": {} + }, + "source": [ + "# Not equal to each other because the dimensions are not equal" + ], + "execution_count": null, + "outputs": [] + }, { "cell_type": "markdown", "metadata": { From 040c75b6c3b0566bafad94bf1f491de560886f26 Mon Sep 17 00:00:00 2001 From: rdukewiesenb <68960154+rdukewiesenb@users.noreply.github.com> Date: Mon, 17 Aug 2020 22:30:18 -0400 Subject: [PATCH 3/3] Created using Colaboratory --- ..._131_Vectors_and_Matrices_Assignment.ipynb | 1038 ++++++++++++++++- 1 file changed, 985 insertions(+), 53 deletions(-) diff --git a/module1-vectors-and-matrices/LS_DS_131_Vectors_and_Matrices_Assignment.ipynb b/module1-vectors-and-matrices/LS_DS_131_Vectors_and_Matrices_Assignment.ipynb index 87fc432d..fd0cdd24 100644 --- a/module1-vectors-and-matrices/LS_DS_131_Vectors_and_Matrices_Assignment.ipynb +++ b/module1-vectors-and-matrices/LS_DS_131_Vectors_and_Matrices_Assignment.ipynb @@ -3,9 +3,10 @@ "nbformat_minor": 0, "metadata": { "colab": { - "name": "LS_DS_131_Vectors_and_Matrices_Assignment.ipynb", + "name": "Copy of LS_DS_131_Vectors_and_Matrices_Assignment.ipynb", "provenance": [], - "collapsed_sections": [] + "collapsed_sections": [], + "include_colab_link": true }, "kernelspec": { "name": "python3", @@ -13,6 +14,16 @@ } }, "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, { "cell_type": "markdown", "metadata": { @@ -25,6 +36,24 @@ "For the questions below it is not sufficient to simply provide answer to the questions, but you must solve the problems and show your work using python (the NumPy library will help a lot!) Translate the vectors and matrices into their appropriate python representations and use numpy or functions that you write yourself to demonstrate the result or property. " ] }, + { + "cell_type": "code", + "metadata": { + "id": "rD74vXW788a-", + "colab_type": "code", + "colab": {} + }, + "source": [ + "# Import\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import math\n", + "from mpl_toolkits.mplot3d import Axes3D" + ], + "execution_count": 39, + "outputs": [] + }, { "cell_type": "markdown", "metadata": { @@ -43,11 +72,57 @@ "colab": {} }, "source": [ - "" + "blue = [.05, .14]\n", + "green = [.5, .8]\n", + "# these are where the vectors end on the graph" ], - "execution_count": 0, + "execution_count": 113, "outputs": [] }, + { + "cell_type": "code", + "metadata": { + "id": "7kO7yTcn7Of9", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 286 + }, + "outputId": "1ead9b98-a457-429d-d5d5-a5883535358d" + }, + "source": [ + "plt.arrow(0, 0, .05, .14, head_width=0.01, head_length=0.05, color=\"blue\")\n", + "plt.arrow(0, 0, .5, .8, head_width=0.01, head_length=0.05, color=\"green\")" + ], + "execution_count": 114, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 114 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, { "cell_type": "markdown", "metadata": { @@ -63,13 +138,51 @@ "metadata": { "id": "atUEd3T6llKm", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 466 + }, + "outputId": "62b79e90-f944-47c2-c326-fe9b40a73a29" }, "source": [ - "" + "c = [1, 4, 7]\n", + "d = [3, 5.5, 0]\n", + "e = [2, 5, 8]\n", + "\n", + "# one spot in the matrix for each axis\n", + "vectors = np.array([[0, 0, 0, 1, 4, 7],\n", + " [0, 0, 0, 3, 5.5, 0],\n", + " [0, 0, 0, 2, 5, 8]])\n", + "\n", + "X, Y, Z, U, V, W = zip(*vectors)\n", + "fig = plt.figure(figsize=(10, 8))\n", + "ax = fig.add_subplot(111, projection='3d')\n", + "ax.quiver(X, Y, Z, U, V, W, length=1)\n", + "ax.set_xlim(0, 10)\n", + "ax.set_ylim(0, 10)\n", + "ax.set_zlim(0, 10)\n", + "ax.set_xlabel('X Axis')\n", + "ax.set_ylabel('Y Axis')\n", + "ax.set_zlabel('Z Axis')\n", + "ax.set(facecolor=\"pink\")\n", + "plt.show()" ], - "execution_count": 0, - "outputs": [] + "execution_count": 99, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] }, { "cell_type": "markdown", @@ -86,18 +199,18 @@ "metadata": { "id": "ah6zMSLJdJwL", "colab_type": "code", - "outputId": "b1ccb836-02b8-4d42-a7db-6c34f010f6c6", "colab": { "base_uri": "https://localhost:8080/", - "height": 52 - } + "height": 51 + }, + "outputId": "4dcd365c-89de-418e-c598-04620b5f24a7" }, "source": [ "from math import e, pi\n", "print(e)\n", "print(pi)" ], - "execution_count": 0, + "execution_count": 10, "outputs": [ { "output_type": "stream", @@ -114,13 +227,94 @@ "metadata": { "id": "3qpwDlzXkVf5", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 281 + }, + "outputId": "2dafd416-8aee-41be-b729-16c0359fee6a" }, "source": [ - "" + "# Scaling 'blue' by 5, π and -e\n", + "blue = [.05, .14]\n", + "\n", + "# multiply by scalar\n", + "\n", + "yellow = np.multiply(5, blue)\n", + "pink = np.multiply(math.pi, blue)\n", + "orange = np.multiply(-0.05, blue)\n", + "\n", + "# plot scaled vectors\n", + "plt.arrow(0, 0, blue[0], blue[1], head_width=0.02, head_length=0.05, color=\"blue\")\n", + "plt.arrow(0, 0, yellow[0], yellow[1], head_width=0.02, head_length=0.05, color=\"yellow\")\n", + "plt.arrow(0, 0, pink[0], pink[1], head_width=0.02, head_length=0.05, color=\"pink\")\n", + "plt.arrow(0, 0, orange[0], orange[1], head_width=0.02, head_length=0.05, color=\"orange\")\n", + "plt.xlim(-0.5, 1)\n", + "plt.ylim(-0.5, 1)\n", + "plt.title(\"Scaling 'blue' by 5, π and -e\")\n", + "plt.show()" ], - "execution_count": 0, - "outputs": [] + "execution_count": 117, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "QaphJRhYVOhL", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 281 + }, + "outputId": "702bf405-6eea-4380-b7f7-c8cccedae880" + }, + "source": [ + "# Scaling 'green' by 5, π and -e\n", + "green = [.5, .8]\n", + "\n", + "teal = np.multiply(5, green) \n", + "grey = np.multiply(math.pi, green) \n", + "navy = np.multiply(-0.5, green) \n", + "\n", + "plt.arrow(0, 0, green[0], green[1], head_width=0.02, head_length=0.05, color=\"green\")\n", + "plt.arrow(0, 0, teal[0], teal[1], head_width=0.02, head_length=0.05, color=\"#48c9b0\")\n", + "plt.arrow(0, 0, grey[0], grey[1], head_width=0.02, head_length=0.05, color=\"#bdbdbd\")\n", + "plt.arrow(0, 0, navy[0], navy[1], head_width=0.02, head_length=0.05, color=\"#34495e\")\n", + "plt.xlim(-1, 1)\n", + "plt.ylim(-1, 1)\n", + "plt.title(\"Scaling 'green' by 5, π and -e\")\n", + "plt.show()\n", + "\n" + ], + "execution_count": 125, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] }, { "cell_type": "markdown", @@ -143,13 +337,38 @@ "metadata": { "id": "I1BGXA_skV-b", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 281 + }, + "outputId": "1f731f88-53f6-48f4-d7a8-bc8ba72c6c75" }, "source": [ - "" + "a = np.array([5, 7])\n", + "b = np.array([3, 4])\n", + "\n", + "a_line = plt.arrow(0, 0, 5, 7, head_width=.02, head_length=.5, color=\"pink\")\n", + "b_line = plt.arrow(0, 0, 3, 4, head_width=.02, head_length=.5, color=\"purple\")\n", + "plt.title(\"Graphing Vectors A and B\")\n", + "plt.legend([a_line, b_line], ['Vector A', 'Vector B'])\n", + "plt.show()" ], - "execution_count": 0, - "outputs": [] + "execution_count": 147, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] }, { "cell_type": "markdown", @@ -166,13 +385,66 @@ "metadata": { "id": "68sWHIOPkXp5", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "425e88ef-606c-4869-944f-1b17720b17fa" }, "source": [ - "" + " a-b" ], - "execution_count": 0, - "outputs": [] + "execution_count": 146, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([2, 3])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 146 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "KoFcl5lVi3k2", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 281 + }, + "outputId": "6844e2b0-7014-484b-87d5-92573127b4a2" + }, + "source": [ + "ab_line = plt.arrow(0, 0, 2, 3, head_width=.02, head_length=.5, color=\"#ec407a\")\n", + "a_line = plt.arrow(0, 0, 5, 7, head_width=.02, head_length=.5, color=\"pink\")\n", + "b_line = plt.arrow(0, 0, 3, 4, head_width=.02, head_length=.5, color=\"purple\")\n", + "plt.title(\"Plotting Vectors A, B and AB\")\n", + "plt.legend([a_line, b_line, ab_line], ['Vector A', 'Vector B', 'Vector AB'])\n", + "plt.show()" + ], + "execution_count": 148, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] }, { "cell_type": "markdown", @@ -195,14 +467,89 @@ "metadata": { "id": "2_cZQFCskYNr", "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 51 + }, + "outputId": "2715d528-5d2c-42c3-e9fa-ee82e2d5e176" + }, + "source": [ + "# dot product -- not multiplication!!\n", + "# need to use np.array() for this to work\n", + "\n", + "c = np.array([7, 22, 4, 16])\n", + "d = np.array([12, 6, 2, 9])\n", + "\n", + "print((c*d).sum())\n", + "np.sqrt((c*d).sum())" + ], + "execution_count": 155, + "outputs": [ + { + "output_type": "stream", + "text": [ + "368\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "19.183326093250876" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 155 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "awNwUbJBkwdB", + "colab_type": "code", "colab": {} }, "source": [ - "" + "c ⋅ d = 19.18" ], - "execution_count": 0, + "execution_count": null, "outputs": [] }, + { + "cell_type": "code", + "metadata": { + "id": "WG2hxeMVqfdt", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "76f34266-80b8-4e3f-a38e-46dde3d0d7b1" + }, + "source": [ + "# other way to find dot product\n", + "np.vdot(c,d)" + ], + "execution_count": 170, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "368" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 170 + } + ] + }, { "cell_type": "markdown", "metadata": { @@ -224,12 +571,46 @@ "metadata": { "id": "ku-TdCKAkYs8", "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "93d47231-2abd-4e9c-b22a-7412b6306dc3" + }, + "source": [ + "# cross product -- not multiplication!!\n", + "\n", + "e = np.array([5, \n", + " 7, \n", + " 2])\n", + "f = np.array([3,\n", + " 4,\n", + " 6])\n", + "\n", + "print(np.cross(e,f))" + ], + "execution_count": 158, + "outputs": [ + { + "output_type": "stream", + "text": [ + "[ 34 -24 -1]\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "b1rgNwZSmTHs", + "colab_type": "code", "colab": {} }, "source": [ - "" + "# e × f = [34, -24, -1]" ], - "execution_count": 0, + "execution_count": null, "outputs": [] }, { @@ -253,13 +634,91 @@ "metadata": { "id": "-5VKOMKBlgaA", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 51 + }, + "outputId": "2f347a57-742c-4b99-be3f-07216cd873b3" }, "source": [ - "" + "# find the norm of g \n", + "g = np.array([1,\n", + " 1,\n", + " 1,\n", + " 8])\n", + "\n", + "print(np.sqrt((g**2).sum()))\n", + "np.linalg.norm(g)\n", + "\n", + "\n" ], - "execution_count": 0, - "outputs": [] + "execution_count": 180, + "outputs": [ + { + "output_type": "stream", + "text": [ + "8.18535277187245\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "8.18535277187245" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 180 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "IlCuVlnjnMLO", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 51 + }, + "outputId": "a17bfdbd-c38a-4b60-c357-5bc3ab509050" + }, + "source": [ + "# Find the norm of h\n", + "\n", + "h = np.array([3,\n", + " 3,\n", + " 3,\n", + " 3])\n", + "\n", + "print(np.sqrt((h**2).sum()))\n", + "np.linalg.norm(h)" + ], + "execution_count": 185, + "outputs": [ + { + "output_type": "stream", + "text": [ + "6.0\n" + ], + "name": "stdout" + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "6.0" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 185 + } + ] }, { "cell_type": "markdown", @@ -313,12 +772,155 @@ "metadata": { "id": "Z69c-uPtnbIx", "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "2859cdca-53c2-4e4c-e246-8db538af4d0b" + }, + "source": [ + "A = np.array([[1, 2],\n", + " [3, 4],\n", + " [5, 6]])\n", + " \n", + "print(\"Dimensions: (3, 2)\")" + ], + "execution_count": 209, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Dimensions: (3, 2)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "PDoTP26t5xPg", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "9b3c1122-db86-4319-b735-a4838ddc5048" + }, + "source": [ + "B = np.array([2, 4, 6])\n", + "\n", + "print(\"Dimensions: (1, 3)\")" + ], + "execution_count": 208, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Dimensions: (1, 3)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "EKlZ1q0M5zl6", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "b2542aec-2b97-4b70-b2bf-6b13b9ec5093" + }, + "source": [ + "C = np.array([[9, 6, 3],\n", + " [4, 7, 11]])\n", + "\n", + "print(\"Dimensions: (2, 3)\")" + ], + "execution_count": 207, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Dimensions: (2, 3)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uZ_RvT6e50St", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "11e7a4d1-520f-4f84-b6d3-5be887a118cd" + }, + "source": [ + "# Matrix D is an identity matrix\n", + "D = np.array([[1, 0, 0],\n", + " [0, 1, 0],\n", + " [0, 0, 1]])\n", + "\n", + "print(\"Dimensions: (3,3)\")" + ], + "execution_count": 206, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Dimensions: (3,3)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "KxggKNY454DB", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "158fbdea-5726-43a6-a01d-bf78393e0843" + }, + "source": [ + "E = np.array([[1, 3],\n", + " [5, 7]])\n", + "\n", + "print(\"Dimensions: (2,2)\")" + ], + "execution_count": 203, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Dimensions: (2,2)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "p_w-5_UG6Qcm", + "colab_type": "code", "colab": {} }, "source": [ - "" + "# Matricies that can be multiplied together:\n", + "# A and C" ], - "execution_count": 0, + "execution_count": null, "outputs": [] }, { @@ -334,16 +936,105 @@ { "cell_type": "code", "metadata": { - "id": "zhKwiSItoE2F", + "id": "KV6zp9xj7KXB", "colab_type": "code", "colab": {} }, "source": [ - "" + "# In each combination, the matricies do not have the same dimensions, so it's an illegal multiplication" ], - "execution_count": 0, + "execution_count": null, "outputs": [] }, + { + "cell_type": "code", + "metadata": { + "id": "zhKwiSItoE2F", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 163 + }, + "outputId": "ec85bddd-52a6-494c-941e-1dbef738035a" + }, + "source": [ + "(C*D)" + ], + "execution_count": 192, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m(\u001b[0m\u001b[0mC\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mD\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (2,3) (3,3) " + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "hIZV6RZY7HsQ", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 163 + }, + "outputId": "d85992e0-7041-486c-c1eb-2c4aaca0e4a8" + }, + "source": [ + "(A*E)" + ], + "execution_count": 194, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mE\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (3,2) (2,2) " + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "hLXT_2lM6-oB", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 316 + }, + "outputId": "5f4349fe-175e-4469-ba71-fdf587f279d3" + }, + "source": [ + "np.cross(A,E)" + ], + "execution_count": 193, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcross\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mE\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mcross\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/numpy/core/numeric.py\u001b[0m in \u001b[0;36mcross\u001b[0;34m(a, b, axisa, axisb, axisc, axis)\u001b[0m\n\u001b[1;32m 1550\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1551\u001b[0m \u001b[0;31m# Create the output array\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1552\u001b[0;31m \u001b[0mshape\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbroadcast\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m...\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m...\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1553\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m3\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1554\u001b[0m \u001b[0mshape\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: shape mismatch: objects cannot be broadcast to a single shape" + ] + } + ] + }, { "cell_type": "markdown", "metadata": { @@ -370,13 +1061,39 @@ "metadata": { "id": "Wl3ElwgLqaAn", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 119 + }, + "outputId": "5537cb86-97f7-427f-cdb6-767b93c35068" }, "source": [ - "" + "# In the transposed matrix, the numbers continue to run along the main diagonal.\n", + "F = np.array([[20, 19, 18, 17],\n", + " [16, 15, 14, 13],\n", + " [12, 11, 10, 9],\n", + " [8, 7, 6, 5],\n", + " [4, 3, 2, 1]])\n", + "\n", + "print(\"Dimensions F: (5,4)\")\n", + "print(\"Dimensions F.T: (4,5)\")\n", + "print(F.T)" ], - "execution_count": 0, - "outputs": [] + "execution_count": 210, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Dimensions F: (5,4)\n", + "Dimensions F.T: (4,5)\n", + "[[20 16 12 8 4]\n", + " [19 15 11 7 3]\n", + " [18 14 10 6 2]\n", + " [17 13 9 5 1]]\n" + ], + "name": "stdout" + } + ] }, { "cell_type": "markdown", @@ -413,13 +1130,68 @@ "metadata": { "id": "ZnqvZBOYqar3", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 51 + }, + "outputId": "0c340371-3ca6-468b-f400-cefd666f49ee" }, "source": [ - "" + "# Inversing Matrix G\n", + "G = np.array([[13, 14],\n", + " [21, 12]])\n", + "\n", + "IG = np.linalg.inv(G)\n", + "IG" ], - "execution_count": 0, - "outputs": [] + "execution_count": 222, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[-0.08695652, 0.10144928],\n", + " [ 0.15217391, -0.0942029 ]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 222 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "zP5SgrBy9SJC", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 51 + }, + "outputId": "9fec28d5-234b-48d0-96cc-6971dbffd054" + }, + "source": [ + "# Mutliplying Matrices G and IG\n", + "G*IG" + ], + "execution_count": 223, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[-1.13043478, 1.42028986],\n", + " [ 3.19565217, -1.13043478]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 223 + } + ] }, { "cell_type": "markdown", @@ -451,13 +1223,76 @@ "metadata": { "id": "5QShhoXyrjDS", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "b17b7417-f005-4649-a45a-25ee1ecc7e14" }, "source": [ - "" + "# Finding the determinant of H\n", + "# determinant for a (2,2) = ad - bc\n", + "\n", + "H = np.array([[12, 11],\n", + " [7, 10]])\n", + "\n", + "H_det = np.linalg.det(H)\n", + "H_det" ], - "execution_count": 0, - "outputs": [] + "execution_count": 240, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "43.000000000000014" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 240 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "mDkPdlHxA1cy", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "outputId": "04ebaffc-57dd-4606-a649-31e96951f070" + }, + "source": [ + "# Finding the determinant of J\n", + "# determinant for a (3,3) = aei +\n", + "# will need to break this matrix up into sub-matrices\n", + "\n", + "J = np.array([[0, 1, 2],\n", + " [7, 10, 4],\n", + " [3, 2, 0]])\n", + "\n", + "J_det = np.linalg.det(J)\n", + "J_det" + ], + "execution_count": 241, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "-19.999999999999996" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 241 + } + ] }, { "cell_type": "markdown", @@ -474,13 +1309,32 @@ "metadata": { "id": "nyX6De2-rio1", "colab_type": "code", - "colab": {} + "colab": { + "base_uri": "https://localhost:8080/", + "height": 102 + }, + "outputId": "3eb013a6-0ed1-4c0a-bf81-d63e07c2926b" }, "source": [ - "" + "IH = np.linalg.inv(H)\n", + "print(IH)\n", + "IJ = np.linalg.inv(J)\n", + "print(IJ)" ], - "execution_count": 0, - "outputs": [] + "execution_count": 243, + "outputs": [ + { + "output_type": "stream", + "text": [ + "[[ 0.23255814 -0.25581395]\n", + " [-0.1627907 0.27906977]]\n", + "[[ 0.4 -0.2 0.8 ]\n", + " [-0.6 0.3 -0.7 ]\n", + " [ 0.8 -0.15 0.35]]\n" + ], + "name": "stdout" + } + ] }, { "cell_type": "markdown", @@ -494,6 +1348,84 @@ "Please ignore Python rounding errors. If necessary, format your output so that it rounds to 5 significant digits (the fifth decimal place)." ] }, + { + "cell_type": "code", + "metadata": { + "id": "kYU4BIY9CXz6", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 51 + }, + "outputId": "311b20ee-951a-4f8f-c6cb-707b0f56d873" + }, + "source": [ + "IHH = (IH*H)\n", + "IHH" + ], + "execution_count": 245, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 2.79069767, -2.81395349],\n", + " [-1.13953488, 2.79069767]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 245 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tGYIsPUjWOZ1", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 68 + }, + "outputId": "fabc7dcf-31a0-4352-d8e5-acaff2079bca" + }, + "source": [ + "IJJ = (IJ*J)\n", + "IJJ" + ], + "execution_count": 247, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[ 0. , -0.2, 1.6],\n", + " [-4.2, 3. , -2.8],\n", + " [ 2.4, -0.3, 0. ]])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 247 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "nKJIFIBvW-UN", + "colab_type": "code", + "colab": {} + }, + "source": [ + "# Not equal to each other because the dimensions are not equal" + ], + "execution_count": null, + "outputs": [] + }, { "cell_type": "markdown", "metadata": {