public static void test03(int degree, int numnodes, double[] vert1, double[] vert2, double[] vert3, string header) //****************************************************************************80 // // Purpose: // // TEST03 calls TRIASYMQ_GNUPLOT to generate graphics files. // // Licensing: // // This code is distributed under the GNU GPL license. // // Modified: // // 30 June 2014 // // Author: // // Original FORTRAN77 version by Hong Xiao, Zydrunas Gimbutas. // C++ version by John Burkardt. // // Reference: // // Hong Xiao, Zydrunas Gimbutas, // A numerical algorithm for the construction of efficient quadrature // rules in two and higher dimensions, // Computers and Mathematics with Applications, // Volume 59, 2010, pages 663-676. // // Parameters: // // Input, int DEGREE, the desired total polynomial degree exactness // of the quadrature rule. 0 <= DEGREE <= 50. // // Input, int NUMNODES, the number of nodes to be used by the rule. // // Input, double VERT1[2], VERT2[2], VERT3[2], the // vertices of the triangle. // // Input, string HEADER, an identifier for the graphics filenames. // { Console.WriteLine(""); Console.WriteLine("TEST03"); Console.WriteLine(" TRIASYMQ_GNUPLOT creates gnuplot graphics files."); Console.WriteLine(" Polynomial exactness degree DEGREE = " + degree + ""); double[] rnodes = new double[2 * numnodes]; double[] weights = new double[numnodes]; SymmetricQuadrature.triasymq(degree, vert1, vert2, vert3, ref rnodes, ref weights, numnodes); Console.WriteLine(" Number of nodes = " + numnodes + ""); SymmetricQuadrature.triasymq_gnuplot(vert1, vert2, vert3, numnodes, rnodes, header); }
public static void test05(int degree, int numnodes, double[] vert1, double[] vert2, double[] vert3) //****************************************************************************80 // // Purpose: // // TEST05 calls TRIASYMQ for a quadrature rule of given order and region. // // Licensing: // // This code is distributed under the GNU GPL license. // // Modified: // // 28 June 2014 // // Author: // // Original FORTRAN77 version by Hong Xiao, Zydrunas Gimbutas. // C++ version by John Burkardt. // // Reference: // // Hong Xiao, Zydrunas Gimbutas, // A numerical algorithm for the construction of efficient quadrature // rules in two and higher dimensions, // Computers and Mathematics with Applications, // Volume 59, 2010, pages 663-676. // // Parameters: // // Input, int DEGREE, the desired total polynomial degree // exactness of the quadrature rule. 0 <= DEGREE <= 50. // // Input, int NUMNODES, the number of nodes to be used by the rule. // // Input, double VERT1[2], VERT2[2], VERT3[2], the // vertices of the triangle. // { int i; int j; double[] z = new double[2]; Console.WriteLine(""); Console.WriteLine("TEST05"); Console.WriteLine(" Compute a quadrature rule for a triangle."); Console.WriteLine(" Check it by integrating orthonormal polynomials."); Console.WriteLine(" Polynomial exactness degree DEGREE = " + degree + ""); double area = typeMethods.triangle_area(vert1, vert2, vert3); // // Retrieve a symmetric quadrature rule. // double[] rnodes = new double[2 * numnodes]; double[] weights = new double[numnodes]; SymmetricQuadrature.triasymq(degree, vert1, vert2, vert3, ref rnodes, ref weights, numnodes); // // Construct the matrix of values of the orthogonal polynomials // at the user-provided nodes // int npols = (degree + 1) * (degree + 2) / 2; double[] rints = new double[npols]; for (j = 0; j < npols; j++) { rints[j] = 0.0; } for (i = 0; i < numnodes; i++) { z[0] = rnodes[0 + i * 2]; z[1] = rnodes[1 + i * 2]; double[] r = typeMethods.triangle_to_ref(vert1, vert2, vert3, z); double[] pols = Orthogonal.ortho2eva(degree, r); for (j = 0; j < npols; j++) { rints[j] += weights[i] * pols[j]; } } double scale = Math.Sqrt(Math.Sqrt(3.0)) / Math.Sqrt(area); for (j = 0; j < npols; j++) { rints[j] *= scale; } double d = Math.Pow(rints[0] - Math.Sqrt(area), 2); for (j = 1; j < npols; j++) { d += rints[j] * rints[j]; } d = Math.Sqrt(d) / npols; Console.WriteLine(""); Console.WriteLine(" RMS integration error = " + d + ""); }
public static void test04(int degree, int numnodes, double[] vert1, double[] vert2, double[] vert3, string header) //****************************************************************************80 // // Purpose: // // TEST04 gets a rule and writes it to a file. // // Licensing: // // This code is distributed under the GNU GPL license. // // Modified: // // 30 June 2014 // // Author: // // Original FORTRAN77 version by Hong Xiao, Zydrunas Gimbutas. // C++ version by John Burkardt. // // Reference: // // Hong Xiao, Zydrunas Gimbutas, // A numerical algorithm for the construction of efficient quadrature // rules in two and higher dimensions, // Computers and Mathematics with Applications, // Volume 59, 2010, pages 663-676. // // Parameters: // // Input, int DEGREE, the desired total polynomial degree exactness // of the quadrature rule. 0 <= DEGREE <= 50. // // Input, int NUMNODES, the number of nodes to be used by the rule. // // Input, double VERT1[2], VERT2[2], VERT3[2], the // vertices of the triangle. // // Input, string HEADER, an identifier for the filenames. // { int j; List <string> rule_unit = new(); Console.WriteLine(""); Console.WriteLine("TEST04"); Console.WriteLine(" Get a quadrature rule for a triangle."); Console.WriteLine(" Then write it to a file."); Console.WriteLine(" Polynomial exactness degree DEGREE = " + degree + ""); // // Retrieve a symmetric quadrature rule. // double[] rnodes = new double[2 * numnodes]; double[] weights = new double[numnodes]; SymmetricQuadrature.triasymq(degree, vert1, vert2, vert3, ref rnodes, ref weights, numnodes); // // Write the points and weights to a file. // string rule_filename = header + ".txt"; for (j = 0; j < numnodes; j++) { rule_unit.Add(rnodes[0 + j * 2] + " " + rnodes[1 + j * 2] + " " + weights[j] + ""); } File.WriteAllLines(rule_filename, rule_unit); Console.WriteLine(""); Console.WriteLine(" Quadrature rule written to file '" + rule_filename + "'"); }
public static void test02(int degree, int numnodes, double[] vert1, double[] vert2, double[] vert3) //****************************************************************************80 // // Purpose: // // TEST02 calls TRIASYMQ for a quadrature rule of given order and region. // // Licensing: // // This code is distributed under the GNU GPL license. // // Modified: // // 28 June 2014 // // Author: // // Original FORTRAN77 version by Hong Xiao, Zydrunas Gimbutas. // C++ version by John Burkardt. // // Reference: // // Hong Xiao, Zydrunas Gimbutas, // A numerical algorithm for the construction of efficient quadrature // rules in two and higher dimensions, // Computers and Mathematics with Applications, // Volume 59, 2010, pages 663-676. // // Parameters: // // Input, int DEGREE, the desired total polynomial degree exactness // of the quadrature rule. 0 <= DEGREE <= 50. // // Input, int NUMNODES, the number of nodes to be used by the rule. // // Input, double VERT1[2], VERT2[2], VERT3[2], the // vertices of the triangle. // { int j; Console.WriteLine(""); Console.WriteLine("TEST02"); Console.WriteLine(" Symmetric quadrature rule for a triangle."); Console.WriteLine(" Polynomial exactness degree DEGREE = " + degree + ""); double area = typeMethods.triangle_area(vert1, vert2, vert3); // // Retrieve and print a symmetric quadrature rule. // double[] rnodes = new double[2 * numnodes]; double[] weights = new double[numnodes]; SymmetricQuadrature.triasymq(degree, vert1, vert2, vert3, ref rnodes, ref weights, numnodes); Console.WriteLine(""); Console.WriteLine(" NUMNODES = " + numnodes + ""); Console.WriteLine(""); Console.WriteLine(" J W X Y"); Console.WriteLine(""); for (j = 0; j < numnodes; j++) { Console.WriteLine(j + " " + weights[j] + " " + rnodes[0 + j * 2] + " " + rnodes[1 + j * 2] + ""); } double d = typeMethods.r8vec_sum(numnodes, weights); Console.WriteLine(" Sum " + d + ""); Console.WriteLine(" Area " + area + ""); }