private static void chebyshev_even2_test() //****************************************************************************80 // // Purpose: // // CHEBYSHEV_EVEN2_TEST tests CHEBYSHEV_EVEN2. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 15 January 2016 // // Author: // // John Burkardt // { Console.WriteLine(""); Console.WriteLine("CHEBYSHEV_EVEN2_TEST:"); Console.WriteLine(" CHEBYSHEV_EVEN2 computes the even Chebyshev coefficients"); Console.WriteLine(" of a function F, using the zeros of Tn(x)."); const int n = 6; double[] b2 = Chebyshev.chebyshev_even2(n, f); const int s = n / 2; typeMethods.r8vec_print(s + 1, b2, " Computed Coefficients:"); }
private static void Main() { Point p = new Point2D(1, 2); IVisitor v = new Chebyshev(); p.Accept(v); Console.WriteLine(p.Metric); }
public void ZeroSizeListTest() { var m = new Chebyshev(); var list = new List <Utility>(); var aVal = m.Calculate(list); Assert.That(aVal, Is.EqualTo(Zero).Within(Tolerance)); }
private static void mltply_test() //****************************************************************************80 // // Purpose: // // MLTPLY_TEST tests MLTPLY, which multiplies two Chebyshev series. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 24 September 2011 // // Author: // // John Burkardt // { int i; const int nf = 5; const int npl = 10; Console.WriteLine(""); Console.WriteLine("MLTPLY_TEST"); Console.WriteLine(" MLTPLY computes the product of two Chebyshev series."); Console.WriteLine(""); Console.WriteLine(" Multiply series for SIN(X) and COS(X)"); Console.WriteLine(" and compare with series for 1/2*SIN(2X)."); double[] x = Chebyshev.cheby(nf, npl, functn); double[] x1 = new double[npl]; double[] x2 = new double[npl]; for (i = 0; i < npl; i++) { x1[i] = x[i + 0 * npl]; x2[i] = x[i + 1 * npl]; x[i + 2 * npl] = 0.5 * x[i + 2 * npl]; } double[] x3 = ChebyshevSeries.mltply_new(x1, x2, npl); Console.WriteLine(""); Console.WriteLine(" Sin(x) Cos(x) 1/2*Sin(2x) RESULT"); Console.WriteLine(""); for (i = 0; i < npl; i++) { Console.WriteLine(" " + x[i + 0 * npl].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + x[i + 1 * npl].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + x[i + 2 * npl].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + x3[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); } }
public void ZeroValuesTest() { var m = new Chebyshev(); var list = MeasureTestsHelper.RandomUtilityWeightList(_rnd.Next(1, MaxVecLen), 0.0f); float aVal = m.Calculate(list); float cVal = MeasureTestsHelper.CalculateChebyshevNorm(list); Assert.That(aVal, Is.EqualTo(Zero).Within(Tolerance)); Assert.That(cVal, Is.EqualTo(Zero).Within(Tolerance)); }
public void CalculateTest() { var m = new Chebyshev(); var list = MeasureTestsHelper.RandomUtilityList(_rnd.Next(1, MaxVecLen)); var aVal = m.Calculate(list); float cVal = MeasureTestsHelper.CalculateChebyshevNorm(list); Assert.That(aVal, Is.EqualTo(cVal).Within(Tolerance)); Assert.That(aVal <= One); Assert.That(aVal >= Zero); }
private void FindNearestNeighbors(Attributes[] testAttributes, Attributes tuner, int k) { foreach (Attributes trainingInstance in testAttributes) { if (trainingInstance.xy != tuner.xy) { Calculator tCalc = new Calculator(tuner.xy, trainingInstance.xy); Euclidaen.Add(new KeyValuePair <float, Attributes>(tCalc.getEuclidaen, trainingInstance)); Chebyshev.Add(new KeyValuePair <float, Attributes>(tCalc.getChebyshev, trainingInstance)); Manhattan.Add(new KeyValuePair <float, Attributes>(tCalc.getManhattan, trainingInstance)); } } Euclidaen = Euclidaen.OrderBy(o => o.Key).Take(k).ToList(); Chebyshev = Chebyshev.OrderBy(o => o.Key).Take(k).ToList(); Manhattan = Manhattan.OrderBy(o => o.Key).Take(k).ToList(); }
public static void cheby_t_poly_values_test() //****************************************************************************80 // // Purpose: // // CHEBY_T_POLY_VALUES_TEST tests CHEBY_T_POLY_VALUES. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 02 March 2007 // // Author: // // John Burkardt // { double fx = 0; int n = 0; double x = 0; Console.WriteLine(""); Console.WriteLine("CHEBY_T_POLY_VALUES_TEST:"); Console.WriteLine(" CHEBY_T_POLY_VALUES returns values of"); Console.WriteLine(" the Chebyshev T polynomials."); Console.WriteLine(""); Console.WriteLine(" N X T(N)(X)"); Console.WriteLine(""); int n_data = 0; for (;;) { Chebyshev.cheby_t_poly_values(ref n_data, ref n, ref x, ref fx); if (n_data == 0) { break; } Console.WriteLine(" " + n.ToString(CultureInfo.InvariantCulture).PadLeft(6) + " " + x.ToString(CultureInfo.InvariantCulture).PadLeft(8) + " " + fx.ToString(CultureInfo.InvariantCulture).PadLeft(12) + ""); } }
private static void cheby_test() //****************************************************************************80 // // Purpose: // // CHEBY_TEST tests CHEBY, which computes Chebyshev series. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 24 September 2011 // // Author: // // John Burkardt // { int i; const int nf = 5; const int npl = 10; Console.WriteLine(""); Console.WriteLine("CHEBY_TEST"); Console.WriteLine(" CHEBY computes the Chebyshev series for several functions."); double[] x = Chebyshev.cheby(nf, npl, functn); Console.WriteLine(""); Console.WriteLine(" Sin(x) Cos(x) Sin(2x) Cos(2x) X^5"); Console.WriteLine(""); for (i = 0; i < npl; i++) { string cout = ""; int j; for (j = 0; j < nf; j++) { cout += " " + x[i + j * npl].ToString(CultureInfo.InvariantCulture).PadLeft(14); } Console.WriteLine(cout); } }
private static void chebyshev_even1_test() //****************************************************************************80 // // Purpose: // // CHEBYSHEV_EVEN1_TEST tests CHEBYSHEV_EVEN1. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 15 January 2016 // // Author: // // John Burkardt // { double[] a2_exact = { 0.4477815660, -0.7056685603, 0.0680357987, -0.0048097159 } ; Console.WriteLine(""); Console.WriteLine("CHEBYSHEV_EVEN1_TEST:"); Console.WriteLine(" CHEBYSHEV_EVEN1 computes the even Chebyshev coefficients"); Console.WriteLine(" of a function F, using the extreme points of Tn(x)."); const int n = 6; double[] a2 = Chebyshev.chebyshev_even1(n, f); const int s = n / 2; typeMethods.r8vec2_print(s + 1, a2, a2_exact, " Computed and Exact Coefficients:"); }
private static void test01() //****************************************************************************80 // // Purpose: // // TEST01 tests CHEBYSHEV_COEFFICIENTS and CHEBYSHEV_INTERPOLANT. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 14 September 2011 // // Author: // // John Burkardt // { int i; Console.WriteLine(""); Console.WriteLine("CHEBYSHEV_TEST01"); Console.WriteLine(" CHEBYSHEV_COEFFICIENTS computes the coefficients of the"); Console.WriteLine(" Chebyshev interpolant."); Console.WriteLine(" CHEBYSHEV_INTERPOLANT evaluates the interpolant."); int n = 5; double a = -1.0; double b = +1.0; double[] c = Chebyshev.chebyshev_coefficients(a, b, n, f1); double[] x = Chebyshev.chebyshev_zeros(n); for (i = 0; i < n; i++) { x[i] = 0.5 * (a + b) + x[i] * 0.5 * (b - a); } int m = n; double[] fc = Chebyshev.chebyshev_interpolant(a, b, n, c, m, x); Console.WriteLine(""); Console.WriteLine(" F(X) is a trig function:"); Console.WriteLine(""); Console.WriteLine(" X C(I) F(X) C(F)(X)"); Console.WriteLine(""); for (i = 0; i < n; i++) { Console.WriteLine(" " + x[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + c[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + f1(x[i]).ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + fc[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); } // // Try a variant interval. // n = 5; a = 0.0; b = +3.0; c = Chebyshev.chebyshev_coefficients(a, b, n, f1); x = Chebyshev.chebyshev_zeros(n); for (i = 0; i < n; i++) { x[i] = 0.5 * (a + b) + x[i] * 0.5 * (b - a); } m = n; fc = Chebyshev.chebyshev_interpolant(a, b, n, c, m, x); Console.WriteLine(""); Console.WriteLine(" Consider the same F(X), but now over [0,3]:"); Console.WriteLine(""); Console.WriteLine(" X C(I) F(X) C(F)(X)"); Console.WriteLine(""); for (i = 0; i < n; i++) { Console.WriteLine(" " + x[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + c[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + f1(x[i]).ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + fc[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); } // // Try a higher order. // n = 10; a = -1.0; b = +1.0; c = Chebyshev.chebyshev_coefficients(a, b, n, f1); x = Chebyshev.chebyshev_zeros(n); for (i = 0; i < n; i++) { x[i] = 0.5 * (a + b) + x[i] * 0.5 * (b - a); } m = n; fc = Chebyshev.chebyshev_interpolant(a, b, n, c, m, x); Console.WriteLine(""); Console.WriteLine(" Consider the same F(X), but now with higher order:"); Console.WriteLine(""); Console.WriteLine(" X C(I) F(X) C(F)(X)"); Console.WriteLine(""); for (i = 0; i < n; i++) { Console.WriteLine(" " + x[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + c[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + f1(x[i]).ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + fc[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); } // // Try a polynomial. // n = 10; a = -1.0; b = +1.0; c = Chebyshev.chebyshev_coefficients(a, b, n, f3); x = Chebyshev.chebyshev_zeros(n); for (i = 0; i < n; i++) { x[i] = 0.5 * (a + b) + x[i] * 0.5 * (b - a); } m = n; fc = Chebyshev.chebyshev_interpolant(a, b, n, c, m, x); Console.WriteLine(""); Console.WriteLine(" F(X) is a degree 4 polynomial:"); Console.WriteLine(""); Console.WriteLine(" X C(I) F(X) C(F)(X)"); Console.WriteLine(""); for (i = 0; i < n; i++) { Console.WriteLine(" " + x[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + c[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + f3(x[i]).ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + fc[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); } // // Try a function with decaying behavior. // n = 10; a = -1.0; b = +1.0; c = Chebyshev.chebyshev_coefficients(a, b, n, f2); x = Chebyshev.chebyshev_zeros(n); for (i = 0; i < n; i++) { x[i] = 0.5 * (a + b) + x[i] * 0.5 * (b - a); } m = n; fc = Chebyshev.chebyshev_interpolant(a, b, n, c, m, x); Console.WriteLine(""); Console.WriteLine(" The polynomial approximation to F(X) decays:"); Console.WriteLine(""); Console.WriteLine(" X C(I) F(X) C(F)(X)"); Console.WriteLine(""); for (i = 0; i < n; i++) { Console.WriteLine(" " + x[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + c[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + f2(x[i]).ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + fc[i].ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); } }
public static double[] cardan_poly(int n, double x, double s) //****************************************************************************80 // // Purpose: // // CARDAN_POLY evaluates the Cardan polynomials. // // First terms: // // N C(N,S,X) // // 0 2 // 1 X // 2 X^2 - 2 S // 3 X^3 - 3 S X // 4 X^4 - 4 S X^2 + 2 S^2 // 5 X^5 - 5 S X^3 + 5 S^2 X // 6 X^6 - 6 S X^4 + 9 S^2 X^2 - 2 S^3 // 7 X^7 - 7 S X^5 + 14 S^2 X^3 - 7 S^3 X // 8 X^8 - 8 S X^6 + 20 S^2 X^4 - 16 S^3 X^2 + 2 S^4 // 9 X^9 - 9 S X^7 + 27 S^2 X^5 - 30 S^3 X^3 + 9 S^4 X // 10 X^10 - 10 S X^8 + 35 S^2 X^6 - 50 S^3 X^4 + 25 S^4 X^2 - 2 S^5 // 11 X^11 - 11 S X^9 + 44 S^2 X^7 - 77 S^3 X^5 + 55 S^4 X^3 - 11 S^5 X // // Recursion: // // Writing the N-th polynomial in terms of its coefficients: // // C(N,S,X) = sum ( 0 <= I <= N ) D(N,I) * S^(N-I)/2 * X^I // // then // // D(0,0) = 1 // // D(1,1) = 1 // D(1,0) = 0 // // D(N,N) = 1 // D(N,K) = D(N-1,K-1) - D(N-2,K) // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 28 March 2012 // // Author: // // John Burkardt // // Reference: // // Thomas Osler, // Cardan Polynomials and the Reduction of Radicals, // Mathematics Magazine, // Volume 74, Number 1, February 2001, pages 26-32. // // Parameters: // // Input, int N, the highest polynomial to compute. // // Input, double X, the point at which the polynomials are to be computed. // // Input, double S, the value of the parameter, which must be positive. // // Output, double CARDAN_POLY[N+1], the values of the Cardan polynomials at X. // { int i; double[] x2 = new double[1]; double s2 = Math.Sqrt(s); x2[0] = 0.5 * x / s2; double[] v = Chebyshev.cheby_t_poly(1, n, x2); double fact = 1.0; for (i = 0; i <= n; i++) { v[i] = 2.0 * fact * v[i]; fact *= s2; } return(v); }
private static void dfrnt_test() //****************************************************************************80 // // Purpose: // // DFRNT_TEST tests DFRNT, which computes the Chebyshev series of a derivative. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 24 September 2011 // // Author: // // John Burkardt // { int i; int j; const int nf = 5; const int npl = 10; Console.WriteLine(""); Console.WriteLine("DFRNT_TEST"); Console.WriteLine(" DFRNT computes the Chebyshev series for the derivative"); Console.WriteLine(" of several functions."); double[] x = Chebyshev.cheby(nf, npl, functn); double[] x2 = new double[npl]; for (j = 0; j < nf; j++) { for (i = 0; i < npl; i++) { x2[i] = x[i + j * npl]; } double[] x3 = ChebyshevSeries.dfrnt(x2, npl); for (i = 0; i < npl; i++) { x[i + j * npl] = x3[i]; } } Console.WriteLine(""); Console.WriteLine(" Chebyshev series for d/dx of:"); Console.WriteLine(""); Console.WriteLine(" Sin(x) Cos(x) Sin(2x) Cos(2x) X^5"); Console.WriteLine(""); for (i = 0; i < npl; i++) { string cout = ""; for (j = 0; j < nf; j++) { cout += " " + x[i + j * npl].ToString(CultureInfo.InvariantCulture).PadLeft(14); } Console.WriteLine(cout); } }
public static BasisFunctionBase BasisFunctionSelector(BasisFunctionsEnum functionChoise) { //default BasisFunctionBase solver = null; switch (functionChoise) { case BasisFunctionsEnum.AsymmetricGaussian: solver = new AsymmetricGaussian(); solver.Coefficients = new double[4]; solver.Coefficients[0] = .5; solver.Coefficients[1] = .5; solver.Coefficients[2] = .3; solver.Coefficients[3] = 1; break; case BasisFunctionsEnum.Linear: solver = new Linear(); solver.Coefficients = new double[2]; solver.Coefficients[0] = 1; // m solver.Coefficients[1] = 0; // b break; case BasisFunctionsEnum.PolynomialQuadratic: { solver = new Quadratic(); solver.Coefficients = new double[3]; solver.Coefficients[0] = 1; //ax^2 solver.Coefficients[1] = 1; //bx solver.Coefficients[2] = 1; //c } break; case BasisFunctionsEnum.PolynomialCubic: { solver = new Cubic(); solver.Coefficients = new double[7]; solver.Coefficients[0] = 1; //ax^3 solver.Coefficients[1] = 1; //bx^2 solver.Coefficients[2] = 1; //cx solver.Coefficients[3] = 1; //d solver.Coefficients[4] = 1; //d solver.Coefficients[5] = 1; //d solver.Coefficients[6] = 1; //d } break; case BasisFunctionsEnum.Lorentzian: { solver = new Lorentian(); solver.Coefficients = new double[3]; solver.Coefficients[0] = 6; //width solver.Coefficients[1] = 50; //height solver.Coefficients[2] = -1; //xoffset } break; case BasisFunctionsEnum.Gaussian: { solver = new Gaussian(); solver.Coefficients = new double[3]; solver.Coefficients[0] = 6; //sigma solver.Coefficients[1] = 50; //height solver.Coefficients[2] = -1; //xoffset } break; case BasisFunctionsEnum.Chebyshev: { solver = new Chebyshev(); solver.Coefficients = new double[6]; solver.Coefficients[0] = 0; //? solver.Coefficients[1] = 1; //? solver.Coefficients[2] = 1; //? solver.Coefficients[3] = 0; //? solver.Coefficients[4] = 0; //? solver.Coefficients[5] = 0; //? } break; case BasisFunctionsEnum.Orbitrap: { solver = new OrbitrapFunction(); solver.Coefficients = new double[3]; solver.Coefficients[0] = 1; //? solver.Coefficients[1] = 1; //? solver.Coefficients[2] = 1; //? //quadSolver.Coefficients[3] = 1;//? //quadSolver.Coefficients[4] = 1;//? //quadSolver.Coefficients[4] = 1;//? } break; case BasisFunctionsEnum.Hanning: { solver = new Hanning(); solver.Coefficients = new double[3]; solver.Coefficients[0] = 1; //? solver.Coefficients[1] = 1; //? solver.Coefficients[2] = 1; //? } break; } return(solver); }
public void ConstructorTest() { var m = new Chebyshev(); Assert.IsNotNull(m); }
private static void edcheb_test() //****************************************************************************80 // // Purpose: // // EDCHEB_TEST tests EDCHEB, which evaluates the derivative of a Chebyshev series. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 24 September 2011 // // Author: // // John Burkardt // { int j; const int nf = 5; const int npl = 10; const int nx = 6; Console.WriteLine(""); Console.WriteLine("EDCHEB_TEST"); Console.WriteLine(" EDCHEB evaluates the derivative of a Chebyshev series."); double[] x = Chebyshev.cheby(nf, npl, functn); double[] x2 = new double[npl]; for (j = 0; j < nf; j++) { int i; for (i = 0; i < npl; i++) { x2[i] = x[i + j * npl]; } Console.WriteLine(""); switch (j) { case 0: Console.WriteLine(" Sin(x)"); break; case 1: Console.WriteLine(" Cos(x)"); break; case 2: Console.WriteLine(" Sin(2x)"); break; case 3: Console.WriteLine(" Cos(2x)"); break; case 4: Console.WriteLine(" x^5"); break; } Console.WriteLine(""); int k; for (k = 0; k < nx; k++) { double xval = 2.0 * k / (nx - 1) - 1.0; double[] fxj = functn_d(xval); double fval = ChebyshevSeries.edcheb(xval, x2, npl); Console.WriteLine(" " + xval.ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + fxj[j].ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + fval.ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); } } }