private static void test02() //****************************************************************************80 // // Purpose: // // TEST02 tests ccs_HEADER_READ and ccs_DATA_READ. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 18 July 2014 // // Author: // // John Burkardt // { int n = 0; int ncc = 0; const string prefix = "simple"; Console.WriteLine(""); Console.WriteLine("TEST02"); Console.WriteLine(" Read a sparse matrix in CCS format from 3 files."); // // Read the header. // CompressedColumnStorage.ccs_header_read(prefix, ref ncc, ref n); // // Allocate space. // double[] acc = new double[ncc]; int[] ccc = new int[n + 1]; int[] icc = new int[ncc]; // // Read the matrix data. // CompressedColumnStorage.ccs_data_read(prefix, ncc, n, ref icc, ref ccc, ref acc); // // Print the CCS matrix. // int m = n; CompressedColumnStorage.ccs_print(m, n, ncc, icc, ccc, acc, " The matrix in 0-based CCS format:"); // // Free memory. // }
private static void test01() //****************************************************************************80 // // Purpose: // // TEST01 tests ccs_WRITE using a tiny matrix. // // Discussion: // // This test uses a trivial matrix whose full representation is: // // 2 3 0 0 0 // 3 0 4 0 6 // A = 0 -1 -3 2 0 // 0 0 1 0 0 // 0 4 2 0 1 // // The 1-based CCS representation is // // # ICC CCC ACC // -- --- --- --- // 1 1 1 2 // 2 2 3 // // 3 1 3 3 // 4 3 -1 // 5 5 4 // // 6 2 6 4 // 7 3 -3 // 8 4 1 // 9 5 2 // // 10 3 10 2 // // 11 2 11 6 // 12 5 1 // // 13 * 13 // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 18 July 2014 // // Author: // // John Burkardt // { const int N = 5; const int NCC = 12; double[] acc = { 2.0, 3.0, 3.0, -1.0, 4.0, 4.0, -3.0, 1.0, 2.0, 2.0, 6.0, 1.0 } ; int[] ccc = { 1, 3, 6, 10, 11, 13 } ; int[] icc = { 1, 2, 1, 3, 5, 2, 3, 4, 5, 3, 2, 5 } ; const string prefix = "simple"; Console.WriteLine(""); Console.WriteLine("TEST01"); Console.WriteLine(" Write a sparse matrix in CCS format to 3 files."); // // Full storage statistics // Console.WriteLine(""); Console.WriteLine(" Full rows M = " + N + ""); Console.WriteLine(" Full columns N = " + N + ""); Console.WriteLine(" Full storage = " + N * N + ""); // // Decrement the 1-based data. // typeMethods.i4vec_dec(N + 1, ref ccc); typeMethods.i4vec_dec(NCC, ref icc); // // Print the CCS matrix. // CompressedColumnStorage.ccs_print(N, N, NCC, icc, ccc, acc, " The matrix in 0-based CCS format:"); // // Write the matrix to 3 files. // CompressedColumnStorage.ccs_write(prefix, NCC, N, icc, ccc, acc); }
private static void test01() //****************************************************************************80 // // Purpose: // // TEST01 tests st_to_ccs using a tiny matrix. // // Discussion: // // This test uses a trivial matrix whose full representation is: // // 2 3 0 0 0 // 3 0 4 0 6 // A = 0 -1 -3 2 0 // 0 0 1 0 0 // 0 4 2 0 1 // // A (1-based) ST representation, reading in order by rows is: // // I J A // -- -- -- // 1 1 2 // 1 2 3 // // 2 1 3 // 2 3 4 // 2 5 6 // // 3 2 -1 // 3 3 -3 // 3 4 2 // // 4 3 1 // // 5 2 4 // 5 3 2 // 5 5 1 // // The CCS representation (which goes in order by columns) is // // # I JC A // -- -- -- -- // 1 1 1 2 // 2 2 3 // // 3 1 3 3 // 4 3 -1 // 5 5 4 // // 6 2 6 4 // 7 3 -3 // 8 4 1 // 9 5 2 // // 10 3 10 2 // // 11 2 11 6 // 12 5 1 // // 13 * 13 // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 23 July 2014 // // Author: // // John Burkardt // { const int NST = 12; double[] ast = { 2.0, 3.0, 3.0, 4.0, 6.0, -1.0, -3.0, 2.0, 1.0, 4.0, 2.0, 1.0 } ; int[] ist = { 1, 1, 2, 2, 2, 3, 3, 3, 4, 5, 5, 5 } ; int[] jst = { 1, 2, 1, 3, 5, 2, 3, 4, 3, 2, 3, 5 } ; const int m = 5; const int n = 5; Console.WriteLine(""); Console.WriteLine("TEST01"); Console.WriteLine(" Convert a sparse matrix from ST to CCS format."); Console.WriteLine(" ST: sparse triplet, I, J, A."); Console.WriteLine(" CCS: compressed column, I, CC, A."); int i_min = typeMethods.i4vec_min(NST, ist); int i_max = typeMethods.i4vec_max(NST, ist); int j_min = typeMethods.i4vec_min(NST, jst); int j_max = typeMethods.i4vec_max(NST, jst); SparseTriplet.st_header_print(i_min, i_max, j_min, j_max, m, n, NST); // // Decrement the 1-based data. // typeMethods.i4vec_dec(NST, ref ist); typeMethods.i4vec_dec(NST, ref jst); // // Print the ST matrix. // SparseTriplet.st_print(m, n, NST, ist, jst, ast, " The matrix in ST format:"); // // Get the CCS size. // int ncc = SparseTriplet.st_to_ccs_size(NST, ist, jst); Console.WriteLine(""); Console.WriteLine(" Number of CCS values = " + ncc + ""); // // Create the CCS indices. // int[] icc = new int[ncc]; int[] ccc = new int[n + 1]; SparseTriplet.st_to_ccs_index(NST, ist, jst, ncc, n, ref icc, ref ccc); // // Create the CCS values. // double[] acc = SparseTriplet.st_to_ccs_values(NST, ist, jst, ast, ncc, n, icc, ccc); // // Print the CCS matrix. // CompressedColumnStorage.ccs_print(m, n, ncc, icc, ccc, acc, " CCS Matrix:"); }
private static void test01() //****************************************************************************80 // // Purpose: // // TEST01 tests ccs_TO_ST using a 1-based matrix. // // Discussion: // // This test uses a trivial matrix whose full representation is: // // 2 3 0 0 0 // 3 0 4 0 6 // A = 0 -1 -3 2 0 // 0 0 1 0 0 // 0 4 2 0 1 // // The 1-based CCS representation is // // # ICC CCC ACC // -- --- --- --- // 1 1 1 2 // 2 2 3 // // 3 1 3 3 // 4 3 -1 // 5 5 4 // // 6 2 6 4 // 7 3 -3 // 8 4 1 // 9 5 2 // // 10 3 10 2 // // 11 2 11 6 // 12 5 1 // // 13 * 13 // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 23 July 2014 // // Author: // // John Burkardt // { const int N = 5; const int NCC = 12; double[] acc = { 2.0, 3.0, 3.0, -1.0, 4.0, 4.0, -3.0, 1.0, 2.0, 2.0, 6.0, 1.0 } ; int[] ccc = { 1, 3, 6, 10, 11, 13 } ; int[] icc = { 1, 2, 1, 3, 5, 2, 3, 4, 5, 3, 2, 5 } ; const int m = 5; int nst = 0; Console.WriteLine(""); Console.WriteLine("TEST01"); Console.WriteLine(" Convert a 1-based CCS matrix to ST format."); // // Print the CCS matrix. // CompressedColumnStorage.ccs_print(m, N, NCC, icc, ccc, acc, " The CCS matrix:"); // // Convert it. // int[] ist = new int[NCC]; int[] jst = new int[NCC]; double[] ast = new double[NCC]; CompressedColumnStorage.ccs_to_st(m, N, NCC, icc, ccc, acc, ref nst, ref ist, ref jst, ref ast); // // Print the ST matrix. // SparseTriplet.st_print(m, N, nst, ist, jst, ast, " The ST matrix:"); }
private static void test02() //****************************************************************************80 // // Purpose: // // TEST02 tests st_to_ccs on a matrix stored in a file. // // Discussion: // // We assume no prior knowledge about the matrix except the filename. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 23 July 2014 // // Author: // // John Burkardt // { const string filename_st = "west_st.txt"; int i_max = 0; int i_min = 0; int j_max = 0; int j_min = 0; int m = 0; int n = 0; int nst = 0; Console.WriteLine(""); Console.WriteLine("TEST02"); Console.WriteLine(" Convert a sparse matrix from ST to CCS format."); Console.WriteLine(" ST: sparse triplet, I, J, A."); Console.WriteLine(" CCS: compressed column, I, CC, A."); Console.WriteLine(" This matrix is read from the file '" + filename_st + "'"); // // Get the size of the ST matrix. // SparseTriplet.st_header_read(filename_st, ref i_min, ref i_max, ref j_min, ref j_max, ref m, ref n, ref nst); SparseTriplet.st_header_print(i_min, i_max, j_min, j_max, m, n, nst); // // Allocate space. // int[] ist = new int[nst]; int[] jst = new int[nst]; double[] ast = new double[nst]; // // Read the ST matrix. // SparseTriplet.st_data_read(filename_st, m, n, nst, ref ist, ref jst, ref ast); // // Decrement the 1-based data. // typeMethods.i4vec_dec(nst, ref ist); typeMethods.i4vec_dec(nst, ref jst); // // Print the ST matrix. // SparseTriplet.st_print(m, n, nst, ist, jst, ast, " The matrix in ST format:"); // // Get the CCS size. // int ncc = SparseTriplet.st_to_ccs_size(nst, ist, jst); Console.WriteLine(""); Console.WriteLine(" Number of CCS values = " + ncc + ""); // // Create the CCS indices. // int[] icc = new int[ncc]; int[] ccc = new int[n + 1]; SparseTriplet.st_to_ccs_index(nst, ist, jst, ncc, n, ref icc, ref ccc); // // Create the CCS values. // double[] acc = SparseTriplet.st_to_ccs_values(nst, ist, jst, ast, ncc, n, icc, ccc); // // Print the CCS matrix. // CompressedColumnStorage.ccs_print(m, n, ncc, icc, ccc, acc, " CCS Matrix:"); }