static void Main() { var rnd = new Random(1); int n = 4; var A = new matrix(n, n); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { A[i, j] = 2 * (rnd.NextDouble() - 0.5); } } A.print("Matrix inverse.\nRandom square matrix A:"); var qra = new gramschmidt(A); var B = qra.inverse(); B.print("\nThe inverse of A, A^-1:"); var Id = new matrix(n, n); for (int i = 0; i < n; i++) { Id[i, i] = 1; } var C = A * B; C.print("\ncheck: A*A^-1:"); if (Id.approx(A * B)) { Write("\nA*A^-1 = Id, test passed\n"); } else { Write("\nA*A^-1 != Id, test failed\n"); } var D = B * A; D.print("\ncheck: A^-1*A="); if (Id.approx(B * A)) { Write("\nA^-1*A = I, test passed\n"); } else { Write("\nA^-1*A != I, test failed\n"); } }
static void Main() { /// Test on random matrix /// WriteLine("/////////////// Part A - Test on random matrix ///////////////"); int n = 5; var rand = new Random(1); matrix A = new matrix(n, n); vector e = new vector(n); matrix V = new matrix(n, n); for (int i = 0; i < n; i++) { for (int j = i; j < n; j++) { A[i, j] = rand.NextDouble(); A[j, i] = A[i, j]; } } A.print($"random {n}x{n} matrix"); WriteLine(); matrix B = A.copy(); int sweeps = jacobi.cyclic(B, e, V); WriteLine($"Number of sweeps in jacobi={sweeps}"); WriteLine(); matrix D = (V.T * A * V); (D).print("Should be a diagonal matrix V.T*B*V="); WriteLine(); e.print("Eigenvalues should equal the diagonal elements above"); vector D_diagonal = new vector(n); for (int i = 0; i < n; i++) { D_diagonal[i] = D[i, i]; } if (D_diagonal.approx(e)) { WriteLine("Eigenvalues agree \tTest passed"); } else { WriteLine("Test failed"); } WriteLine(); matrix A2 = (V * D * V.T); (A2).print("Check that V*D*V.T=A"); if (A2.approx(A)) { WriteLine("V*D*V.T = A \tTest passed"); } else { WriteLine("V*D*V.T != A \tTest failed"); } }
static void Main() { var rand = new Random(); // We can pull out new random numbers between 0 and 1 with rand.NextDouble() and // stuff it into a matrix int n = 4; matrix A = new matrix(n, n); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { A[i, j] = 2 - 4 * rand.NextDouble(); } } WriteLine("Set up a random matrix, and try to find the inverse matrix via QR" + " decomposition.\n"); WriteLine("Printing random matrix A:"); A.print(); // Factorize the matrix into two matrices Q and R, and calculate the inverse matrix B var qrGS = new qrDecompositionGS(A); matrix B = qrGS.inverse(); matrix Q = qrGS.Q; matrix R = qrGS.R; WriteLine("\nPrinting matrix R:"); R.print(); WriteLine("\nPrinting matrix Q:"); Q.print(); WriteLine("\nPrinting matrix B (inverse to A):"); B.print(); // Let's check if B is actually the inverse by calculating A*B which then should // give the identity matrix matrix AB = A * B; WriteLine("\nPrinting matrix A*B:"); AB.print(); matrix I = new matrix(n, n); I.set_identity(); bool approx = AB.approx(I); if (approx == true) { WriteLine("A*B is approximately equal to the identity matrix."); } else { WriteLine("A*B is not approximately equal to the identity matrix."); } }
static void Main(string[] args) { int n = 5; matrix D = GenRandSymMatrix(n, n); matrix A = D.copy(); A.print($"Symmetric matrix A:"); (vector e, matrix V, int n1) = cyclic(D); for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) { D[j, i] = D[i, j]; // complete the matrix } } matrix VTAV = V.transpose() * A * V; e.print($"Eigenvalues e:"); V.print($"Eigenvectors V:"); A.print($"D matrix: "); VTAV.print($"Matrix V^TAV:"); if (D.approx(VTAV)) { WriteLine("V^TAV = D, test passed."); } else { WriteLine("V^TAV != D, test failed."); } matrix B = A.copy(); (vector e2, _, int n2) = lowest_eigens(A, 3); (vector e4, _, int n4) = highest_eigens(A, 3); e.print($"\nEigenvalues from cyclic method found after {n1, 3} rotations: "); e2.print($"3 lowest eigenvalues from row-by-row method found after {n2, 3} rotations: "); e4.print($"3 highest eigenvalues from row-by-row method found after {n4, 3} rotations: "); (vector e3, _, int n3) = classic(B); e3.print($"Eigenvalues from the classic method found after {n3, 3} rotations: "); WriteLine(); }
static void Main() { int n = 4, m = 3; matrix A = new matrix(n, m); /* Construction of a random matrix A */ var rnd = new Random(1); for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { A[i, j] = 2 * (rnd.NextDouble() - 0.5); } } A.print($"QR-decomposition:\nrandom {n}x{m} matrix A:"); var qra = new gramschmidt(A); var Q = qra.Q; var R = qra.R; Q.print("matrix Q:"); R.print("matrix R:"); matrix qtq = (Q.T * Q); qtq.print("Q^T*Q:"); matrix qr = (Q * R); qr.print("Q*R:"); if (A.approx(Q * R)) { Write("Q*R=A, test passed\n"); } else { Write("Q*R!=A, test failed\n"); } }
public static int Main() { int n = 5; int m = 4; matrix A = new matrix(n, m); var rand = new Random(1); for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { A[i, j] = 10 * (rand.NextDouble()); } } // A.1 WriteLine("Assignment A.1:"); A.print($"Matrix A {n}x{m}:"); var qr_A = new qrdecompositionGS(A); var Q = qr_A.Q; var R = qr_A.R; R.print($"The upper triangular matrix R:"); var qq = Q.transpose() * Q; qq.print($"Q^T Q =1: "); var qr = Q * R; qr.print($"Q*R=A: "); if (A.approx(Q * R)) { Write("Q*R=A, test passed\n"); } else { Write("Q*R!=A, test failed\n"); } WriteLine(""); // A.2 WriteLine("Assignment A.2:"); matrix A2 = new matrix(n, n); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { A2[i, j] = 10 * (rand.NextDouble()); } } A2.print($"Matrix A {n}x{n}:"); var qr_A2 = new qrdecompositionGS(A2); vector b = new vector(n); for (int i = 0; i < n; i++) { b[i] = 10 * (rand.NextDouble()); } b.print($"Vector b with size {n}: "); var qrxb = qr_A2.solve(qr_A2.Q, b); qrxb.print($"solve x for QRx=b:\nx = "); var ax = A2 * qrxb; ax.print("Ax = "); WriteLine("which is equal to b.\n"); return(0); }
static void Main() { /// Test on random matrix /// WriteLine("/////////////// Part B - test of row by row method///////////////"); int n = 5; var rand = new Random(1); matrix A = new matrix(n, n); vector e = new vector(n); matrix V = new matrix(n, n); for (int i = 0; i < n; i++) { for (int j = i; j < n; j++) { A[i, j] = 2 * (rand.NextDouble() - 0.5); A[j, i] = A[i, j]; } } A.print($"random {n}x{n} matrix"); WriteLine(); matrix B = A.copy(); int reps = jacobi_row.row(B, e, n, V); WriteLine($"Number of repititions in jacobi={reps}"); WriteLine(); matrix D = (V.T * A * V); (D).print("Should be a diagonal matrix V.T*B*V="); WriteLine(); e.print("Eigenvalues should equal the diagonal elements above"); WriteLine(); vector D_diagonal = new vector(n); for (int i = 0; i < n; i++) { D_diagonal[i] = D[i, i]; } if (D_diagonal.approx(e)) { WriteLine("Test passed"); } else { WriteLine("Test failed"); } matrix A2 = (V * D * V.T); (A2).print("Check that V*D*V.T=A"); WriteLine(); if (A2.approx(A)) { WriteLine("V*D*V.T = A \tTest passed"); } else { WriteLine("V*D*V.T != A \tTest failed"); } WriteLine(); WriteLine(); WriteLine("/////////////// Find only the higest eigen values///////////////"); vector e1 = new vector(n); matrix V1 = new matrix(n, n); string order = "high"; A.print($"random {n}x{n} matrix"); WriteLine(); matrix C = A.copy(); int reps1 = jacobi_row.row(C, e1, 2, V1, order); WriteLine($"Number of repititions in jacobi={reps1}"); WriteLine(); matrix D1 = (V1.T * A * V1); (D1).print("First two diagonal elements should be the two higest eigenvalues"); WriteLine(); vector D1_diagonal2highest = new vector(D1[0, 0], D1[1, 1]); vector D_diagonal2highest = new vector(D[n - 1, n - 1], D[n - 2, n - 2]); if (D1_diagonal2highest.approx(D_diagonal2highest)) { WriteLine("Eigenvalues match \tTest passed"); } else { WriteLine("Eigenvalues do not match \tTest failed"); } }
public static void Main(string[] args) { int n = 5; matrix A = myMatrixMethods.randMatrix(n, n); // Make A symetrical myMatrixMethods.mirrorLower(A); A.print($"A is a symetrical matrix of size {n}"); matrix V = new matrix(n, n); vector e = new vector(n); int sweeps = jacobi.cyclic(A, V, e); //V.print("Eigenvectors for A:"); matrix D = new matrix(n, n); for (int i = 0; i < n; i++) { D[i, i] = e[i]; } D.print("The diagonal composition, D:"); // Restore A to the original symetrical matrix myMatrixMethods.mirrorLower(A); matrix test = V.transpose() * A * V; test.print("Test that V^T * A * V = D"); if (test.approx(D, 1e-5)) { WriteLine("V^T * A * V == D - Works as intended"); } else { WriteLine("V^T * A * V != D - Not as intended! Try again!"); } WriteLine(""); matrix test2 = V * D * V.transpose(); test2.print("Test that V * D * V^T = A"); if (test2.approx(A)) { WriteLine("V * D * V^T == A - Works as intended"); } else { WriteLine("V * A * V^T != A - Not as intended! Try again!"); } WriteLine(""); WriteLine("----- Particle in a box -----"); // Generate a Hamiltonian n = 30; double s = 1.0 / (n + 1); matrix H = new matrix(n, n); for (int i = 0; i < n - 1; i++) { H[i, i] = -2; H[i, i + 1] = 1; H[i + 1, i] = 1; } H[n - 1, n - 1] = -2; H = -(n + 1) * (n + 1) * H; // Diagonolize H V = new matrix(n, n); vector eigenvals = new vector(n); sweeps = 0; sweeps = jacobi.cyclic(H, V, eigenvals); // Check that the eigenvalues are correct WriteLine("E_n \t calculated \t exact"); for (int k = 0; k < n / 3; k++) { double exact = PI * PI * (k + 1) * (k + 1); double calculated = eigenvals[k]; WriteLine($"E_{k} \t {calculated.ToString("F5")} \t {exact.ToString("F5")}"); } // preparing data to be plotted using (StreamWriter sw = new StreamWriter("data.txt")){ sw.WriteLine($"0 \t 0 \t 0 \t 0 \t 0 "); for (int i = 0; i < n; i++) { sw.Write($"{(i + 1) * 1.0 / (n + 1)}"); for (int j = 0; j < 4; j++) { sw.Write($"\t {V[i, j]} "); } sw.Write("\n"); } sw.WriteLine($"1 \t 0 \t 0 \t 0 \t 0"); } WriteLine(""); WriteLine(""); WriteLine("----- Problem B -----"); n = 7; A = myMatrixMethods.randMatrix(n, n); myMatrixMethods.mirrorLower(A); A.print("Matrix A:"); V = new matrix(n, n); e = new vector(n); jacobi.cyclic(A, V, e); e.print("Has the eigenvals:"); myMatrixMethods.mirrorLower(A); int kLowest = n - 1; vector kLowestEigenvals = jacobi.kLowestEigen(A, V, e, kLowest); kLowestEigenvals.print($"The {kLowest} lowest eigenvals are:"); myMatrixMethods.mirrorLower(A); int kHighest = 3; vector kHighestEigenvals = jacobi.kHighestEigen(A, V, e, kHighest); kHighestEigenvals.print($"The {kHighest} highest eigenvals are:"); }
static void Main() { //// Del A //// int n = 3; matrix A = rand_matrix(n); var cd = new cholesky(A); var L = cd.L; var LT = cd.LT; WriteLine("_____________________________________"); WriteLine(); WriteLine("Part A - decomposit A into L*LT"); (A).print("Matrix A="); WriteLine(); (L).print("Matrix L="); WriteLine(); (LT).print("Matrix LT="); WriteLine(); WriteLine("Check if L*LT=A"); matrix LLT = L * LT; LLT.print("L*LT="); WriteLine(); if (A.approx(LLT)) { WriteLine("L*LT=A\tTEST PASSED"); } else { WriteLine("L*LT!=A\tTEST FAILED"); } //// Del B //// vector v = rand_vector(n); vector b = v.copy(); vector x = cd.solve(v); WriteLine("_____________________________________"); WriteLine(); WriteLine("Part B - Solving linear equation: A*x=b"); A.print("Matrix A="); WriteLine(); b.print("Vector b="); WriteLine(); x.print("Solution x="); WriteLine(); vector Ax = (A * x); Ax.print("Check A*x="); WriteLine(); if (b.approx(Ax)) { WriteLine("A*x=b TEST PASSED"); } else { WriteLine("A*x!=b TEST FAILED"); } //// Del C //// WriteLine("_____________________________________"); WriteLine(); WriteLine("Part C - Determinant of A"); double D = cd.determinant(); WriteLine($"det(A)={D}"); WriteLine(); //Determinant test is only avalible for n=3 if (n == 3) { double D_alt = A[0, 0] * A[1, 1] * A[2, 2] + A[0, 1] * A[1, 2] * A[2, 0] + A[0, 2] * A[1, 0] * A[2, 1] - A[0, 2] * A[1, 1] * A[2, 0] - A[0, 1] * A[1, 0] * A[2, 2] - A[1, 2] * A[2, 1] * A[0, 0]; if (matrix.approx(D_alt, D)) { WriteLine("TEST PASSED"); } else { WriteLine("TEST FAILED"); } } //// Del D //// WriteLine("_____________________________________"); WriteLine(); WriteLine("Part D - find the inverse matrix of A"); var A_inv = cd.inverse(); A_inv.print("A_inv="); WriteLine(); WriteLine("Check if A_inv is the inverse:"); WriteLine(); matrix AA_inv1 = A * A_inv; AA_inv1.print("A*A_inv="); WriteLine(); matrix AA_inv2 = A * A_inv; AA_inv2.print("A_inv*A="); WriteLine(); matrix I = matrix.id(n); if (I.approx(AA_inv1) && I.approx(AA_inv2)) { WriteLine("A*A_inv=I\tTEST PASSED"); } else { WriteLine("A*A_inv=I\tTEST FAILED"); } } //Method: Main
static void Main() { // Part 1 of exercise A WriteLine("-------Part 1 of exercise A:-------\n"); // We start out by creating a random matrix. var rand = new Random(); // We can pull out new random numbers between 0 and 1 with rand.NextDouble() and // stuff it into a matrix int nA = 5; int mA = 4; matrix A = new matrix(nA, mA); for (int i = 0; i < nA; i++) { for (int j = 0; j < mA; j++) { A[i, j] = 2 - 4 * rand.NextDouble(); } } // Print A WriteLine("We will setup a random tall matrix and perform QR factorization on it."); WriteLine("Printing random tall matrix A:"); A.print(); // We can now try to factorize the matrix A into the two matrĂces Q and R var qrGSA = new qrDecompositionGS(A); matrix Q = qrGSA.Q; matrix R = qrGSA.R; // Let's check that R is upper triangular WriteLine("\nPrinting matrix R:"); R.print(); WriteLine("\nPrinting matrix Q:"); Q.print(); // Checking that Q^T * Q = 1 WriteLine("\nPrinting (Q^T)*Q:"); matrix QTQ = Q.transpose() * Q; QTQ.print(); // Let's check if (Q^T)*Q is approximately the identity matrix matrix I = new matrix(mA, mA); I.set_identity(); bool approx = QTQ.approx(I); if (approx == true) { WriteLine("(Q^T)*Q is approximately equal to the identity matrix."); } else { WriteLine("(Q^T)*Q is not approximately equal to the identity matrix."); } // Checking that Q*R=A, or in other words that A-Q*R = 0 WriteLine("\nPrinting out A-Q*R:"); matrix AmQR = A - Q * R; AmQR.print(); // Let's check if Q*R is approximately equal to A, or that A-QR is approx. the zero // matrix matrix nullMatrix = new matrix(AmQR.size1, AmQR.size2); nullMatrix.set_zero(); approx = AmQR.approx(nullMatrix); if (approx == true) { WriteLine("QR is thus approximately equal to A."); } else { WriteLine("QR is thus not approximately equal to A."); } // Part 2 of exercise A WriteLine("\n\n-------Part 2 of exercise A:-------\n"); // At first we create a random square matrix - let's call it C now to avoid confusion // with part 1 above WriteLine("Setting up system C*x = b."); int nC = 4; matrix C = new matrix(nC, nC); for (int i = 0; i < nC; i++) { for (int j = 0; j < nC; j++) { C[i, j] = 2 - 4 * rand.NextDouble(); } } WriteLine("Printing matrix C:"); C.print(); // Next we generate a vector b of a length corresponding to the dimension of the // square matrix vector b = new vector(nC); for (int i = 0; i < nC; i++) { b[i] = 3 * rand.NextDouble() - 1.5; } WriteLine("\nPrinting out b:"); b.print(); // Once again we factorize our matrix into two matrices Q and R var qrGSC = new qrDecompositionGS(C); Q = qrGSC.Q; R = qrGSC.R; WriteLine("\nSolving by QR decomposition and back-substitution."); vector x = qrGSC.solve(b); WriteLine("\nThe obtained x-vector from the routine is:"); x.print(); WriteLine("\nPrinting vector C*x :"); vector Cx = C * x; Cx.print(); // Let's check if C*x is approximately equal to b approx = Cx.approx(b); if (approx == true) { WriteLine("Cx is approximately equal to b. The system has been solved."); } else { WriteLine("Cx is not approximately equal to b. The system has not been solved."); } }
static void Main() { WriteLine("_____________________________________"); WriteLine("Part C1 - decomposition of random matrix A"); int n = 5; matrix A = new matrix(n, n); var rand = new Random(1); // make random matrix A for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { A[i, j] = 2 * (rand.NextDouble() - 0.5); } } vector b = new vector(n); // make random vector b for (int i = 0; i < n; i++) { b[i] = 2 * (rand.NextDouble() - 0.5); } // make the QR decomposition through givens-rotation var qr1 = new givens(A); // Matrix with R in the right diagonal and givens-angels in the lower sub-diagonal var G = qr1.G; // make the QR decomposition through GS var qr2 = new gs(A); var R = qr2.R; A.print("Matrix A="); WriteLine(); WriteLine("Upper triangular part of matrix G contains the elements of R."); WriteLine("The enteries below the diagonal of G contains givens-rotation angles."); G.print("Matrix G="); WriteLine(); R.print("Matrix R="); WriteLine(); WriteLine("The upper triangular part of G should match the elements in R achived through GS."); //Filter out the lower part of G matrix R2 = G.copy(); for (int j = 0; j < G.size2; j++) { for (int i = j + 1; i < G.size1; i++) { R2[i, j] = 0; } } if (R2.approx(R)) { WriteLine("Upper triangular part identical - TEST PASSED"); } else { WriteLine("Upper triangular part not identical - TEST FAILED"); } WriteLine("_____________________________________"); WriteLine("Part C2 - solve the linear equations of A*x=b"); WriteLine(); // solve the equation A*x=b for vector x var x = qr1.solve(b); b.print("Vector b="); WriteLine(); x.print("Solution x="); WriteLine(); vector Ax = (A * x); Ax.print("Check A*x="); if (b.approx(Ax)) { WriteLine("A*x=b - TEST PASSED"); } else { WriteLine("A*x!=b - TEST FAILED"); } } //Method: Main
static void Main() { int n = 5, m = 4; matrix A1 = new matrix(n, m); var rnd = new Random(1); for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { A1[i, j] = 2 * (rnd.NextDouble() - 0.5); } } WriteLine("____Assignment A1____"); A1.print($"QR-decomposition:\nrandom {n}x{m} matrix A:"); (matrix Q, matrix R1) = qrDecomp.qr_gs_decomp(A1); R1.print("matrix R:"); matrix QTQ = Q.T * Q; matrix QR = Q * R1; QTQ.print("Q^T*Q:"); QR.print("Q*R:"); if (A1.approx(QR)) { WriteLine("Q*R=A, test passed"); } else { WriteLine("Q*R!=A, test failed"); } Write("\n\n"); matrix A2 = new matrix(n, n); rnd = new Random(2); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { A2[i, j] = 2 * (rnd.NextDouble() - 0.5); } } vector b = new vector(n); rnd = new Random(3); for (int i = 0; i < n; i++) { b[i] = 2 * (rnd.NextDouble() - 0.5); } WriteLine("____Assignment A2____"); A2.print($"Solving system of equations A*x=Q*R*x=b:\nrandom {n}x{n} matrix A:"); (matrix Q2, matrix R2) = qrDecomp.qr_gs_decomp(A2); Q2.print("matrix Q:"); R2.print("matrix R:"); b.print("vector b:"); vector x2 = qrDecomp.qr_gs_solve(Q2, R2, b); vector Ax2 = A2 * x2; x2.print("solution vector x:"); Ax2.print("A*x:"); if (b.approx(A2 * x2)) { WriteLine("A*x=b, test passed"); } else { WriteLine("A*x!=b, test failed"); } Write("\n\n"); matrix A3 = new matrix(n, n); rnd = new Random(4); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { A3[i, j] = 2 * (rnd.NextDouble() - 0.5); } } WriteLine("____Assignment B____"); A3.print($"Decomposing A into Q*R:\nrandom {n}x{n} matrix A:"); (matrix Q3, matrix R3) = qrDecomp.qr_gs_decomp(A3); Q3.print("matrix Q:"); R3.print("matrix R:"); matrix B = qrDecomp.qr_gs_inverse(Q3, R3); matrix I = new matrix(n, n); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { I[i, j] = 0; if (i == j) { I[i, j] = 1; } } } I.print($"Idenity matrix I({n}):"); B.print("Inverse matrix B:"); matrix AB = A3 * B; matrix AB_round = new matrix(n, n); // rounded matrix to 10th decimal to get a nicer output for (int i = 0; i <= n - 1; i++) { for (int j = 0; j <= n - 1; j++) { AB_round[i, j] = Math.Round((Double)AB[i, j], 10); } } AB_round.print("A*B:"); if (AB.approx(I)) { WriteLine("A*B=I, test passed"); // test is still with unrounded matrix } else { WriteLine("A*B!=I, test failed"); } Write("\n\n"); WriteLine("____Assignment C____"); A2.print($"Givens rotation of the same coefficient matrix as in part A(2):\nrandom {n}x{m} matrix A:"); matrix T = A2.copy(); qrDecomp.qr_givens_decomp(T); T.print("Matrix with R in the upper trinagle and angles of the Givens rotation below, T:"); b.print("Same vector b as in A(2):"); vector Gb = b.copy(); vector x4 = qrDecomp.qr_givens_solve(T, Gb); vector Ax4 = A2 * x4; x4.print("solution vector x:"); Ax4.print("A*x:"); if (b.approx(A2 * x4)) { WriteLine("A*x=b, test passed"); } else { WriteLine("A*x!=b, test failed"); } Write("\n\n"); }
static void Main(string[] args) { int n = 3, m = 3; // QR DECOMPOSITION writetitle("\nQR decomposition"); matrix A = GenRandMatrix(n, m); matrix R = new matrix(m, m); matrix Q = A.copy(); A.print($"QR-decomposition of the matrix A:"); gs.decomp(Q, R); R.print($"Matrix R:"); var QQT = Q.T * Q; // does not work within parantheses var QR = Q * R; // same QQT.print("Q^T Q:"); QR.print("QR:"); if (A.approx(QR)) { writepass("QR = A, test passed."); } else { writefail("QR != A, test failed."); } // SOLVING writetitle("\nQR solving"); A = GenRandMatrix(n, m); vector b = GenRandVector(m); R = new matrix(m, m); //A[0, 0] = 1; A[0, 1] = 1; A[0, 2] = 1; //A[1, 0] = 0; A[1, 1] = 2; A[1, 2] = 5; //A[2, 0] = 2; A[2, 1] = 5; A[2, 2] = -1; //vector b = new vector(6, -4, 27); A.print($"Solving the equation Ax = b, with A:"); b.print($"and b:\n"); Q = A.copy(); gs.decomp(Q, R); vector x = gs.solve(Q, R, b); x.print($"\nSolution is x:\n"); var Ax = A * x; Ax.print($"Ax:\n"); if (b.approx(Ax)) { writepass("Ax = Q^T b, test passed."); } else { writefail("Ax != Q^T b, test failed."); } // INVERSE writetitle("\nQR inverse"); A = GenRandMatrix(n, m); R = new matrix(m, m); Q = A.copy(); gs.decomp(Q, R); matrix B = gs.inverse(Q, R); // B = A^-1 A.print($"Solving for the inverse of A:"); B.print($"Inverse is B:"); matrix AB = A * B; AB.print($"AB:"); matrix I = new matrix(n, m); for (int i = 0; i < n; i++) { I[i, i] = 1; } if (AB.approx(I)) { writepass("AB = I, test passed."); } else { writefail("AB != I, test failed."); } // GIVENS writetitle("\nGivens rotations"); A = GenRandMatrix(n, m); b = GenRandVector(m); A.print($"Solving the equation Ax = b, with A:"); b.print($"and b:\n"); givens decomp = new givens(A); x = decomp.solve(b); x.print("\nSolution is x:\n"); Ax = A * x; Ax.print("Ax:\n"); if (Ax.approx(b)) { writepass("Ax = b, test passed."); } else { writefail("Ax != b, test failed."); } }
static void Main(string[] args) { WriteLine("----- Problem A -----"); WriteLine("------- testing the decomp function --------"); int n = 5, m = 3; matrix A = randMatrix(n, m); matrix R = new matrix(m, m); matrix Q = A.copy(); A.print("QR-decomposition of the matrix A: "); gs.decomp(Q, R); R.print("The matrix R: "); matrix QTQ = Q.transpose() * Q; QTQ.print("Q^t * t: "); matrix QR = Q * R; QR.print("QR: "); if (QR.approx(A)) { WriteLine("QR = A - Works as intended!"); } else { WriteLine("QR != A - This does not work as intended. Try again!"); } WriteLine("------- testing the solve function --------"); n = 4; A = randMatrix(n, n); R = new matrix(n, n); Q = A.copy(); vector b = randVector(n); gs.decomp(Q, R); // Q.print("A:"); // R.print("R:"); // b.print("b:"); vector x = gs.solve(Q, R, b); x.print("x:"); vector Ax = A * x; if (Ax.approx(b)) { WriteLine("A * x == b - works as intended"); } else { WriteLine("A * x != b - this is not as intended! Try again!"); } WriteLine("----- Problem B -----"); WriteLine("------- testing the inverse function --------"); n = 6; A = randMatrix(n, n); R = new matrix(n, n); Q = A.copy(); gs.decomp(Q, R); matrix Ai = gs.inverse(Q, R); matrix AAi = A * Ai; AAi.print("A * Ai:"); matrix I = new matrix(n, n); I.set_identity(); if (I.approx(AAi)) { WriteLine("A * Ainverse is the identity! - this is as intended!"); } else { WriteLine("A * Ainverse is not the identity! - this is not as intended! Try again!"); } }
static void Main(){ //// Del A1 //// int n=4, m=3; matrix A= new matrix(n,m); var rand= new Random(1); for(int i=0;i<n;i++){ for(int j=0;j<m;j++){ A[i,j]=2*(rand.NextDouble()-0.5); } } var qra1=new gs(A); var Q=qra1.Q; var R=qra1.R; WriteLine("_____________________________________"); WriteLine("Part A1 - decomposit A into Q*R"); (A).print("Matrix A=");WriteLine(); (Q).print("Matrix Q=");WriteLine(); (R).print("Matrix R=");WriteLine(); WriteLine("Check if Q.T is the inverse of Q"); ((Q.T)*Q).print("Q.T*Q=");WriteLine(); WriteLine("Check if Q*R=A"); matrix QR=Q*R; QR.print("Q*R="); if(A.approx(QR)){WriteLine("Q*R=A\nTest passed");} else {WriteLine("Q*R!=A\nTest failed");} //// Del A2 //// WriteLine("_____________________________________"); WriteLine("Part A2 - solve the linear equations of A*x=b"); n=4; A=new matrix(n,n); for(int i=0;i<n;i++){ for(int j=0;j<n;j++){ A[i,j]=2*(rand.NextDouble()-0.5); } } vector b= new vector(n); for(int i=0;i<n;i++){ b[i]=2*(rand.NextDouble()-0.5); } var qra2=new gs(A); var x=qra2.solve(b); A.print("Matrix A=");WriteLine(); b.print("Vector b=");WriteLine(); x.print("Solution x=");WriteLine(); vector Ax=(A*x); Ax.print("Check A*x="); if(b.approx(Ax)){WriteLine("A*x=b Test passed");} else {WriteLine("A*x!=b Test failed");} //// Del B //// WriteLine("_____________________________________"); WriteLine("Part B - find the inverse matrix of A"); var A_inv=qra2.inverse(); A_inv.print("A_inv=");WriteLine(); WriteLine("Check if A_inv is the inverse:");WriteLine(); matrix AA_inv1=A*A_inv; AA_inv1.print("A*A_inv=");WriteLine(); matrix AA_inv2=A*A_inv; AA_inv2.print("A_inv*A=");WriteLine(); matrix I= new matrix(n,n); for(int i=0;i<n;i++){ for(int j=0;j<n;j++){ if(i==j) I[i,j]=1; else I[i,j]=0; } } if(I.approx(AA_inv1) || I.approx(AA_inv2)){WriteLine("A*A_inv=I\nTest passed");} else {WriteLine("A*A_inv=I\nTest failed");} } //Method: Main