/* Function for Evaluating Polynomials */ void poly_eval (double c[], double xvec[], double yvec[]) { yvec[0] = gsl_poly_eval(c, N, xvec[0]); int i; for (i = 1; i < M; i++) yvec[i] = gsl_poly_eval(c, N, xvec[i]); return; }
void polyval (double p[], double xv[], double yv[], int n, int m) { int j; yv[0] = gsl_poly_eval(p, n, xv[0]); for (j = 1; j < m; j++) yv[j] = gsl_poly_eval(p, n, xv[j]); return; } /* end polyval */
void polyval (double p[], double xv[], double yv[], int n, int m) { int j; yv[0] = gsl_poly_eval(p, N, xv[0]); for (j = 1; j < M; j++) { yv[j] = gsl_poly_eval(p, N, xv[j]); } return; }
/** * \brief A variant of the Savitzky-Golay algorithm able to handle non-uniformly distributed data. * * In comparison to smoothSavGol(), this method trades proper handling of the X coordinates for * runtime efficiency by abandoning a central idea of Savitzky-Golay algorithm, namely that * polynomial smoothing can be expressed as a convolution. * * TODO: integrate this option into the GUI. */ void SmoothFilter::smoothModifiedSavGol(double *x_in, double *y_inout) { // total number of points in smoothing window int points = d_left_points + d_right_points + 1; if (points < d_polynom_order+1) { QMessageBox::critical((ApplicationWindow *)parent(), tr("SciDAVis") + " - " + tr("Error"), tr("The polynomial order must be lower than the number of left points plus the number of right points!")); return; } // allocate memory for the result QVector<double> result(d_n); // allocate memory for the linear algegra computations // Vandermonde matrix for x values of points in the current smoothing window gsl_matrix *vandermonde = gsl_matrix_alloc(points, d_polynom_order+1); // stores part of the QR decomposition of vandermonde gsl_vector *tau = gsl_vector_alloc(qMin(points, d_polynom_order+1)); // coefficients of polynomial approximation computed for each smoothing window gsl_vector *poly = gsl_vector_alloc(d_polynom_order+1); // residual of the (least-squares) approximation (by-product of GSL's algorithm) gsl_vector *residual = gsl_vector_alloc(points); for (int target_index = 0; target_index < d_n; target_index++) { int offset = target_index - d_left_points; // use a fixed number of points; near left/right borders, use offset to change // effective number of left/right points considered if (target_index < d_left_points) offset += d_left_points - target_index; else if (target_index + d_right_points >= d_n) offset += d_n - 1 - (target_index + d_right_points); // fill Vandermonde matrix for (int i = 0; i < points; ++i) { gsl_matrix_set(vandermonde, i, 0, 1.0); for (int j = 1; j <= d_polynom_order; ++j) gsl_matrix_set(vandermonde, i, j, gsl_matrix_get(vandermonde,i,j-1) * x_in[offset + i]); } // Y values within current smoothing window gsl_vector_view y_slice = gsl_vector_view_array(y_inout+offset, points); // compute QR decomposition of Vandermonde matrix if (int error=gsl_linalg_QR_decomp(vandermonde, tau)) QMessageBox::critical((ApplicationWindow *)parent(), tr("SciDAVis") + " - " + tr("Error"), tr("Internal error in Savitzky-Golay algorithm: QR decomposition failed.\n") + gsl_strerror(error)); // least-squares-solve vandermonde*poly=y_slice using the QR decomposition now stored in // vandermonde and tau else if (int error=gsl_linalg_QR_lssolve(vandermonde, tau, &y_slice.vector, poly, residual)) QMessageBox::critical((ApplicationWindow *)parent(), tr("SciDAVis") + " - " + tr("Error"), tr("Internal error in Savitzky-Golay algorithm: least-squares solution failed.\n") + gsl_strerror(error)); else result[target_index] = gsl_poly_eval(poly->data, d_polynom_order+1, x_in[target_index]); } // deallocate memory gsl_vector_free(residual); gsl_vector_free(poly); gsl_vector_free(tau); gsl_matrix_free(vandermonde); // write result into *y_inout qCopy(result.begin(), result.end(), y_inout); }
extern "C" { #endif /* ------------------------------------------------------------------------ */ DEFAPI(void) defGslPoly(CTX ctx, kclass_t cid, kclassdef_t *cdef) { cdef->name = "GslPoly"; } //## @Native float GslPoly.eval(float[] c, float x); KMETHOD GslPoly_eval(CTX ctx, ksfp_t *sfp _RIX) { kArray *c = sfp[1].a; double x = sfp[2].fvalue; double r = gsl_poly_eval(c->flist, knh_Array_size(c), x); RETURNf_(r); } //## @Native int GslPoly.evalDerivs(float[] c, float x, float[] res); KMETHOD GslPoly_evalDerivs(CTX ctx, ksfp_t *sfp _RIX) { kArray *c = sfp[1].a; double x = sfp[2].fvalue; kArray *res = sfp[3].a; int n = gsl_poly_eval_derivs(c->flist, knh_Array_size(c), x, res->flist, knh_Array_size(res)); RETURNi_(n); } //## @Native int GslPoly.ddInit(float[] dd, float[] xa, double ya[]); KMETHOD GslPoly_ddInit(CTX ctx, ksfp_t *sfp _RIX)
CAMLprim value ml_gsl_poly_eval(value c, value x) { int len = Double_array_length(c); return copy_double(gsl_poly_eval(Double_array_val(c), len, Double_val(x))); }
int main (void) { const double eps = 100.0 * GSL_DBL_EPSILON; gsl_ieee_env_setup (); /* Polynomial evaluation */ { double x, y; double c[3] = { 1.0, 0.5, 0.3 }; x = 0.5; y = gsl_poly_eval (c, 3, x); gsl_test_rel (y, 1 + 0.5 * x + 0.3 * x * x, eps, "gsl_poly_eval({1, 0.5, 0.3}, 0.5)"); } { double x, y; double d[11] = { 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1 }; x = 1.0; y = gsl_poly_eval (d, 11, x); gsl_test_rel (y, 1.0, eps, "gsl_poly_eval({1,-1, 1, -1, 1, -1, 1, -1, 1, -1, 1}, 1.0)"); } { gsl_complex x, y; double c[1] = {0.3}; GSL_SET_REAL (&x, 0.75); GSL_SET_IMAG (&x, 1.2); y = gsl_poly_complex_eval (c, 1, x); gsl_test_rel (GSL_REAL (y), 0.3, eps, "y.real, gsl_poly_complex_eval ({0.3}, 0.75 + 1.2i)"); gsl_test_rel (GSL_IMAG (y), 0.0, eps, "y.imag, gsl_poly_complex_eval ({0.3}, 0.75 + 1.2i)"); } { gsl_complex x, y; double c[4] = {2.1, -1.34, 0.76, 0.45}; GSL_SET_REAL (&x, 0.49); GSL_SET_IMAG (&x, 0.95); y = gsl_poly_complex_eval (c, 4, x); gsl_test_rel (GSL_REAL (y), 0.3959143, eps, "y.real, gsl_poly_complex_eval ({2.1, -1.34, 0.76, 0.45}, 0.49 + 0.95i)"); gsl_test_rel (GSL_IMAG (y), -0.6433305, eps, "y.imag, gsl_poly_complex_eval ({2.1, -1.34, 0.76, 0.45}, 0.49 + 0.95i)"); } { gsl_complex x, y; gsl_complex c[1]; GSL_SET_REAL (&c[0], 0.674); GSL_SET_IMAG (&c[0], -1.423); GSL_SET_REAL (&x, -1.44); GSL_SET_IMAG (&x, 9.55); y = gsl_complex_poly_complex_eval (c, 1, x); gsl_test_rel (GSL_REAL (y), 0.674, eps, "y.real, gsl_complex_poly_complex_eval ({0.674 - 1.423i}, -1.44 + 9.55i)"); gsl_test_rel (GSL_IMAG (y), -1.423, eps, "y.imag, gsl_complex_poly_complex_eval ({0.674 - 1.423i}, -1.44 + 9.55i)"); } { gsl_complex x, y; gsl_complex c[4]; GSL_SET_REAL (&c[0], -2.31); GSL_SET_IMAG (&c[0], 0.44); GSL_SET_REAL (&c[1], 4.21); GSL_SET_IMAG (&c[1], -3.19); GSL_SET_REAL (&c[2], 0.93); GSL_SET_IMAG (&c[2], 1.04); GSL_SET_REAL (&c[3], -0.42); GSL_SET_IMAG (&c[3], 0.68); GSL_SET_REAL (&x, 0.49); GSL_SET_IMAG (&x, 0.95); y = gsl_complex_poly_complex_eval (c, 4, x); gsl_test_rel (GSL_REAL (y), 1.82462012, eps, "y.real, gsl_complex_poly_complex_eval ({-2.31 + 0.44i, 4.21 - 3.19i, 0.93 + 1.04i, -0.42 + 0.68i}, 0.49 + 0.95i)"); gsl_test_rel (GSL_IMAG (y), 2.30389412, eps, "y.imag, gsl_complex_poly_complex_eval ({-2.31 + 0.44i, 4.21 - 3.19i, 0.93 + 1.04i, -0.42 + 0.68i}, 0.49 + 0.95i)"); } /* Quadratic */ { double x0, x1; int n = gsl_poly_solve_quadratic (4.0, -20.0, 26.0, &x0, &x1); gsl_test (n != 0, "gsl_poly_solve_quadratic, no roots, (2x - 5)^2 = -1"); } { double x0, x1; int n = gsl_poly_solve_quadratic (4.0, -20.0, 25.0, &x0, &x1); gsl_test (n != 2, "gsl_poly_solve_quadratic, one root, (2x - 5)^2 = 0"); gsl_test_rel (x0, 2.5, 1e-9, "x0, (2x - 5)^2 = 0"); gsl_test_rel (x1, 2.5, 1e-9, "x1, (2x - 5)^2 = 0"); gsl_test (x0 != x1, "x0 == x1, (2x - 5)^2 = 0"); } { double x0, x1; int n = gsl_poly_solve_quadratic (4.0, -20.0, 21.0, &x0, &x1); gsl_test (n != 2, "gsl_poly_solve_quadratic, two roots, (2x - 5)^2 = 4"); gsl_test_rel (x0, 1.5, 1e-9, "x0, (2x - 5)^2 = 4"); gsl_test_rel (x1, 3.5, 1e-9, "x1, (2x - 5)^2 = 4"); } { double x0, x1; int n = gsl_poly_solve_quadratic (4.0, 7.0, 0.0, &x0, &x1); gsl_test (n != 2, "gsl_poly_solve_quadratic, two roots, x(4x + 7) = 0"); gsl_test_rel (x0, -1.75, 1e-9, "x0, x(4x + 7) = 0"); gsl_test_rel (x1, 0.0, 1e-9, "x1, x(4x + 7) = 0"); } { double x0, x1; int n = gsl_poly_solve_quadratic (5.0, 0.0, -20.0, &x0, &x1); gsl_test (n != 2, "gsl_poly_solve_quadratic, two roots b = 0, 5 x^2 = 20"); gsl_test_rel (x0, -2.0, 1e-9, "x0, 5 x^2 = 20"); gsl_test_rel (x1, 2.0, 1e-9, "x1, 5 x^2 = 20"); } { double x0, x1; int n = gsl_poly_solve_quadratic (0.0, 3.0, -21.0, &x0, &x1); gsl_test (n != 1, "gsl_poly_solve_quadratic, one root (linear) 3 x - 21 = 0"); gsl_test_rel (x0, 7.0, 1e-9, "x0, 3x - 21 = 0"); } { double x0, x1; int n = gsl_poly_solve_quadratic (0.0, 0.0, 1.0, &x0, &x1); gsl_test (n != 0, "gsl_poly_solve_quadratic, no roots 1 = 0"); } /* Cubic */ { double x0, x1, x2; int n = gsl_poly_solve_cubic (0.0, 0.0, -27.0, &x0, &x1, &x2); gsl_test (n != 1, "gsl_poly_solve_cubic, one root, x^3 = 27"); gsl_test_rel (x0, 3.0, 1e-9, "x0, x^3 = 27"); } { double x0, x1, x2; int n = gsl_poly_solve_cubic (-51.0, 867.0, -4913.0, &x0, &x1, &x2); gsl_test (n != 3, "gsl_poly_solve_cubic, three roots, (x-17)^3=0"); gsl_test_rel (x0, 17.0, 1e-9, "x0, (x-17)^3=0"); gsl_test_rel (x1, 17.0, 1e-9, "x1, (x-17)^3=0"); gsl_test_rel (x2, 17.0, 1e-9, "x2, (x-17)^3=0"); } { double x0, x1, x2; int n = gsl_poly_solve_cubic (-57.0, 1071.0, -6647.0, &x0, &x1, &x2); gsl_test (n != 3, "gsl_poly_solve_cubic, three roots, (x-17)(x-17)(x-23)=0"); gsl_test_rel (x0, 17.0, 1e-9, "x0, (x-17)(x-17)(x-23)=0"); gsl_test_rel (x1, 17.0, 1e-9, "x1, (x-17)(x-17)(x-23)=0"); gsl_test_rel (x2, 23.0, 1e-9, "x2, (x-17)(x-17)(x-23)=0"); } { double x0, x1, x2; int n = gsl_poly_solve_cubic (-11.0, -493.0, +6647.0, &x0, &x1, &x2); gsl_test (n != 3, "gsl_poly_solve_cubic, three roots, (x+23)(x-17)(x-17)=0"); gsl_test_rel (x0, -23.0, 1e-9, "x0, (x+23)(x-17)(x-17)=0"); gsl_test_rel (x1, 17.0, 1e-9, "x1, (x+23)(x-17)(x-17)=0"); gsl_test_rel (x2, 17.0, 1e-9, "x2, (x+23)(x-17)(x-17)=0"); } { double x0, x1, x2; int n = gsl_poly_solve_cubic (-143.0, 5087.0, -50065.0, &x0, &x1, &x2); gsl_test (n != 3, "gsl_poly_solve_cubic, three roots, (x-17)(x-31)(x-95)=0"); gsl_test_rel (x0, 17.0, 1e-9, "x0, (x-17)(x-31)(x-95)=0"); gsl_test_rel (x1, 31.0, 1e-9, "x1, (x-17)(x-31)(x-95)=0"); gsl_test_rel (x2, 95.0, 1e-9, "x2, (x-17)(x-31)(x-95)=0"); } { double x0, x1, x2; int n = gsl_poly_solve_cubic (-109.0, 803.0, 50065.0, &x0, &x1, &x2); gsl_test (n != 3, "gsl_poly_solve_cubic, three roots, (x+17)(x-31)(x-95)=0"); gsl_test_rel (x0, -17.0, 1e-9, "x0, (x+17)(x-31)(x-95)=0"); gsl_test_rel (x1, 31.0, 1e-9, "x1, (x+17)(x-31)(x-95)=0"); gsl_test_rel (x2, 95.0, 1e-9, "x2, (x+17)(x-31)(x-95)=0"); } /* Quadratic with complex roots */ { gsl_complex z0, z1; int n = gsl_poly_complex_solve_quadratic (4.0, -20.0, 26.0, &z0, &z1); gsl_test (n != 2, "gsl_poly_complex_solve_quadratic, 2 roots (2x - 5)^2 = -1"); gsl_test_rel (GSL_REAL (z0), 2.5, 1e-9, "z0.real, (2x - 5)^2 = -1"); gsl_test_rel (GSL_IMAG (z0), -0.5, 1e-9, "z0.imag, (2x - 5)^2 = -1"); gsl_test_rel (GSL_REAL (z1), 2.5, 1e-9, "z1.real, (2x - 5)^2 = -1"); gsl_test_rel (GSL_IMAG (z1), 0.5, 1e-9, "z1.imag, (2x - 5)^2 = -1"); } { gsl_complex z0, z1; int n = gsl_poly_complex_solve_quadratic (4.0, -20.0, 25.0, &z0, &z1); gsl_test (n != 2, "gsl_poly_complex_solve_quadratic, one root, (2x - 5)^2 = 0"); gsl_test_rel (GSL_REAL (z0), 2.5, 1e-9, "z0.real, (2x - 5)^2 = 0"); gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag (2x - 5)^2 = 0"); gsl_test_rel (GSL_REAL (z1), 2.5, 1e-9, "z1.real, (2x - 5)^2 = 0"); gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag (2x - 5)^2 = 0"); gsl_test (GSL_REAL (z0) != GSL_REAL (z1), "z0.real == z1.real, (2x - 5)^2 = 0"); gsl_test (GSL_IMAG (z0) != GSL_IMAG (z1), "z0.imag == z1.imag, (2x - 5)^2 = 0"); } { gsl_complex z0, z1; int n = gsl_poly_complex_solve_quadratic (4.0, -20.0, 21.0, &z0, &z1); gsl_test (n != 2, "gsl_poly_complex_solve_quadratic, two roots, (2x - 5)^2 = 4"); gsl_test_rel (GSL_REAL (z0), 1.5, 1e-9, "z0.real, (2x - 5)^2 = 4"); gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, (2x - 5)^2 = 4"); gsl_test_rel (GSL_REAL (z1), 3.5, 1e-9, "z1.real, (2x - 5)^2 = 4"); gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag, (2x - 5)^2 = 4"); } { gsl_complex z0, z1; int n = gsl_poly_complex_solve_quadratic (4.0, 7.0, 0.0, &z0, &z1); gsl_test (n != 2, "gsl_poly_complex_solve_quadratic, two roots, x(4x + 7) = 0"); gsl_test_rel (GSL_REAL (z0), -1.75, 1e-9, "z0.real, x(4x + 7) = 0"); gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, x(4x + 7) = 0"); gsl_test_rel (GSL_REAL (z1), 0.0, 1e-9, "z1.real, x(4x + 7) = 0"); gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag, x(4x + 7) = 0"); } { gsl_complex z0, z1; int n = gsl_poly_complex_solve_quadratic (5.0, 0.0, -20.0, &z0, &z1); gsl_test (n != 2, "gsl_poly_complex_solve_quadratic, two roots b = 0, 5 x^2 = 20"); gsl_test_rel (GSL_REAL (z0), -2.0, 1e-9, "z0.real, 5 x^2 = 20"); gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, 5 x^2 = 20"); gsl_test_rel (GSL_REAL (z1), 2.0, 1e-9, "z1.real, 5 x^2 = 20"); gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag, 5 x^2 = 20"); } { gsl_complex z0, z1; int n = gsl_poly_complex_solve_quadratic (5.0, 0.0, 20.0, &z0, &z1); gsl_test (n != 2, "gsl_poly_complex_solve_quadratic, two roots b = 0, 5 x^2 = -20"); gsl_test_rel (GSL_REAL (z0), 0.0, 1e-9, "z0.real, 5 x^2 = -20"); gsl_test_rel (GSL_IMAG (z0), -2.0, 1e-9, "z0.imag, 5 x^2 = -20"); gsl_test_rel (GSL_REAL (z1), 0.0, 1e-9, "z1.real, 5 x^2 = -20"); gsl_test_rel (GSL_IMAG (z1), 2.0, 1e-9, "z1.imag, 5 x^2 = -20"); } { gsl_complex z0, z1; int n = gsl_poly_complex_solve_quadratic (0.0, 3.0, -21.0, &z0, &z1); gsl_test (n != 1, "gsl_poly_complex_solve_quadratic, one root (linear) 3 x - 21 = 0"); gsl_test_rel (GSL_REAL (z0), 7.0, 1e-9, "z0.real, 3x - 21 = 0"); gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, 3x - 21 = 0"); } { gsl_complex z0, z1; int n = gsl_poly_complex_solve_quadratic (0.0, 0.0, 1.0, &z0, &z1); gsl_test (n != 0, "gsl_poly_complex_solve_quadratic, no roots 1 = 0"); } /* Cubic with complex roots */ { gsl_complex z0, z1, z2; int n = gsl_poly_complex_solve_cubic (0.0, 0.0, -27.0, &z0, &z1, &z2); gsl_test (n != 3, "gsl_poly_complex_solve_cubic, three root, x^3 = 27"); gsl_test_rel (GSL_REAL (z0), -1.5, 1e-9, "z0.real, x^3 = 27"); gsl_test_rel (GSL_IMAG (z0), -1.5 * sqrt (3.0), 1e-9, "z0.imag, x^3 = 27"); gsl_test_rel (GSL_REAL (z1), -1.5, 1e-9, "z1.real, x^3 = 27"); gsl_test_rel (GSL_IMAG (z1), 1.5 * sqrt (3.0), 1e-9, "z1.imag, x^3 = 27"); gsl_test_rel (GSL_REAL (z2), 3.0, 1e-9, "z2.real, x^3 = 27"); gsl_test_rel (GSL_IMAG (z2), 0.0, 1e-9, "z2.imag, x^3 = 27"); } { gsl_complex z0, z1, z2; int n = gsl_poly_complex_solve_cubic (-1.0, 1.0, 39.0, &z0, &z1, &z2); gsl_test (n != 3, "gsl_poly_complex_solve_cubic, three root, (x+3)(x^2-4x+13) = 0"); gsl_test_rel (GSL_REAL (z0), -3.0, 1e-9, "z0.real, (x+3)(x^2+1) = 0"); gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, (x+3)(x^2+1) = 0"); gsl_test_rel (GSL_REAL (z1), 2.0, 1e-9, "z1.real, (x+3)(x^2+1) = 0"); gsl_test_rel (GSL_IMAG (z1), -3.0, 1e-9, "z1.imag, (x+3)(x^2+1) = 0"); gsl_test_rel (GSL_REAL (z2), 2.0, 1e-9, "z2.real, (x+3)(x^2+1) = 0"); gsl_test_rel (GSL_IMAG (z2), 3.0, 1e-9, "z2.imag, (x+3)(x^2+1) = 0"); } { gsl_complex z0, z1, z2; int n = gsl_poly_complex_solve_cubic (-51.0, 867.0, -4913.0, &z0, &z1, &z2); gsl_test (n != 3, "gsl_poly_complex_solve_cubic, three roots, (x-17)^3=0"); gsl_test_rel (GSL_REAL (z0), 17.0, 1e-9, "z0.real, (x-17)^3=0"); gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, (x-17)^3=0"); gsl_test_rel (GSL_REAL (z1), 17.0, 1e-9, "z1.real, (x-17)^3=0"); gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag, (x-17)^3=0"); gsl_test_rel (GSL_REAL (z2), 17.0, 1e-9, "z2.real, (x-17)^3=0"); gsl_test_rel (GSL_IMAG (z2), 0.0, 1e-9, "z2.imag, (x-17)^3=0"); } { gsl_complex z0, z1, z2; int n = gsl_poly_complex_solve_cubic (-57.0, 1071.0, -6647.0, &z0, &z1, &z2); gsl_test (n != 3, "gsl_poly_complex_solve_cubic, three roots, (x-17)(x-17)(x-23)=0"); gsl_test_rel (GSL_REAL (z0), 17.0, 1e-9, "z0.real, (x-17)(x-17)(x-23)=0"); gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, (x-17)(x-17)(x-23)=0"); gsl_test_rel (GSL_REAL (z1), 17.0, 1e-9, "z1.real, (x-17)(x-17)(x-23)=0"); gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag, (x-17)(x-17)(x-23)=0"); gsl_test_rel (GSL_REAL (z2), 23.0, 1e-9, "z2.real, (x-17)(x-17)(x-23)=0"); gsl_test_rel (GSL_IMAG (z2), 0.0, 1e-9, "z2.imag, (x-17)(x-17)(x-23)=0"); } { gsl_complex z0, z1, z2; int n = gsl_poly_complex_solve_cubic (-11.0, -493.0, +6647.0, &z0, &z1, &z2); gsl_test (n != 3, "gsl_poly_complex_solve_cubic, three roots, (x+23)(x-17)(x-17)=0"); gsl_test_rel (GSL_REAL (z0), -23.0, 1e-9, "z0.real, (x+23)(x-17)(x-17)=0"); gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, (x+23)(x-17)(x-17)=0"); gsl_test_rel (GSL_REAL (z1), 17.0, 1e-9, "z1.real, (x+23)(x-17)(x-17)=0"); gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag, (x+23)(x-17)(x-17)=0"); gsl_test_rel (GSL_REAL (z2), 17.0, 1e-9, "z2.real, (x+23)(x-17)(x-17)=0"); gsl_test_rel (GSL_IMAG (z2), 0.0, 1e-9, "z2.imag, (x+23)(x-17)(x-17)=0"); } { gsl_complex z0, z1, z2; int n = gsl_poly_complex_solve_cubic (-143.0, 5087.0, -50065.0, &z0, &z1, &z2); gsl_test (n != 3, "gsl_poly_complex_solve_cubic, three roots, (x-17)(x-31)(x-95)=0"); gsl_test_rel (GSL_REAL (z0), 17.0, 1e-9, "z0.real, (x-17)(x-31)(x-95)=0"); gsl_test_rel (GSL_IMAG (z0), 0.0, 1e-9, "z0.imag, (x-17)(x-31)(x-95)=0"); gsl_test_rel (GSL_REAL (z1), 31.0, 1e-9, "z1.real, (x-17)(x-31)(x-95)=0"); gsl_test_rel (GSL_IMAG (z1), 0.0, 1e-9, "z1.imag, (x-17)(x-31)(x-95)=0"); gsl_test_rel (GSL_REAL (z2), 95.0, 1e-9, "z2.real, (x-17)(x-31)(x-95)=0"); gsl_test_rel (GSL_IMAG (z2), 0.0, 1e-9, "z2.imag, (x-17)(x-31)(x-95)=0"); } { /* Wilkinson polynomial: y = (x-1)(x-2)(x-3)(x-4)(x-5) */ double a[6] = { -120, 274, -225, 85, -15, 1 }; double z[6*2]; gsl_poly_complex_workspace *w = gsl_poly_complex_workspace_alloc (6); int status = gsl_poly_complex_solve (a, 6, w, z); gsl_poly_complex_workspace_free (w); gsl_test (status, "gsl_poly_complex_solve, 5th-order Wilkinson polynomial"); gsl_test_rel (z[0], 1.0, 1e-9, "z0.real, 5th-order polynomial"); gsl_test_rel (z[1], 0.0, 1e-9, "z0.imag, 5th-order polynomial"); gsl_test_rel (z[2], 2.0, 1e-9, "z1.real, 5th-order polynomial"); gsl_test_rel (z[3], 0.0, 1e-9, "z1.imag, 5th-order polynomial"); gsl_test_rel (z[4], 3.0, 1e-9, "z2.real, 5th-order polynomial"); gsl_test_rel (z[5], 0.0, 1e-9, "z2.imag, 5th-order polynomial"); gsl_test_rel (z[6], 4.0, 1e-9, "z3.real, 5th-order polynomial"); gsl_test_rel (z[7], 0.0, 1e-9, "z3.imag, 5th-order polynomial"); gsl_test_rel (z[8], 5.0, 1e-9, "z4.real, 5th-order polynomial"); gsl_test_rel (z[9], 0.0, 1e-9, "z4.imag, 5th-order polynomial"); } { /* : 8-th order polynomial y = x^8 + x^4 + 1 */ double a[9] = { 1, 0, 0, 0, 1, 0, 0, 0, 1 }; double z[8*2]; double C = 0.5; double S = sqrt (3.0) / 2.0; gsl_poly_complex_workspace *w = gsl_poly_complex_workspace_alloc (9); int status = gsl_poly_complex_solve (a, 9, w, z); gsl_poly_complex_workspace_free (w); gsl_test (status, "gsl_poly_complex_solve, 8th-order polynomial"); gsl_test_rel (z[0], -S, 1e-9, "z0.real, 8th-order polynomial"); gsl_test_rel (z[1], C, 1e-9, "z0.imag, 8th-order polynomial"); gsl_test_rel (z[2], -S, 1e-9, "z1.real, 8th-order polynomial"); gsl_test_rel (z[3], -C, 1e-9, "z1.imag, 8th-order polynomial"); gsl_test_rel (z[4], -C, 1e-9, "z2.real, 8th-order polynomial"); gsl_test_rel (z[5], S, 1e-9, "z2.imag, 8th-order polynomial"); gsl_test_rel (z[6], -C, 1e-9, "z3.real, 8th-order polynomial"); gsl_test_rel (z[7], -S, 1e-9, "z3.imag, 8th-order polynomial"); gsl_test_rel (z[8], C, 1e-9, "z4.real, 8th-order polynomial"); gsl_test_rel (z[9], S, 1e-9, "z4.imag, 8th-order polynomial"); gsl_test_rel (z[10], C, 1e-9, "z5.real, 8th-order polynomial"); gsl_test_rel (z[11], -S, 1e-9, "z5.imag, 8th-order polynomial"); gsl_test_rel (z[12], S, 1e-9, "z6.real, 8th-order polynomial"); gsl_test_rel (z[13], C, 1e-9, "z6.imag, 8th-order polynomial"); gsl_test_rel (z[14], S, 1e-9, "z7.real, 8th-order polynomial"); gsl_test_rel (z[15], -C, 1e-9, "z7.imag, 8th-order polynomial"); } { int i; double xa[7] = {0.16, 0.97, 1.94, 2.74, 3.58, 3.73, 4.70 }; double ya[7] = {0.73, 1.11, 1.49, 1.84, 2.30, 2.41, 3.07 }; double dd_expected[7] = { 7.30000000000000e-01, 4.69135802469136e-01, -4.34737219941284e-02, 2.68681098870099e-02, -3.22937056934996e-03, 6.12763259971375e-03, -6.45402453527083e-03 }; double dd[7], coeff[7], work[7]; gsl_poly_dd_init (dd, xa, ya, 7); for (i = 0; i < 7; i++) { gsl_test_rel (dd[i], dd_expected[i], 1e-10, "divided difference dd[%d]", i); } for (i = 0; i < 7; i++) { double y = gsl_poly_dd_eval(dd, xa, 7, xa[i]); gsl_test_rel (y, ya[i], 1e-10, "divided difference y[%d]", i); } gsl_poly_dd_taylor (coeff, 1.5, dd, xa, 7, work); for (i = 0; i < 7; i++) { double y = gsl_poly_eval(coeff, 7, xa[i] - 1.5); gsl_test_rel (y, ya[i], 1e-10, "taylor expansion about 1.5 y[%d]", i); } } { double c[6] = { +1.0, -2.0, +3.0, -4.0, +5.0, -6.0 }; double dc[6]; double x; x = -0.5; gsl_poly_eval_derivs(c, 6, x, dc, 6); gsl_test_rel (dc[0], c[0] + c[1]*x + c[2]*x*x + c[3]*x*x*x + c[4]*x*x*x*x + c[5]*x*x*x*x*x , eps, "gsl_poly_eval_dp({+1, -2, +3, -4, +5, -6}, 3.75)"); gsl_test_rel (dc[1], c[1] + 2.0*c[2]*x + 3.0*c[3]*x*x + 4.0*c[4]*x*x*x + 5.0*c[5]*x*x*x*x , eps, "gsl_poly_eval_dp({+1, -2, +3, -4, +5, -6} deriv 1, -12.375)"); gsl_test_rel (dc[2], 2.0*c[2] + 3.0*2.0*c[3]*x + 4.0*3.0*c[4]*x*x + 5.0*4.0*c[5]*x*x*x , eps, "gsl_poly_eval_dp({+1, -2, +3, -4, +5, -6} deriv 2, +48.0)"); gsl_test_rel (dc[3], 3.0*2.0*c[3] + 4.0*3.0*2.0*c[4]*x + 5.0*4.0*3.0*c[5]*x*x , eps,"gsl_poly_eval_dp({+1, -2, +3, -4, +5, -6} deriv 3, -174.0)"); gsl_test_rel (dc[4], 4.0*3.0*2.0*c[4] + 5.0*4.0*3.0*2.0*c[5]*x, eps, "gsl_poly_eval_dp({+1, -2, +3, -4, +5, -6} deriv 4, +480.0)"); gsl_test_rel (dc[5], 5.0*4.0*3.0*2.0*c[5] , eps, "gsl_poly_eval_dp({+1, -2, +3, -4, +5, -6} deriv 5, -720.0)"); } /* now summarize the results */ exit (gsl_test_summary ()); }
int main(int argc, char *argv []) { if(populate_env_variable(REF_ERROR_CODES_FILE, "L2_ERROR_CODES_FILE")) { printf("\nUnable to populate [REF_ERROR_CODES_FILE] variable with corresponding environment variable. Routine will proceed without error handling\n"); } if (argc != 5) { if(populate_env_variable(SPCS_BLURB_FILE, "L2_SPCS_BLURB_FILE")) { RETURN_FLAG = 1; } else { print_file(SPCS_BLURB_FILE); } write_key_to_file(ERROR_CODES_FILE, REF_ERROR_CODES_FILE, "L2STATCO", -1, "Status flag for L2 spcorrect routine", ERROR_CODES_FILE_WRITE_ACCESS); return 1; } else { // *********************************************************************** // Redefine routine input parameters char *input_f = strdup(argv[1]); char *interpolation_type = strdup(argv[2]); int conserve_flux = strtol(argv[3], NULL, 0); char *output_f = strdup(argv[4]); // *********************************************************************** // Open input file (ARG 1), get parameters and perform any data format // checks fitsfile *input_f_ptr; int input_f_maxdim = 2, input_f_status = 0, input_f_bitpix, input_f_naxis; long input_f_naxes [2] = {1,1}; if(!fits_open_file(&input_f_ptr, input_f, IMG_READ_ACCURACY, &input_f_status)) { if(!populate_img_parameters(input_f, input_f_ptr, input_f_maxdim, &input_f_bitpix, &input_f_naxis, input_f_naxes, &input_f_status, "INPUT FRAME")) { if (input_f_naxis != 2) { // any data format checks here write_key_to_file(ERROR_CODES_FILE, REF_ERROR_CODES_FILE, "L2STATCO", -2, "Status flag for L2 spcorrect routine", ERROR_CODES_FILE_WRITE_ACCESS); free(input_f); free(output_f); free(interpolation_type); if(fits_close_file(input_f_ptr, &input_f_status)) fits_report_error (stdout, input_f_status); return 1; } } else { write_key_to_file(ERROR_CODES_FILE, REF_ERROR_CODES_FILE, "L2STATCO", -3, "Status flag for L2 spcorrect routine", ERROR_CODES_FILE_WRITE_ACCESS); fits_report_error(stdout, input_f_status); free(input_f); free(output_f); free(interpolation_type); if(fits_close_file(input_f_ptr, &input_f_status)) fits_report_error (stdout, input_f_status); return 1; } } else { write_key_to_file(ERROR_CODES_FILE, REF_ERROR_CODES_FILE, "L2STATCO", -4, "Status flag for L2 spcorrect routine", ERROR_CODES_FILE_WRITE_ACCESS); fits_report_error(stdout, input_f_status); free(input_f); free(output_f); free(interpolation_type); return 1; } // *********************************************************************** // Set the range limits int cut_x [2] = {1, input_f_naxes[0]}; int cut_y [2] = {1, input_f_naxes[1]}; // *********************************************************************** // Set parameters used when reading data from input file (ARG 1) long fpixel [2] = {cut_x[0], cut_y[0]}; long nxelements = (cut_x[1] - cut_x[0]) + 1; long nyelements = (cut_y[1] - cut_y[0]) + 1; // *********************************************************************** // Create arrays to store pixel values from input fits file (ARG 1) double input_f_pixels [nxelements]; // *********************************************************************** // Get input fits file (ARG 1) values and store in 2D array int ii; double input_frame_values [nyelements][nxelements]; memset(input_frame_values, 0, sizeof(double)*nxelements*nyelements); for (fpixel[1] = cut_y[0]; fpixel[1] <= cut_y[1]; fpixel[1]++) { memset(input_f_pixels, 0, sizeof(double)*nxelements); if(!fits_read_pix(input_f_ptr, TDOUBLE, fpixel, nxelements, NULL, input_f_pixels, NULL, &input_f_status)) { for (ii=0; ii<nxelements; ii++) { input_frame_values[fpixel[1]-1][ii] = input_f_pixels[ii]; } } else { write_key_to_file(ERROR_CODES_FILE, REF_ERROR_CODES_FILE, "L2STATCO", -5, "Status flag for L2 spcorrect routine", ERROR_CODES_FILE_WRITE_ACCESS); fits_report_error(stdout, input_f_status); free(input_f); free(output_f); free(interpolation_type); if(fits_close_file(input_f_ptr, &input_f_status)) fits_report_error (stdout, input_f_status); return 1; } } // *********************************************************************** // Open [SPTRACE_OUTPUTF_TRACES_FILE] input file FILE *inputfile; if (!check_file_exists(SPTRACE_OUTPUTF_TRACES_FILE)) { inputfile = fopen(SPTRACE_OUTPUTF_TRACES_FILE , "r"); } else { write_key_to_file(ERROR_CODES_FILE, REF_ERROR_CODES_FILE, "L2STATCO", -6, "Status flag for L2 spcorrect routine", ERROR_CODES_FILE_WRITE_ACCESS); return 1; } // *********************************************************************** // Find some [SPTRACE_OUTPUTF_TRACES_FILE] file details char input_string [500]; bool find_polynomialorder_comment = FALSE; int polynomial_order; char search_string_1 [20] = "# Polynomial Order:\0"; // this is the comment to be found from the [SPTRACE_OUTPUTF_TRACES_FILE] file while(!feof(inputfile)) { memset(input_string, '\0', sizeof(char)*500); fgets(input_string, 500, inputfile); if (strncmp(input_string, search_string_1, strlen(search_string_1)) == 0) { sscanf(input_string, "%*[^\t]%d", &polynomial_order); // read all data up to tab as string ([^\t]), but do not store (*) find_polynomialorder_comment = TRUE; break; } } if (find_polynomialorder_comment == FALSE) { // error check - didn't find the comment in the [SPTRACE_OUTPUTF_TRACES_FILE] file write_key_to_file(ERROR_CODES_FILE, REF_ERROR_CODES_FILE, "L2STATCO", -7, "Status flag for L2 frcorrect routine", ERROR_CODES_FILE_WRITE_ACCESS); free(input_f); free(output_f); free(interpolation_type); if(fits_close_file(input_f_ptr, &input_f_status)) fits_report_error (stdout, input_f_status); return 1; } // *********************************************************************** // Rewind and extract coefficients from [SPTRACE_OUTPUTF_TRACES_FILE] file rewind(inputfile); int token_index; // this variable will hold which token we're dealing with int coeff_index; // this variable will hold which coefficient we're dealing with double this_coeff; double this_chisquared; char *token; double coeffs [polynomial_order+1]; memset(coeffs, 0, sizeof(double)*(polynomial_order+1)); while(!feof(inputfile)) { memset(input_string, '\0', sizeof(char)*500); fgets(input_string, 500, inputfile); token_index = 0; coeff_index = 0; if (strtol(&input_string[0], NULL, 0) > 0) { // check the line begins with a positive number // *********************************************************************** // String tokenisation loop: // // 1. init calls strtok() loading the function with input_string // 2. terminate when token is null // 3. we keep assigning tokens of input_string to token until termination by calling strtok with a NULL first argument // // n.b. searching for tab or newline separators ('\t' and '\n') for (token=strtok(input_string, "\t\n"); token !=NULL; token = strtok(NULL, "\t\n")) { if ((token_index >= 0) && (token_index <= polynomial_order)) { // coeff token this_coeff = strtod(token, NULL); //printf("%d\t%e\n", coeff_index, this_coeff); // DEBUG coeffs[coeff_index] = this_coeff; coeff_index++; } else if (token_index == polynomial_order+1) { // chisquared token this_chisquared = strtod(token, NULL); } token_index++; } } } // *********************************************************************** // Determine the min and max offsets from c0 (this is needed to avoid // trying to interpolate past the limits) otherwise throws GSL // INTERPOLATION ERROR. double c0 = coeffs[0]; float min_offset = 0; // this is how much the curvature extends in -ve y float max_offset = 0; // this is how much the curvature extends in +ve y for (ii=0; ii<nxelements; ii++) { float this_offset = gsl_poly_eval(coeffs, polynomial_order+1, ii) - c0; if (this_offset > max_offset) { max_offset = this_offset; } if (this_offset < min_offset) { min_offset = this_offset; } } int min_offset_int = (int)ceil(fabs(min_offset)); int max_offset_int = (int)ceil(fabs(max_offset)); int nyelements_reb = nyelements - max_offset_int - min_offset_int; // *********************************************************************** // Do the rebinning (conserving flux where applicable) double reb_values[nyelements_reb][nxelements]; memset(reb_values, 0, sizeof(double)*nyelements_reb*nxelements); double this_pre_rebin_flux, this_post_rebin_flux; double this_column_values[nyelements]; double this_column_values_reb[nyelements_reb]; double x_offsetted[nyelements]; int jj; for (ii=0; ii<nxelements; ii++) { this_pre_rebin_flux = 0.; double this_offset = gsl_poly_eval(coeffs, polynomial_order+1, ii) - c0; memset(this_column_values, 0, sizeof(double)*nyelements); memset(this_column_values_reb, 0, sizeof(double)*nyelements_reb); for (jj=0; jj<nyelements; jj++) { this_column_values[jj] = input_frame_values[jj][ii]; x_offsetted[jj] = jj - this_offset; this_pre_rebin_flux += input_frame_values[jj][ii]; } interpolate(interpolation_type, x_offsetted, this_column_values, nyelements, min_offset_int, nyelements_reb-max_offset_int, 1, this_column_values_reb); // get post rebin flux this_post_rebin_flux = 0.; for (jj=0; jj<nyelements_reb; jj++) { this_post_rebin_flux += this_column_values_reb[jj]; } // apply conservation factor double conservation_factor = this_pre_rebin_flux/this_post_rebin_flux; //printf("%f\t%f\t%f\n", this_pre_rebin_flux, this_post_rebin_flux, conservation_factor); // DEBUG if (conserve_flux == TRUE) { for (jj=0; jj<nyelements_reb; jj++) { reb_values[jj][ii] = this_column_values_reb[jj] * conservation_factor; } } else { for (jj=0; jj<nyelements_reb; jj++) { reb_values[jj][ii] = this_column_values_reb[jj]; } } } // *********************************************************************** // Set output frame parameters fitsfile *output_f_ptr; int output_f_status = 0; long output_f_naxes [2] = {nxelements,nyelements_reb}; long output_f_fpixel = 1; // *********************************************************************** // Create [output_frame_values] array to hold the output data in the // correct format int kk; double output_frame_values [nxelements*nyelements_reb]; memset(output_frame_values, 0, sizeof(double)*nxelements*nyelements_reb); for (ii=0; ii<nyelements_reb; ii++) { jj = ii * nxelements; for (kk=0; kk<nxelements; kk++) { output_frame_values[jj] = reb_values[ii][kk]; jj++; } } // *********************************************************************** // Create and write [output_frame_values] to output file (ARG 4) if (!fits_create_file(&output_f_ptr, output_f, &output_f_status)) { if (!fits_create_img(output_f_ptr, INTERMEDIATE_IMG_ACCURACY[0], 2, output_f_naxes, &output_f_status)) { if (!fits_write_img(output_f_ptr, INTERMEDIATE_IMG_ACCURACY[1], output_f_fpixel, nxelements*nyelements_reb, output_frame_values, &output_f_status)) { } else { write_key_to_file(ERROR_CODES_FILE, REF_ERROR_CODES_FILE, "L2STATCO", -8, "Status flag for L2 spcorrect routine", ERROR_CODES_FILE_WRITE_ACCESS); fits_report_error(stdout, output_f_status); free(input_f); free(output_f); free(interpolation_type); if(fits_close_file(input_f_ptr, &input_f_status)) fits_report_error (stdout, input_f_status); if(fits_close_file(output_f_ptr, &output_f_status)) fits_report_error (stdout, output_f_status); return 1; } } else { write_key_to_file(ERROR_CODES_FILE, REF_ERROR_CODES_FILE, "L2STATCO", -9, "Status flag for L2 spcorrect routine", ERROR_CODES_FILE_WRITE_ACCESS); fits_report_error(stdout, output_f_status); free(input_f); free(output_f); free(interpolation_type); if(fits_close_file(input_f_ptr, &input_f_status)) fits_report_error (stdout, input_f_status); if(fits_close_file(output_f_ptr, &output_f_status)) fits_report_error (stdout, output_f_status); return 1; } } else { write_key_to_file(ERROR_CODES_FILE, REF_ERROR_CODES_FILE, "L2STATCO", -10, "Status flag for L2 spcorrect routine", ERROR_CODES_FILE_WRITE_ACCESS); fits_report_error(stdout, output_f_status); free(input_f); free(output_f); free(interpolation_type); if(fits_close_file(input_f_ptr, &input_f_status)) fits_report_error (stdout, input_f_status); return 1; } // *********************************************************************** // Free arrays on heap free(input_f); free(interpolation_type); free(output_f); // *********************************************************************** // Close [SPTRACE_OUTPUTF_TRACES_FILE] output file, input file (ARG 1) and // output file (ARG 4) if (fclose(inputfile)) { write_key_to_file(ERROR_CODES_FILE, REF_ERROR_CODES_FILE, "L2STATCO", -11, "Status flag for L2 spcorrect routine", ERROR_CODES_FILE_WRITE_ACCESS); if(fits_close_file(input_f_ptr, &input_f_status)) fits_report_error (stdout, input_f_status); return 1; } if(fits_close_file(input_f_ptr, &input_f_status)) { write_key_to_file(ERROR_CODES_FILE, REF_ERROR_CODES_FILE, "L2STATCO", -12, "Status flag for L2 spcorrect routine", ERROR_CODES_FILE_WRITE_ACCESS); fits_report_error (stdout, input_f_status); return 1; } if(fits_close_file(output_f_ptr, &output_f_status)) { write_key_to_file(ERROR_CODES_FILE, REF_ERROR_CODES_FILE, "L2STATCO", -13, "Status flag for L2 spcorrect routine", ERROR_CODES_FILE_WRITE_ACCESS); fits_report_error (stdout, output_f_status); return 1; } // *********************************************************************** // Write success to [ERROR_CODES_FILE] write_key_to_file(ERROR_CODES_FILE, REF_ERROR_CODES_FILE, "L2STATCO", RETURN_FLAG, "Status flag for L2 spcorrect routine", ERROR_CODES_FILE_WRITE_ACCESS); return 0; } }
int main(int argc, char *argv[]) { gboolean BUTTON_ORDER = FALSE; GtkWidget *window; GtkWidget *vbox; GtkWidget *label; GtkWidget *label2; GtkWidget *hbox; GtkWidget *launchbutton; GtkWidget *cancelbutton; double pars[7] = {1, -6, 15, -20, 15, -6, 1}; char theResult[40]; //char *theResult; bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); gtk_init(&argc, &argv); g_object_get (gtk_settings_get_default(), "gtk-alternative-button-order", &BUTTON_ORDER, NULL); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), _("Gtk+ Demo copied from Tetralet")); gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_container_set_border_width(GTK_CONTAINER(window), 15); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(delete), NULL); vbox = gtk_vbox_new(FALSE, 20); gtk_container_add(GTK_CONTAINER(window), vbox); gtk_widget_show(vbox); label = gtk_label_new(_("Press 'View source code' button to open gtkdemo.c \n" "by launching Leafpad; \n" "Press 'Cancel' button to exit.")); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); gtk_widget_show(label); sprintf(theResult, "The result is: %g", gsl_poly_eval(pars, 7, (double) rand())); #ifdef DEBUG printf("%40c\n", *theResult); label2 = gtk_label_new(_("Helo")); #else label2 = gtk_label_new(_(theResult)); #endif gtk_box_pack_start(GTK_BOX(vbox), label2, TRUE, TRUE, 0); gtk_widget_show(label2); hbox = gtk_hbox_new (TRUE, 30); gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); launchbutton = gtk_button_new_with_label(_("View Source Code: ")); if(BUTTON_ORDER) gtk_box_pack_start(GTK_BOX(hbox), launchbutton, TRUE, TRUE, 0); else gtk_box_pack_end(GTK_BOX(hbox), launchbutton, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(launchbutton), "clicked", G_CALLBACK(launch_leafpad), NULL); gtk_widget_show(launchbutton); cancelbutton = gtk_button_new_from_stock(GTK_STOCK_CANCEL); if (BUTTON_ORDER) gtk_box_pack_start(GTK_BOX(hbox), cancelbutton, TRUE, TRUE, 0); else gtk_box_pack_end(GTK_BOX(hbox), cancelbutton, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(cancelbutton), "clicked", G_CALLBACK(gtk_main_quit), NULL); gtk_widget_show(cancelbutton); gtk_widget_show(window); gtk_main(); return 0; }
int gsl_filter_gaussian_kernel(const double alpha, const size_t order, const int normalize, gsl_vector * kernel) { const size_t N = kernel->size; if (alpha <= 0.0) { GSL_ERROR("alpha must be positive", GSL_EDOM); } else if (order > GSL_FILTER_GAUSSIAN_MAX_ORDER) { GSL_ERROR("derivative order is too large", GSL_EDOM); } else { const double half = 0.5 * (N - 1.0); /* (N - 1) / 2 */ double sum = 0.0; size_t i; /* check for quick return */ if (N == 1) { if (order == 0) gsl_vector_set(kernel, 0, 1.0); else gsl_vector_set(kernel, 0, 0.0); return GSL_SUCCESS; } for (i = 0; i < N; ++i) { double xi = ((double)i - half) / half; double yi = alpha * xi; double gi = exp(-0.5 * yi * yi); gsl_vector_set(kernel, i, gi); sum += gi; } /* normalize so sum(kernel) = 1 */ if (normalize) gsl_vector_scale(kernel, 1.0 / sum); if (order > 0) { const double beta = -0.5 * alpha * alpha; double q[GSL_FILTER_GAUSSIAN_MAX_ORDER + 1]; size_t k; /* * Need to calculate derivatives of the Gaussian window; define * * w(n) = C * exp [ p(n) ] * * p(n) = beta * n^2 * beta = -1/2 * ( alpha / ((N-1)/2) )^2 * * Then: * * d^k/dn^k w(n) = q_k(n) * w(n) * * where q_k(n) is a degree-k polynomial in n, which satisfies: * * q_k(n) = d/dn q_{k-1}(n) + q_{k-1}(n) * dp(n)/dn * q_0(n) = 1 / half^{order} */ /* initialize q_0(n) = 1 / half^{order} */ q[0] = 1.0 / gsl_pow_uint(half, order); for (i = 1; i <= GSL_FILTER_GAUSSIAN_MAX_ORDER; ++i) q[i] = 0.0; /* loop through derivative orders and calculate q_k(n) for k = 1,...,order */ for (k = 1; k <= order; ++k) { double qm1 = q[0]; q[0] = q[1]; for (i = 1; i <= k; ++i) { double tmp = q[i]; q[i] = (i + 1.0) * q[i + 1] + /* d/dn q_{k-1} */ 2.0 * beta * qm1; /* q_{k-1}(n) p'(n) */ qm1 = tmp; } } /* now set w(n) := q(n) * w(n) */ for (i = 0; i < N; ++i) { double xi = ((double)i - half) / half; double qn = gsl_poly_eval(q, order + 1, xi); double *wn = gsl_vector_ptr(kernel, i); *wn *= qn; } } return GSL_SUCCESS; } }