private static void bernstein_vandermonde_test() //****************************************************************************80 // // Purpose: // // BERNSTEIN_VANDERMONDE_TEST tests BERNSTEIN_VANDERMONDE. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 03 December 2015 // // Author: // // John Burkardt // { double[] a; int n; Console.WriteLine(""); Console.WriteLine("BERNSTEIN_VANDERMONDE_TEST"); Console.WriteLine(" BERNSTEIN_VANDERMONDE returns an NxN matrix whose (I,J) entry"); Console.WriteLine(" is the value of the J-th Bernstein polynomial of degree N-1"); Console.WriteLine(" evaluated at the I-th equally spaced point in [0,1]."); n = 8; a = BernsteinPolynomial.bernstein_vandermonde(n); typeMethods.r8mat_print(n, n, a, " Bernstein Vandermonde ( 8 ):"); }
private static void bernstein_matrix_test() //****************************************************************************80 // // Purpose: // // BERNSTEIN_MATRIX_TEST tests BERNSTEIN_MATRIX. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 26 January 2016 // // Author: // // John Burkardt // { Console.WriteLine(""); Console.WriteLine("BERNSTEIN_MATRIX_TEST"); Console.WriteLine(" BERNSTEIN_MATRIX returns a matrix A which transforms a"); Console.WriteLine(" polynomial coefficient vector from the power basis to"); Console.WriteLine(" the Bernstein basis."); int n = 5; double[] a = BernsteinPolynomial.bernstein_matrix(n); typeMethods.r8mat_print(n, n, a, " Bernstein matrix A of order 5:"); }
public void BernsteinPolynomialCalculation_ShouldWork(int i, int n, double u, double expected) { // Arrange // Act var actual = BernsteinPolynomial.Calculate(i, n, u); // Assert Assert.AreEqual(expected, actual, 0.0001); }
public static void bernstein_poly_test( ) //****************************************************************************80 // // Purpose: // // BERNSTEIN_POLY_TEST tests BERNSTEIN_POLY. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 27 February 2015 // // Author: // // John Burkardt // { double b = 0; double[] bvec = new double[11]; int k = 0; int n = 0; double x = 0; Console.WriteLine(""); Console.WriteLine("BERNSTEIN_POLY_TEST:"); Console.WriteLine(" BERNSTEIN_POLY evaluates the Bernstein polynomials."); Console.WriteLine(""); Console.WriteLine(" N K X Exact B(N,K)(X)"); Console.WriteLine(""); int n_data = 0; for ( ; ;) { Burkardt.Values.Bernstein.bernstein_poly_values(ref n_data, ref n, ref k, ref x, ref b); if (n_data == 0) { break; } BernsteinPolynomial.bernstein_poly(n, x, ref bvec); Console.WriteLine(" " + n.ToString(CultureInfo.InvariantCulture).PadLeft(4) + " " + k.ToString(CultureInfo.InvariantCulture).PadLeft(4) + " " + x.ToString(CultureInfo.InvariantCulture).PadLeft(7) + " " + b.ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + bvec[k].ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); } }
private static void bernstein_poly_01_matrix_test() //****************************************************************************80 // // Purpose: // // BERNSTEIN_POLY_01_MATRIX_TEST tests BERNSTEIN_POLY_01_MATRIX. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 27 January 2016 // // Author: // // John Burkardt // { Console.WriteLine(""); Console.WriteLine("BERNSTEIN_POLY_01_MATRIX_TEST"); Console.WriteLine(" BERNSTEIN_POLY_01_MATRIX is given M data values X,"); Console.WriteLine(" and a degree N, and returns an Mx(N+1) matrix B such that"); Console.WriteLine(" B(i,j) is the j-th Bernstein polynomial evaluated at the."); Console.WriteLine(" i-th data value."); int m = 5; double[] x = typeMethods.r8vec_linspace_new(m, 0.0, 1.0); int n = 1; double[] b = BernsteinPolynomial.bernstein_poly_01_matrix(m, n, x); typeMethods.r8mat_print(m, n + 1, b, " B(5,1+1):"); m = 5; x = typeMethods.r8vec_linspace_new(m, 0.0, 1.0); n = 4; b = BernsteinPolynomial.bernstein_poly_01_matrix(m, n, x); typeMethods.r8mat_print(m, n + 1, b, " B(5,4+1):"); m = 10; x = typeMethods.r8vec_linspace_new(m, 0.0, 1.0); n = 4; b = BernsteinPolynomial.bernstein_poly_01_matrix(m, n, x); typeMethods.r8mat_print(m, n + 1, b, " B(10,4+1):"); m = 3; x = typeMethods.r8vec_linspace_new(m, 0.0, 1.0); n = 5; b = BernsteinPolynomial.bernstein_poly_01_matrix(m, n, x); typeMethods.r8mat_print(m, n + 1, b, " B(3,5+1):"); }
private static void bernstein_poly_01_test() //****************************************************************************80 // // Purpose: // // BERNSTEIN_POLY_01_TEST tests BERNSTEIN_POLY_01. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 29 July 2011 // // Author: // // John Burkardt // { double b = 0; int k = 0; int n = 0; double x = 0; Console.WriteLine(""); Console.WriteLine("BERNSTEIN_POLY_01_TEST:"); Console.WriteLine(" BERNSTEIN_POLY_01 evaluates the Bernstein polynomials"); Console.WriteLine(" based on the interval [0,1]."); Console.WriteLine(""); Console.WriteLine(" N K X Exact BP01(N,K)(X)"); Console.WriteLine(""); int n_data = 0; while (true) { Burkardt.Values.Bernstein.bernstein_poly_01_values(ref n_data, ref n, ref k, ref x, ref b); if (n_data == 0) { break; } double[] bvec = BernsteinPolynomial.bernstein_poly_01(n, x); Console.WriteLine(" " + n.ToString().PadLeft(4) + " " + k.ToString().PadLeft(4) + " " + x.ToString().PadLeft(7) + " " + b.ToString().PadLeft(14) + " " + bvec[k].ToString().PadLeft(14) + ""); } }
private double[] CalculateUFactors(double u) { double[] uFactors = new double[Degree + 1]; for (int i = 0; i < uFactors.Length; i++) { uFactors[i] = BernsteinPolynomial.Calculate(i, Degree, u); } return(uFactors); }
public static void bpab_test( ) //****************************************************************************80 // // Purpose: // // BPAB_TEST tests BPAB. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 02 June 2007 // // Author: // // John Burkardt // { const int N = 10; double[] bern = new double[N + 1]; int i; Console.WriteLine(""); Console.WriteLine("BPAB_TEST"); Console.WriteLine(" BPAB evaluates Bernstein polynomials."); Console.WriteLine(""); const double x = 0.3; const double a = 0.0; const double b = 1.0; BernsteinPolynomial.bpab(N, x, a, b, ref bern); Console.WriteLine(" The Bernstein polynomials of degree " + N + ""); Console.WriteLine(" based on the interval from " + a + ""); Console.WriteLine(" to " + b + ""); Console.WriteLine(" evaluated at X = " + x + ""); Console.WriteLine(""); for (i = 0; i <= N; i++) { Console.WriteLine(" " + i.ToString(CultureInfo.InvariantCulture).PadLeft(4) + " " + bern[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); } }
public Point3D Evaluate(double u, double v) { var subpoints = new List <Point3D>(); for (var i = 0; i < 4; ++i) { var subpoint = BernsteinPolynomial.Evaluate3DPolynomial( ArrayHelpers.GetRow(ControlPoints, i), u ); subpoints.Add(subpoint); } return(BernsteinPolynomial.Evaluate3DPolynomial(subpoints, v)); }
private static void bernstein_poly_01_test2() //****************************************************************************80 // // Purpose: // // BERNSTEIN_POLY_01_TEST2 tests BERNSTEIN_POLY_01. // // Discussion: // // Here we test the Partition-of-Unity property. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 27 January 2016 // // Author: // // John Burkardt // { Console.WriteLine(""); Console.WriteLine("BERNSTEIN_POLY_01_TEST2:"); Console.WriteLine(" BERNSTEIN_POLY_01 evaluates the Bernstein polynomials"); Console.WriteLine(" based on the interval [0,1]."); Console.WriteLine(""); Console.WriteLine(" Here we test the partition of unity property."); Console.WriteLine(""); Console.WriteLine(" N X Sum ( 0 <= K <= N ) BP01(N,K)(X)"); Console.WriteLine(""); int seed = 123456789; for (int n = 0; n <= 10; n++) { double x = UniformRNG.r8_uniform_01(ref seed); double[] bvec = BernsteinPolynomial.bernstein_poly_01(n, x); Console.WriteLine(" " + n.ToString().PadLeft(4) + " " + x.ToString().PadLeft(7) + " " + typeMethods.r8vec_sum(n + 1, bvec).ToString().PadLeft(14) + ""); } }
public Vector3D Derivative( double u, double v, DerivativeParameter parameter ) { double firstParameter, secondParameter; Func <int, Point3D[]> generator; switch (parameter) { case DerivativeParameter.U: generator = (i) => ArrayHelpers.GetColumn(ControlPoints, i); firstParameter = v; secondParameter = u; break; case DerivativeParameter.V: generator = (i) => ArrayHelpers.GetRow(ControlPoints, i); firstParameter = u; secondParameter = v; break; default: throw new ArgumentOutOfRangeException( nameof(parameter), parameter, null ); } var subpoints = new List <Point3D>(); for (var i = 0; i < 4; ++i) { subpoints.Add(BernsteinPolynomial.Evaluate3DPolynomial( generator(i), firstParameter )); } var derivative = BernsteinPolynomial.CalculateDerivative(subpoints); return((Vector3D)BernsteinPolynomial.Evaluate3DPolynomial( derivative, secondParameter )); }
private static void bernstein_matrix_inverse_test() //****************************************************************************80 // // Purpose: // // BERNSTEIN_MATRIX_INVERSE_TEST tests BERNSTEIN_MATRIX_INVERSE. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 26 January 2016 // // Author: // // John Burkardt // { Console.WriteLine(""); Console.WriteLine("BERNSTEIN_MATRIX_INVERSE_TEST"); Console.WriteLine(" BERNSTEIN_MATRIX_INVERSE computes the inverse of the"); Console.WriteLine(" Bernstein matrix A."); Console.WriteLine(""); Console.WriteLine(" N ||A|| ||inv(A)|| ||I-A*inv(A)||"); Console.WriteLine(""); for (int n = 5; n <= 15; n++) { double[] a = BernsteinPolynomial.bernstein_matrix(n); double a_norm_frobenius = typeMethods.r8mat_norm_fro(n, n, a); double[] b = BernsteinPolynomial.bernstein_matrix_inverse(n); double b_norm_frobenius = typeMethods.r8mat_norm_fro(n, n, b); double[] c = typeMethods.r8mat_mm_new(n, n, n, a, b); double error_norm_frobenius = typeMethods.r8mat_is_identity(n, c); Console.WriteLine(" " + n.ToString().PadLeft(4) + " " + a_norm_frobenius.ToString().PadLeft(14) + " " + b_norm_frobenius.ToString().PadLeft(14) + " " + error_norm_frobenius.ToString().PadLeft(14) + ""); } }
private static void bernstein_matrix_determinant_test() //****************************************************************************80 // // Purpose: // // BERNSTEIN_MATRIX_DETERMINANT_TEST tests BERNSTEIN_MATRIX_DETERMINANT. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 26 January 2016 // // Author: // // John Burkardt // { Console.WriteLine(""); Console.WriteLine("BERNSTEIN_MATRIX_DETERMINANT_TEST"); Console.WriteLine(" BERNSTEIN_MATRIX_DETERMINANT computes the determinant of"); Console.WriteLine(" the Bernstein matrix."); Console.WriteLine(""); Console.WriteLine(" N ||A|| det(A)"); Console.WriteLine(" computed"); Console.WriteLine(""); for (int n = 5; n <= 15; n++) { double[] a = BernsteinPolynomial.bernstein_matrix(n); double a_norm_frobenius = typeMethods.r8mat_norm_fro(n, n, a); double d1 = BernsteinPolynomial.bernstein_matrix_determinant(n); Console.WriteLine(" " + n.ToString().PadLeft(4) + " " + a_norm_frobenius.ToString().PadLeft(14) + " " + d1.ToString().PadLeft(14) + ""); } }
private static void bernstein_to_power_test() //*****************************************************************************/ // // Purpose: // // BERNSTEIN_TO_POWER_TEST tests BERNSTEIN_TO_POWER. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 17 March 2016 // // Author: // // John Burkardt // { int n = 5; Console.WriteLine(""); Console.WriteLine("BERNSTEIN_TO_POWER_TEST:"); Console.WriteLine(" BERNSTEIN_TO_POWER returns the matrix A which maps"); Console.WriteLine(" polynomial coefficients from Bernstein to Power form."); double[] a = BernsteinPolynomial.bernstein_to_power(n); typeMethods.r8mat_print(n + 1, n + 1, a, " A = bernstein_to_power(5):"); double[] b = BernsteinPolynomial.power_to_bernstein(n); typeMethods.r8mat_print(n + 1, n + 1, b, " B = power_to_bernstein(5):"); double[] c = typeMethods.r8mat_mm_new(n + 1, n + 1, n + 1, a, b); double e = typeMethods.r8mat_is_identity(n + 1, c); Console.WriteLine(""); Console.WriteLine(" ||A*B-I|| = " + e + ""); }
public void ReshapeEdge( int edgeId, Func <double, Point3D> boundaryCurve, Func <double, Vector3D> boundaryDerivative, Vector3D a0, Vector3D b0, Vector3D a3, Vector3D b3 ) { var c0 = boundaryDerivative(0); var c2 = boundaryDerivative(1); var g0 = (a0 + b0) / 2.0; var g2 = (a3 + b3) / 2.0; var g1 = (g0 + g2) / 2.0; var gPolynomial = new List <Point3D>() { (Point3D)g0, (Point3D)g1, (Point3D)g2 }; double k0, k1, h0, h1; CalculateTangentVectorFieldCoefficients(b0, g0, c0, out k0, out h0); CalculateTangentVectorFieldCoefficients(b3, g2, c2, out k1, out h1); Func <double, double> k = v => k0 * (1 - v) + k1 * v; Func <double, double> h = v => h0 * (1 - v) + h1 * v; Func <double, Vector3D> g = v => (Vector3D)BernsteinPolynomial.Evaluate3DPolynomial( gPolynomial, v ); Func <double, Vector3D> d = v => k(v) * g(v) + h(v) * boundaryDerivative(v); int v0 = 3, v1 = 1, derivativeIndex = 0; if (edgeId == 0) { v0 = 0; v1 = 2; derivativeIndex = 0; } else if (edgeId == 1) { v0 = 1; v1 = 0; derivativeIndex = 1; } else if (edgeId == 2) { v0 = 2; v1 = 3; derivativeIndex = 1; } else if (edgeId == 3) { v0 = 1; v1 = 3; derivativeIndex = 0; } _cornerPoints[v0] = boundaryCurve(0); _cornerPoints[v1] = boundaryCurve(1); _cornerDerivatives[v0, derivativeIndex] = c0; _cornerDerivatives[v1, derivativeIndex] = c2; _cornerTwistVectors[v0, derivativeIndex] = d(1.0 / 3.0); _cornerTwistVectors[v1, derivativeIndex] = d(2.0 / 3.0); }
public static double bez_val(int n, double x, double a, double b, double[] y) //****************************************************************************80 // // Purpose: // // BEZ_VAL evaluates a Bezier function at a point. // // Discussion: // // The Bezier function has the form: // // BEZ(X) = Sum ( 0 <= I <= N ) Y(I) * BERN(N,I)( (X-A)/(B-A) ) // // BERN(N,I)(X) is the I-th Bernstein polynomial of order N // defined on the interval [0,1], // // Y(0:N) is a set of coefficients, // // and if, for I = 0 to N, we define the N+1 points // // X(I) = ( (N-I)*A + I*B) / N, // // equally spaced in [A,B], the pairs ( X(I), Y(I) ) can be regarded as // "control points". // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 12 February 2004 // // Author: // // John Burkardt // // Reference: // // David Kahaner, Cleve Moler, Steven Nash, // Numerical Methods and Software, // Prentice Hall, 1989, // ISBN: 0-13-627258-4, // LC: TA345.K34. // // Parameters: // // Input, int N, the order of the Bezier function, which // must be at least 0. // // Input, double X, the point at which the Bezier function should // be evaluated. The best results are obtained within the interval // [A,B] but X may be anywhere. // // Input, double A, B, the interval over which the Bezier function // has been defined. This is the interval in which the control // points have been set up. Note BEZ(A) = Y(0) and BEZ(B) = Y(N), // although BEZ will not, in general pass through the other // control points. A and B must not be equal. // // Input, double Y[0:N], a set of data defining the Y coordinates // of the control points. // // Output, double BEZ_VAL, the value of the Bezier function at X. // { int i; switch (b - a) { case 0.0: Console.WriteLine(""); Console.WriteLine("BEZ_VAL - Fatal error!"); Console.WriteLine(" Null interval, A = B = " + a + ""); return(1); } // // X01 lies in [0,1], in the same relative position as X in [A,B]. // double x01 = (x - a) / (b - a); double[] bval = BernsteinPolynomial.bernstein_poly_01(n, x01); double value = 0.0; for (i = 0; i <= n; i++) { value += y[i] * bval[i]; } return(value); }
public static void bc_val(int n, double t, double[] xcon, double[] ycon, ref double xval, ref double yval) //****************************************************************************80 // // Purpose: // // BC_VAL evaluates a parameterized Bezier curve. // // Discussion: // // BC_VAL(T) is the value of a vector function of the form // // BC_VAL(T) = ( X(T), Y(T) ) // // where // // X(T) = Sum ( 0 <= I <= N ) XCON(I) * BERN(I,N)(T) // Y(T) = Sum ( 0 <= I <= N ) YCON(I) * BERN(I,N)(T) // // BERN(I,N)(T) is the I-th Bernstein polynomial of order N // defined on the interval [0,1], // // XCON(0:N) and YCON(0:N) are the coordinates of N+1 "control points". // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 12 February 2004 // // Author: // // John Burkardt // // Reference: // // David Kahaner, Cleve Moler, Steven Nash, // Numerical Methods and Software, // Prentice Hall, 1989, // ISBN: 0-13-627258-4, // LC: TA345.K34. // // Parameters: // // Input, int N, the order of the Bezier curve, which // must be at least 0. // // Input, double T, the point at which the Bezier curve should // be evaluated. The best results are obtained within the interval // [0,1] but T may be anywhere. // // Input, double XCON[0:N], YCON[0:N], the X and Y coordinates // of the control points. The Bezier curve will pass through // the points ( XCON(0), YCON(0) ) and ( XCON(N), YCON(N) ), but // generally NOT through the other control points. // // Output, double *XVAL, *YVAL, the X and Y coordinates of the point // on the Bezier curve corresponding to the given T value. // { int i; double[] bval = BernsteinPolynomial.bernstein_poly_01(n, t); xval = 0.0; for (i = 0; i <= n; i++) { xval += xcon[i] * bval[i]; } yval = 0.0; for (i = 0; i <= n; i++) { yval += ycon[i] * bval[i]; } }
private static void bernstein_matrix_test2() //****************************************************************************80 // // Purpose: // // BERNSTEIN_MATRIX_TEST2 tests BERNSTEIN_MATRIX. // // Discussion: // // Here we use the Bernstein matrix to describe a Bernstein polynomial // in terms of the standard monomials. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 27 January 2016 // // Author: // // John Burkardt // { Console.WriteLine(""); Console.WriteLine("TEST06"); Console.WriteLine(" BERNSTEIN_MATRIX returns a matrix A which"); Console.WriteLine(" transforms a polynomial coefficient vector"); Console.WriteLine(" from the the Bernstein basis to the power basis."); Console.WriteLine(" We can use this to get explicit values of the"); Console.WriteLine(" 4-th degree Bernstein polynomial coefficients as"); Console.WriteLine(""); Console.WriteLine(" b(4,K)(X) = C4 * x^4"); Console.WriteLine(" + C3 * x^3"); Console.WriteLine(" + C2 * x^2"); Console.WriteLine(" + C1 * x"); Console.WriteLine(" + C0 * 1"); int n = 5; Console.WriteLine(""); Console.WriteLine(" K C4 C3 C2" + " C1 C0"); Console.WriteLine(""); double[] a = BernsteinPolynomial.bernstein_matrix(n); double[] x = new double[n]; for (int k = 0; k < n; k++) { for (int i = 0; i < n; i++) { x[i] = 0.0; } x[k] = 1.0; double[] ax = typeMethods.r8mat_mv_new(n, n, a, x); string cout = " " + k.ToString().PadLeft(4) + " "; for (int i = 0; i < n; i++) { cout += " " + ax[i].ToString().PadLeft(14); } Console.WriteLine(cout); } }
private static void bernstein_poly_ab_test() //****************************************************************************80 // // Purpose: // // BERNSTEIN_POLY_AB_TEST tests BERNSTEIN_POLY_AB. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 05 July 2011 // // Author: // // John Burkardt // { int n = 10; Console.WriteLine(""); Console.WriteLine("BERNSTEIN_POLY_AB_TEST"); Console.WriteLine(" BERNSTEIN_POLY_AB evaluates Bernstein polynomials over an"); Console.WriteLine(" arbitrary interval [A,B]."); Console.WriteLine(""); Console.WriteLine(" Here, we demonstrate that "); Console.WriteLine(" BPAB(N,K,A1,B1)(X1) = BPAB(N,K,A2,B2)(X2)"); Console.WriteLine(" provided only that"); Console.WriteLine(" (X1-A1)/(B1-A1) = (X2-A2)/(B2-A2)."); double x = 0.3; double a = 0.0; double b = 1.0; double[] bern = BernsteinPolynomial.bernstein_poly_ab(n, a, b, x); Console.WriteLine(""); Console.WriteLine(" N K A B X BPAB(N,K,A,B)(X)"); Console.WriteLine(""); for (int k = 0; k <= n; k++) { Console.WriteLine(" " + n.ToString().PadLeft(4) + " " + k.ToString().PadLeft(4) + " " + a.ToString().PadLeft(7) + " " + b.ToString().PadLeft(7) + " " + x.ToString().PadLeft(7) + " " + bern[k].ToString().PadLeft(14) + ""); } x = 1.3; a = 1.0; b = 2.0; bern = BernsteinPolynomial.bernstein_poly_ab(n, a, b, x); Console.WriteLine(""); Console.WriteLine(" N K A B X BPAB(N,K,A,B)(X)"); Console.WriteLine(""); for (int k = 0; k <= n; k++) { Console.WriteLine(" " + n.ToString().PadLeft(4) + " " + k.ToString().PadLeft(4) + " " + a.ToString().PadLeft(7) + " " + b.ToString().PadLeft(7) + " " + x.ToString().PadLeft(7) + " " + bern[k].ToString().PadLeft(14) + ""); } x = 2.6; a = 2.0; b = 4.0; bern = BernsteinPolynomial.bernstein_poly_ab(n, a, b, x); Console.WriteLine(""); Console.WriteLine(" N K A B X BPAB(N,K,A,B)(X)"); Console.WriteLine(""); for (int k = 0; k <= n; k++) { Console.WriteLine(" " + n.ToString().PadLeft(4) + " " + k.ToString().PadLeft(4) + " " + a.ToString().PadLeft(7) + " " + b.ToString().PadLeft(7) + " " + x.ToString().PadLeft(7) + " " + bern[k].ToString().PadLeft(14) + ""); } }
private static void bernstein_poly_ab_approx_test() //****************************************************************************80 // // Purpose: // // BERNSTEIN_POLY_AB_APPROX_TEST tests BERNSTEIN_POLY_AB_APPROX. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 27 January 2016 // // Author: // // John Burkardt // { int maxdata = 20; int nval = 501; Console.WriteLine(""); Console.WriteLine("BERNSTEIN_POLY_AB_APPROX_TEST"); Console.WriteLine(" BERNSTEIN_POLY_AB_APPROX evaluates the Bernstein polynomial"); Console.WriteLine(" approximant to a function F(X)."); double a = 1.0; double b = 3.0; Console.WriteLine(""); Console.WriteLine(" N Max Error"); Console.WriteLine(""); for (int ndata = 0; ndata <= maxdata; ndata++) { // // Generate data values. // double[] xdata = new double[ndata + 1]; double[] ydata = new double[ndata + 1]; for (int i = 0; i <= ndata; i++) { xdata[i] = ndata switch { 0 => 0.5 * (a + b), _ => ((ndata - i) * a + i * b) / ndata }; ydata[i] = Math.Sin(xdata[i]); } // // Compare the true function and the approximant. // double[] xval = typeMethods.r8vec_linspace_new(nval, a, b); double error_max = 0.0; double[] yval = BernsteinPolynomial.bernstein_poly_ab_approx(ndata, a, b, ydata, nval, xval); error_max = 0.0; for (int i = 0; i < nval; i++) { error_max = Math.Max(error_max, Math.Abs(yval[i] - Math.Sin(xval[i]))); } Console.WriteLine(" " + ndata.ToString().PadLeft(4) + " " + error_max.ToString().PadLeft(14) + ""); } }