notes_math.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "source": [
    "# Applied Seismology, GEOS 626/426, University of Alaska Fairbanks\n",
    "# Inverse Problems and Parameter Estimation, GEOS 627/427, University of Alaska Fairbanks\n",
    "\n",
    "- script hw_math.ipynb\n",
    "- examples of working with matrices in Python\n",
    "- warning: watch out for numpy array dimensions VERY carefully. Stylized column vectors make computations\n",
    "difficult at times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%run lib_header.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "from scipy.linalg import null_space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### using a custom function showmat to display vectors and matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a function that will return a 3x3 martrix containing values generated from\n",
    "# a normal distribution with mean 0 and standard deviation = 1\n",
    "def Grand():\n",
    "    return np.random.normal(loc=0, scale=1, size=(3, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# note: only one matrix is displayed\n",
    "showmat(Grand())\n",
    "showmat(Grand())\n",
    "showmat(Grand())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "showmat(Grand())\n",
    "showmat(Grand())\n",
    "showmat(Grand())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = Grand()\n",
    "showmat(G,2)\n",
    "showmat(G,1)\n",
    "showmat(G,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### matrix and vector operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an array\n",
    "a0 = np.array([1,2,3,4])\n",
    "print(f'a0 = {a0}')\n",
    "print(f'shape = {a0.shape}')\n",
    "showmat(a0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a row vector (a)\n",
    "a = np.array([[1,2,3,4]])\n",
    "print(f'a = {a}')\n",
    "print(f'a.shape = {a.shape}')\n",
    "showmat(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a column vector (b)\n",
    "b = np.array([[5,6,7,8]]).T\n",
    "print(f'b = \\n {b}')\n",
    "print(f'b.shape = {b.shape}')\n",
    "showmat(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# outer product\n",
    "C = b @ a\n",
    "showmat(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# inner product\n",
    "showmat(a @ b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Transpose C\n",
    "Ct = C.T\n",
    "#print('Ct = \\n',Ct)\n",
    "showmat(Ct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute RREF of C\n",
    "# Each array within the showmat object is a row\n",
    "C1 = Matrix(C)\n",
    "rref_mat, rref_ind = C1.rref() # Get both the RREF and the pivots\n",
    "#print('rref(C) = \\n', rref_mat)\n",
    "Matrix(rref_mat)\n",
    "#Matrix(C).rref()[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another example\n",
    "A = np.array([[1, 2, 4], [5, 3, 2], [1, 0, 1]])\n",
    "showmat(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Matrix(A).rref()[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the example matrix\n",
    "\n",
    "# option 1: all at once\n",
    "A = np.array([[-1, 0, -4], [0, 2, 1], [1, 1, 4]])\n",
    "print(f'A = ')\n",
    "showmat(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# option 2: define column vectors, which will be useful later\n",
    "v1 = np.array([[-1], [0], [1]])\n",
    "v2 = np.array([[0], [2], [1]])\n",
    "v3 = np.array([[-4], [1], [4]])\n",
    "\n",
    "#A = np.append(v1,v2,axis=1)\n",
    "#A = np.append(A,v3,axis=1)\n",
    "A = np.hstack((v1,v2,v3))\n",
    "showmat(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([[1], [2], [3]])\n",
    "x.shape\n",
    "showmat(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'A = ')\n",
    "showmat(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'A*x =')\n",
    "showmat(A@x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'A*A =\\n')\n",
    "showmat(A@A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'A*At =')\n",
    "showmat(A@A.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'At*A =')\n",
    "showmat(A.T@A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### matrix operations in NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create first 1D array\n",
    "a = np.array([1, 2, 3, 4])\n",
    "print(f'a = {a}')\n",
    "print(f'a.shape = {a.shape}')\n",
    "print(f'a.ndim = {a.ndim}')\n",
    "showmat(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create second 1D array\n",
    "b = np.array([5, 6, 7, 8])\n",
    "print(f'b = {b}')\n",
    "print(f'b.shape = {b.shape}')\n",
    "print(f'b.ndim = {b.ndim}')\n",
    "showmat(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Inner product (creates 0D array, AKA scalar)\n",
    "c = np.inner(a, b)\n",
    "print(f'c = np.inner(a, b) = {c}')\n",
    "print(f'c.shape = {c.shape}')\n",
    "print(f'c.ndim = {c.ndim}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# There are many ways to do the inner product...\n",
    "#np.inner(a, b)\n",
    "#np.inner(b, a)\n",
    "a @ b\n",
    "#b @ a\n",
    "#np.dot(a, b)\n",
    "#np.dot(b, a)\n",
    "#np.matmul(a, b)\n",
    "#np.matmul(b, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Outer product (creates 2D array, AKA matrix)\n",
    "print(f'C = np.outer(a, b) =')\n",
    "C = np.outer(a, b)\n",
    "showmat(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'C.shape = {C.shape}')\n",
    "print(f'C.ndim = {C.ndim}')\n",
    "print(f'C.T =')\n",
    "showmat(C.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# There is only one way to do the outer product, and note this difference in order!\n",
    "print(f'np.outer(a, b) == np.outer(b, a) =\\n{np.outer(a, b) == np.outer(b, a)}\\n')\n",
    "print(f'C.T == np.outer(b, a) =\\n{C.T == np.outer(b, a)}\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Element-wise just uses * sign\n",
    "print(f'a * b = {a * b} \\n')\n",
    "print(f'a * b == b * a = {a * b == b * a}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "inverse [conda env:inverse]",
   "language": "python",
   "name": "conda-env-inverse-py"
  },
  "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}