Matrices - Code Challenge.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Matrices\n",
    "## Code Challenge: 37\n",
    "#### The goal of this challenge is to determine whether the scalar multiplication is linear s(A+B) = sA  + sB "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "import imagesc as imagesc\n",
    "from scipy import linalg\n",
    "import matplotlib.pyplot as plt \n",
    "from sympy import * \n",
    "scalar_ = 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.random.randint(50, size = (4,4))\n",
    "a_s= a * scalar_\n",
    "a\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.random.randint(50, size = (4,4))\n",
    "b_s = b * scalar_\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ans_1 = a+b\n",
    "ans_1\n",
    "ans_1_s = ans_1 * scalar_\n",
    "ans_1_s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ans_2 = a_s + b_s\n",
    "ans_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = (ans_1_s - ans_2)\n",
    "print(x)\n",
    "print(f'The Result is \\n {ans_1_s == ans_2}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Thus we can see Scalar-Multiplication is the linear"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code Challenge: 41 - The Linearity of Trace \n",
    "\n",
    "### An operator is linear if it is closed under addition and multiplication. \n",
    "\n",
    "#### Determine the relationship between tr(A) + tr(B) and tr(A+B)  (If trace is linear operator then this should be equal to each other) \n",
    "#### Determine the relationship between tr(scalar*A) and scalar * tr(A). (If trace is linear operator then this should be equal ) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aa =np.random.randint(50, size = (4,4))\n",
    "aa\n",
    "aa_trace = np.trace(aa)\n",
    "aa_trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bb = np.random.randint(50, size = (4,4))\n",
    "bb\n",
    "bb_trace = np.trace(bb)\n",
    "bb_trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum_1 = aa + bb\n",
    "sum_1\n",
    "sum_trace_1 = np.trace(sum_1)\n",
    "sum_trace_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print((aa_trace+bb_trace) == sum_trace_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trc_scl_aa = np.trace(aa*scalar_)\n",
    "trc_scl_aa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "RHS = scalar_ * aa_trace\n",
    "RHS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(trc_scl_aa == RHS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Thus both the condition proves that trace is the linear operator of those two conditions given above! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 45 - Matrix Multiplication by Layering\n",
    "#### Implement Matrix Multiplication by layering using for loops and outer product. \n",
    "#### Generate Two Matrices (A,B). Build the product matrix layer-wise (for loops).\n",
    "#### Implement the matrix multiplication directly \n",
    "#### Compare the results.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aaa = np.random.randint(10, size = (2,2))\n",
    "aaa\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bbb = np.random.randint(10, size = (2,2))\n",
    "bbb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zeroes_ = np.zeros(((np.shape(aaa)[0]),(np.shape(bbb)[1])))\n",
    "zeroes_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for ii_r,ii_val in enumerate(aaa):\n",
    "#     for jj_c,jj_val in enumerate(ii_val):\n",
    "#         zeroes_[ii_r][jj_c] =  aaa[ii_r][jj_c] *bbb[ii_r][jj_c]\n",
    "# zeroes_\n",
    "\n",
    "for ii in range(0,np.shape(aaa)[1]):\n",
    "    zeroes_ += (np.outer(np.transpose(aaa)[ii],bbb[ii]))\n",
    "zeroes_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ans_2 = np.matmul(aaa,bbb)\n",
    "ans_2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### It's working now! \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 50- Pure and Impure Rotation Matrices\n",
    "#### Take a code from 2D Transformation and keep it in a for loop and vary the theta(angle) with we rotate using pure rotation and impure rotation matrix. \n",
    "#### Then compute the length of the output vector and once you finish the for loop, generate the plot that will show the magnitude of the vector with or without the pure and impure rotation. \n",
    "#### Length of the vector on the y-axis and thetas(angle) on the x-axis. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## pure rotation\n",
    "\n",
    "# 2D input vector\n",
    "v = np.array([ 3, -2 ])\n",
    "\n",
    "# 2x2 rotation matrix\n",
    "thetas = np.linspace(0,2*np.pi,100)\n",
    "\n",
    "\n",
    "lenth_ = len(thetas)\n",
    "# print(lenth_)\n",
    "\n",
    "s = (lenth_,2)\n",
    "print(s)\n",
    "mag_vec = np.zeros(s)\n",
    "mag_vec_2 = np.zeros(s)\n",
    "\n",
    "\n",
    "for i in range(lenth_):\n",
    "    theta = thetas[i]\n",
    "    \n",
    "    A1 = np.array([ [math.cos(theta),-math.sin(theta)], [math.sin(theta),math.cos(theta)] ]) # Pure Rotation\n",
    "    A2 = np.array([ [2*math.cos(theta),-math.sin(theta)], [math.sin(theta),math.cos(theta)] ]) #Impure Rotation \n",
    "    \n",
    "    mag_vec[i][0] = np.linalg.norm(A1@np.matrix.transpose(v))\n",
    "    mag_vec[i][1] = np.linalg.norm(A2@np.matrix.transpose(v))\n",
    "    vec_1 = np.matmul(A1,v)\n",
    "    vec_2 = np.matmul(A2,v)\n",
    "\n",
    "\n",
    "    \n",
    "    plt.figure(1)\n",
    "    plt.grid(b = True)\n",
    "    plt.plot([0, vec_1[0]], [0, vec_1[1]],'k')\n",
    "    plt.plot([0, vec_2[0]], [0, vec_2[1]],linestyle='dashed')\n",
    "    plt.legend(['Pure Rotation', 'Impure Rotation'],loc ='upper right');\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "plt.figure()\n",
    "plt.plot(thetas,mag_vec)\n",
    "plt.legend(['Pure Rotation', 'Impure Rotation'],loc ='upper right');\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 51 - Geometric Transformations via matrix multiplication\n",
    "#### Generate XY Coordinates for a Circle\n",
    "#### Plot the circle \n",
    "#### Create the 2x2 Identity Matrix \n",
    "#### Multiply the matrix by the co-ordinates \n",
    "#### Plot the new coordinates \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "angles_ = np.linspace(0,2*np.pi,num = 80)\n",
    "radius = 1\n",
    "\n",
    "x = 10\n",
    "plt.figure(1,figsize=(x,x))\n",
    "\n",
    "# Generate XY Coordinates for a Circle\n",
    "x = radius * np.cos(angles_)\n",
    "y = radius * np.sin(angles_)\n",
    "print(np.shape(y))\n",
    "\n",
    "\n",
    "xy = np.column_stack((x,y))\n",
    "\n",
    "\n",
    "#### Create the 2x2 Identity Matrix \n",
    "T = np.array([[1,0],[0,2]])\n",
    "print(T)\n",
    "\n",
    "#### Multiply the matrix by the co-ordinates \n",
    "newxy = np.matmul(xy,T)\n",
    "\n",
    "print(newxy[79])\n",
    "\n",
    "#### Plot the new coordinates \n",
    "for i in range(0,80):\n",
    "        plt.scatter(x,y,s=20,facecolors='red',marker='^')\n",
    "        plt.scatter(newxy[i][0],newxy[i][1],s=80,facecolors = 'cyan', edgecolors = 'k')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 55 - Symmetry of combined symmetric Matrices\n",
    "#### Create two symmetric matrices \n",
    "#### compute sum, multiplication and Hadamard multiplication of the two matrices \n",
    "#### Determine whether the result is still symmetric \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat_1 = np.array([[1,2,4],[2,3,6],[4,6,5]])\n",
    "print(mat_1)\n",
    "\n",
    "mat_2 = np.array([[7,10,12],[10,9,13],[12,13,11]])\n",
    "print(mat_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#SUM \n",
    "\n",
    "sum_11  = mat_1 + mat_2\n",
    "print(sum_11)\n",
    "\n",
    "#CHECK \n",
    "\n",
    "check_11 = sum_11 - sum_11.transpose()\n",
    "print(check_11)\n",
    "\n",
    "# THUS IT IS VALID UNDER SUM "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Multiplication\n",
    "\n",
    "mult_11 = np.matmul(mat_1,mat_2)\n",
    "print(mult_11)\n",
    "\n",
    "#Check \n",
    "check_22 = mult_11 - mult_11.transpose()\n",
    "print(check_22)\n",
    "\n",
    "#The return matrix is not zero so it does not produce symmetric matrix by multiplying two symmetric matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#HADAMARD Multiplication\n",
    "had_mult = mat_1 * mat_2\n",
    "print(had_mult)\n",
    "\n",
    "#CHECK \n",
    "check_33 = had_mult - np.transpose(had_mult)\n",
    "print(check_33)\n",
    "\n",
    "# THE RETURN MATRIX RESULTS IN SYMMETRIC MATRIC WHEN MULTIPLIED TWO SYMMETRIC MATRIX USING HADAMARD MULTIPLICATION\n",
    "# THUS WE CAN SAY THAT ANY ELEMENT BASED OPERATION PRESERVES THE SYMMETRY (THE RESULT MATRIX WILL BE SYMMETRIC \n",
    "# PERFOMED OPERATION ON TWO SYMMETRIC MATRICES)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 57 - Code challenge: standard and Hadamard multiplication for diagonal matrices\n",
    "#### create two matrices (4x4) : \"full\" and diagonal\n",
    "#### multiply each matrix by itself (A*A); standard and hadamard multiplications "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.random.randint(100, size=(4,4))\n",
    "A\n",
    "D = np.diag_indices(4)\n",
    "B = np.zeros((4,4))\n",
    "B[D] = 9\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Multiply each matrix by itself using standard and hadarmard multiplication \n",
    "\n",
    "#FULL MATRIX\n",
    "mat_check_std = np.matmul(A,A)\n",
    "print(mat_check_std)\n",
    "\n",
    "mat_check_had = A*A\n",
    "print(mat_check_had)\n",
    "\n",
    "#Diagonal \n",
    "mat_d_check_std = np.matmul(B,B)\n",
    "print(mat_d_check_std)\n",
    "\n",
    "mat_d_check_had = B*B\n",
    "print(mat_d_check_had)\n",
    "\n",
    "#FROM THIS WE CAN SEE THAT DIAGONAL MATRIX HAS A SPECIAL PROPERTY: IT GIVES SAME RESULT WHEN PERFORMED\n",
    "#STANDARD MULTIPLICATION OR WHEN PERFORMED HADAMARD MULTIPLICATION. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 58 - Code challenge: Implement fourier transformation through matrix multiplication. \n",
    "#### create two matrices (4x4) : \"full\" and diagonal\n",
    "#### multiply each matrix by itself (A*A); standard and hadamard multiplications \n",
    "\n",
    "# DONE IN MATLAB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 66  - Reduced-rank matrix via multiplication\n",
    "#### Create 10x10 matrix with rank= 4 (use matrix multiplication) \n",
    "#### Generalize the procedure to create any MxN matrix with rank r \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create 10x10 Matrix with rank 4 \n",
    "A11 = np.random.random((10,4))\n",
    "A11\n",
    "np.linalg.matrix_rank(A11)\n",
    "A12 = np.random.random((4,10))\n",
    "A12\n",
    "\n",
    "results_ = np.matmul(A11,A12)\n",
    "print(np.linalg.matrix_rank(results_))\n",
    "# print(results_.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Generalize the procedure to create any MxN matrix with rank r \n",
    "r = 7\n",
    "M = 47\n",
    "N = 52\n",
    "\n",
    "A11u = np.random.random((M,r))\n",
    "A12u = np.random.random((r,N))\n",
    "\n",
    "results_u = np.matmul(A11u,A12u)\n",
    "\n",
    "print(np.linalg.matrix_rank(results_u))\n",
    "print(results_u.shape)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 67  - Scalar Multiplication and rank\n",
    "\n",
    "#### test whether the matrix rank is invariant to scalar multiplication\n",
    "####  create two matrices: Full-Rank and a reduced-rank (random) \n",
    "####  create some scalar \n",
    "#### print ranks of F,R, l*F , l*R\n",
    "#### check whether rank(l*F) == l*rank(F)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create two matrices: Full Rank and Reduced Rank \n",
    "\n",
    "AA11 = np.random.random((4,4))\n",
    "np.linalg.matrix_rank(AA11)\n",
    "AA12 = np.random.random((4,10))\n",
    "np.linalg.matrix_rank(AA12)\n",
    "\n",
    "#Create Some Scalar \n",
    "S = 4\n",
    "\n",
    "#Print ranks of F,R, S*F, S*R\n",
    "F = np.linalg.matrix_rank(AA11)\n",
    "R = np.linalg.matrix_rank(AA12)\n",
    "R1 = S * AA11\n",
    "R2 = S * AA12\n",
    "R3 = S* F \n",
    "print('-------------Ranks---------------')\n",
    "print('Rank of F:',F)\n",
    "print('Rank of R:',R)\n",
    "print('Rank of R1:',np.linalg.matrix_rank(R1))\n",
    "print('Rank of R2:',np.linalg.matrix_rank(R2))\n",
    "\n",
    "#Check whether rank(lxF) == l*rank(F)\n",
    "print('------------------Check--------------------')\n",
    "print('Rank of rank(lxF):',np.linalg.matrix_rank(R1))\n",
    "print('l*rank(F):',(S * F))\n",
    "\n",
    "print(np.linalg.matrix_rank(R1)==R3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 69  - Rank of Multiploed and Summed Matrices  \n",
    "\n",
    "####  rules: rank of AB<= min(rank(A),rank(B))\n",
    "####             rank of A + B <= rank(A) + rank(B)\n",
    "####  generate two matrices (A and B), 2x5\n",
    "####  compute AtA and BtB \n",
    "#### find their ranks \n",
    "#### find ranks of (AtA + BtB) and (Ata x BtB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Generate two matrices A, B\n",
    "\n",
    "m=2\n",
    "n= 5\n",
    "AAA11 = np.random.random((2,5))\n",
    "AAA12 = np.random.random((2,5))\n",
    "\n",
    "print(np.linalg.matrix_rank(AAA11))\n",
    "print(np.linalg.matrix_rank(AAA12))\n",
    "\n",
    "#Compute AtA and BtB \n",
    "AAA11_trans = np.transpose(AAA11)\n",
    "results_trans1 = np.matmul(AAA11_trans,AAA11)\n",
    "\n",
    "print('Rank of AtA:',np.linalg.matrix_rank(results_trans1))\n",
    "\n",
    "\n",
    "AAA12_trans = np.transpose(AAA12)\n",
    "results_trans2 = np.matmul(AAA12_trans,AAA12)\n",
    "\n",
    "print('Rank of BtB:',np.linalg.matrix_rank(results_trans2))\n",
    "\n",
    "#Find Ranks of (AtA + BtB) and (AtA * Btb)\n",
    "print('---------------Ranks of (AtA + BtB) and (AtA * Btb)---------------')\n",
    "\n",
    "ranks1 = results_trans1 + results_trans2\n",
    "print('AtA + BtB:',np.linalg.matrix_rank(ranks1))\n",
    "\n",
    "ranks2 = np.matmul(results_trans1,results_trans2)\n",
    "print('AtA * BtB:',np.linalg.matrix_rank(ranks2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 71  - Is this vector in the span of this set?  \n",
    "\n",
    "####  determine where the given vector V = [1 2 3 4]' \n",
    "#### is in the span of these sets s = [ [ 4 3 6 2 ]' [0 4 0 1]' ] and t = [ [ 1 2 2 2 ]' [0 0 1 2]' ] \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create V\n",
    "v = np.array([[1],[2],[3],[4]])\n",
    "\n",
    "#Create two sets \n",
    "s = np.array([[4,0],[3,4],[6,0],[2,1]])\n",
    "t = np.array([[1,0],[2,0],[2,1],[2,2]])\n",
    "\n",
    "#Check whether v spans in set S\n",
    "test_1 = np.concatenate((s,v),axis = 1)\n",
    "print('Rank: ',np.linalg.matrix_rank(test_1))\n",
    "print('No, v does not spans in set S because the rank is now 3 \\n ')\n",
    "\n",
    "#Check whether v spans in set t\n",
    "test_2 = np.concatenate((t,v),axis = 1)\n",
    "print('Rank: ',np.linalg.matrix_rank(test_2))\n",
    "print('Yes, v does spans in set T because the rank is now 2')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 88  - RREF of matrices with different sizes and rank,   \n",
    "#### RREF of different matrices (random) \n",
    "#### Square \n",
    "#### Rectangle (tall, and wide)\n",
    "#### linearly dependcies (columns, rows) \n",
    "     \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = 4 \n",
    "n = 8\n",
    "\n",
    "#square\n",
    "AAAAA11 = np.random.random((m,m))\n",
    "\n",
    "print('The RREF of AAAAA11:',Matrix(AAAAA11).rref())\n",
    "print('\\n')\n",
    "\n",
    "\n",
    "#Rectangle\n",
    "M1 = np.random.random((m,n))\n",
    "M2 = np.random.random((n,m))\n",
    "\n",
    "print('The RREF of M1:',Matrix(M1).rref())\n",
    "print('\\n')\n",
    "\n",
    "print('The RREF of M2:',Matrix(M2).rref())\n",
    "print('\\n')\n",
    "\n",
    "#Linearly dependent set\n",
    "MM1 = Matrix([[1, 2, 2],[2, 4, 4],[4,7,9]]) #row\n",
    "MM1\n",
    "MM2 = Matrix([[1,4,5],[6,9,11],[12,15,18]]) #column\n",
    "MM2\n",
    "\n",
    "print('The RREF of MM1:',MM1.rref())\n",
    "print('\\n')\n",
    "\n",
    "print('The RREF of M1:',MM2.rref())\n",
    "print('\\n')\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 93  - determinant of small and large singular matrices    \n",
    "#### generatr a 2x2 matrix of integers, and with linear dependencies \n",
    "#### Compute the rank\n",
    "#### generate mxm matrix, impose linear dependencies \n",
    "#### compute the rank \n",
    "#### Small m and for large m\n",
    "\n",
    "     \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#For smaller Matrices \n",
    "\n",
    "n = 2\n",
    "\n",
    "ABA_1 = np.random.random((n,n))\n",
    "ABA_1_det = np.linalg.det(ABA_1)\n",
    "ABA_1_rank = np.linalg.matrix_rank(ABA_1)\n",
    "\n",
    "print('The Matrix ABA:',ABA_1)\n",
    "print('The det ABA:',ABA_1_det)\n",
    "print('The Rank ABA:',ABA_1_rank)\n",
    "print('\\n')\n",
    "\n",
    "\n",
    "ABA_1[:,0] = 5*ABA_1[:,1]\n",
    "ABA_1_det = np.linalg.det(ABA_1)\n",
    "ABA_1_rank = np.linalg.matrix_rank(ABA_1)\n",
    "\n",
    "print('The Matrix ABA:',ABA_1)\n",
    "print('The det ABA:',ABA_1_det)\n",
    "print('The Rank ABA:',ABA_1_rank)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#For larger Matrices \n",
    "\n",
    "m = 150\n",
    "ABB_1 = np.random.random((m,m))\n",
    "print(ABB_1)\n",
    "\n",
    "print('Rank:',np.linalg.matrix_rank(ABB_1))\n",
    "print('Det:',np.linalg.det(ABB_1))\n",
    "\n",
    "ABB_1[:,0] = ABB_1[:,1]\n",
    "# ABB_1[1,:] = 4*ABB_1[9,:]\n",
    "\n",
    "print('\\n')\n",
    "print(ABB_1)\n",
    "\n",
    "print('Rank:',np.linalg.matrix_rank(ABB_1))\n",
    "print('Det:',np.linalg.det(ABB_1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 95  - Large Matrices with row exchanges     \n",
    "\n",
    "#### generatr a  6x6 matrix \n",
    "#### Compute the determinant \n",
    "#### Swap one row, find determinant \n",
    "#### Swap two row, find determinant again\n",
    "\n",
    "\n",
    "\n",
    "     \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ACA_1 = np.random.random((6,6))\n",
    "\n",
    "#Swap One row\n",
    "print(ACA_1)\n",
    "x = np.linalg.det(ACA_1)\n",
    "print('\\n')\n",
    "print('Determinant before swapping one row:',x)\n",
    "print('\\n')\n",
    "# ACA_1[0,:],ACA_1[1,:] = ACA_1[1,:].copy(),ACA_1[0,:].copy() #Swapped \n",
    "ACA_1[[0,1]] = ACA_1[[1,0]]\n",
    "print(ACA_1)\n",
    "x = np.linalg.det(ACA_1)\n",
    "print('\\n')\n",
    "print('Determinant After swapping one row:',x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Swap Two row \n",
    "print(ACA_1)\n",
    "x = np.linalg.det(ACA_1)\n",
    "print('\\n')\n",
    "print('Determinant before swapping two row:',x)\n",
    "print('\\n')\n",
    "ACA_1[[0,1]] = ACA_1[[1,0]]#Swapped \n",
    "ACA_1[[3,4]] = ACA_1[[4,3]] #Swapped \n",
    "print(ACA_1)\n",
    "x = np.linalg.det(ACA_1)\n",
    "print('\\n')\n",
    "print('Determinant After swapping two row:',x)\n",
    "print('Thus, Swapping two row the determinant remains same, even in magnitude')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 97  - Determinant of shifted matrices     \n",
    "\n",
    "#### generate a square random matrix ( 20x20)\n",
    "#### impose a linear dependence\n",
    "#### Shift the matrix (0 -> .1 times the identity matrix) (lambda) \n",
    "#### Compute the abs(determinant) of the shifted matrix. \n",
    "#### repeat 1000 times, take the average abs(det) \n",
    "#### plot of det as a funcion of lambda. \n",
    "\n",
    "\n",
    "     \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "s = np.linspace(0,0.1,50)\n",
    "I = np.identity(20)\n",
    "results_ = np.zeros(50)\n",
    "for i in range(0,50,1):\n",
    "    for j in range(0,1000,1):\n",
    "        AAP1 = np.random.random((20,20))\n",
    "        AAP1[:,1] = AAP1[:,2]\n",
    "        B = np.abs(np.linalg.det(s[i]*I + AAP1))\n",
    "        results_[i] = results_[i] + B\n",
    "\n",
    "ax.plot(s,results_,marker=\"o\")\n",
    "plt.grid()\n",
    "plt.xlabel('Fraction of identity matrix for shifting')\n",
    "plt.ylabel('Determinant')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 103  -  Implement the MCA Algorithm\n",
    "\n",
    "#### Compute the Inverse using numpy inverse, compare to your implemenation of MCA.     \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A1 = np.random.randn(3,3)\n",
    "A1_m = np.zeros((3,3))\n",
    "\n",
    "#Implement MCA Algorithm \n",
    "#M\n",
    "print('-------- Normal Matrix ----------')\n",
    "print(A1)\n",
    "print('\\n')\n",
    "A11 = A1[1:,1:]\n",
    "A12 = A1[[1,2]]\n",
    "A12 = np.delete(A12,-2,axis=1)\n",
    "A13 = A1[1:,0:2]\n",
    "A21 = A1[[0,2]]\n",
    "A21 = np.delete(A21,0,axis=1)\n",
    "A22 = A1[[0,2]]\n",
    "A22 = np.delete(A22,-2,axis=1)\n",
    "A23 = A1[[0,2]]\n",
    "A23 = np.delete(A23,-1,axis=1)\n",
    "A31 = A1[[0,1]]\n",
    "A31 = np.delete(A31,0,axis=1)\n",
    "A32 = A1[[0,1]]\n",
    "A32 = np.delete(A32,-2,axis=1)\n",
    "A33 = A1[[0,1]]\n",
    "A33 = np.delete(A33,-1,axis=1)\n",
    "\n",
    "\n",
    "A11_d = np.linalg.det(A11)\n",
    "A12_d = np.linalg.det(A12)\n",
    "A13_d = np.linalg.det(A13)\n",
    "A21_d = np.linalg.det(A21)\n",
    "A22_d = np.linalg.det(A22)\n",
    "A23_d = np.linalg.det(A23)\n",
    "A31_d = np.linalg.det(A31)\n",
    "A32_d = np.linalg.det(A32)\n",
    "A33_d = np.linalg.det(A33)\n",
    "\n",
    "\n",
    "A1_m[0,:] = A11_d, A12_d, A13_d\n",
    "A1_m[1,:] = A21_d, A22_d, A23_d\n",
    "A1_m[2,:] = A31_d, A32_d, A33_d\n",
    "\n",
    "print('-------- M Matrix ----------')\n",
    "\n",
    "print(A1_m)\n",
    "print('\\n')\n",
    "\n",
    "#C \n",
    "A1_c = np.ones((3,3))\n",
    "\n",
    "for i in range(0,A1_c.shape[0]):\n",
    "    for j in range(0,A1_c.shape[1]):\n",
    "        A1_c[i,j] = (-1)**(i+1+j+1)*A1_c[i,j]\n",
    "        \n",
    "print('-------- Co-factor Matrix ----------')\n",
    "print(A1_c)\n",
    "print('\\n')\n",
    "\n",
    "A1_m = np.multiply(A1_m,A1_c)\n",
    "# print(A1_m)\n",
    "\n",
    "#A \n",
    "A_inv = np.divide(np.transpose(A1_m),np.linalg.det(A1))\n",
    "\n",
    "print('-------- Matrix Inverse using MCA  ----------')\n",
    "print(A_inv)\n",
    "print('\\n')\n",
    "\n",
    "#NUMPY A_INV \n",
    "print('-------- Matrix Inverse using Numpy Inverse ----------')\n",
    "A_np_inv = np.linalg.inv(A1)\n",
    "print(A_np_inv)\n",
    "\n",
    "#Check \n",
    "print('\\n')\n",
    "print('-------- Check whether both are same ----------')\n",
    "print(A_inv-A_np_inv)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 105 -  Inverse of a diagonal Matrix \n",
    "\n",
    "#### Diagonal Matricesm and their inverses \n",
    "#### Create some diagonal matrix, and work upto larger diagonal matrix\n",
    "#### compute there inverses and observe \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create Diagonal Matrix \n",
    "m = 5\n",
    "\n",
    "AAAA1 = np.random.randint(10, size = (m,m))\n",
    "# print(AAAA1)\n",
    "A_1_A = np.diag(np.diag(AAAA1))\n",
    "print(A_1_A)\n",
    "\n",
    "A_1_Ainv = np.linalg.inv(A_1_A)\n",
    "print(A_1_Ainv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 110 -  Pseudoinverse of invertible Matrices  \n",
    "\n",
    "#### Is the pseudoinverse is the same as the \"real\" inverse for an invertible matrix? \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create an invertible matrix \n",
    "m = 2\n",
    "\n",
    "AAAA2= np.random.randint(1000, size = (m,m))\n",
    "AAAA2_inv = np.linalg.inv(AAAA2)\n",
    "print('The Real Inverse is: \\n', AAAA2_inv)\n",
    "print('\\n')\n",
    "AAAA2_pinv = np.linalg.pinv(AAAA2)\n",
    "print('The PseudoInverse is: \\n', AAAA2_pinv)\n",
    "print('\\n')\n",
    "\n",
    "print('Yes, the pseudoInverse is the same as real inverse for the invertible matrix ')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 115 -  Decompose vector to orthogonal components. \n",
    "#### Create two vectors \n",
    "#### Compute the one vector in terms of parallel to another.\n",
    "#### Confirm the results algebraically \n",
    "#### plot all four vectors "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create two vectors \n",
    "w = np.random.random((2,1))\n",
    "v = np.random.random((2,1))\n",
    "\n",
    "# print(w)\n",
    "# print('\\n')\n",
    "# print(v)\n",
    "\n",
    "#w || v = (wTv/vTv) * v\n",
    "# print('------W parallel to v -------')\n",
    "parl = np.divide((np.dot(np.transpose(w),v)),(np.dot(np.transpose(v),v))) * v\n",
    "# print('\\n')\n",
    "# print(parl)\n",
    "\n",
    "#w perp v = (w - w||V)\n",
    "# print('------W perpendicular to v -------')\n",
    "perp = w - parl\n",
    "# print('\\n')\n",
    "# print(perp)\n",
    "\n",
    "#check \n",
    "# print('------Check-------')\n",
    "res_ = perp + parl\n",
    "# print('\\n')\n",
    "# print(res_)\n",
    "# print('\\n')\n",
    "res_oth = perp * parl\n",
    "# print('Result in orthogonal \\n',res_oth)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "plt.plot((0,w[0]),(0,w[1]),color='r',marker=\"o\")\n",
    "plt.plot((0,v[0]),(0,v[1]),color='b',marker=\"o\")\n",
    "\n",
    "plt.grid()\n",
    "plt.xlabel('Fraction of identity matrix for shifting')\n",
    "plt.ylabel('Determinant')\n",
    "plt.show()\n",
    "\n",
    "plt.figure()\n",
    "plt.grid()\n",
    "plt.plot((0,parl[0]),(0,parl[1]),\"r--\")\n",
    "plt.plot((0,perp[0]),(0,perp[1]),\"b--\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 119 -  Gram-Schmidt Algorithm\n",
    "#### Generate MxN random matrix  \n",
    "#### Compute QR decomposition and compare to the output for the Gram-Schmidt Matrix "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create Matrix \n",
    "m= 3 \n",
    "n = 3 \n",
    "A = np.random.random((m,n))\n",
    "G = A\n",
    "A = np.random.randn(m,n)\n",
    "G = np.copy(A)\n",
    " \n",
    "def parallel(proj_vector, ref_vector):\n",
    "    beta = (ref_vector @ proj_vector) / (ref_vector @ ref_vector)\n",
    "    return beta * ref_vector\n",
    "    \n",
    "def normalized(vector):\n",
    "    return vector / np.linalg.norm(vector)\n",
    " \n",
    "for i in range(n):    \n",
    "    # orthogonalize\n",
    "    for j in range(i):\n",
    "        G[:,i] = G[:,i] - parallel(G[:,i], G[:,j])   \n",
    "    # normalize\n",
    "    G[:,i] = normalized(G[:,i])\n",
    " \n",
    "# compute QR decomp.compare with matrix G\n",
    "Q,R = np.linalg.qr(A,'complete')\n",
    "print(G)\n",
    "print(Q)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 121 -  Inverse Via QR\n",
    "#### Generate a large (e.g., N=100) matrix and invert using QR and inv()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create Matrix \n",
    "m = 1000\n",
    "O = np.random.randint(1000, size = (m,m))\n",
    "\n",
    "#Create inv using inverse function\n",
    "Oi = np.linalg.inv(O)\n",
    "\n",
    "#Create inv via QR \n",
    "Oq,Or = np.linalg.qr(O)\n",
    "OiQR = np.matmul(np.linalg.inv(Or),np.transpose(Oq))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 122 -  Implement Sherman-Morrison Formula"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make the matrix\n",
    "m = 3\n",
    "a = np.random.randn(m,1)\n",
    "b = np.random.randn(m,1)\n",
    "I = np.eye(m,m)\n",
    " \n",
    "# A = I - abT\n",
    "A = I - (a@np.matrix.transpose(b))\n",
    " \n",
    "print('----------Matrix A----------')\n",
    "print(A), print('')\n",
    " \n",
    "# Ainv = I + abT/1 - aTb\n",
    "Ainv = I + (a@np.matrix.transpose(b)) / (1-(np.matrix.transpose(a)@b))\n",
    " \n",
    "print('------------------Inverse of A--------------------')\n",
    "print(Ainv), print('')\n",
    " \n",
    "# Check\n",
    "Ainv2 = np.linalg.inv(A)\n",
    "print('------------------Inverse of A using np.linalg.inv-----------------------')\n",
    "print(Ainv2), print('')\n",
    " \n",
    "print('------------------A*Ainv = I-----------------------')\n",
    "print(A@Ainv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 123 -  AtA == RtR\n",
    "#### Generate random matrix \n",
    "#### Compute its QR decomp\n",
    "#### Test the conditions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Generate Matrix\n",
    "m=5\n",
    "A = np.random.randint(1000,size=(m,m))\n",
    "Q,R = np.linalg.qr(A)\n",
    "\n",
    "#Check-1\n",
    "AtA1 = np.matmul(np.transpose(A),A)\n",
    "print(AtA1),print('')\n",
    "\n",
    "#Check-2 \n",
    "RtR1 = np.matmul(np.transpose(R),R)\n",
    "print(RtR1)\n",
    "\n",
    "print('YES AtA == RtR')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 132 - Least Squared via QR Decompostion.\n",
    "#### Before you start the code prove on paper the equation: Xb=y by converting into QR decomposition method. \n",
    "#### Outcome for that equation should be: b =  inv(RtR) * transpose(QR)*y\n",
    "#### Generate random data (Design matrix X, data y)\n",
    "#### Solve for beta using QR decomp. \n",
    "#### Compare the QR results against the \"standard\" left-inverse method  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#Create Random Data\n",
    "m = 10\n",
    "n = 3\n",
    "X1 = np.random.randint(1000,size=(m,n))\n",
    "X2 = np.random.randint(1000,size=(m,1))\n",
    "\n",
    "#Solve for beta using QR \n",
    "Q,R = np.linalg.qr(X1)\n",
    "\n",
    "beta1_1 = np.matmul(np.linalg.inv(np.matmul(np.transpose(R),R)),np.transpose(np.matmul(Q,R)))\n",
    "beta1 = np.matmul(beta1_1,X2)\n",
    "print(beta1)\n",
    "print(\"\")\n",
    "#Solve beta using Standard Left inverse\n",
    "beta2 = np.matmul(np.linalg.pinv(X1),X2)\n",
    "print(beta2)\n",
    "print('')\n",
    "\n",
    "#Check results \n",
    "beta_check = np.concatenate((beta1,beta2),axis=1)\n",
    "beta_check\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 137 - Eigenvalues of diagonal and \n",
    "#### Generate a diagonal matrix (2x2), compute its eignevalues \n",
    "#### Expand this to nxn diagonal matrix \n",
    "#### generate upper and lower triangular matrics and compute eigenvalues "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 2 \n",
    "A = np.random.randint(1000,size=(n,n))\n",
    "\n",
    "np.diag(np.diag(A))\n",
    "\n",
    "evalA,evecA = np.linalg.eig(A)\n",
    "print('--------2x2 Diagonal Matrix Eigendecomposition---------------')\n",
    "print(evalA,'\\n')\n",
    "print(evecA)\n",
    "\n",
    "print('\\n')\n",
    "print('-----------NxN Diagonal Matrix-----------')\n",
    "m = 5\n",
    "B = np.random.randint(-10,10,size=(m,m))\n",
    "B = (B + B.T) #Creating Symmetric Matrix \n",
    "B = np.diag(np.diag(B))\n",
    "print(B)\n",
    "evalB,evecB = np.linalg.eig(B)\n",
    "print('\\n')\n",
    "print('----------- NxN Matrix Eigendecomposition-----------')\n",
    "print(evalB,'\\n')\n",
    "print(evecB)\n",
    "\n",
    "print('\\n')\n",
    "\n",
    "print('----------- Lower Triangular Matrix-----------')\n",
    "C = np.random.randint(100,size=(3,3))\n",
    "print(C)\n",
    "CL = np.tril(C)\n",
    "print('New Lower Triangular C:')\n",
    "print(CL)\n",
    "evalC,evecC = np.linalg.eig(CL)\n",
    "print('\\n')\n",
    "print('----------- Lower  Matrix Eigendecomposition -----------')\n",
    "print(evalC,'\\n')\n",
    "print(evecC)\n",
    "print('\\n')\n",
    "\n",
    "print('----------- Upper Triangular Matrix-----------')\n",
    "D = np.random.randint(100,size=(3,3))\n",
    "print(D)\n",
    "DU = np.triu(D)\n",
    "print('New Upper Triangular D:')\n",
    "print(DU)\n",
    "evalD,evecD = np.linalg.eig(DU)\n",
    "print('\\n')\n",
    "print('----------- Upper  Matrix Eigendecomposition -----------')\n",
    "print(evalD,'\\n')\n",
    "print(evecD)\n",
    "\n",
    "\n",
    "print('For Diagonal Matrix, the eigenvalues are been the diagonal elements of that matrix')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 138 - Eigenvalues of random matrices \n",
    "#### Generate \"large\" (40x40) random matrices, extract eigenvalues, plot\n",
    "#### Repeat this lots of times for lots of random matrices, put all the eigenvalues in the same plot. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = 41\n",
    "iter_ = 150\n",
    "evals = np.zeros((iter_,m),dtype = 'complex')\n",
    "plt.figure(1,figsize=(10,10))\n",
    "plt.grid()\n",
    "\n",
    "\n",
    "for i in range(iter_):\n",
    "    A = np.random.randn(m,m)\n",
    "    evals = np.linalg.eig(A)[0] \n",
    "    plt.plot(evals.real,evals.imag,\"x\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 143 - Eigendecomposition of matrix differences  \n",
    "### Note: Before writng this code, we need to prove the theory on paper. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Generate Random Matrix \n",
    "m = 5\n",
    "A = np.random.randint(10,size=(m,m))\n",
    "A = (A + A.T) #Creating Symmetric Matrix \n",
    "print('A')\n",
    "print(A)\n",
    "print('\\n')\n",
    "\n",
    "B = np.random.randint(10,size=(m,m))\n",
    "B = (B + B.T) #Creating Symmetric Matrix \n",
    "print('B')\n",
    "print(B)\n",
    "print('\\n')\n",
    "\n",
    "print('------------- Eigendecomposition (A-B) ------------')\n",
    "evals1,evecs1 = np.linalg.eig(A-B)\n",
    "print(evals1)\n",
    "print('\\n')\n",
    "print(evecs1)\n",
    "\n",
    "print('\\n')\n",
    "print('------------ Eigendecomposition (A-B)^2 --------------')\n",
    "evals2,evecs2 = np.linalg.eig((A@A) - (A@B) - (B@A) + (B@B))\n",
    "print(evals2)\n",
    "print('\\n')\n",
    "print(evecs2)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 148 - Reconstruct a matrix from eigenlayers.   \n",
    "#### Create MxM symmetric Matrix  \n",
    "#### take its eigendecomposition\n",
    "#### Show that norm of the outer product of v_i (one eigenvector of the matrix) \n",
    "#### Create one layer of matrix A as lvv' compute its norm. \n",
    "#### Reconstruct A by summing over the eigenlayers(outerproduct) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Generate Random Matrix \n",
    "m = 5\n",
    "A = np.random.randint(10,size=(m,m))\n",
    "A = (A + A.T) #Creating Symmetric Matrix \n",
    "print('A')\n",
    "print(A)\n",
    "print('\\n')\n",
    "\n",
    "#Get Eigendecompostion\n",
    "evalA, evecA = np.linalg.eig(A)\n",
    "print(evalA,'\\n',evecA)\n",
    "\n",
    "# show that norm of outerproduct & Create one layer of matrix as lvv'\n",
    "ev1 = np.linalg.norm(np.outer(evecA[:,0] ,evecA[:,0]) * evalA[0])\n",
    "print(ev1)\n",
    "print('\\n')\n",
    "\n",
    "#Recontruct A by summing over the eigenlayers\n",
    "A_recon = np.zeros((m,m))\n",
    "\n",
    "for i in range(m):\n",
    "    A_recon = A_recon + np.outer(evecA[:,i] ,evecA[:,i]) * evalA[i]\n",
    "    \n",
    "print('---------------Reconstructed Matrix---------------')\n",
    "print(A_recon)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 150 - Trace and Determinant, eigenvalues sum and product   \n",
    "#### trace(A) = sum(evals)\n",
    "#### det(A) = prod(evals) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Generate Random Matrix \n",
    "m = 5\n",
    "A = np.random.randint(10,size=(m,m))\n",
    "# A = (A + A.T) #Creating Symmetric Matrix \n",
    "print('A')\n",
    "print(A)\n",
    "print('\\n')\n",
    "\n",
    "#Get Eigenvales\n",
    "eval1A,evec1A = np.linalg.eig(A)\n",
    "print(eval1A)\n",
    "\n",
    "#Trace A\n",
    "A_trace = np.trace(A)\n",
    "print('\\n')\n",
    "print('Trace of Matrix :',A_trace)\n",
    "print('Sum of Eigenvalues:',np.sum(eval1A))\n",
    "print('Check:',A_trace - np.sum(eval1A))\n",
    "print('\\n')\n",
    "\n",
    "#Det A \n",
    "A_det = np.linalg.det(A)\n",
    "print('\\n')\n",
    "print('Determinant of Matrix :',A_det)\n",
    "print('Product of Eigenvalues:',np.prod(eval1A))\n",
    "print('Check:',A_det - (np.prod(eval1A)))\n",
    "print('\\n')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 152 - GED in small and large matrices   \n",
    "#### goal: compare  eig(S,R) with eig(inv(R)xS)\n",
    "#### Part 1 : GED on 2x2 matrix. Plot EigenVectors \n",
    "#### Part 2 : With real data matrices. Plot Eigenvalues"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.io import loadmat\n",
    "xx = loadmat('real_matrices.mat')\n",
    "\n",
    "R = xx['R']\n",
    "S = xx['S']\n",
    "\n",
    "m = 2\n",
    "AA = np.random.randint(10,size=(m,m))\n",
    "# A = (AA + AA.T) #Creating Symmetric Matrix \n",
    "print('AA')\n",
    "print(AA)\n",
    "print('\\n')\n",
    "\n",
    "BA = np.random.randint(10,size=(m,m))\n",
    "# BA = (BA + BA.T) #Creating Symmetric Matrix \n",
    "print('BA')\n",
    "print(BA)\n",
    "print('\\n')\n",
    "\n",
    "evalsAA, evecsAA = linalg.eig(AA,BA)\n",
    "print(evalsAA)\n",
    "print('\\n')\n",
    "print(evecsAA)\n",
    "print('\\n')\n",
    "\n",
    "[evalsRiS,evecsRiS] = np.linalg.eig(np.linalg.inv(BA)@AA)\n",
    "print(evalsRiS)\n",
    "print('\\n')\n",
    "print(evecsRiS)\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.plot([0,evecsAA[0,0]],[0,evecsAA[1,0]],'k--')\n",
    "plt.plot([0,evecsAA[0,1]],[0,evecsAA[1,1]],'k--')\n",
    "plt.plot([0,evecsRiS[0,0]],[0,evecsRiS[1,0]],'r--')\n",
    "plt.plot([0,evecsRiS[0,1]],[0,evecsRiS[1,1]],'r--')\n",
    "plt.axis([-1.5,1.5,-1.5,1.5])\n",
    "plt.grid()\n",
    "\n",
    "\n",
    "print('-------------PERFORMING ON REAL MATRICES--------------------')\n",
    "print('\\n')\n",
    "evalsSR, evecsSR = linalg.eig(S,R)\n",
    "print(evalsSR)\n",
    "print('\\n')\n",
    "print(evecsSR)\n",
    "print('\\n')\n",
    "\n",
    "[evalsRinS,evecsRinS] = np.linalg.eig(np.linalg.inv(R)@S)\n",
    "print(evalsRinS)\n",
    "print('\\n')\n",
    "print(evecsRinS)\n",
    "\n",
    "plt.figure()\n",
    "plt.plot([0,evecsSR[0,0]],[0,evecsSR[1,0]],'k--')\n",
    "plt.plot([0,evecsSR[0,1]],[0,evecsSR[1,1]],'k--')\n",
    "plt.plot([0,evecsRinS[0,0]],[0,evecsRinS[1,0]],'r--')\n",
    "plt.plot([0,evecsRinS[0,1]],[0,evecsRinS[1,1]],'r--')\n",
    "plt.axis([-1.5,1.5,-1.5,1.5])\n",
    "plt.grid()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 155 - SVD vs eigendecompostion  \n",
    "#### what is relationship between eig and SVD for a square symmetric matrix \n",
    "#### Create Symmetric matrix (5x5)\n",
    "#### compute it's eigenvalues and svd \n",
    "#### images of all matrices \n",
    "#### Compare U and V, between U and W "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "[[ 66 148  56 130 108]\n",
      " [148  96  94 142  53]\n",
      " [ 56  94  64 108  82]\n",
      " [130 142 108 186 111]\n",
      " [108  53  82 111  60]]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Create Symmetric Matrix \n",
    "m = 5\n",
    "A = np.random.randint(100,size=(m,m))\n",
    "A = (A + A.T) #Creating Symmetric Matrix \n",
    "print('A')\n",
    "print(A)\n",
    "print('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eigenvalue: [526.82329267 -98.00196935  29.12899361   9.63608985   4.41359321]\n",
      "\n",
      "\n",
      "Eigenvector: [[-0.43999733 -0.65382899  0.34015493  0.51241822  0.02514332]\n",
      " [-0.46403589  0.54397184  0.61514336 -0.09712002 -0.31769746]\n",
      " [-0.34732738 -0.2886519  -0.42468874 -0.35017674 -0.70218195]\n",
      " [-0.58684981 -0.03423758 -0.15851022 -0.47359986  0.63640615]\n",
      " [-0.35502682  0.43830372 -0.5480942   0.61731247  0.01907526]]\n"
     ]
    }
   ],
   "source": [
    "#Calculate Eigendecomposition\n",
    "L,W = np.linalg.eig(A)\n",
    "print('Eigenvalue:',L)\n",
    "print('\\n')\n",
    "print('Eigenvector:',W)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Orthogonal Matrix: [[-0.43999733  0.65382899  0.34015493  0.51241822  0.02514332]\n",
      " [-0.46403589 -0.54397184  0.61514336 -0.09712002 -0.31769746]\n",
      " [-0.34732738  0.2886519  -0.42468874 -0.35017674 -0.70218195]\n",
      " [-0.58684981  0.03423758 -0.15851022 -0.47359986  0.63640615]\n",
      " [-0.35502682 -0.43830372 -0.5480942   0.61731247  0.01907526]]\n",
      "\n",
      "\n",
      "Singular Value: [526.82329267  98.00196935  29.12899361   9.63608985   4.41359321]\n",
      "\n",
      "\n",
      "V: [[-0.43999733 -0.46403589 -0.34732738 -0.58684981 -0.35502682]\n",
      " [-0.65382899  0.54397184 -0.2886519  -0.03423758  0.43830372]\n",
      " [ 0.34015493  0.61514336 -0.42468874 -0.15851022 -0.5480942 ]\n",
      " [ 0.51241822 -0.09712002 -0.35017674 -0.47359986  0.61731247]\n",
      " [ 0.02514332 -0.31769746 -0.70218195  0.63640615  0.01907526]]\n"
     ]
    }
   ],
   "source": [
    "#Calculate Singular Value decomposition (SVD)\n",
    "U,S,V = np.linalg.svd(A)\n",
    "print('Orthogonal Matrix:',U)\n",
    "print('\\n')\n",
    "print('Singular Value:',S)\n",
    "print('\\n')\n",
    "print('V:',V)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'V (SVD)')"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Create Images\n",
    "\n",
    "plt.imshow(W)\n",
    "plt.title('W (eig)')\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(np.diag(L))\n",
    "plt.title('L (eig)')\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(U)\n",
    "plt.title('U (SVD)')\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(np.diag(S))\n",
    "plt.title('S (SVD)')\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(V)\n",
    "plt.title('V (SVD)')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.11022302e-16  1.11786489e+00  6.87482313e-01  1.09926803e+00\n",
      "   3.80170131e-01]\n",
      " [ 1.89793101e-01 -1.08794369e+00  9.03795254e-01 -6.28824390e-02\n",
      "  -7.56001177e-01]\n",
      " [-6.87482313e-01 -3.26491460e-01 -3.33066907e-16 -1.91666529e-01\n",
      "  -1.54087748e-01]\n",
      " [-1.09926803e+00  1.31357601e-01  1.91666529e-01  1.33226763e-15\n",
      "   1.90936720e-02]\n",
      " [-3.80170131e-01 -1.20606260e-01  1.54087748e-01 -1.90936720e-02\n",
      "  -1.18308141e-15]]\n"
     ]
    }
   ],
   "source": [
    "print(U-V)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 3.88578059e-16  1.30765799e+00  7.77156117e-16  0.00000000e+00\n",
      "   4.37150316e-16]\n",
      " [ 5.55111512e-17 -1.08794369e+00 -2.22044605e-16 -9.15933995e-16\n",
      "  -1.66533454e-16]\n",
      " [-2.22044605e-16  5.77303794e-01  2.77555756e-16 -8.88178420e-16\n",
      "  -4.44089210e-16]\n",
      " [-1.11022302e-16  6.84751616e-02 -5.55111512e-16  1.27675648e-15\n",
      "  -7.77156117e-16]\n",
      " [ 5.55111512e-17 -8.76607438e-01  2.22044605e-16 -1.11022302e-16\n",
      "   7.18175519e-16]]\n"
     ]
    }
   ],
   "source": [
    "print(U-W)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thus for Square symmetric matrix, the eigendecompostion and SVD is same. Unless, the Eigevalues are needed to be sorted and also there is some sign differences, while the values remain same.\n"
     ]
    }
   ],
   "source": [
    "print('Thus for Square symmetric matrix, the eigendecompostion and SVD is same. Unless, the Eigevalues are needed to be sorted and also there is some sign differences, while the values remain same.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 157 - U from Eigendecomposition of AtA \n",
    "#### Create a marix (3,6)\n",
    "#### Full SVD (variables Us, Ss, Vs) \n",
    "#### compute eig of A'A\n",
    "#### confirm that V == Vs\n",
    "#### check the relationship between Ss and L \n",
    "#### Create U using only A,V and L\n",
    "#### Confirm that U == Us"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "[[0.68472926 0.82522656 0.98782828 0.34234683 0.32543748 0.49417708]\n",
      " [0.49346821 0.41624995 0.45247678 0.38660202 0.32527452 0.07583898]\n",
      " [0.78551153 0.99609484 0.6964803  0.45822758 0.73560203 0.26301907]]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Create  Matrix \n",
    "m = 3\n",
    "n = 6\n",
    "A1A = np.random.random((m,n))\n",
    "# A = (A + A.T) #Creating Symmetric Matrix \n",
    "print('A')\n",
    "print(A1A)\n",
    "print('\\n')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Orthogonal Matrix: [[-0.63467444  0.77155641  0.04346328]\n",
      " [-0.36860106 -0.2528158  -0.89454873]\n",
      " [-0.6792066  -0.58376783  0.44485224]]\n",
      "\n",
      "\n",
      "Singular Value: [2.48256678 0.43048114 0.20404443]\n",
      "\n",
      "\n",
      "Vs: [[-0.46322931 -0.54529634 -0.510273   -0.27028957 -0.332748   -0.20955738]\n",
      " [-0.12777718 -0.11618126  0.56027814 -0.23484821 -0.60528078  0.4845047 ]\n",
      " [-0.30500326  0.5225637  -0.25483397 -0.62295874  0.24702894  0.34620652]\n",
      " [-0.57365279  0.37314499 -0.15191438  0.65961726 -0.21760215  0.16174572]\n",
      " [-0.5655665  -0.31099991  0.49354954  0.00553126  0.57886278 -0.06862749]\n",
      " [ 0.16468645 -0.42440885 -0.30675787  0.22042403  0.28188264  0.75538767]]\n",
      "\n",
      "\n",
      "Eigenvalue: [ 6.16313782e+00  1.85314009e-01  4.16341295e-02 -8.38455880e-16\n",
      "  5.46568720e-17  9.64238745e-18]\n",
      "\n",
      "\n",
      "Eigenvector: [[-0.46322931 -0.54529634 -0.510273   -0.27028957 -0.332748   -0.20955738]\n",
      " [-0.12777718 -0.11618126  0.56027814 -0.23484821 -0.60528078  0.4845047 ]\n",
      " [ 0.30500326 -0.5225637   0.25483397  0.62295874 -0.24702894 -0.34620652]\n",
      " [ 0.75953556 -0.19073202 -0.43096905 -0.20877116 -0.14652613  0.36869689]\n",
      " [-0.29470026 -0.42978031 -0.02031253  0.32883123  0.49099289  0.61548684]\n",
      " [ 0.13306161  0.41858313 -0.52004429  0.41044288 -0.55768114  0.23909221]]\n",
      "\n",
      "\n",
      "[[-2.77555756e-16  4.17519161e-01  8.15276257e-01  1.02982513e+00\n",
      "   3.80477475e-02  3.42618985e-01]\n",
      " [-4.17519161e-01  6.93889390e-17 -1.08284184e+00  4.41161878e-02\n",
      "   1.75500472e-01 -6.59215695e-02]\n",
      " [-2.05269745e-01  3.77144420e-02  5.09667944e-01  1.91989686e-01\n",
      "  -2.67341474e-01 -8.66250819e-01]\n",
      " [ 3.03363228e-01 -6.07993199e-01  7.74873115e-01 -8.68388427e-01\n",
      "   5.46433373e-01  2.48697162e-01]\n",
      " [ 2.32818492e-01 -2.94280878e-01 -7.40578480e-01 -1.52057392e-01\n",
      "  -8.78698930e-02 -4.89053651e-01]\n",
      " [-3.74243829e-01  9.08913553e-01 -3.94486532e-02  1.48272862e-01\n",
      "   3.33604196e-01 -5.16295462e-01]]\n",
      "\n",
      "\n",
      "[2.48256678 0.43048114 0.20404443]\n",
      "[2.48256678 0.43048114 0.20404443]\n",
      "[ 8.88178420e-16 -5.55111512e-17  6.93889390e-16]\n",
      "\n",
      "\n",
      "[[-0.63467444  0.77155641 -0.04346328]\n",
      " [-0.36860106 -0.2528158   0.89454873]\n",
      " [-0.6792066  -0.58376783 -0.44485224]]\n",
      "\n",
      "\n",
      "[[-2.22044605e-16  7.77156117e-16 -8.69265644e-02]\n",
      " [-2.22044605e-16 -1.11022302e-16  1.78909746e+00]\n",
      " [-2.22044605e-16  7.77156117e-16 -8.89704478e-01]]\n"
     ]
    }
   ],
   "source": [
    "#solve SVD\n",
    "Us, Ss, Vs = np.linalg.svd(A1A)\n",
    "print('Orthogonal Matrix:',Us)\n",
    "print('\\n')\n",
    "print('Singular Value:',Ss)\n",
    "print('\\n')\n",
    "print('Vs:',Vs)\n",
    "\n",
    "print('\\n')\n",
    "\n",
    "#Solve Eig of A'A\n",
    "L,V = np.linalg.eig(np.matmul(np.transpose(A1A),A1A))\n",
    "print('Eigenvalue:',L)\n",
    "print('\\n')\n",
    "print('Eigenvector:',V.T)\n",
    "print('\\n')\n",
    "\n",
    "#check V == VS (ANS: IT IS NOT SAME)\n",
    "print(V - Vs)\n",
    "print('\\n')\n",
    "\n",
    "#Check the relationship between Ss and L \n",
    "print(Ss)\n",
    "L_sqrt =np.sqrt(L[0:m]) \n",
    "print(L_sqrt)\n",
    "print(Ss - L_sqrt)\n",
    "\n",
    "#Create U using A, V and L \n",
    "U = np.zeros((m,m))\n",
    "for x in range(m):\n",
    "    U[:,x] = (np.matmul(A1A,V[:,x]))/L_sqrt[x]\n",
    "print('\\n')    \n",
    "print(U)\n",
    "\n",
    "print('\\n')    \n",
    "\n",
    "#Check U with the Us\n",
    "print(U-Us)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 158 - AtA, Av and singular value\n",
    "#### Before Solving this, prove the claims present in the video."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A2A\n",
      "[[0.52816226 0.72114471 0.16804043 0.39413547]\n",
      " [0.07419505 0.61761075 0.46903363 0.32052256]\n",
      " [0.78969672 0.41972304 0.45242967 0.04194825]\n",
      " [0.59803953 0.72665844 0.22880818 0.93173592]]\n",
      "\n",
      "\n",
      "AtA [[1.26573246 1.19272946 0.61767115 0.82228998]\n",
      " [1.19272946 1.60569264 0.76702222 1.17684731]\n",
      " [0.61767115 0.76702222 0.50527592 0.44873399]\n",
      " [0.82228998 1.17684731 0.44873399 1.12796896]]\n",
      "\n",
      "\n",
      "AAt [[0.98258541 0.68971967 0.81232882 1.245567  ]\n",
      " [0.68971967 0.70967519 0.54346714 0.89912475]\n",
      " [0.81232882 0.54346714 1.00624059 0.91986945]\n",
      " [1.245567   0.89912475 0.91986945 1.80616878]]\n",
      "\n",
      "\n",
      "1.9721522630525295e-30\n",
      "1.5261264481584434e-31\n",
      "4.620200612291145e-32\n",
      "5.5914189654207565e-31\n"
     ]
    }
   ],
   "source": [
    "#Create  Matrix \n",
    "m = 4\n",
    "A2A = np.random.random((m,m))\n",
    "# A = (A + A.T) #Creating Symmetric Matrix \n",
    "print('A2A')\n",
    "print(A2A)\n",
    "print('\\n')\n",
    "\n",
    "AtA = np.matmul(np.transpose(A2A),A2A)\n",
    "print('AtA', AtA)\n",
    "print('\\n')\n",
    "\n",
    "AAt = np.matmul(A2A,np.transpose(A2A))\n",
    "print('AAt', AAt)\n",
    "print('\\n')\n",
    "\n",
    "#SVD of AtA\n",
    "U1, S1, V1 = np.linalg.svd(AtA)\n",
    "S1 = np.diag(S1)\n",
    "\n",
    "\n",
    "for i in range(m):\n",
    "    print(np.sum(np.square(AAt@A2A@U1[:,i] - A2A@U1[:,i]*S1[i,i])))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 163 - When is U*VT is valid, what is its norm and is it orthogonal\n",
    "#### generate a matrix such that U*VT is valid\n",
    "#### Calculate norm of U,V and the norm of U*V'\n",
    "#### Compute U*U', V*V', and U*V'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A3A\n",
      "[[0.91070019 0.30373079 0.47729456 0.23748241 0.24023611]\n",
      " [0.23253023 0.53357013 0.55690208 0.3081122  0.26906303]\n",
      " [0.6737027  0.76264644 0.83428366 0.71871329 0.11746385]\n",
      " [0.96455334 0.96482635 0.33731517 0.3378896  0.08996474]\n",
      " [0.10459849 0.24547144 0.21640386 0.0796139  0.49888013]]\n",
      "\n",
      "\n",
      "Orthogonal Matrix U: [[-0.42459791  0.34888644  0.53892054  0.61225684 -0.18083441]\n",
      " [-0.34111441 -0.52210217  0.00338569 -0.16754099 -0.76352396]\n",
      " [-0.59759563 -0.3505474  -0.47366811  0.32990895  0.4321974 ]\n",
      " [-0.56478031  0.54861753 -0.10721547 -0.60699995  0.00989449]\n",
      " [-0.16510675 -0.42640697  0.68825617 -0.3460964   0.44433949]]\n",
      "\n",
      "\n",
      "Singular Value S: [2.44664542 0.63485693 0.4913442  0.41610494 0.09235874]\n",
      "\n",
      "\n",
      "V2: [[-0.58473256 -0.55266285 -0.45671864 -0.34308778 -0.16232826]\n",
      " [ 0.70052166 -0.02410681 -0.51021456 -0.28121373 -0.41144648]\n",
      " [ 0.28706219 -0.26507916 -0.04739719 -0.39246718  0.83129499]\n",
      " [ 0.2864653  -0.7748912   0.46746306  0.23608395 -0.20790361]\n",
      " [ 0.05376022 -0.15251003 -0.55706461  0.77035283  0.26473774]]\n",
      "\n",
      "\n",
      "Unorm 1.0000000000000004\n",
      "\n",
      "\n",
      "Vnorm 1.0000000000000004\n",
      "\n",
      "\n",
      "U*V Norm 1.0000000000000007\n",
      "\n",
      "\n",
      "U*U' [[ 1.00000000e+00 -1.29739220e-16 -6.89530813e-17 -7.85271291e-17\n",
      "   1.59958203e-16]\n",
      " [-1.29739220e-16  1.00000000e+00 -6.34796361e-17  1.29493934e-16\n",
      "   3.38160561e-16]\n",
      " [-6.89530813e-17 -6.34796361e-17  1.00000000e+00 -5.70722775e-17\n",
      "  -3.75352593e-16]\n",
      " [-7.85271291e-17  1.29493934e-16 -5.70722775e-17  1.00000000e+00\n",
      "  -6.23704960e-18]\n",
      " [ 1.59958203e-16  3.38160561e-16 -3.75352593e-16 -6.23704960e-18\n",
      "   1.00000000e+00]]\n",
      "\n",
      "\n",
      "V*V' [[ 1.00000000e+00  2.06318055e-16  1.50926548e-16  1.35068840e-16\n",
      "   3.32632120e-17]\n",
      " [ 2.06318055e-16  1.00000000e+00 -7.61078792e-18 -2.13976997e-16\n",
      "   2.32261077e-16]\n",
      " [ 1.50926548e-16 -7.61078792e-18  1.00000000e+00  4.08785866e-16\n",
      "  -1.19341437e-16]\n",
      " [ 1.35068840e-16 -2.13976997e-16  4.08785866e-16  1.00000000e+00\n",
      "  -7.69875815e-17]\n",
      " [ 3.32632120e-17  2.32261077e-16 -1.19341437e-16 -7.69875815e-17\n",
      "   1.00000000e+00]]\n",
      "\n",
      "\n",
      "U*V' [[-0.37137871 -0.67858703 -0.6305293   0.04208398  0.04753138]\n",
      " [ 0.66788365  0.13316482 -0.52864242  0.42762326 -0.27179791]\n",
      " [ 0.57615562 -0.43910676  0.17363133 -0.13294585  0.65376411]\n",
      " [ 0.28266033 -0.18753769 -0.05601963 -0.78238818 -0.51929113]\n",
      " [ 0.06447574 -0.54203472  0.53822296  0.4307684  -0.4762309 ]]\n",
      "\n",
      "\n",
      "(U*V')*(U*V')' [[ 1.00000000e+00 -1.62820247e-16 -1.93781645e-16  1.03385293e-16\n",
      "   1.95684301e-16]\n",
      " [-1.62820247e-16  1.00000000e+00  1.08999674e-16 -1.65957285e-16\n",
      "   3.35592143e-16]\n",
      " [-1.93781645e-16  1.08999674e-16  1.00000000e+00  5.79258505e-17\n",
      "  -2.30225918e-16]\n",
      " [ 1.03385293e-16 -1.65957285e-16  5.79258505e-17  1.00000000e+00\n",
      "  -4.38516350e-16]\n",
      " [ 1.95684301e-16  3.35592143e-16 -2.30225918e-16 -4.38516350e-16\n",
      "   1.00000000e+00]]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Create  Matrix\n",
    "# U*V' is only valid when Matrix is square \n",
    "m = 5\n",
    "A3A = np.random.random((m,m))\n",
    "# A = (A + A.T) #Creating Symmetric Matrix \n",
    "print('A3A')\n",
    "print(A3A)\n",
    "print('\\n')\n",
    "\n",
    "#Compute SVD\n",
    "U2, S2, V2 = np.linalg.svd(A3A)\n",
    "\n",
    "print('Orthogonal Matrix U:',U2)\n",
    "print('\\n')\n",
    "print('Singular Value S:',S2)\n",
    "print('\\n')\n",
    "print('V2:',V2)\n",
    "print('\\n')\n",
    "\n",
    "#Compute Norm\n",
    "Unorm = np.linalg.norm(U2,2)\n",
    "Vnorm = np.linalg.norm(V2,2)\n",
    "UVtrans_norm = np.linalg.norm(np.matmul(U2,np.transpose(V2)),2)\n",
    "print('Unorm',Unorm)\n",
    "print('\\n')\n",
    "print('Vnorm',Vnorm)\n",
    "print('\\n')\n",
    "print('U*V Norm',UVtrans_norm)\n",
    "print('\\n')\n",
    "\n",
    "#Compute \n",
    "print(\"U*U'\", U2@U2.T)\n",
    "print('\\n')\n",
    "print(\"V*V'\", V2@V2.T)\n",
    "print('\\n')\n",
    "print(\"U*V'\", U2@V2.T)\n",
    "print('\\n')\n",
    "print(\"(U*V')*(U*V')'\", (U2@V2.T)@(U2@V2.T).T)\n",
    "print('\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code Challenge: 166 - Create Matrix with desired condition number\n",
    "#### create a random matrix witha specified condition number\n",
    "#### Create Singular vectors matrices \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A4A\n",
      "[[0.14848117 0.53691726 0.1252316  0.08842587 0.98169999 0.86554551\n",
      "  0.23483495 0.51977813 0.63086217 0.05125588 0.93200621 0.2003871\n",
      "  0.31523728 0.93689882 0.43753765 0.08376597]\n",
      " [0.81201005 0.2988967  0.12310379 0.07259508 0.87090023 0.19127037\n",
      "  0.40916531 0.37365528 0.92480057 0.4790283  0.16534166 0.39175008\n",
      "  0.21419327 0.92530775 0.53964568 0.59932219]\n",
      " [0.08077826 0.7733097  0.62952749 0.18209073 0.42645122 0.0034688\n",
      "  0.83123836 0.89337029 0.72145878 0.21757064 0.04040553 0.11563399\n",
      "  0.92889135 0.06312843 0.41906826 0.01585323]\n",
      " [0.65056303 0.62747652 0.78845058 0.05598835 0.09690887 0.39576299\n",
      "  0.8689776  0.44029466 0.28727951 0.20598315 0.30700918 0.14208909\n",
      "  0.72932787 0.75393092 0.78412506 0.87028574]\n",
      " [0.70667019 0.79631438 0.95238323 0.00560269 0.32883347 0.889171\n",
      "  0.28978381 0.66707721 0.11638519 0.14934263 0.27083116 0.44419799\n",
      "  0.55974323 0.23944553 0.27374314 0.19238421]\n",
      " [0.06310652 0.80433928 0.28809581 0.70103282 0.87224739 0.1729918\n",
      "  0.54098012 0.28019373 0.70802501 0.32200158 0.09051892 0.08644116\n",
      "  0.84274773 0.59794328 0.35996249 0.55138736]]\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "[41.99  33.792 25.594 17.396  9.198  1.   ]\n",
      "\n",
      "\n",
      "Condition Number for Matrix AE4: 41.99000000000004\n"
     ]
    }
   ],
   "source": [
    "#Create  Matrix\n",
    "# U*V' is only valid when Matrix is square \n",
    "m = 6\n",
    "n = 16\n",
    "A4A = np.random.random((m,n))\n",
    "# A = (A + A.T) #Creating Symmetric Matrix \n",
    "print('A4A')\n",
    "print(A4A)\n",
    "print('\\n')\n",
    "\n",
    "#Condition number\n",
    "Condnum = 41.99\n",
    "\n",
    "#Create Singular vector  matrices \n",
    "print('\\n')\n",
    "Q4,R4 = np.linalg.qr(np.random.random((m,m)))\n",
    "V4, VR4 = np.linalg.qr(np.random.random((n,n)))\n",
    "\n",
    "s = np.linspace(Condnum,1,min(m,n))\n",
    "S4 = np.zeros((m,n))\n",
    "print(s)\n",
    "print('\\n')\n",
    "for i in range(6):\n",
    "    S4[i,i] = s[i]\n",
    "    \n",
    "#Create the matrix A4\n",
    "AE4 = Q4@S4@V4.T\n",
    "\n",
    "A_cond = np.linalg.cond(AE4)\n",
    "print('Condition Number for Matrix AE4:',A_cond)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}