matrix_manipulation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Matrix Manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transposing a matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before Transpose\n",
      " [[1 2]\n",
      " [3 4]]\n",
      "After Transpose\n",
      " [[1 3]\n",
      " [2 4]]\n"
     ]
    }
   ],
   "source": [
    "matrix = np.array([[1, 2], [3, 4]])\n",
    "print(\"Before Transpose\\n\", matrix)\n",
    "transpose = matrix.T\n",
    "print(\"After Transpose\\n\",transpose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reshaping Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before Shaping\n",
      " [[1 2]\n",
      " [3 4]]\n",
      "After Shaping to 1 row and 4 columns:\n",
      " [[1 2 3 4]]\n"
     ]
    }
   ],
   "source": [
    "matrix = np.array([[1, 2], [3, 4]])\n",
    "print(\"Before Shaping\\n\", matrix)\n",
    "\n",
    "\n",
    "reshaped = matrix.reshape((1, 4))\n",
    "print(\"After Shaping to 1 row and 4 columns:\\n\", reshaped)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flattening a matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This method transforms a Multidimentional array into a one dimentional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "matrix = np.array([[1, 2], [3, 4]])\n",
    "flattened = matrix.flatten()\n",
    "print(flattened)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concatenating matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]\n",
      " [7 8]]\n"
     ]
    }
   ],
   "source": [
    "matrix1 = np.array([[1, 2], [3, 4]])\n",
    "matrix2 = np.array([[5, 6], [7, 8]])\n",
    "concatenated = np.concatenate((matrix1, matrix2))\n",
    "print(concatenated)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## determinant of a matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Determinat =  -2.0000000000000004\n"
     ]
    }
   ],
   "source": [
    "matrix = np.array([[1, 2], [3, 4]])\n",
    "det = np.linalg.det(matrix)\n",
    "print(\"Determinat = \", det)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inverse Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-2.   1. ]\n",
      " [ 1.5 -0.5]]\n"
     ]
    }
   ],
   "source": [
    "# create a 2x2 matrix\n",
    "A = np.array([[1, 2], [3, 4]], dtype=np.int64)\n",
    "\n",
    "# calculate the inverse of A\n",
    "A_inv = np.linalg.inv(A)\n",
    "\n",
    "# print the result\n",
    "print(A_inv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### proving it's inverted\n",
    "matrix * it's_inverse = identity_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### identity = np.dot(A, A_inv)\n",
    "identity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solving linear Equations\n",
    "\n",
    "2x + 3y = 7  \n",
    "4x + 5y = 11\n",
    "\n",
    "In NumPy, you can solve a system of linear equations using matrices. The process involves setting up the equations in matrix form and then using NumPy's linear algebra functions to solve for the unknown variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "q = np.array([[2, 3], [4, 5]])\n",
    "a = np.array([7, 11])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = np.linalg.solve(q, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.,  3.])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on package numpy.linalg in numpy:\n",
      "\n",
      "NAME\n",
      "    numpy.linalg\n",
      "\n",
      "DESCRIPTION\n",
      "    ``numpy.linalg``\n",
      "    ================\n",
      "    \n",
      "    The NumPy linear algebra functions rely on BLAS and LAPACK to provide efficient\n",
      "    low level implementations of standard linear algebra algorithms. Those\n",
      "    libraries may be provided by NumPy itself using C versions of a subset of their\n",
      "    reference implementations but, when possible, highly optimized libraries that\n",
      "    take advantage of specialized processor functionality are preferred. Examples\n",
      "    of such libraries are OpenBLAS, MKL (TM), and ATLAS. Because those libraries\n",
      "    are multithreaded and processor dependent, environmental variables and external\n",
      "    packages such as threadpoolctl may be needed to control the number of threads\n",
      "    or specify the processor architecture.\n",
      "    \n",
      "    - OpenBLAS: https://www.openblas.net/\n",
      "    - threadpoolctl: https://github.com/joblib/threadpoolctl\n",
      "    \n",
      "    Please note that the most-used linear algebra functions in NumPy are present in\n",
      "    the main ``numpy`` namespace rather than in ``numpy.linalg``.  There are:\n",
      "    ``dot``, ``vdot``, ``inner``, ``outer``, ``matmul``, ``tensordot``, ``einsum``,\n",
      "    ``einsum_path`` and ``kron``.\n",
      "    \n",
      "    Functions present in numpy.linalg are listed below.\n",
      "    \n",
      "    \n",
      "    Matrix and vector products\n",
      "    --------------------------\n",
      "    \n",
      "       multi_dot\n",
      "       matrix_power\n",
      "    \n",
      "    Decompositions\n",
      "    --------------\n",
      "    \n",
      "       cholesky\n",
      "       qr\n",
      "       svd\n",
      "    \n",
      "    Matrix eigenvalues\n",
      "    ------------------\n",
      "    \n",
      "       eig\n",
      "       eigh\n",
      "       eigvals\n",
      "       eigvalsh\n",
      "    \n",
      "    Norms and other numbers\n",
      "    -----------------------\n",
      "    \n",
      "       norm\n",
      "       cond\n",
      "       det\n",
      "       matrix_rank\n",
      "       slogdet\n",
      "    \n",
      "    Solving equations and inverting matrices\n",
      "    ----------------------------------------\n",
      "    \n",
      "       solve\n",
      "       tensorsolve\n",
      "       lstsq\n",
      "       inv\n",
      "       pinv\n",
      "       tensorinv\n",
      "    \n",
      "    Exceptions\n",
      "    ----------\n",
      "    \n",
      "       LinAlgError\n",
      "\n",
      "PACKAGE CONTENTS\n",
      "    _umath_linalg\n",
      "    lapack_lite\n",
      "    linalg\n",
      "    setup\n",
      "    tests (package)\n",
      "\n",
      "CLASSES\n",
      "    builtins.Exception(builtins.BaseException)\n",
      "        LinAlgError\n",
      "    \n",
      "    class LinAlgError(builtins.Exception)\n",
      "     |  Generic Python-exception-derived object raised by linalg functions.\n",
      "     |  \n",
      "     |  General purpose exception class, derived from Python's exception.Exception\n",
      "     |  class, programmatically raised in linalg functions when a Linear\n",
      "     |  Algebra-related condition would prevent further correct execution of the\n",
      "     |  function.\n",
      "     |  \n",
      "     |  Parameters\n",
      "     |  ----------\n",
      "     |  None\n",
      "     |  \n",
      "     |  Examples\n",
      "     |  --------\n",
      "     |  >>> from numpy import linalg as LA\n",
      "     |  >>> LA.inv(np.zeros((2,2)))\n",
      "     |  Traceback (most recent call last):\n",
      "     |    File \"<stdin>\", line 1, in <module>\n",
      "     |    File \"...linalg.py\", line 350,\n",
      "     |      in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))\n",
      "     |    File \"...linalg.py\", line 249,\n",
      "     |      in solve\n",
      "     |      raise LinAlgError('Singular matrix')\n",
      "     |  numpy.linalg.LinAlgError: Singular matrix\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      LinAlgError\n",
      "     |      builtins.Exception\n",
      "     |      builtins.BaseException\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.Exception:\n",
      "     |  \n",
      "     |  __init__(self, /, *args, **kwargs)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods inherited from builtins.Exception:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.BaseException:\n",
      "     |  \n",
      "     |  __delattr__(self, name, /)\n",
      "     |      Implement delattr(self, name).\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  __setattr__(self, name, value, /)\n",
      "     |      Implement setattr(self, name, value).\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |  \n",
      "     |  __str__(self, /)\n",
      "     |      Return str(self).\n",
      "     |  \n",
      "     |  with_traceback(...)\n",
      "     |      Exception.with_traceback(tb) --\n",
      "     |      set self.__traceback__ to tb and return self.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from builtins.BaseException:\n",
      "     |  \n",
      "     |  __cause__\n",
      "     |      exception cause\n",
      "     |  \n",
      "     |  __context__\n",
      "     |      exception context\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |  \n",
      "     |  __suppress_context__\n",
      "     |  \n",
      "     |  __traceback__\n",
      "     |  \n",
      "     |  args\n",
      "\n",
      "FUNCTIONS\n",
      "    cholesky(a)\n",
      "        Cholesky decomposition.\n",
      "        \n",
      "        Return the Cholesky decomposition, `L * L.H`, of the square matrix `a`,\n",
      "        where `L` is lower-triangular and .H is the conjugate transpose operator\n",
      "        (which is the ordinary transpose if `a` is real-valued).  `a` must be\n",
      "        Hermitian (symmetric if real-valued) and positive-definite. No\n",
      "        checking is performed to verify whether `a` is Hermitian or not.\n",
      "        In addition, only the lower-triangular and diagonal elements of `a`\n",
      "        are used. Only `L` is actually returned.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : (..., M, M) array_like\n",
      "            Hermitian (symmetric if all elements are real), positive-definite\n",
      "            input matrix.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        L : (..., M, M) array_like\n",
      "            Upper or lower-triangular Cholesky factor of `a`.  Returns a\n",
      "            matrix object if `a` is a matrix object.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        LinAlgError\n",
      "           If the decomposition fails, for example, if `a` is not\n",
      "           positive-definite.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.linalg.cholesky : Similar function in SciPy.\n",
      "        scipy.linalg.cholesky_banded : Cholesky decompose a banded Hermitian\n",
      "                                       positive-definite matrix.\n",
      "        scipy.linalg.cho_factor : Cholesky decomposition of a matrix, to use in\n",
      "                                  `scipy.linalg.cho_solve`.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        .. versionadded:: 1.8.0\n",
      "        \n",
      "        Broadcasting rules apply, see the `numpy.linalg` documentation for\n",
      "        details.\n",
      "        \n",
      "        The Cholesky decomposition is often used as a fast way of solving\n",
      "        \n",
      "        .. math:: A \\mathbf{x} = \\mathbf{b}\n",
      "        \n",
      "        (when `A` is both Hermitian/symmetric and positive-definite).\n",
      "        \n",
      "        First, we solve for :math:`\\mathbf{y}` in\n",
      "        \n",
      "        .. math:: L \\mathbf{y} = \\mathbf{b},\n",
      "        \n",
      "        and then for :math:`\\mathbf{x}` in\n",
      "        \n",
      "        .. math:: L.H \\mathbf{x} = \\mathbf{y}.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> A = np.array([[1,-2j],[2j,5]])\n",
      "        >>> A\n",
      "        array([[ 1.+0.j, -0.-2.j],\n",
      "               [ 0.+2.j,  5.+0.j]])\n",
      "        >>> L = np.linalg.cholesky(A)\n",
      "        >>> L\n",
      "        array([[1.+0.j, 0.+0.j],\n",
      "               [0.+2.j, 1.+0.j]])\n",
      "        >>> np.dot(L, L.T.conj()) # verify that L * L.H = A\n",
      "        array([[1.+0.j, 0.-2.j],\n",
      "               [0.+2.j, 5.+0.j]])\n",
      "        >>> A = [[1,-2j],[2j,5]] # what happens if A is only array_like?\n",
      "        >>> np.linalg.cholesky(A) # an ndarray object is returned\n",
      "        array([[1.+0.j, 0.+0.j],\n",
      "               [0.+2.j, 1.+0.j]])\n",
      "        >>> # But a matrix object is returned if A is a matrix object\n",
      "        >>> np.linalg.cholesky(np.matrix(A))\n",
      "        matrix([[ 1.+0.j,  0.+0.j],\n",
      "                [ 0.+2.j,  1.+0.j]])\n",
      "    \n",
      "    cond(x, p=None)\n",
      "        Compute the condition number of a matrix.\n",
      "        \n",
      "        This function is capable of returning the condition number using\n",
      "        one of seven different norms, depending on the value of `p` (see\n",
      "        Parameters below).\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : (..., M, N) array_like\n",
      "            The matrix whose condition number is sought.\n",
      "        p : {None, 1, -1, 2, -2, inf, -inf, 'fro'}, optional\n",
      "            Order of the norm:\n",
      "        \n",
      "            =====  ============================\n",
      "            p      norm for matrices\n",
      "            =====  ============================\n",
      "            None   2-norm, computed directly using the ``SVD``\n",
      "            'fro'  Frobenius norm\n",
      "            inf    max(sum(abs(x), axis=1))\n",
      "            -inf   min(sum(abs(x), axis=1))\n",
      "            1      max(sum(abs(x), axis=0))\n",
      "            -1     min(sum(abs(x), axis=0))\n",
      "            2      2-norm (largest sing. value)\n",
      "            -2     smallest singular value\n",
      "            =====  ============================\n",
      "        \n",
      "            inf means the numpy.inf object, and the Frobenius norm is\n",
      "            the root-of-sum-of-squares norm.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        c : {float, inf}\n",
      "            The condition number of the matrix. May be infinite.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        numpy.linalg.norm\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The condition number of `x` is defined as the norm of `x` times the\n",
      "        norm of the inverse of `x` [1]_; the norm can be the usual L2-norm\n",
      "        (root-of-sum-of-squares) or one of a number of other matrix norms.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] G. Strang, *Linear Algebra and Its Applications*, Orlando, FL,\n",
      "               Academic Press, Inc., 1980, pg. 285.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> from numpy import linalg as LA\n",
      "        >>> a = np.array([[1, 0, -1], [0, 1, 0], [1, 0, 1]])\n",
      "        >>> a\n",
      "        array([[ 1,  0, -1],\n",
      "               [ 0,  1,  0],\n",
      "               [ 1,  0,  1]])\n",
      "        >>> LA.cond(a)\n",
      "        1.4142135623730951\n",
      "        >>> LA.cond(a, 'fro')\n",
      "        3.1622776601683795\n",
      "        >>> LA.cond(a, np.inf)\n",
      "        2.0\n",
      "        >>> LA.cond(a, -np.inf)\n",
      "        1.0\n",
      "        >>> LA.cond(a, 1)\n",
      "        2.0\n",
      "        >>> LA.cond(a, -1)\n",
      "        1.0\n",
      "        >>> LA.cond(a, 2)\n",
      "        1.4142135623730951\n",
      "        >>> LA.cond(a, -2)\n",
      "        0.70710678118654746 # may vary\n",
      "        >>> min(LA.svd(a, compute_uv=False))*min(LA.svd(LA.inv(a), compute_uv=False))\n",
      "        0.70710678118654746 # may vary\n",
      "    \n",
      "    det(a)\n",
      "        Compute the determinant of an array.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : (..., M, M) array_like\n",
      "            Input array to compute determinants for.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        det : (...) array_like\n",
      "            Determinant of `a`.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        slogdet : Another way to represent the determinant, more suitable\n",
      "          for large matrices where underflow/overflow may occur.\n",
      "        scipy.linalg.det : Similar function in SciPy.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        .. versionadded:: 1.8.0\n",
      "        \n",
      "        Broadcasting rules apply, see the `numpy.linalg` documentation for\n",
      "        details.\n",
      "        \n",
      "        The determinant is computed via LU factorization using the LAPACK\n",
      "        routine ``z/dgetrf``.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        The determinant of a 2-D array [[a, b], [c, d]] is ad - bc:\n",
      "        \n",
      "        >>> a = np.array([[1, 2], [3, 4]])\n",
      "        >>> np.linalg.det(a)\n",
      "        -2.0 # may vary\n",
      "        \n",
      "        Computing determinants for a stack of matrices:\n",
      "        \n",
      "        >>> a = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ])\n",
      "        >>> a.shape\n",
      "        (3, 2, 2)\n",
      "        >>> np.linalg.det(a)\n",
      "        array([-2., -3., -8.])\n",
      "    \n",
      "    eig(a)\n",
      "        Compute the eigenvalues and right eigenvectors of a square array.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : (..., M, M) array\n",
      "            Matrices for which the eigenvalues and right eigenvectors will\n",
      "            be computed\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        w : (..., M) array\n",
      "            The eigenvalues, each repeated according to its multiplicity.\n",
      "            The eigenvalues are not necessarily ordered. The resulting\n",
      "            array will be of complex type, unless the imaginary part is\n",
      "            zero in which case it will be cast to a real type. When `a`\n",
      "            is real the resulting eigenvalues will be real (0 imaginary\n",
      "            part) or occur in conjugate pairs\n",
      "        \n",
      "        v : (..., M, M) array\n",
      "            The normalized (unit \"length\") eigenvectors, such that the\n",
      "            column ``v[:,i]`` is the eigenvector corresponding to the\n",
      "            eigenvalue ``w[i]``.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        LinAlgError\n",
      "            If the eigenvalue computation does not converge.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        eigvals : eigenvalues of a non-symmetric array.\n",
      "        eigh : eigenvalues and eigenvectors of a real symmetric or complex\n",
      "               Hermitian (conjugate symmetric) array.\n",
      "        eigvalsh : eigenvalues of a real symmetric or complex Hermitian\n",
      "                   (conjugate symmetric) array.\n",
      "        scipy.linalg.eig : Similar function in SciPy that also solves the\n",
      "                           generalized eigenvalue problem.\n",
      "        scipy.linalg.schur : Best choice for unitary and other non-Hermitian\n",
      "                             normal matrices.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        .. versionadded:: 1.8.0\n",
      "        \n",
      "        Broadcasting rules apply, see the `numpy.linalg` documentation for\n",
      "        details.\n",
      "        \n",
      "        This is implemented using the ``_geev`` LAPACK routines which compute\n",
      "        the eigenvalues and eigenvectors of general square arrays.\n",
      "        \n",
      "        The number `w` is an eigenvalue of `a` if there exists a vector\n",
      "        `v` such that ``a @ v = w * v``. Thus, the arrays `a`, `w`, and\n",
      "        `v` satisfy the equations ``a @ v[:,i] = w[i] * v[:,i]``\n",
      "        for :math:`i \\in \\{0,...,M-1\\}`.\n",
      "        \n",
      "        The array `v` of eigenvectors may not be of maximum rank, that is, some\n",
      "        of the columns may be linearly dependent, although round-off error may\n",
      "        obscure that fact. If the eigenvalues are all different, then theoretically\n",
      "        the eigenvectors are linearly independent and `a` can be diagonalized by\n",
      "        a similarity transformation using `v`, i.e, ``inv(v) @ a @ v`` is diagonal.\n",
      "        \n",
      "        For non-Hermitian normal matrices the SciPy function `scipy.linalg.schur`\n",
      "        is preferred because the matrix `v` is guaranteed to be unitary, which is\n",
      "        not the case when using `eig`. The Schur factorization produces an\n",
      "        upper triangular matrix rather than a diagonal matrix, but for normal\n",
      "        matrices only the diagonal of the upper triangular matrix is needed, the\n",
      "        rest is roundoff error.\n",
      "        \n",
      "        Finally, it is emphasized that `v` consists of the *right* (as in\n",
      "        right-hand side) eigenvectors of `a`.  A vector `y` satisfying\n",
      "        ``y.T @ a = z * y.T`` for some number `z` is called a *left*\n",
      "        eigenvector of `a`, and, in general, the left and right eigenvectors\n",
      "        of a matrix are not necessarily the (perhaps conjugate) transposes\n",
      "        of each other.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando, FL,\n",
      "        Academic Press, Inc., 1980, Various pp.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> from numpy import linalg as LA\n",
      "        \n",
      "        (Almost) trivial example with real e-values and e-vectors.\n",
      "        \n",
      "        >>> w, v = LA.eig(np.diag((1, 2, 3)))\n",
      "        >>> w; v\n",
      "        array([1., 2., 3.])\n",
      "        array([[1., 0., 0.],\n",
      "               [0., 1., 0.],\n",
      "               [0., 0., 1.]])\n",
      "        \n",
      "        Real matrix possessing complex e-values and e-vectors; note that the\n",
      "        e-values are complex conjugates of each other.\n",
      "        \n",
      "        >>> w, v = LA.eig(np.array([[1, -1], [1, 1]]))\n",
      "        >>> w; v\n",
      "        array([1.+1.j, 1.-1.j])\n",
      "        array([[0.70710678+0.j        , 0.70710678-0.j        ],\n",
      "               [0.        -0.70710678j, 0.        +0.70710678j]])\n",
      "        \n",
      "        Complex-valued matrix with real e-values (but complex-valued e-vectors);\n",
      "        note that ``a.conj().T == a``, i.e., `a` is Hermitian.\n",
      "        \n",
      "        >>> a = np.array([[1, 1j], [-1j, 1]])\n",
      "        >>> w, v = LA.eig(a)\n",
      "        >>> w; v\n",
      "        array([2.+0.j, 0.+0.j])\n",
      "        array([[ 0.        +0.70710678j,  0.70710678+0.j        ], # may vary\n",
      "               [ 0.70710678+0.j        , -0.        +0.70710678j]])\n",
      "        \n",
      "        Be careful about round-off error!\n",
      "        \n",
      "        >>> a = np.array([[1 + 1e-9, 0], [0, 1 - 1e-9]])\n",
      "        >>> # Theor. e-values are 1 +/- 1e-9\n",
      "        >>> w, v = LA.eig(a)\n",
      "        >>> w; v\n",
      "        array([1., 1.])\n",
      "        array([[1., 0.],\n",
      "               [0., 1.]])\n",
      "    \n",
      "    eigh(a, UPLO='L')\n",
      "        Return the eigenvalues and eigenvectors of a complex Hermitian\n",
      "        (conjugate symmetric) or a real symmetric matrix.\n",
      "        \n",
      "        Returns two objects, a 1-D array containing the eigenvalues of `a`, and\n",
      "        a 2-D square array or matrix (depending on the input type) of the\n",
      "        corresponding eigenvectors (in columns).\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : (..., M, M) array\n",
      "            Hermitian or real symmetric matrices whose eigenvalues and\n",
      "            eigenvectors are to be computed.\n",
      "        UPLO : {'L', 'U'}, optional\n",
      "            Specifies whether the calculation is done with the lower triangular\n",
      "            part of `a` ('L', default) or the upper triangular part ('U').\n",
      "            Irrespective of this value only the real parts of the diagonal will\n",
      "            be considered in the computation to preserve the notion of a Hermitian\n",
      "            matrix. It therefore follows that the imaginary part of the diagonal\n",
      "            will always be treated as zero.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        w : (..., M) ndarray\n",
      "            The eigenvalues in ascending order, each repeated according to\n",
      "            its multiplicity.\n",
      "        v : {(..., M, M) ndarray, (..., M, M) matrix}\n",
      "            The column ``v[:, i]`` is the normalized eigenvector corresponding\n",
      "            to the eigenvalue ``w[i]``.  Will return a matrix object if `a` is\n",
      "            a matrix object.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        LinAlgError\n",
      "            If the eigenvalue computation does not converge.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        eigvalsh : eigenvalues of real symmetric or complex Hermitian\n",
      "                   (conjugate symmetric) arrays.\n",
      "        eig : eigenvalues and right eigenvectors for non-symmetric arrays.\n",
      "        eigvals : eigenvalues of non-symmetric arrays.\n",
      "        scipy.linalg.eigh : Similar function in SciPy (but also solves the\n",
      "                            generalized eigenvalue problem).\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        .. versionadded:: 1.8.0\n",
      "        \n",
      "        Broadcasting rules apply, see the `numpy.linalg` documentation for\n",
      "        details.\n",
      "        \n",
      "        The eigenvalues/eigenvectors are computed using LAPACK routines ``_syevd``,\n",
      "        ``_heevd``.\n",
      "        \n",
      "        The eigenvalues of real symmetric or complex Hermitian matrices are\n",
      "        always real. [1]_ The array `v` of (column) eigenvectors is unitary\n",
      "        and `a`, `w`, and `v` satisfy the equations\n",
      "        ``dot(a, v[:, i]) = w[i] * v[:, i]``.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,\n",
      "               FL, Academic Press, Inc., 1980, pg. 222.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> from numpy import linalg as LA\n",
      "        >>> a = np.array([[1, -2j], [2j, 5]])\n",
      "        >>> a\n",
      "        array([[ 1.+0.j, -0.-2.j],\n",
      "               [ 0.+2.j,  5.+0.j]])\n",
      "        >>> w, v = LA.eigh(a)\n",
      "        >>> w; v\n",
      "        array([0.17157288, 5.82842712])\n",
      "        array([[-0.92387953+0.j        , -0.38268343+0.j        ], # may vary\n",
      "               [ 0.        +0.38268343j,  0.        -0.92387953j]])\n",
      "        \n",
      "        >>> np.dot(a, v[:, 0]) - w[0] * v[:, 0] # verify 1st e-val/vec pair\n",
      "        array([5.55111512e-17+0.0000000e+00j, 0.00000000e+00+1.2490009e-16j])\n",
      "        >>> np.dot(a, v[:, 1]) - w[1] * v[:, 1] # verify 2nd e-val/vec pair\n",
      "        array([0.+0.j, 0.+0.j])\n",
      "        \n",
      "        >>> A = np.matrix(a) # what happens if input is a matrix object\n",
      "        >>> A\n",
      "        matrix([[ 1.+0.j, -0.-2.j],\n",
      "                [ 0.+2.j,  5.+0.j]])\n",
      "        >>> w, v = LA.eigh(A)\n",
      "        >>> w; v\n",
      "        array([0.17157288, 5.82842712])\n",
      "        matrix([[-0.92387953+0.j        , -0.38268343+0.j        ], # may vary\n",
      "                [ 0.        +0.38268343j,  0.        -0.92387953j]])\n",
      "        \n",
      "        >>> # demonstrate the treatment of the imaginary part of the diagonal\n",
      "        >>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]])\n",
      "        >>> a\n",
      "        array([[5.+2.j, 9.-2.j],\n",
      "               [0.+2.j, 2.-1.j]])\n",
      "        >>> # with UPLO='L' this is numerically equivalent to using LA.eig() with:\n",
      "        >>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])\n",
      "        >>> b\n",
      "        array([[5.+0.j, 0.-2.j],\n",
      "               [0.+2.j, 2.+0.j]])\n",
      "        >>> wa, va = LA.eigh(a)\n",
      "        >>> wb, vb = LA.eig(b)\n",
      "        >>> wa; wb\n",
      "        array([1., 6.])\n",
      "        array([6.+0.j, 1.+0.j])\n",
      "        >>> va; vb\n",
      "        array([[-0.4472136 +0.j        , -0.89442719+0.j        ], # may vary\n",
      "               [ 0.        +0.89442719j,  0.        -0.4472136j ]])\n",
      "        array([[ 0.89442719+0.j       , -0.        +0.4472136j],\n",
      "               [-0.        +0.4472136j,  0.89442719+0.j       ]])\n",
      "    \n",
      "    eigvals(a)\n",
      "        Compute the eigenvalues of a general matrix.\n",
      "        \n",
      "        Main difference between `eigvals` and `eig`: the eigenvectors aren't\n",
      "        returned.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : (..., M, M) array_like\n",
      "            A complex- or real-valued matrix whose eigenvalues will be computed.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        w : (..., M,) ndarray\n",
      "            The eigenvalues, each repeated according to its multiplicity.\n",
      "            They are not necessarily ordered, nor are they necessarily\n",
      "            real for real matrices.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        LinAlgError\n",
      "            If the eigenvalue computation does not converge.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        eig : eigenvalues and right eigenvectors of general arrays\n",
      "        eigvalsh : eigenvalues of real symmetric or complex Hermitian\n",
      "                   (conjugate symmetric) arrays.\n",
      "        eigh : eigenvalues and eigenvectors of real symmetric or complex\n",
      "               Hermitian (conjugate symmetric) arrays.\n",
      "        scipy.linalg.eigvals : Similar function in SciPy.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        .. versionadded:: 1.8.0\n",
      "        \n",
      "        Broadcasting rules apply, see the `numpy.linalg` documentation for\n",
      "        details.\n",
      "        \n",
      "        This is implemented using the ``_geev`` LAPACK routines which compute\n",
      "        the eigenvalues and eigenvectors of general square arrays.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Illustration, using the fact that the eigenvalues of a diagonal matrix\n",
      "        are its diagonal elements, that multiplying a matrix on the left\n",
      "        by an orthogonal matrix, `Q`, and on the right by `Q.T` (the transpose\n",
      "        of `Q`), preserves the eigenvalues of the \"middle\" matrix.  In other words,\n",
      "        if `Q` is orthogonal, then ``Q * A * Q.T`` has the same eigenvalues as\n",
      "        ``A``:\n",
      "        \n",
      "        >>> from numpy import linalg as LA\n",
      "        >>> x = np.random.random()\n",
      "        >>> Q = np.array([[np.cos(x), -np.sin(x)], [np.sin(x), np.cos(x)]])\n",
      "        >>> LA.norm(Q[0, :]), LA.norm(Q[1, :]), np.dot(Q[0, :],Q[1, :])\n",
      "        (1.0, 1.0, 0.0)\n",
      "        \n",
      "        Now multiply a diagonal matrix by ``Q`` on one side and by ``Q.T`` on the other:\n",
      "        \n",
      "        >>> D = np.diag((-1,1))\n",
      "        >>> LA.eigvals(D)\n",
      "        array([-1.,  1.])\n",
      "        >>> A = np.dot(Q, D)\n",
      "        >>> A = np.dot(A, Q.T)\n",
      "        >>> LA.eigvals(A)\n",
      "        array([ 1., -1.]) # random\n",
      "    \n",
      "    eigvalsh(a, UPLO='L')\n",
      "        Compute the eigenvalues of a complex Hermitian or real symmetric matrix.\n",
      "        \n",
      "        Main difference from eigh: the eigenvectors are not computed.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : (..., M, M) array_like\n",
      "            A complex- or real-valued matrix whose eigenvalues are to be\n",
      "            computed.\n",
      "        UPLO : {'L', 'U'}, optional\n",
      "            Specifies whether the calculation is done with the lower triangular\n",
      "            part of `a` ('L', default) or the upper triangular part ('U').\n",
      "            Irrespective of this value only the real parts of the diagonal will\n",
      "            be considered in the computation to preserve the notion of a Hermitian\n",
      "            matrix. It therefore follows that the imaginary part of the diagonal\n",
      "            will always be treated as zero.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        w : (..., M,) ndarray\n",
      "            The eigenvalues in ascending order, each repeated according to\n",
      "            its multiplicity.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        LinAlgError\n",
      "            If the eigenvalue computation does not converge.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        eigh : eigenvalues and eigenvectors of real symmetric or complex Hermitian\n",
      "               (conjugate symmetric) arrays.\n",
      "        eigvals : eigenvalues of general real or complex arrays.\n",
      "        eig : eigenvalues and right eigenvectors of general real or complex\n",
      "              arrays.\n",
      "        scipy.linalg.eigvalsh : Similar function in SciPy.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        .. versionadded:: 1.8.0\n",
      "        \n",
      "        Broadcasting rules apply, see the `numpy.linalg` documentation for\n",
      "        details.\n",
      "        \n",
      "        The eigenvalues are computed using LAPACK routines ``_syevd``, ``_heevd``.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> from numpy import linalg as LA\n",
      "        >>> a = np.array([[1, -2j], [2j, 5]])\n",
      "        >>> LA.eigvalsh(a)\n",
      "        array([ 0.17157288,  5.82842712]) # may vary\n",
      "        \n",
      "        >>> # demonstrate the treatment of the imaginary part of the diagonal\n",
      "        >>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]])\n",
      "        >>> a\n",
      "        array([[5.+2.j, 9.-2.j],\n",
      "               [0.+2.j, 2.-1.j]])\n",
      "        >>> # with UPLO='L' this is numerically equivalent to using LA.eigvals()\n",
      "        >>> # with:\n",
      "        >>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])\n",
      "        >>> b\n",
      "        array([[5.+0.j, 0.-2.j],\n",
      "               [0.+2.j, 2.+0.j]])\n",
      "        >>> wa = LA.eigvalsh(a)\n",
      "        >>> wb = LA.eigvals(b)\n",
      "        >>> wa; wb\n",
      "        array([1., 6.])\n",
      "        array([6.+0.j, 1.+0.j])\n",
      "    \n",
      "    inv(a)\n",
      "        Compute the (multiplicative) inverse of a matrix.\n",
      "        \n",
      "        Given a square matrix `a`, return the matrix `ainv` satisfying\n",
      "        ``dot(a, ainv) = dot(ainv, a) = eye(a.shape[0])``.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : (..., M, M) array_like\n",
      "            Matrix to be inverted.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        ainv : (..., M, M) ndarray or matrix\n",
      "            (Multiplicative) inverse of the matrix `a`.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        LinAlgError\n",
      "            If `a` is not square or inversion fails.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.linalg.inv : Similar function in SciPy.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        .. versionadded:: 1.8.0\n",
      "        \n",
      "        Broadcasting rules apply, see the `numpy.linalg` documentation for\n",
      "        details.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> from numpy.linalg import inv\n",
      "        >>> a = np.array([[1., 2.], [3., 4.]])\n",
      "        >>> ainv = inv(a)\n",
      "        >>> np.allclose(np.dot(a, ainv), np.eye(2))\n",
      "        True\n",
      "        >>> np.allclose(np.dot(ainv, a), np.eye(2))\n",
      "        True\n",
      "        \n",
      "        If a is a matrix object, then the return value is a matrix as well:\n",
      "        \n",
      "        >>> ainv = inv(np.matrix(a))\n",
      "        >>> ainv\n",
      "        matrix([[-2. ,  1. ],\n",
      "                [ 1.5, -0.5]])\n",
      "        \n",
      "        Inverses of several matrices can be computed at once:\n",
      "        \n",
      "        >>> a = np.array([[[1., 2.], [3., 4.]], [[1, 3], [3, 5]]])\n",
      "        >>> inv(a)\n",
      "        array([[[-2.  ,  1.  ],\n",
      "                [ 1.5 , -0.5 ]],\n",
      "               [[-1.25,  0.75],\n",
      "                [ 0.75, -0.25]]])\n",
      "    \n",
      "    lstsq(a, b, rcond='warn')\n",
      "        Return the least-squares solution to a linear matrix equation.\n",
      "        \n",
      "        Computes the vector `x` that approximatively solves the equation\n",
      "        ``a @ x = b``. The equation may be under-, well-, or over-determined\n",
      "        (i.e., the number of linearly independent rows of `a` can be less than,\n",
      "        equal to, or greater than its number of linearly independent columns).\n",
      "        If `a` is square and of full rank, then `x` (but for round-off error)\n",
      "        is the \"exact\" solution of the equation. Else, `x` minimizes the\n",
      "        Euclidean 2-norm :math:`||b - ax||`. If there are multiple minimizing \n",
      "        solutions, the one with the smallest 2-norm :math:`||x||` is returned.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : (M, N) array_like\n",
      "            \"Coefficient\" matrix.\n",
      "        b : {(M,), (M, K)} array_like\n",
      "            Ordinate or \"dependent variable\" values. If `b` is two-dimensional,\n",
      "            the least-squares solution is calculated for each of the `K` columns\n",
      "            of `b`.\n",
      "        rcond : float, optional\n",
      "            Cut-off ratio for small singular values of `a`.\n",
      "            For the purposes of rank determination, singular values are treated\n",
      "            as zero if they are smaller than `rcond` times the largest singular\n",
      "            value of `a`.\n",
      "        \n",
      "            .. versionchanged:: 1.14.0\n",
      "               If not set, a FutureWarning is given. The previous default\n",
      "               of ``-1`` will use the machine precision as `rcond` parameter,\n",
      "               the new default will use the machine precision times `max(M, N)`.\n",
      "               To silence the warning and use the new default, use ``rcond=None``,\n",
      "               to keep using the old behavior, use ``rcond=-1``.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        x : {(N,), (N, K)} ndarray\n",
      "            Least-squares solution. If `b` is two-dimensional,\n",
      "            the solutions are in the `K` columns of `x`.\n",
      "        residuals : {(1,), (K,), (0,)} ndarray\n",
      "            Sums of squared residuals: Squared Euclidean 2-norm for each column in\n",
      "            ``b - a @ x``.\n",
      "            If the rank of `a` is < N or M <= N, this is an empty array.\n",
      "            If `b` is 1-dimensional, this is a (1,) shape array.\n",
      "            Otherwise the shape is (K,).\n",
      "        rank : int\n",
      "            Rank of matrix `a`.\n",
      "        s : (min(M, N),) ndarray\n",
      "            Singular values of `a`.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        LinAlgError\n",
      "            If computation does not converge.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.linalg.lstsq : Similar function in SciPy.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        If `b` is a matrix, then all array results are returned as matrices.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Fit a line, ``y = mx + c``, through some noisy data-points:\n",
      "        \n",
      "        >>> x = np.array([0, 1, 2, 3])\n",
      "        >>> y = np.array([-1, 0.2, 0.9, 2.1])\n",
      "        \n",
      "        By examining the coefficients, we see that the line should have a\n",
      "        gradient of roughly 1 and cut the y-axis at, more or less, -1.\n",
      "        \n",
      "        We can rewrite the line equation as ``y = Ap``, where ``A = [[x 1]]``\n",
      "        and ``p = [[m], [c]]``.  Now use `lstsq` to solve for `p`:\n",
      "        \n",
      "        >>> A = np.vstack([x, np.ones(len(x))]).T\n",
      "        >>> A\n",
      "        array([[ 0.,  1.],\n",
      "               [ 1.,  1.],\n",
      "               [ 2.,  1.],\n",
      "               [ 3.,  1.]])\n",
      "        \n",
      "        >>> m, c = np.linalg.lstsq(A, y, rcond=None)[0]\n",
      "        >>> m, c\n",
      "        (1.0 -0.95) # may vary\n",
      "        \n",
      "        Plot the data along with the fitted line:\n",
      "        \n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> _ = plt.plot(x, y, 'o', label='Original data', markersize=10)\n",
      "        >>> _ = plt.plot(x, m*x + c, 'r', label='Fitted line')\n",
      "        >>> _ = plt.legend()\n",
      "        >>> plt.show()\n",
      "    \n",
      "    matrix_power(a, n)\n",
      "        Raise a square matrix to the (integer) power `n`.\n",
      "        \n",
      "        For positive integers `n`, the power is computed by repeated matrix\n",
      "        squarings and matrix multiplications. If ``n == 0``, the identity matrix\n",
      "        of the same shape as M is returned. If ``n < 0``, the inverse\n",
      "        is computed and then raised to the ``abs(n)``.\n",
      "        \n",
      "        .. note:: Stacks of object matrices are not currently supported.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : (..., M, M) array_like\n",
      "            Matrix to be \"powered\".\n",
      "        n : int\n",
      "            The exponent can be any integer or long integer, positive,\n",
      "            negative, or zero.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        a**n : (..., M, M) ndarray or matrix object\n",
      "            The return value is the same shape and type as `M`;\n",
      "            if the exponent is positive or zero then the type of the\n",
      "            elements is the same as those of `M`. If the exponent is\n",
      "            negative the elements are floating-point.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        LinAlgError\n",
      "            For matrices that are not square or that (for negative powers) cannot\n",
      "            be inverted numerically.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> from numpy.linalg import matrix_power\n",
      "        >>> i = np.array([[0, 1], [-1, 0]]) # matrix equiv. of the imaginary unit\n",
      "        >>> matrix_power(i, 3) # should = -i\n",
      "        array([[ 0, -1],\n",
      "               [ 1,  0]])\n",
      "        >>> matrix_power(i, 0)\n",
      "        array([[1, 0],\n",
      "               [0, 1]])\n",
      "        >>> matrix_power(i, -3) # should = 1/(-i) = i, but w/ f.p. elements\n",
      "        array([[ 0.,  1.],\n",
      "               [-1.,  0.]])\n",
      "        \n",
      "        Somewhat more sophisticated example\n",
      "        \n",
      "        >>> q = np.zeros((4, 4))\n",
      "        >>> q[0:2, 0:2] = -i\n",
      "        >>> q[2:4, 2:4] = i\n",
      "        >>> q # one of the three quaternion units not equal to 1\n",
      "        array([[ 0., -1.,  0.,  0.],\n",
      "               [ 1.,  0.,  0.,  0.],\n",
      "               [ 0.,  0.,  0.,  1.],\n",
      "               [ 0.,  0., -1.,  0.]])\n",
      "        >>> matrix_power(q, 2) # = -np.eye(4)\n",
      "        array([[-1.,  0.,  0.,  0.],\n",
      "               [ 0., -1.,  0.,  0.],\n",
      "               [ 0.,  0., -1.,  0.],\n",
      "               [ 0.,  0.,  0., -1.]])\n",
      "    \n",
      "    matrix_rank(M, tol=None, hermitian=False)\n",
      "        Return matrix rank of array using SVD method\n",
      "        \n",
      "        Rank of the array is the number of singular values of the array that are\n",
      "        greater than `tol`.\n",
      "        \n",
      "        .. versionchanged:: 1.14\n",
      "           Can now operate on stacks of matrices\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        M : {(M,), (..., M, N)} array_like\n",
      "            Input vector or stack of matrices.\n",
      "        tol : (...) array_like, float, optional\n",
      "            Threshold below which SVD values are considered zero. If `tol` is\n",
      "            None, and ``S`` is an array with singular values for `M`, and\n",
      "            ``eps`` is the epsilon value for datatype of ``S``, then `tol` is\n",
      "            set to ``S.max() * max(M.shape) * eps``.\n",
      "        \n",
      "            .. versionchanged:: 1.14\n",
      "               Broadcasted against the stack of matrices\n",
      "        hermitian : bool, optional\n",
      "            If True, `M` is assumed to be Hermitian (symmetric if real-valued),\n",
      "            enabling a more efficient method for finding singular values.\n",
      "            Defaults to False.\n",
      "        \n",
      "            .. versionadded:: 1.14\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        rank : (...) array_like\n",
      "            Rank of M.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The default threshold to detect rank deficiency is a test on the magnitude\n",
      "        of the singular values of `M`.  By default, we identify singular values less\n",
      "        than ``S.max() * max(M.shape) * eps`` as indicating rank deficiency (with\n",
      "        the symbols defined above). This is the algorithm MATLAB uses [1].  It also\n",
      "        appears in *Numerical recipes* in the discussion of SVD solutions for linear\n",
      "        least squares [2].\n",
      "        \n",
      "        This default threshold is designed to detect rank deficiency accounting for\n",
      "        the numerical errors of the SVD computation.  Imagine that there is a column\n",
      "        in `M` that is an exact (in floating point) linear combination of other\n",
      "        columns in `M`. Computing the SVD on `M` will not produce a singular value\n",
      "        exactly equal to 0 in general: any difference of the smallest SVD value from\n",
      "        0 will be caused by numerical imprecision in the calculation of the SVD.\n",
      "        Our threshold for small SVD values takes this numerical imprecision into\n",
      "        account, and the default threshold will detect such numerical rank\n",
      "        deficiency.  The threshold may declare a matrix `M` rank deficient even if\n",
      "        the linear combination of some columns of `M` is not exactly equal to\n",
      "        another column of `M` but only numerically very close to another column of\n",
      "        `M`.\n",
      "        \n",
      "        We chose our default threshold because it is in wide use.  Other thresholds\n",
      "        are possible.  For example, elsewhere in the 2007 edition of *Numerical\n",
      "        recipes* there is an alternative threshold of ``S.max() *\n",
      "        np.finfo(M.dtype).eps / 2. * np.sqrt(m + n + 1.)``. The authors describe\n",
      "        this threshold as being based on \"expected roundoff error\" (p 71).\n",
      "        \n",
      "        The thresholds above deal with floating point roundoff error in the\n",
      "        calculation of the SVD.  However, you may have more information about the\n",
      "        sources of error in `M` that would make you consider other tolerance values\n",
      "        to detect *effective* rank deficiency.  The most useful measure of the\n",
      "        tolerance depends on the operations you intend to use on your matrix.  For\n",
      "        example, if your data come from uncertain measurements with uncertainties\n",
      "        greater than floating point epsilon, choosing a tolerance near that\n",
      "        uncertainty may be preferable.  The tolerance may be absolute if the\n",
      "        uncertainties are absolute rather than relative.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] MATLAB reference documention, \"Rank\"\n",
      "               https://www.mathworks.com/help/techdoc/ref/rank.html\n",
      "        .. [2] W. H. Press, S. A. Teukolsky, W. T. Vetterling and B. P. Flannery,\n",
      "               \"Numerical Recipes (3rd edition)\", Cambridge University Press, 2007,\n",
      "               page 795.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> from numpy.linalg import matrix_rank\n",
      "        >>> matrix_rank(np.eye(4)) # Full rank matrix\n",
      "        4\n",
      "        >>> I=np.eye(4); I[-1,-1] = 0. # rank deficient matrix\n",
      "        >>> matrix_rank(I)\n",
      "        3\n",
      "        >>> matrix_rank(np.ones((4,))) # 1 dimension - rank 1 unless all 0\n",
      "        1\n",
      "        >>> matrix_rank(np.zeros((4,)))\n",
      "        0\n",
      "    \n",
      "    multi_dot(arrays, *, out=None)\n",
      "        Compute the dot product of two or more arrays in a single function call,\n",
      "        while automatically selecting the fastest evaluation order.\n",
      "        \n",
      "        `multi_dot` chains `numpy.dot` and uses optimal parenthesization\n",
      "        of the matrices [1]_ [2]_. Depending on the shapes of the matrices,\n",
      "        this can speed up the multiplication a lot.\n",
      "        \n",
      "        If the first argument is 1-D it is treated as a row vector.\n",
      "        If the last argument is 1-D it is treated as a column vector.\n",
      "        The other arguments must be 2-D.\n",
      "        \n",
      "        Think of `multi_dot` as::\n",
      "        \n",
      "            def multi_dot(arrays): return functools.reduce(np.dot, arrays)\n",
      "        \n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        arrays : sequence of array_like\n",
      "            If the first argument is 1-D it is treated as row vector.\n",
      "            If the last argument is 1-D it is treated as column vector.\n",
      "            The other arguments must be 2-D.\n",
      "        out : ndarray, optional\n",
      "            Output argument. This must have the exact kind that would be returned\n",
      "            if it was not used. In particular, it must have the right type, must be\n",
      "            C-contiguous, and its dtype must be the dtype that would be returned\n",
      "            for `dot(a, b)`. This is a performance feature. Therefore, if these\n",
      "            conditions are not met, an exception is raised, instead of attempting\n",
      "            to be flexible.\n",
      "        \n",
      "            .. versionadded:: 1.19.0\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        output : ndarray\n",
      "            Returns the dot product of the supplied arrays.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        numpy.dot : dot multiplication with two arguments.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        \n",
      "        .. [1] Cormen, \"Introduction to Algorithms\", Chapter 15.2, p. 370-378\n",
      "        .. [2] https://en.wikipedia.org/wiki/Matrix_chain_multiplication\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        `multi_dot` allows you to write::\n",
      "        \n",
      "        >>> from numpy.linalg import multi_dot\n",
      "        >>> # Prepare some data\n",
      "        >>> A = np.random.random((10000, 100))\n",
      "        >>> B = np.random.random((100, 1000))\n",
      "        >>> C = np.random.random((1000, 5))\n",
      "        >>> D = np.random.random((5, 333))\n",
      "        >>> # the actual dot multiplication\n",
      "        >>> _ = multi_dot([A, B, C, D])\n",
      "        \n",
      "        instead of::\n",
      "        \n",
      "        >>> _ = np.dot(np.dot(np.dot(A, B), C), D)\n",
      "        >>> # or\n",
      "        >>> _ = A.dot(B).dot(C).dot(D)\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The cost for a matrix multiplication can be calculated with the\n",
      "        following function::\n",
      "        \n",
      "            def cost(A, B):\n",
      "                return A.shape[0] * A.shape[1] * B.shape[1]\n",
      "        \n",
      "        Assume we have three matrices\n",
      "        :math:`A_{10x100}, B_{100x5}, C_{5x50}`.\n",
      "        \n",
      "        The costs for the two different parenthesizations are as follows::\n",
      "        \n",
      "            cost((AB)C) = 10*100*5 + 10*5*50   = 5000 + 2500   = 7500\n",
      "            cost(A(BC)) = 10*100*50 + 100*5*50 = 50000 + 25000 = 75000\n",
      "    \n",
      "    norm(x, ord=None, axis=None, keepdims=False)\n",
      "        Matrix or vector norm.\n",
      "        \n",
      "        This function is able to return one of eight different matrix norms,\n",
      "        or one of an infinite number of vector norms (described below), depending\n",
      "        on the value of the ``ord`` parameter.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            Input array.  If `axis` is None, `x` must be 1-D or 2-D, unless `ord`\n",
      "            is None. If both `axis` and `ord` are None, the 2-norm of\n",
      "            ``x.ravel`` will be returned.\n",
      "        ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional\n",
      "            Order of the norm (see table under ``Notes``). inf means numpy's\n",
      "            `inf` object. The default is None.\n",
      "        axis : {None, int, 2-tuple of ints}, optional.\n",
      "            If `axis` is an integer, it specifies the axis of `x` along which to\n",
      "            compute the vector norms.  If `axis` is a 2-tuple, it specifies the\n",
      "            axes that hold 2-D matrices, and the matrix norms of these matrices\n",
      "            are computed.  If `axis` is None then either a vector norm (when `x`\n",
      "            is 1-D) or a matrix norm (when `x` is 2-D) is returned. The default\n",
      "            is None.\n",
      "        \n",
      "            .. versionadded:: 1.8.0\n",
      "        \n",
      "        keepdims : bool, optional\n",
      "            If this is set to True, the axes which are normed over are left in the\n",
      "            result as dimensions with size one.  With this option the result will\n",
      "            broadcast correctly against the original `x`.\n",
      "        \n",
      "            .. versionadded:: 1.10.0\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        n : float or ndarray\n",
      "            Norm of the matrix or vector(s).\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.linalg.norm : Similar function in SciPy.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        For values of ``ord < 1``, the result is, strictly speaking, not a\n",
      "        mathematical 'norm', but it may still be useful for various numerical\n",
      "        purposes.\n",
      "        \n",
      "        The following norms can be calculated:\n",
      "        \n",
      "        =====  ============================  ==========================\n",
      "        ord    norm for matrices             norm for vectors\n",
      "        =====  ============================  ==========================\n",
      "        None   Frobenius norm                2-norm\n",
      "        'fro'  Frobenius norm                --\n",
      "        'nuc'  nuclear norm                  --\n",
      "        inf    max(sum(abs(x), axis=1))      max(abs(x))\n",
      "        -inf   min(sum(abs(x), axis=1))      min(abs(x))\n",
      "        0      --                            sum(x != 0)\n",
      "        1      max(sum(abs(x), axis=0))      as below\n",
      "        -1     min(sum(abs(x), axis=0))      as below\n",
      "        2      2-norm (largest sing. value)  as below\n",
      "        -2     smallest singular value       as below\n",
      "        other  --                            sum(abs(x)**ord)**(1./ord)\n",
      "        =====  ============================  ==========================\n",
      "        \n",
      "        The Frobenius norm is given by [1]_:\n",
      "        \n",
      "            :math:`||A||_F = [\\sum_{i,j} abs(a_{i,j})^2]^{1/2}`\n",
      "        \n",
      "        The nuclear norm is the sum of the singular values.\n",
      "        \n",
      "        Both the Frobenius and nuclear norm orders are only defined for\n",
      "        matrices and raise a ValueError when ``x.ndim != 2``.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,\n",
      "               Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> from numpy import linalg as LA\n",
      "        >>> a = np.arange(9) - 4\n",
      "        >>> a\n",
      "        array([-4, -3, -2, ...,  2,  3,  4])\n",
      "        >>> b = a.reshape((3, 3))\n",
      "        >>> b\n",
      "        array([[-4, -3, -2],\n",
      "               [-1,  0,  1],\n",
      "               [ 2,  3,  4]])\n",
      "        \n",
      "        >>> LA.norm(a)\n",
      "        7.745966692414834\n",
      "        >>> LA.norm(b)\n",
      "        7.745966692414834\n",
      "        >>> LA.norm(b, 'fro')\n",
      "        7.745966692414834\n",
      "        >>> LA.norm(a, np.inf)\n",
      "        4.0\n",
      "        >>> LA.norm(b, np.inf)\n",
      "        9.0\n",
      "        >>> LA.norm(a, -np.inf)\n",
      "        0.0\n",
      "        >>> LA.norm(b, -np.inf)\n",
      "        2.0\n",
      "        \n",
      "        >>> LA.norm(a, 1)\n",
      "        20.0\n",
      "        >>> LA.norm(b, 1)\n",
      "        7.0\n",
      "        >>> LA.norm(a, -1)\n",
      "        -4.6566128774142013e-010\n",
      "        >>> LA.norm(b, -1)\n",
      "        6.0\n",
      "        >>> LA.norm(a, 2)\n",
      "        7.745966692414834\n",
      "        >>> LA.norm(b, 2)\n",
      "        7.3484692283495345\n",
      "        \n",
      "        >>> LA.norm(a, -2)\n",
      "        0.0\n",
      "        >>> LA.norm(b, -2)\n",
      "        1.8570331885190563e-016 # may vary\n",
      "        >>> LA.norm(a, 3)\n",
      "        5.8480354764257312 # may vary\n",
      "        >>> LA.norm(a, -3)\n",
      "        0.0\n",
      "        \n",
      "        Using the `axis` argument to compute vector norms:\n",
      "        \n",
      "        >>> c = np.array([[ 1, 2, 3],\n",
      "        ...               [-1, 1, 4]])\n",
      "        >>> LA.norm(c, axis=0)\n",
      "        array([ 1.41421356,  2.23606798,  5.        ])\n",
      "        >>> LA.norm(c, axis=1)\n",
      "        array([ 3.74165739,  4.24264069])\n",
      "        >>> LA.norm(c, ord=1, axis=1)\n",
      "        array([ 6.,  6.])\n",
      "        \n",
      "        Using the `axis` argument to compute matrix norms:\n",
      "        \n",
      "        >>> m = np.arange(8).reshape(2,2,2)\n",
      "        >>> LA.norm(m, axis=(1,2))\n",
      "        array([  3.74165739,  11.22497216])\n",
      "        >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])\n",
      "        (3.7416573867739413, 11.224972160321824)\n",
      "    \n",
      "    pinv(a, rcond=1e-15, hermitian=False)\n",
      "        Compute the (Moore-Penrose) pseudo-inverse of a matrix.\n",
      "        \n",
      "        Calculate the generalized inverse of a matrix using its\n",
      "        singular-value decomposition (SVD) and including all\n",
      "        *large* singular values.\n",
      "        \n",
      "        .. versionchanged:: 1.14\n",
      "           Can now operate on stacks of matrices\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : (..., M, N) array_like\n",
      "            Matrix or stack of matrices to be pseudo-inverted.\n",
      "        rcond : (...) array_like of float\n",
      "            Cutoff for small singular values.\n",
      "            Singular values less than or equal to\n",
      "            ``rcond * largest_singular_value`` are set to zero.\n",
      "            Broadcasts against the stack of matrices.\n",
      "        hermitian : bool, optional\n",
      "            If True, `a` is assumed to be Hermitian (symmetric if real-valued),\n",
      "            enabling a more efficient method for finding singular values.\n",
      "            Defaults to False.\n",
      "        \n",
      "            .. versionadded:: 1.17.0\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        B : (..., N, M) ndarray\n",
      "            The pseudo-inverse of `a`. If `a` is a `matrix` instance, then so\n",
      "            is `B`.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        LinAlgError\n",
      "            If the SVD computation does not converge.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.linalg.pinv : Similar function in SciPy.\n",
      "        scipy.linalg.pinv2 : Similar function in SciPy (SVD-based).\n",
      "        scipy.linalg.pinvh : Compute the (Moore-Penrose) pseudo-inverse of a\n",
      "                             Hermitian matrix.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The pseudo-inverse of a matrix A, denoted :math:`A^+`, is\n",
      "        defined as: \"the matrix that 'solves' [the least-squares problem]\n",
      "        :math:`Ax = b`,\" i.e., if :math:`\\bar{x}` is said solution, then\n",
      "        :math:`A^+` is that matrix such that :math:`\\bar{x} = A^+b`.\n",
      "        \n",
      "        It can be shown that if :math:`Q_1 \\Sigma Q_2^T = A` is the singular\n",
      "        value decomposition of A, then\n",
      "        :math:`A^+ = Q_2 \\Sigma^+ Q_1^T`, where :math:`Q_{1,2}` are\n",
      "        orthogonal matrices, :math:`\\Sigma` is a diagonal matrix consisting\n",
      "        of A's so-called singular values, (followed, typically, by\n",
      "        zeros), and then :math:`\\Sigma^+` is simply the diagonal matrix\n",
      "        consisting of the reciprocals of A's singular values\n",
      "        (again, followed by zeros). [1]_\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,\n",
      "               FL, Academic Press, Inc., 1980, pp. 139-142.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        The following example checks that ``a * a+ * a == a`` and\n",
      "        ``a+ * a * a+ == a+``:\n",
      "        \n",
      "        >>> a = np.random.randn(9, 6)\n",
      "        >>> B = np.linalg.pinv(a)\n",
      "        >>> np.allclose(a, np.dot(a, np.dot(B, a)))\n",
      "        True\n",
      "        >>> np.allclose(B, np.dot(B, np.dot(a, B)))\n",
      "        True\n",
      "    \n",
      "    qr(a, mode='reduced')\n",
      "        Compute the qr factorization of a matrix.\n",
      "        \n",
      "        Factor the matrix `a` as *qr*, where `q` is orthonormal and `r` is\n",
      "        upper-triangular.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : array_like, shape (M, N)\n",
      "            Matrix to be factored.\n",
      "        mode : {'reduced', 'complete', 'r', 'raw'}, optional\n",
      "            If K = min(M, N), then\n",
      "        \n",
      "            * 'reduced'  : returns q, r with dimensions (M, K), (K, N) (default)\n",
      "            * 'complete' : returns q, r with dimensions (M, M), (M, N)\n",
      "            * 'r'        : returns r only with dimensions (K, N)\n",
      "            * 'raw'      : returns h, tau with dimensions (N, M), (K,)\n",
      "        \n",
      "            The options 'reduced', 'complete, and 'raw' are new in numpy 1.8,\n",
      "            see the notes for more information. The default is 'reduced', and to\n",
      "            maintain backward compatibility with earlier versions of numpy both\n",
      "            it and the old default 'full' can be omitted. Note that array h\n",
      "            returned in 'raw' mode is transposed for calling Fortran. The\n",
      "            'economic' mode is deprecated.  The modes 'full' and 'economic' may\n",
      "            be passed using only the first letter for backwards compatibility,\n",
      "            but all others must be spelled out. See the Notes for more\n",
      "            explanation.\n",
      "        \n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        q : ndarray of float or complex, optional\n",
      "            A matrix with orthonormal columns. When mode = 'complete' the\n",
      "            result is an orthogonal/unitary matrix depending on whether or not\n",
      "            a is real/complex. The determinant may be either +/- 1 in that\n",
      "            case.\n",
      "        r : ndarray of float or complex, optional\n",
      "            The upper-triangular matrix.\n",
      "        (h, tau) : ndarrays of np.double or np.cdouble, optional\n",
      "            The array h contains the Householder reflectors that generate q\n",
      "            along with r. The tau array contains scaling factors for the\n",
      "            reflectors. In the deprecated  'economic' mode only h is returned.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        LinAlgError\n",
      "            If factoring fails.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.linalg.qr : Similar function in SciPy.\n",
      "        scipy.linalg.rq : Compute RQ decomposition of a matrix.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This is an interface to the LAPACK routines ``dgeqrf``, ``zgeqrf``,\n",
      "        ``dorgqr``, and ``zungqr``.\n",
      "        \n",
      "        For more information on the qr factorization, see for example:\n",
      "        https://en.wikipedia.org/wiki/QR_factorization\n",
      "        \n",
      "        Subclasses of `ndarray` are preserved except for the 'raw' mode. So if\n",
      "        `a` is of type `matrix`, all the return values will be matrices too.\n",
      "        \n",
      "        New 'reduced', 'complete', and 'raw' options for mode were added in\n",
      "        NumPy 1.8.0 and the old option 'full' was made an alias of 'reduced'.  In\n",
      "        addition the options 'full' and 'economic' were deprecated.  Because\n",
      "        'full' was the previous default and 'reduced' is the new default,\n",
      "        backward compatibility can be maintained by letting `mode` default.\n",
      "        The 'raw' option was added so that LAPACK routines that can multiply\n",
      "        arrays by q using the Householder reflectors can be used. Note that in\n",
      "        this case the returned arrays are of type np.double or np.cdouble and\n",
      "        the h array is transposed to be FORTRAN compatible.  No routines using\n",
      "        the 'raw' return are currently exposed by numpy, but some are available\n",
      "        in lapack_lite and just await the necessary work.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> a = np.random.randn(9, 6)\n",
      "        >>> q, r = np.linalg.qr(a)\n",
      "        >>> np.allclose(a, np.dot(q, r))  # a does equal qr\n",
      "        True\n",
      "        >>> r2 = np.linalg.qr(a, mode='r')\n",
      "        >>> np.allclose(r, r2)  # mode='r' returns the same r as mode='full'\n",
      "        True\n",
      "        \n",
      "        Example illustrating a common use of `qr`: solving of least squares\n",
      "        problems\n",
      "        \n",
      "        What are the least-squares-best `m` and `y0` in ``y = y0 + mx`` for\n",
      "        the following data: {(0,1), (1,0), (1,2), (2,1)}. (Graph the points\n",
      "        and you'll see that it should be y0 = 0, m = 1.)  The answer is provided\n",
      "        by solving the over-determined matrix equation ``Ax = b``, where::\n",
      "        \n",
      "          A = array([[0, 1], [1, 1], [1, 1], [2, 1]])\n",
      "          x = array([[y0], [m]])\n",
      "          b = array([[1], [0], [2], [1]])\n",
      "        \n",
      "        If A = qr such that q is orthonormal (which is always possible via\n",
      "        Gram-Schmidt), then ``x = inv(r) * (q.T) * b``.  (In numpy practice,\n",
      "        however, we simply use `lstsq`.)\n",
      "        \n",
      "        >>> A = np.array([[0, 1], [1, 1], [1, 1], [2, 1]])\n",
      "        >>> A\n",
      "        array([[0, 1],\n",
      "               [1, 1],\n",
      "               [1, 1],\n",
      "               [2, 1]])\n",
      "        >>> b = np.array([1, 0, 2, 1])\n",
      "        >>> q, r = np.linalg.qr(A)\n",
      "        >>> p = np.dot(q.T, b)\n",
      "        >>> np.dot(np.linalg.inv(r), p)\n",
      "        array([  1.1e-16,   1.0e+00])\n",
      "    \n",
      "    slogdet(a)\n",
      "        Compute the sign and (natural) logarithm of the determinant of an array.\n",
      "        \n",
      "        If an array has a very small or very large determinant, then a call to\n",
      "        `det` may overflow or underflow. This routine is more robust against such\n",
      "        issues, because it computes the logarithm of the determinant rather than\n",
      "        the determinant itself.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : (..., M, M) array_like\n",
      "            Input array, has to be a square 2-D array.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        sign : (...) array_like\n",
      "            A number representing the sign of the determinant. For a real matrix,\n",
      "            this is 1, 0, or -1. For a complex matrix, this is a complex number\n",
      "            with absolute value 1 (i.e., it is on the unit circle), or else 0.\n",
      "        logdet : (...) array_like\n",
      "            The natural log of the absolute value of the determinant.\n",
      "        \n",
      "        If the determinant is zero, then `sign` will be 0 and `logdet` will be\n",
      "        -Inf. In all cases, the determinant is equal to ``sign * np.exp(logdet)``.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        det\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        .. versionadded:: 1.8.0\n",
      "        \n",
      "        Broadcasting rules apply, see the `numpy.linalg` documentation for\n",
      "        details.\n",
      "        \n",
      "        .. versionadded:: 1.6.0\n",
      "        \n",
      "        The determinant is computed via LU factorization using the LAPACK\n",
      "        routine ``z/dgetrf``.\n",
      "        \n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        The determinant of a 2-D array ``[[a, b], [c, d]]`` is ``ad - bc``:\n",
      "        \n",
      "        >>> a = np.array([[1, 2], [3, 4]])\n",
      "        >>> (sign, logdet) = np.linalg.slogdet(a)\n",
      "        >>> (sign, logdet)\n",
      "        (-1, 0.69314718055994529) # may vary\n",
      "        >>> sign * np.exp(logdet)\n",
      "        -2.0\n",
      "        \n",
      "        Computing log-determinants for a stack of matrices:\n",
      "        \n",
      "        >>> a = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ])\n",
      "        >>> a.shape\n",
      "        (3, 2, 2)\n",
      "        >>> sign, logdet = np.linalg.slogdet(a)\n",
      "        >>> (sign, logdet)\n",
      "        (array([-1., -1., -1.]), array([ 0.69314718,  1.09861229,  2.07944154]))\n",
      "        >>> sign * np.exp(logdet)\n",
      "        array([-2., -3., -8.])\n",
      "        \n",
      "        This routine succeeds where ordinary `det` does not:\n",
      "        \n",
      "        >>> np.linalg.det(np.eye(500) * 0.1)\n",
      "        0.0\n",
      "        >>> np.linalg.slogdet(np.eye(500) * 0.1)\n",
      "        (1, -1151.2925464970228)\n",
      "    \n",
      "    solve(a, b)\n",
      "        Solve a linear matrix equation, or system of linear scalar equations.\n",
      "        \n",
      "        Computes the \"exact\" solution, `x`, of the well-determined, i.e., full\n",
      "        rank, linear matrix equation `ax = b`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : (..., M, M) array_like\n",
      "            Coefficient matrix.\n",
      "        b : {(..., M,), (..., M, K)}, array_like\n",
      "            Ordinate or \"dependent variable\" values.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        x : {(..., M,), (..., M, K)} ndarray\n",
      "            Solution to the system a x = b.  Returned shape is identical to `b`.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        LinAlgError\n",
      "            If `a` is singular or not square.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.linalg.solve : Similar function in SciPy.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        .. versionadded:: 1.8.0\n",
      "        \n",
      "        Broadcasting rules apply, see the `numpy.linalg` documentation for\n",
      "        details.\n",
      "        \n",
      "        The solutions are computed using LAPACK routine ``_gesv``.\n",
      "        \n",
      "        `a` must be square and of full-rank, i.e., all rows (or, equivalently,\n",
      "        columns) must be linearly independent; if either is not true, use\n",
      "        `lstsq` for the least-squares best \"solution\" of the\n",
      "        system/equation.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,\n",
      "               FL, Academic Press, Inc., 1980, pg. 22.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Solve the system of equations ``x0 + 2 * x1 = 1`` and ``3 * x0 + 5 * x1 = 2``:\n",
      "        \n",
      "        >>> a = np.array([[1, 2], [3, 5]])\n",
      "        >>> b = np.array([1, 2])\n",
      "        >>> x = np.linalg.solve(a, b)\n",
      "        >>> x\n",
      "        array([-1.,  1.])\n",
      "        \n",
      "        Check that the solution is correct:\n",
      "        \n",
      "        >>> np.allclose(np.dot(a, x), b)\n",
      "        True\n",
      "    \n",
      "    svd(a, full_matrices=True, compute_uv=True, hermitian=False)\n",
      "        Singular Value Decomposition.\n",
      "        \n",
      "        When `a` is a 2D array, it is factorized as ``u @ np.diag(s) @ vh\n",
      "        = (u * s) @ vh``, where `u` and `vh` are 2D unitary arrays and `s` is a 1D\n",
      "        array of `a`'s singular values. When `a` is higher-dimensional, SVD is\n",
      "        applied in stacked mode as explained below.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : (..., M, N) array_like\n",
      "            A real or complex array with ``a.ndim >= 2``.\n",
      "        full_matrices : bool, optional\n",
      "            If True (default), `u` and `vh` have the shapes ``(..., M, M)`` and\n",
      "            ``(..., N, N)``, respectively.  Otherwise, the shapes are\n",
      "            ``(..., M, K)`` and ``(..., K, N)``, respectively, where\n",
      "            ``K = min(M, N)``.\n",
      "        compute_uv : bool, optional\n",
      "            Whether or not to compute `u` and `vh` in addition to `s`.  True\n",
      "            by default.\n",
      "        hermitian : bool, optional\n",
      "            If True, `a` is assumed to be Hermitian (symmetric if real-valued),\n",
      "            enabling a more efficient method for finding singular values.\n",
      "            Defaults to False.\n",
      "        \n",
      "            .. versionadded:: 1.17.0\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        u : { (..., M, M), (..., M, K) } array\n",
      "            Unitary array(s). The first ``a.ndim - 2`` dimensions have the same\n",
      "            size as those of the input `a`. The size of the last two dimensions\n",
      "            depends on the value of `full_matrices`. Only returned when\n",
      "            `compute_uv` is True.\n",
      "        s : (..., K) array\n",
      "            Vector(s) with the singular values, within each vector sorted in\n",
      "            descending order. The first ``a.ndim - 2`` dimensions have the same\n",
      "            size as those of the input `a`.\n",
      "        vh : { (..., N, N), (..., K, N) } array\n",
      "            Unitary array(s). The first ``a.ndim - 2`` dimensions have the same\n",
      "            size as those of the input `a`. The size of the last two dimensions\n",
      "            depends on the value of `full_matrices`. Only returned when\n",
      "            `compute_uv` is True.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        LinAlgError\n",
      "            If SVD computation does not converge.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.linalg.svd : Similar function in SciPy.\n",
      "        scipy.linalg.svdvals : Compute singular values of a matrix.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        .. versionchanged:: 1.8.0\n",
      "           Broadcasting rules apply, see the `numpy.linalg` documentation for\n",
      "           details.\n",
      "        \n",
      "        The decomposition is performed using LAPACK routine ``_gesdd``.\n",
      "        \n",
      "        SVD is usually described for the factorization of a 2D matrix :math:`A`.\n",
      "        The higher-dimensional case will be discussed below. In the 2D case, SVD is\n",
      "        written as :math:`A = U S V^H`, where :math:`A = a`, :math:`U= u`,\n",
      "        :math:`S= \\mathtt{np.diag}(s)` and :math:`V^H = vh`. The 1D array `s`\n",
      "        contains the singular values of `a` and `u` and `vh` are unitary. The rows\n",
      "        of `vh` are the eigenvectors of :math:`A^H A` and the columns of `u` are\n",
      "        the eigenvectors of :math:`A A^H`. In both cases the corresponding\n",
      "        (possibly non-zero) eigenvalues are given by ``s**2``.\n",
      "        \n",
      "        If `a` has more than two dimensions, then broadcasting rules apply, as\n",
      "        explained in :ref:`routines.linalg-broadcasting`. This means that SVD is\n",
      "        working in \"stacked\" mode: it iterates over all indices of the first\n",
      "        ``a.ndim - 2`` dimensions and for each combination SVD is applied to the\n",
      "        last two indices. The matrix `a` can be reconstructed from the\n",
      "        decomposition with either ``(u * s[..., None, :]) @ vh`` or\n",
      "        ``u @ (s[..., None] * vh)``. (The ``@`` operator can be replaced by the\n",
      "        function ``np.matmul`` for python versions below 3.5.)\n",
      "        \n",
      "        If `a` is a ``matrix`` object (as opposed to an ``ndarray``), then so are\n",
      "        all the return values.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> a = np.random.randn(9, 6) + 1j*np.random.randn(9, 6)\n",
      "        >>> b = np.random.randn(2, 7, 8, 3) + 1j*np.random.randn(2, 7, 8, 3)\n",
      "        \n",
      "        Reconstruction based on full SVD, 2D case:\n",
      "        \n",
      "        >>> u, s, vh = np.linalg.svd(a, full_matrices=True)\n",
      "        >>> u.shape, s.shape, vh.shape\n",
      "        ((9, 9), (6,), (6, 6))\n",
      "        >>> np.allclose(a, np.dot(u[:, :6] * s, vh))\n",
      "        True\n",
      "        >>> smat = np.zeros((9, 6), dtype=complex)\n",
      "        >>> smat[:6, :6] = np.diag(s)\n",
      "        >>> np.allclose(a, np.dot(u, np.dot(smat, vh)))\n",
      "        True\n",
      "        \n",
      "        Reconstruction based on reduced SVD, 2D case:\n",
      "        \n",
      "        >>> u, s, vh = np.linalg.svd(a, full_matrices=False)\n",
      "        >>> u.shape, s.shape, vh.shape\n",
      "        ((9, 6), (6,), (6, 6))\n",
      "        >>> np.allclose(a, np.dot(u * s, vh))\n",
      "        True\n",
      "        >>> smat = np.diag(s)\n",
      "        >>> np.allclose(a, np.dot(u, np.dot(smat, vh)))\n",
      "        True\n",
      "        \n",
      "        Reconstruction based on full SVD, 4D case:\n",
      "        \n",
      "        >>> u, s, vh = np.linalg.svd(b, full_matrices=True)\n",
      "        >>> u.shape, s.shape, vh.shape\n",
      "        ((2, 7, 8, 8), (2, 7, 3), (2, 7, 3, 3))\n",
      "        >>> np.allclose(b, np.matmul(u[..., :3] * s[..., None, :], vh))\n",
      "        True\n",
      "        >>> np.allclose(b, np.matmul(u[..., :3], s[..., None] * vh))\n",
      "        True\n",
      "        \n",
      "        Reconstruction based on reduced SVD, 4D case:\n",
      "        \n",
      "        >>> u, s, vh = np.linalg.svd(b, full_matrices=False)\n",
      "        >>> u.shape, s.shape, vh.shape\n",
      "        ((2, 7, 8, 3), (2, 7, 3), (2, 7, 3, 3))\n",
      "        >>> np.allclose(b, np.matmul(u * s[..., None, :], vh))\n",
      "        True\n",
      "        >>> np.allclose(b, np.matmul(u, s[..., None] * vh))\n",
      "        True\n",
      "    \n",
      "    tensorinv(a, ind=2)\n",
      "        Compute the 'inverse' of an N-dimensional array.\n",
      "        \n",
      "        The result is an inverse for `a` relative to the tensordot operation\n",
      "        ``tensordot(a, b, ind)``, i. e., up to floating-point accuracy,\n",
      "        ``tensordot(tensorinv(a), a, ind)`` is the \"identity\" tensor for the\n",
      "        tensordot operation.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : array_like\n",
      "            Tensor to 'invert'. Its shape must be 'square', i. e.,\n",
      "            ``prod(a.shape[:ind]) == prod(a.shape[ind:])``.\n",
      "        ind : int, optional\n",
      "            Number of first indices that are involved in the inverse sum.\n",
      "            Must be a positive integer, default is 2.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        b : ndarray\n",
      "            `a`'s tensordot inverse, shape ``a.shape[ind:] + a.shape[:ind]``.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        LinAlgError\n",
      "            If `a` is singular or not 'square' (in the above sense).\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        numpy.tensordot, tensorsolve\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> a = np.eye(4*6)\n",
      "        >>> a.shape = (4, 6, 8, 3)\n",
      "        >>> ainv = np.linalg.tensorinv(a, ind=2)\n",
      "        >>> ainv.shape\n",
      "        (8, 3, 4, 6)\n",
      "        >>> b = np.random.randn(4, 6)\n",
      "        >>> np.allclose(np.tensordot(ainv, b), np.linalg.tensorsolve(a, b))\n",
      "        True\n",
      "        \n",
      "        >>> a = np.eye(4*6)\n",
      "        >>> a.shape = (24, 8, 3)\n",
      "        >>> ainv = np.linalg.tensorinv(a, ind=1)\n",
      "        >>> ainv.shape\n",
      "        (8, 3, 24)\n",
      "        >>> b = np.random.randn(24)\n",
      "        >>> np.allclose(np.tensordot(ainv, b, 1), np.linalg.tensorsolve(a, b))\n",
      "        True\n",
      "    \n",
      "    tensorsolve(a, b, axes=None)\n",
      "        Solve the tensor equation ``a x = b`` for x.\n",
      "        \n",
      "        It is assumed that all indices of `x` are summed over in the product,\n",
      "        together with the rightmost indices of `a`, as is done in, for example,\n",
      "        ``tensordot(a, x, axes=b.ndim)``.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        a : array_like\n",
      "            Coefficient tensor, of shape ``b.shape + Q``. `Q`, a tuple, equals\n",
      "            the shape of that sub-tensor of `a` consisting of the appropriate\n",
      "            number of its rightmost indices, and must be such that\n",
      "            ``prod(Q) == prod(b.shape)`` (in which sense `a` is said to be\n",
      "            'square').\n",
      "        b : array_like\n",
      "            Right-hand tensor, which can be of any shape.\n",
      "        axes : tuple of ints, optional\n",
      "            Axes in `a` to reorder to the right, before inversion.\n",
      "            If None (default), no reordering is done.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        x : ndarray, shape Q\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        LinAlgError\n",
      "            If `a` is singular or not 'square' (in the above sense).\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        numpy.tensordot, tensorinv, numpy.einsum\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> a = np.eye(2*3*4)\n",
      "        >>> a.shape = (2*3, 4, 2, 3, 4)\n",
      "        >>> b = np.random.randn(2*3, 4)\n",
      "        >>> x = np.linalg.tensorsolve(a, b)\n",
      "        >>> x.shape\n",
      "        (2, 3, 4)\n",
      "        >>> np.allclose(np.tensordot(a, x, axes=3), b)\n",
      "        True\n",
      "\n",
      "DATA\n",
      "    __all__ = ['matrix_power', 'solve', 'tensorsolve', 'tensorinv', 'inv',...\n",
      "\n",
      "FILE\n",
      "    c:\\users\\edgar\\anaconda3\\lib\\site-packages\\numpy\\linalg\\__init__.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.linalg)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}