Practice_with_Gram_Schmidt_Process.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Practice with Gram Schmidt Process.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyMg3o7xvmbkwCWMPlNKx9AW",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/awangberg/Math242_Linear_algebra_code_projects/blob/master/Practice_with_Gram_Schmidt_Process.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TXMv3l0X-SNN"
      },
      "source": [
        "# import the numpy library....\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "from sympy import Poly\n",
        "import sympy as sym\n",
        "import numpy as np\n",
        "from numpy import c_\n",
        "\n",
        "# We'll specify that x and t are variables:\n",
        "x, t = sym.symbols('x, t')\n",
        "\n",
        "ll = \"loaded\""
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SLPvYqM4-ogb",
        "outputId": "a3c91abf-edd5-43b5-b6db-681e0fc046fd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#  How do I do a dot product?\n",
        "np.dot([ 1, 2], [ 3, 4])\n",
        "\n",
        "# How do I find the magnitude in np?\n",
        "np.sqrt(np.dot([1,2],[1,2]))"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "11"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QudEaC_f-wxD",
        "outputId": "5da26f04-74bb-40f1-ed87-6820f5ec366e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#  Define the original vectors:\n",
        "\n",
        "r1 = [ 2, 4, 0, 0 ]\n",
        "r2 = [ 1, 2, 3, 6]\n",
        "r3 = [ 2, -1, 2, -1]\n",
        "r4 = [ 1, 2, 3, 4]\n",
        "\n",
        "# Look at r1:\n",
        "r1\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2, 4, 0, 0]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RyVRQzxU_Hlr",
        "outputId": "0f64ee9f-984f-4d0a-fc75-97a27944d568",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#  Find the first nice basis vector u1:\n",
        "\n",
        "# 1:  Pick a new vector\n",
        "r1\n",
        "\n",
        "# 2:  Subtract the projection of r1 onto the nice basis  u1, u2, u3...\n",
        "#     and save this as a temp vector n1\n",
        "n1 = r1\n",
        "n1\n",
        "\n",
        "# 3:  Find the magnitude of n1\n",
        "np.sqrt(np.dot(n1, n1))\n",
        "\n",
        "# 4:  Create the nice basis vector u1 = 1/ | n1 |  * n1\n",
        "u1 = n1 / np.sqrt(np.dot(n1,n1))\n",
        "u1\n"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.4472136 , 0.89442719, 0.        , 0.        ])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u9CfZIpP_v6W",
        "outputId": "ff61f834-0d0b-4319-b4d0-4be88898362d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# Check that u1 has magnitude 1:\n",
        "np.dot(u1, u1)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.9999999999999999"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7vvz8pFVAYqu",
        "outputId": "80e6246e-d981-4e16-cf62-c1d278855c7c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#  Find the second nice basis vector u2:\n",
        "\n",
        "# 1:  Pick a new vector\n",
        "r2\n",
        "\n",
        "# 2:  Subtract the projection of r2 onto the nice basis  u1, u2, u3...\n",
        "#     and save this as a temp vector n2\n",
        "n2 = r2 - np.dot(r2, u1) * u1\n",
        "n2\n",
        "\n",
        "# 3:  Find the magnitude of n2\n",
        "np.sqrt(np.dot(n2, n2))\n",
        "\n",
        "# 4:  Create the nice basis vector u2 = 1/ | n2 |  * n2\n",
        "u2 = n2 / np.sqrt(np.dot(n2,n2))\n",
        "u2"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.        , 0.        , 0.4472136 , 0.89442719])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E8MSoEgLApb2",
        "outputId": "703b334b-6562-4cc1-8838-51ddaac207a1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#  Check that u1 and u2 are orthogonal:\n",
        "np.dot(u1, u2)\n",
        "\n",
        "# Check that u2 has magnitude 1:\n",
        "np.dot(u2, u2)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.9999999999999999"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q5qfh3DBA6aG",
        "outputId": "fd58964f-40d0-4849-ce7a-6fa15983c510",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# Find the third nice basis vector u3:\n",
        "\n",
        "# 1:  Pick a new vector\n",
        "r3\n",
        "\n",
        "# 2:  Subtract the projection of r3 onto the nice basis  u1, u2, ...\n",
        "#     and save this as a temp vector n3\n",
        "n3 = r3 - np.dot(r3, u1) * u1 - np.dot(r3, u2) * u2\n",
        "n3\n",
        "\n",
        "# 3:  Find the magnitude of n2\n",
        "np.sqrt(np.dot(n3, n3))\n",
        "\n",
        "# 4:  Create the nice basis vector u3 = 1/ | n3 |  * n3\n",
        "u3 = n3 / np.sqrt(np.dot(n3,n3))\n",
        "u3"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0.63245553, -0.31622777,  0.63245553, -0.31622777])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OS6-dBU7BO1m",
        "outputId": "1bb64694-ed35-4e7d-d75b-0bc101db57db",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "#  Check that u3 is orthogonal to u1 and u2\n",
        "print(np.dot(u1, u3))\n",
        "print(np.dot(u2, u3))\n",
        "print(np.dot(u3,u3))"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.0\n",
            "0.0\n",
            "1.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8MM-zytTBhfm",
        "outputId": "00937461-2b4a-40f7-8139-6ed6b2d117ce",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# Find the third nice basis vector u4:\n",
        "\n",
        "# 1:  Pick a new vector\n",
        "r4\n",
        "\n",
        "# 2:  Subtract the projection of r4 onto the nice basis  u1, u2, u3 ...\n",
        "#     and save this as a temp vector n4\n",
        "n4 = r4 - np.dot(r4, u1) * u1 - np.dot(r4, u2) * u2 - np.dot(r4, u3) * u3\n",
        "n4\n",
        "\n",
        "# 3:  Find the magnitude of n4\n",
        "np.sqrt(np.dot(n4, n4))\n",
        "\n",
        "# 4:  Create the nice basis vector u4 = 1/ | n4 |  * n4\n",
        "u4 = n4 / np.sqrt(np.dot(n4,n4))\n",
        "u4"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-0.63245553,  0.31622777,  0.63245553, -0.31622777])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-YH83yi_B3TW",
        "outputId": "6cc544a1-1866-4025-e015-f16748947d6a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        }
      },
      "source": [
        "# Check that u4 is orthogonal to u1, u2, and u3\n",
        "# and check that |u4| = 1\n",
        "print(np.dot(u4, u1))\n",
        "print(np.dot(u4, u2))\n",
        "print(np.dot(u4, u3))\n",
        "print(np.dot(u4, u4))\n"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.0\n",
            "9.43689570931383e-16\n",
            "9.71445146547012e-17\n",
            "0.9999999999999998\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5E1Mx7OOCPi_"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}