private static void test01() //****************************************************************************80 // // Purpose: // // TEST01 uses a 4x4 test matrix. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 15 July 2013 // // Author: // // John Burkardt // { const int N = 4; double[] a = { 4.0, -30.0, 60.0, -35.0, -30.0, 300.0, -675.0, 420.0, 60.0, -675.0, 1620.0, -1050.0, -35.0, 420.0, -1050.0, 700.0 } ; double[] d = new double[N]; int it_num = 0; int rot_num = 0; double[] v = new double[N * N]; Console.WriteLine(""); Console.WriteLine("TEST01"); Console.WriteLine(" For a symmetric matrix A,"); Console.WriteLine(" JACOBI_EIGENVALUE computes the eigenvalues D"); Console.WriteLine(" and eigenvectors V so that A * V = D * V."); typeMethods.r8mat_print(N, N, a, " Input matrix A:"); const int it_max = 100; Jacobi.jacobi_eigenvalue(N, a, it_max, ref v, ref d, ref it_num, ref rot_num); Console.WriteLine(""); Console.WriteLine(" Number of iterations = " + it_num + ""); Console.WriteLine(" Number of rotations = " + rot_num + ""); typeMethods.r8vec_print(N, d, " Eigenvalues D:"); typeMethods.r8mat_print(N, N, v, " Eigenvector matrix V:"); // // Compute eigentest. // double error_frobenius = typeMethods.r8mat_is_eigen_right(N, N, a, v, d); Console.WriteLine(""); Console.WriteLine(" Frobenius norm error in eigensystem A*V-D*V = " + error_frobenius + ""); }
private static void test03() //****************************************************************************80 // // Purpose: // // TEST03 uses a 5x5 test matrix. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 15 July 2013 // // Author: // // John Burkardt // { const int N = 5; double[] a = new double[N * N]; double[] d = new double[N]; int it_num = 0; int j; int rot_num = 0; double[] v = new double[N * N]; Console.WriteLine(""); Console.WriteLine("TEST03"); Console.WriteLine(" For a symmetric matrix A,"); Console.WriteLine(" JACOBI_EIGENVALUE computes the eigenvalues D"); Console.WriteLine(" and eigenvectors V so that A * V = D * V."); Console.WriteLine(""); Console.WriteLine(" Use the discretized second derivative matrix."); for (j = 0; j < N; j++) { int i; for (i = 0; i < N; i++) { if (i == j) { a[i + j * N] = -2.0; } else if (i == j + 1 || i == j - 1) { a[i + j * N] = 1.0; } else { a[i + j * N] = 0.0; } } } typeMethods.r8mat_print(N, N, a, " Input matrix A:"); const int it_max = 100; Jacobi.jacobi_eigenvalue(N, a, it_max, ref v, ref d, ref it_num, ref rot_num); Console.WriteLine(""); Console.WriteLine(" Number of iterations = " + it_num + ""); Console.WriteLine(" Number of rotations = " + rot_num + ""); typeMethods.r8vec_print(N, d, " Eigenvalues D:"); typeMethods.r8mat_print(N, N, v, " Eigenvector matrix V:"); // // Compute eigentest. // double error_frobenius = typeMethods.r8mat_is_eigen_right(N, N, a, v, d); Console.WriteLine(""); Console.WriteLine(" Frobenius norm error in eigensystem A*V-D*V = " + error_frobenius + ""); }
private static void wishart_unit_sample_test() //****************************************************************************80 // // Purpose: // // WISHART_UNIT_SAMPLE_TEST demonstrates the unit Wishart sampling function. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 02 August 2013 // // Author: // // John Burkardt // { int it_num = 0; int rot_num = 0; Console.WriteLine(""); Console.WriteLine("WISHART_UNIT_SAMPLE_TEST:"); Console.WriteLine(" WISHART_UNIT_SAMPLE samples unit Wishart matrices by:"); Console.WriteLine(" W = Wishart.wishart_unit_sample ( n, df );"); // // Set the parameters and call. // int n = 5; int df = 8; double[] w = Wishart.wishart_unit_sample(n, df); typeMethods.r8mat_print(n, n, w, " Wishart.wishart_unit_sample ( 5, 8 ):"); // // Calling again yields a new matrix. // w = Wishart.wishart_unit_sample(n, df); typeMethods.r8mat_print(n, n, w, " Wishart.wishart_unit_sample ( 5, 8 ):"); // // Reduce DF // n = 5; df = 5; w = Wishart.wishart_unit_sample(n, df); typeMethods.r8mat_print(n, n, w, " Wishart.wishart_unit_sample ( 5, 5 ):"); // // Try a smaller matrix. // n = 3; df = 5; w = Wishart.wishart_unit_sample(n, df); typeMethods.r8mat_print(n, n, w, " Wishart.wishart_unit_sample ( 3, 5 ):"); // // What is the eigendecomposition of the matrix? // int it_max = 50; double[] v = new double[n * n]; double[] lambda = new double[n]; Jacobi.jacobi_eigenvalue(n, w, it_max, ref v, ref lambda, ref it_num, ref rot_num); typeMethods.r8mat_print(n, n, v, " Eigenvectors of previous matrix:"); typeMethods.r8vec_print(n, lambda, " Eigenvalues of previous matrix:"); }
public static void moment_method(int n, double[] moment, ref double[] x, ref double[] w) //****************************************************************************80 // // Purpose: // // MOMENT_METHOD computes a quadrature rule by the method of moments. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 18 September 2013 // // Author: // // John Burkardt // // Reference: // // Gene Golub, John Welsch, // Calculation of Gaussian Quadrature Rules, // Mathematics of Computation, // Volume 23, Number 106, April 1969, pages 221-230. // // Parameters: // // Input, int N, the order of the quadrature rule. // // Input, double MOMENT[2*N+1], moments 0 through 2*N. // // Output, double X[N], W[N], the points and weights of the quadrature rule. // { int flag = 0; int i; int it_num = 0; int j; int rot_num = 0; const bool debug = false; switch (debug) { case true: typeMethods.r8vec_print(2 * n + 1, moment, " Moments:"); break; } // // Define the N+1 by N+1 Hankel matrix H(I,J) = moment(I+J). // double[] h = new double[(n + 1) * (n + 1)]; for (i = 0; i <= n; i++) { for (j = 0; j <= n; j++) { h[i + j * (n + 1)] = moment[i + j]; } } switch (debug) { case true: typeMethods.r8mat_print(n + 1, n + 1, h, " Hankel matrix:"); break; } // // Compute R, the upper triangular Cholesky factor of H. // double[] r = typeMethods.r8mat_cholesky_factor_upper(n + 1, h, ref flag); if (flag != 0) { Console.WriteLine(""); Console.WriteLine("MOMENT_METHOD - Fatal error!"); Console.WriteLine(" R8MAT_CHOLESKY_FACTOR_UPPER returned FLAG = " + flag + ""); return; } switch (debug) { case true: typeMethods.r8mat_print(n + 1, n + 1, r, " Cholesky factor:"); break; } // // Compute ALPHA and BETA from R, using Golub and Welsch's formula. // double[] alpha = new double[n]; alpha[0] = r[0 + 1 * (n + 1)] / r[0 + 0 * (n + 1)]; for (i = 1; i < n; i++) { alpha[i] = r[i + (i + 1) * (n + 1)] / r[i + i * (n + 1)] - r[i - 1 + i * (n + 1)] / r[i - 1 + (i - 1) * (n + 1)]; } double[] beta = new double[n - 1]; for (i = 0; i < n - 1; i++) { beta[i] = r[i + 1 + (i + 1) * (n + 1)] / r[i + i * (n + 1)]; } // // Compute the points and weights from the moments. // double[] jacobi = new double[n * n]; for (j = 0; j < n; j++) { for (i = 0; i < n; i++) { jacobi[i + j * n] = 0.0; } } for (i = 0; i < n; i++) { jacobi[i + i * n] = alpha[i]; } for (i = 0; i < n - 1; i++) { jacobi[i + (i + 1) * n] = beta[i]; jacobi[i + 1 + i * n] = beta[i]; } switch (debug) { case true: typeMethods.r8mat_print(n, n, jacobi, " The Jacobi matrix:"); break; } // // Get the eigendecomposition of the Jacobi matrix. // const int it_max = 100; double[] v = new double[n * n]; Jacobi.jacobi_eigenvalue(n, jacobi, it_max, ref v, ref x, ref it_num, ref rot_num); switch (debug) { case true: typeMethods.r8mat_print(n, n, v, " Eigenvector"); break; } for (i = 0; i < n; i++) { w[i] = moment[0] * Math.Pow(v[0 + i * n], 2); } }
private static void wishart_test05() //****************************************************************************80 // // Purpose: // // WISHART_TEST05 demonstrates the Bartlett sampling function. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 02 August 2013 // // Author: // // John Burkardt // { int it_num = 0; // // Note that R is an upper triangular matrix, // whose entries here are listed in column major order. // double[] r = { 5.0, 0.0, 0.0, 1.0, 4.0, 0.0, 3.0, 2.0, 6.0 } ; int rot_num = 0; double[] sigma_diag = { 1.0, 2.0, 3.0, 4.0, 5.0 } ; Console.WriteLine(""); Console.WriteLine("WISHART_TEST05:"); Console.WriteLine(" We can compute sample Bartlett matrices by:"); Console.WriteLine(" T = Bartlett.bartlett_sample ( n, df, sigma );"); // // Set the parameters and call. // int n = 5; int df = 8; double[] sigma = typeMethods.r8mat_identity_new(n); double[] t = Bartlett.bartlett_sample(n, df, sigma); typeMethods.r8mat_print(n, n, t, " Bartlett.bartlett_sample ( 5, 8, Identity ):"); // // Calling again yields a new matrix. // t = Bartlett.bartlett_sample(n, df, sigma); typeMethods.r8mat_print(n, n, t, " Bartlett.bartlett_sample ( 5, 8, Identity ):"); // // Try a diagonal matrix. // sigma = typeMethods.r8mat_diagonal_new(n, sigma_diag); t = Bartlett.bartlett_sample(n, df, sigma); typeMethods.r8mat_print(n, n, t, " Bartlett.bartlett_sample ( 5, 8, diag(1,2,3,4,5) ):"); // // Try a smaller matrix. // n = 3; df = 3; sigma = typeMethods.r8mat_mtm_new(n, n, n, r, r); typeMethods.r8mat_print(n, n, sigma, " Set covariance SIGMA:"); t = Bartlett.bartlett_sample(n, df, sigma); typeMethods.r8mat_print(n, n, t, " Bartlett.bartlett_sample ( 3, 3, sigma ):"); // // What is the eigendecomposition of T' * T? // double[] w = typeMethods.r8mat_mtm_new(n, n, n, t, t); int it_max = 50; double[] v = new double[n * n]; double[] lambda = new double[n]; Jacobi.jacobi_eigenvalue(n, w, it_max, ref v, ref lambda, ref it_num, ref rot_num); typeMethods.r8mat_print(n, n, v, " Eigenvectors of previous matrix:"); typeMethods.r8vec_print(n, lambda, " Eigenvalues of previous matrix:"); }