static void SplineData_Init( SplineData **splinedata ) { if(!splinedata) exit(1); if(*splinedata) SplineData_Destroy(*splinedata); (*splinedata)=XLALCalloc(1,sizeof(SplineData)); const int ncx = 159; // points in q const int ncy = 49; // points in chi (*splinedata)->ncx = ncx; (*splinedata)->ncy = ncy; // Set up B-spline basis for desired knots double qvec[] = {1., 1.125, 1.25, 1.375, 1.5, 1.75, 2., 2.25, 2.5, 2.75, 3., 3.25, \ 3.5, 3.75, 4., 4.25, 4.5, 4.75, 5., 5.5, 6., 6.5, 7., 7.5, 8., 8.5, \ 9., 9.5, 10., 10.5, 11., 11.5, 12., 12.5, 13., 13.5, 14., 14.5, 15., \ 15.5, 16., 16.5, 17., 17.5, 18., 18.5, 19., 19.5, 20., 20.5, 21., \ 21.5, 22., 22.5, 23., 23.5, 24., 24.5, 25., 25.5, 26., 26.5, 27., \ 27.5, 28., 28.5, 29., 29.5, 30., 30.5, 31., 31.5, 32., 32.5, 33., \ 33.5, 34., 34.5, 35., 35.5, 36., 36.5, 37., 37.5, 38., 38.5, 39., \ 39.5, 40., 41., 42., 43., 44., 45., 46., 47., 48., 49., 50., 51., \ 52., 53., 54., 55., 56., 57., 58., 59., 60., 61., 62., 63., 64., 65., \ 66., 67., 68., 69., 70., 71., 72., 73., 74., 75., 76., 77., 78., 79., \ 80., 81., 82., 83., 84., 85., 86., 87., 88., 89., 90., 91., 92., 93., \ 94., 95., 95.5, 96., 96.5, 97., 97.5, 98., 98.5, 98.75, 99., 99.25, \ 99.5, 99.75, 100.}; double chivec[] = {-1., -0.975, -0.95, -0.925, -0.9, -0.875, -0.85, -0.825, -0.8, \ -0.775, -0.75, -0.725, -0.7, -0.675, -0.65, -0.625, -0.6, -0.55, \ -0.5, -0.45, -0.4, -0.35, -0.3, -0.25, -0.2, -0.15, -0.1, -0.05, 0., \ 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.325, 0.35, 0.375, 0.4, 0.425, \ 0.45, 0.475, 0.5, 0.525, 0.55, 0.575, 0.6}; const size_t nbreak_x = ncx-2; // must have nbreak = n -2 for cubic splines const size_t nbreak_y = ncy-2; // must have nbreak = n -2 for cubic splines // allocate a cubic bspline workspace (k = 4) gsl_bspline_workspace *bwx = gsl_bspline_alloc(4, nbreak_x); gsl_bspline_workspace *bwy = gsl_bspline_alloc(4, nbreak_y); // set breakpoints (and thus knots by hand) gsl_vector *breakpts_x = gsl_vector_alloc(nbreak_x); gsl_vector *breakpts_y = gsl_vector_alloc(nbreak_y); for (UINT4 i=0; i<nbreak_x; i++) gsl_vector_set(breakpts_x, i, qvec[i]); for (UINT4 j=0; j<nbreak_y; j++) gsl_vector_set(breakpts_y, j, chivec[j]); gsl_bspline_knots(breakpts_x, bwx); gsl_bspline_knots(breakpts_y, bwy); gsl_vector_free(breakpts_x); gsl_vector_free(breakpts_y); (*splinedata)->bwx=bwx; (*splinedata)->bwy=bwy; }
static void SplineData_Init( SplineData **splinedata ) { if(!splinedata) exit(1); if(*splinedata) SplineData_Destroy(*splinedata); (*splinedata)=XLALCalloc(1,sizeof(SplineData)); int ncx = 41+2; // points in q int ncy = 21+2; // points in chi1 int ncz = 21+2; // points in chi2 (*splinedata)->ncx = ncx; (*splinedata)->ncy = ncy; (*splinedata)->ncz = ncz; // Set up B-spline basis for desired knots double qvec[] = {1., 1.125, 1.25, 1.375, 1.5, 1.625, 1.75, 1.875, 2., 2.25, 2.5, \ 2.75, 3., 3.25, 3.5, 3.75, 4., 4.25, 4.5, 4.75, 5., 5.25, 5.5, 5.75, \ 6., 6.25, 6.5, 6.75, 7., 7.25, 7.5, 7.75, 8., 8.25, 8.5, 8.75, 9., \ 9.25, 9.5, 9.75, 10.}; double chi1vec[] = {-1., -0.95, -0.9, -0.85, -0.8, -0.75, -0.7, -0.6, -0.5, -0.4, -0.3, \ -0.2, -0.1, 0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.55, 0.6}; double chi2vec[] = {-1., -0.95, -0.9, -0.85, -0.8, -0.75, -0.7, -0.6, -0.5, -0.4, -0.3, \ -0.2, -0.1, 0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.55, 0.6}; const size_t nbreak_x = ncx-2; // must have nbreak = n-2 for cubic splines const size_t nbreak_y = ncy-2; // must have nbreak = n-2 for cubic splines const size_t nbreak_z = ncz-2; // must have nbreak = n-2 for cubic splines // allocate a cubic bspline workspace (k = 4) gsl_bspline_workspace *bwx = gsl_bspline_alloc(4, nbreak_x); gsl_bspline_workspace *bwy = gsl_bspline_alloc(4, nbreak_y); gsl_bspline_workspace *bwz = gsl_bspline_alloc(4, nbreak_z); // set breakpoints (and thus knots by hand) gsl_vector *breakpts_x = gsl_vector_alloc(nbreak_x); gsl_vector *breakpts_y = gsl_vector_alloc(nbreak_y); gsl_vector *breakpts_z = gsl_vector_alloc(nbreak_z); for (UINT4 i=0; i<nbreak_x; i++) gsl_vector_set(breakpts_x, i, qvec[i]); for (UINT4 j=0; j<nbreak_y; j++) gsl_vector_set(breakpts_y, j, chi1vec[j]); for (UINT4 k=0; k<nbreak_z; k++) gsl_vector_set(breakpts_z, k, chi2vec[k]); gsl_bspline_knots(breakpts_x, bwx); gsl_bspline_knots(breakpts_y, bwy); gsl_bspline_knots(breakpts_z, bwz); gsl_vector_free(breakpts_x); gsl_vector_free(breakpts_y); gsl_vector_free(breakpts_z); (*splinedata)->bwx=bwx; (*splinedata)->bwy=bwy; (*splinedata)->bwz=bwz; }
CAMLprim value ml_gsl_bspline_alloc(value k, value nbreak) { value r; gsl_bspline_workspace *w = gsl_bspline_alloc (Long_val(k), Long_val(nbreak)); Abstract_ptr(r, w); return r; }
int main (int argc, char **argv) { int status = 0; size_t order, breakpoints, i; gsl_ieee_env_setup (); argc = 0; /* prevent warnings about unused parameters */ argv = 0; for (order = 1; order < 10; order++) { for (breakpoints = 2; breakpoints < 100; breakpoints++) { double a = -1.23 * order, b = 45.6 * order; gsl_bspline_workspace *bw = gsl_bspline_alloc (order, breakpoints); gsl_bspline_knots_uniform (a, b, bw); test_bspline (bw); gsl_bspline_free (bw); } } for (order = 1; order < 10; order++) { for (breakpoints = 2; breakpoints < 100; breakpoints++) { double a = -1.23 * order, b = 45.6 * order; gsl_bspline_workspace *bw = gsl_bspline_alloc (order, breakpoints); gsl_vector *k = gsl_vector_alloc (breakpoints); for (i = 0; i < breakpoints; i++) { double f, x; f = sqrt (i / (breakpoints - 1.0)); x = (1 - f) * a + f * b; gsl_vector_set (k, i, x); }; gsl_bspline_knots (k, bw); test_bspline (bw); gsl_vector_free (k); gsl_bspline_free (bw); } } exit (gsl_test_summary ()); }
int gsl_bspline_deriv(double *x, int *n, int *degree, int *nbreak, int *order, int *order_max, double *x_min, double *x_max, double *quantile_vector, int *knots_int, double *Bx) { int k = *degree + 1; /* k in gsl */ int ncoeffs; size_t i, j; gsl_bspline_workspace *bw = gsl_bspline_alloc(k, *nbreak); ncoeffs = (int)gsl_bspline_ncoeffs(bw); gsl_vector *dBorder = gsl_vector_alloc(ncoeffs); gsl_bspline_deriv_workspace *derivWS = gsl_bspline_deriv_alloc(k); gsl_matrix *dB = gsl_matrix_alloc(ncoeffs, *order_max+1); gsl_vector *quantile_vec = gsl_vector_alloc(*nbreak); /* 7/12/10 added support for quantile knots */ if(*knots_int == 0) { gsl_bspline_knots_uniform(*x_min, *x_max, bw); } else { for(i = 0; i < *nbreak; i++) gsl_vector_set(quantile_vec, i, quantile_vector[i]); gsl_bspline_knots(quantile_vec, bw); } for (i = 0; i < *n; ++i) { /* compute B_j(xi) for all j */ gsl_bspline_deriv_eval(x[i], order[i], dB, bw, derivWS); /* fill in row i of Bx */ gsl_matrix_get_col(dBorder, dB, order[i]); for (j = 0; j < ncoeffs; ++j) { double Bj = gsl_vector_get(dBorder, j); Bx[i*ncoeffs+j] = Bj; } } gsl_bspline_free(bw); gsl_vector_free(dBorder); gsl_matrix_free(dB); /* gsl_vector_free(quantile_vec);*/ gsl_bspline_deriv_free(derivWS); return(0); } /* main() */
BSplineInterpolation::BSplineInterpolation(int ncoeffs, int k) : nCoeffs(ncoeffs), splineK(k) { /* init bSpline */ bSplineWorkspace = gsl_bspline_alloc(splineK, nCoeffs + 2 - splineK); bSpline = gsl_vector_alloc(nCoeffs); /* parameters and covariance */ cParameters = gsl_vector_alloc(nCoeffs); covMatrix = gsl_matrix_alloc(nCoeffs, nCoeffs); }
int gsl_bspline(double *x, int *n, int *degree, int *nbreak, double *x_min, double *x_max, double *quantile_vector, int *knots_int, double *Bx) { int k = *degree + 1; /* k in gsl */ int ncoeffs; int i, j; gsl_bspline_workspace *bw = gsl_bspline_alloc(k, *nbreak); ncoeffs = (int)gsl_bspline_ncoeffs(bw); /* *nbreak+k-2 */ gsl_vector *B = gsl_vector_alloc(ncoeffs); gsl_vector *quantile_vec = gsl_vector_alloc(*nbreak); /* 7/12/10 added support for quantile knots */ if(*knots_int == 0) { gsl_bspline_knots_uniform(*x_min, *x_max, bw); } else { for(i = 0; i < *nbreak; i++) gsl_vector_set(quantile_vec, i, quantile_vector[i]); gsl_bspline_knots(quantile_vec, bw); } for (i = 0; i < *n; ++i) { /* compute B_j(xi) for all j */ gsl_bspline_eval(x[i], B, bw); /* fill in row i of Bx */ for (j = 0; j < ncoeffs; ++j) { double Bj = gsl_vector_get(B, j); Bx[i*ncoeffs+j] = Bj; /* Bx:*n-by-(*nbreak+*degree-1) */ } } gsl_bspline_free(bw); gsl_vector_free(B); gsl_vector_free(quantile_vec); return(0); } /* main() */
/** * Initialize the GSL objects. */ void BSpline::resetGSLObjects() { int order = getAttribute("Order").asInt(); int nbreak = getAttribute("NBreak").asInt(); if (order <= 0) { throw std::invalid_argument("BSpline: Order must be greater than zero."); } if (nbreak < 2) { throw std::invalid_argument("BSpline: NBreak must be at least 2."); } gsl_bspline_workspace *ws = gsl_bspline_alloc(static_cast<size_t>(order), static_cast<size_t>(nbreak)); m_bsplineWorkspace = boost::shared_ptr<gsl_bspline_workspace>(ws, ReleaseBSplineWorkspace()); m_bsplineDerivWorkspace.reset(); }
/** Executes the algorithm * */ void SplineBackground::exec() { API::MatrixWorkspace_sptr inWS = getProperty("InputWorkspace"); int spec = getProperty("WorkspaceIndex"); if (spec > static_cast<int>(inWS->getNumberHistograms())) throw std::out_of_range("WorkspaceIndex is out of range."); const MantidVec& X = inWS->readX(spec); const MantidVec& Y = inWS->readY(spec); const MantidVec& E = inWS->readE(spec); const bool isHistogram = inWS->isHistogramData(); const int ncoeffs = getProperty("NCoeff"); const int k = 4; // order of the spline + 1 (cubic) const int nbreak = ncoeffs - (k - 2); if (nbreak <= 0) throw std::out_of_range("Too low NCoeff"); gsl_bspline_workspace *bw; gsl_vector *B; gsl_vector *c, *w, *x, *y; gsl_matrix *Z, *cov; gsl_multifit_linear_workspace *mw; double chisq; int n = static_cast<int>(Y.size()); bool isMasked = inWS->hasMaskedBins(spec); std::vector<int> masked(Y.size()); if (isMasked) { for(API::MatrixWorkspace::MaskList::const_iterator it=inWS->maskedBins(spec).begin();it!=inWS->maskedBins(spec).end();++it) masked[it->first] = 1; n -= static_cast<int>(inWS->maskedBins(spec).size()); } if (n < ncoeffs) { g_log.error("Too many basis functions (NCoeff)"); throw std::out_of_range("Too many basis functions (NCoeff)"); } /* allocate a cubic bspline workspace (k = 4) */ bw = gsl_bspline_alloc(k, nbreak); B = gsl_vector_alloc(ncoeffs); x = gsl_vector_alloc(n); y = gsl_vector_alloc(n); Z = gsl_matrix_alloc(n, ncoeffs); c = gsl_vector_alloc(ncoeffs); w = gsl_vector_alloc(n); cov = gsl_matrix_alloc(ncoeffs, ncoeffs); mw = gsl_multifit_linear_alloc(n, ncoeffs); /* this is the data to be fitted */ int j = 0; for (MantidVec::size_type i = 0; i < Y.size(); ++i) { if (isMasked && masked[i]) continue; gsl_vector_set(x, j, (isHistogram ? (0.5*(X[i]+X[i+1])) : X[i])); // Middle of the bins, if a histogram gsl_vector_set(y, j, Y[i]); gsl_vector_set(w, j, E[i]>0.?1./(E[i]*E[i]):0.); ++j; } if (n != j) { gsl_bspline_free(bw); gsl_vector_free(B); gsl_vector_free(x); gsl_vector_free(y); gsl_matrix_free(Z); gsl_vector_free(c); gsl_vector_free(w); gsl_matrix_free(cov); gsl_multifit_linear_free(mw); throw std::runtime_error("Assertion failed: n != j"); } double xStart = X.front(); double xEnd = X.back(); /* use uniform breakpoints */ gsl_bspline_knots_uniform(xStart, xEnd, bw); /* construct the fit matrix X */ for (int i = 0; i < n; ++i) { double xi=gsl_vector_get(x, i); /* compute B_j(xi) for all j */ gsl_bspline_eval(xi, B, bw); /* fill in row i of X */ for (j = 0; j < ncoeffs; ++j) { double Bj = gsl_vector_get(B, j); gsl_matrix_set(Z, i, j, Bj); } } /* do the fit */ gsl_multifit_wlinear(Z, w, y, c, cov, &chisq, mw); /* output the smoothed curve */ API::MatrixWorkspace_sptr outWS = WorkspaceFactory::Instance().create(inWS,1,X.size(),Y.size()); { outWS->getAxis(1)->setValue(0, inWS->getAxis(1)->spectraNo(spec)); double xi, yi, yerr; for (MantidVec::size_type i=0;i<Y.size();i++) { xi = X[i]; gsl_bspline_eval(xi, B, bw); gsl_multifit_linear_est(B, c, cov, &yi, &yerr); outWS->dataY(0)[i] = yi; outWS->dataE(0)[i] = yerr; } outWS->dataX(0) = X; } gsl_bspline_free(bw); gsl_vector_free(B); gsl_vector_free(x); gsl_vector_free(y); gsl_matrix_free(Z); gsl_vector_free(c); gsl_vector_free(w); gsl_matrix_free(cov); gsl_multifit_linear_free(mw); setProperty("OutputWorkspace",outWS); }
// [[Rcpp::export]] Rcpp::List fitData(Rcpp::DataFrame ds) { const size_t ncoeffs = NCOEFFS; const size_t nbreak = NBREAK; const size_t n = N; size_t i, j; Rcpp::DataFrame D(ds); // construct the data.frame object RcppGSL::vector<double> y = D["y"]; // access columns by name, RcppGSL::vector<double> x = D["x"]; // assigning to GSL vectors RcppGSL::vector<double> w = D["w"]; gsl_bspline_workspace *bw; gsl_vector *B; gsl_vector *c; gsl_matrix *X, *cov; gsl_multifit_linear_workspace *mw; double chisq, Rsq, dof, tss; bw = gsl_bspline_alloc(4, nbreak); // allocate a cubic bspline workspace (k = 4) B = gsl_vector_alloc(ncoeffs); X = gsl_matrix_alloc(n, ncoeffs); c = gsl_vector_alloc(ncoeffs); cov = gsl_matrix_alloc(ncoeffs, ncoeffs); mw = gsl_multifit_linear_alloc(n, ncoeffs); gsl_bspline_knots_uniform(0.0, 15.0, bw); // use uniform breakpoints on [0, 15] for (i = 0; i < n; ++i) { // construct the fit matrix X double xi = gsl_vector_get(x, i); gsl_bspline_eval(xi, B, bw); // compute B_j(xi) for all j for (j = 0; j < ncoeffs; ++j) { // fill in row i of X double Bj = gsl_vector_get(B, j); gsl_matrix_set(X, i, j, Bj); } } gsl_multifit_wlinear(X, w, y, c, cov, &chisq, mw); // do the fit dof = n - ncoeffs; tss = gsl_stats_wtss(w->data, 1, y->data, 1, y->size); Rsq = 1.0 - chisq / tss; Rcpp::NumericVector FX(151), FY(151); // output the smoothed curve double xi, yi, yerr; for (xi = 0.0, i=0; xi < 15.0; xi += 0.1, i++) { gsl_bspline_eval(xi, B, bw); gsl_multifit_linear_est(B, c, cov, &yi, &yerr); FX[i] = xi; FY[i] = yi; } Rcpp::List res = Rcpp::List::create(Rcpp::Named("X")=FX, Rcpp::Named("Y")=FY, Rcpp::Named("chisqdof")=Rcpp::wrap(chisq/dof), Rcpp::Named("rsq")=Rcpp::wrap(Rsq)); gsl_bspline_free(bw); gsl_vector_free(B); gsl_matrix_free(X); gsl_vector_free(c); gsl_matrix_free(cov); gsl_multifit_linear_free(mw); y.free(); x.free(); w.free(); return(res); }
static VALUE rb_gsl_bspline_alloc(VALUE klass, VALUE k, VALUE n) { gsl_bspline_workspace *w; w = gsl_bspline_alloc(FIX2INT(k), FIX2INT(n)); return Data_Wrap_Struct(klass, 0, gsl_bspline_free, w); }
TransformationModelBSpline::TransformationModelBSpline( const TransformationModel::DataPoints & data, const Param & params) { params_ = params; Param defaults; getDefaultParameters(defaults); params_.setDefaults(defaults); if (data.size() < 4) // TODO: check number { throw Exception::IllegalArgument(__FILE__, __LINE__, __PRETTY_FUNCTION__, "'b_spline' model needs at least four data points"); } Size num_breakpoints = params_.getValue("num_breakpoints"); String break_positions = params_.getValue("break_positions"); if ((break_positions != "uniform") && (break_positions != "quantiles")) { throw Exception::IllegalArgument(__FILE__, __LINE__, __PRETTY_FUNCTION__, "parameter 'break_positions' for 'b_spline' model must be 'uniform' or 'quantiles'"); } size_ = data.size(); x_ = gsl_vector_alloc(size_); y_ = gsl_vector_alloc(size_); w_ = gsl_vector_alloc(size_); for (size_t i = 0; i < size_; ++i) { gsl_vector_set(x_, i, data[i].first); gsl_vector_set(y_, i, data[i].second); gsl_vector_set(w_, i, 1.0); // TODO: non-uniform weights } gsl_vector_minmax(x_, &xmin_, &xmax_); // set up cubic (k = 4) spline workspace: if (num_breakpoints < 2) { num_breakpoints = 2; LOG_WARN << "Warning: Increased parameter 'num_breakpoints' to 2 (minimum)." << endl; } else if (num_breakpoints > size_ - 2) { num_breakpoints = size_ - 2; LOG_WARN << "Warning: Decreased parameter 'num_breakpoints' to " + String(num_breakpoints) + " (maximum for this number of data points)." << endl; } workspace_ = gsl_bspline_alloc(4, num_breakpoints); if (break_positions == "uniform") { gsl_bspline_knots_uniform(xmin_, xmax_, workspace_); } else { vector<double> quantiles(num_breakpoints, 1.0); double step = 1.0 / (num_breakpoints - 1); for (Size i = 0; i < num_breakpoints - 1; ++i) { quantiles[i] = i * step; } gsl_vector * breakpoints; breakpoints = gsl_vector_alloc(num_breakpoints); getQuantiles_(x_, quantiles, breakpoints); gsl_bspline_knots(breakpoints, workspace_); gsl_vector_free(breakpoints); } ncoeffs_ = gsl_bspline_ncoeffs(workspace_); gsl_vector_minmax(workspace_->knots, &xmin_, &xmax_); computeFit_(); }
void bSplineGSLOriginalDemo () { const size_t n = N; const size_t ncoeffs = NCOEFFS; const size_t nbreak = NBREAK; size_t i, j; gsl_bspline_workspace *bw; gsl_vector *B; double dy; gsl_rng *r; gsl_vector *c, *w; gsl_vector *x, *y; gsl_matrix *X, *cov; gsl_multifit_linear_workspace *mw; double chisq, Rsq, dof, tss; vector<double> xControl, yControl, xFit, yFit; gsl_rng_env_setup(); r = gsl_rng_alloc(gsl_rng_default); /* allocate a cubic bspline workspace (k = 4) */ bw = gsl_bspline_alloc(4, nbreak); B = gsl_vector_alloc(ncoeffs); x = gsl_vector_alloc(n); y = gsl_vector_alloc(n); X = gsl_matrix_alloc(n, ncoeffs); c = gsl_vector_alloc(ncoeffs); w = gsl_vector_alloc(n); cov = gsl_matrix_alloc(ncoeffs, ncoeffs); mw = gsl_multifit_linear_alloc(n, ncoeffs); printf("#m=0,S=0\n"); /* this is the data to be fitted */ for (i = 0; i < n; ++i) { double sigma; double xi = (15.0 / (N - 1)) * i; double yi = cos(xi) * exp(-0.1 * xi); sigma = 0.1 * yi; dy = gsl_ran_gaussian(r, sigma); yi += dy; gsl_vector_set(x, i, xi); xControl.push_back(xi); gsl_vector_set(y, i, yi); yControl.push_back(yi); gsl_vector_set(w, i, 1.0 / (sigma * sigma)); printf("%f %f\n", xi, yi); } /* use uniform breakpoints on [0, 15] */ gsl_bspline_knots_uniform(0.0, 15.0, bw); /* construct the fit matrix X */ for (i = 0; i < n; ++i) { double xi = gsl_vector_get(x, i); /* compute B_j(xi) for all j */ gsl_bspline_eval(xi, B, bw); /* fill in row i of X */ for (j = 0; j < ncoeffs; ++j) { double Bj = gsl_vector_get(B, j); gsl_matrix_set(X, i, j, Bj); } } /* do the fit */ gsl_multifit_wlinear(X, w, y, c, cov, &chisq, mw); dof = n - ncoeffs; tss = gsl_stats_wtss(w->data, 1, y->data, 1, y->size); Rsq = 1.0 - chisq / tss; fprintf(stderr, "chisq/dof = %e, Rsq = %f\n", chisq / dof, Rsq); /* output the smoothed curve */ { double xi, yi, yerr; printf("#m=1,S=0\n"); for (xi = 0.0; xi < 15.0; xi += 0.1) { gsl_bspline_eval(xi, B, bw); gsl_multifit_linear_est(B, c, cov, &yi, &yerr); xFit.push_back(xi); yFit.push_back(yi); printf("%f %f\n", xi, yi); } } gsl_rng_free(r); gsl_bspline_free(bw); gsl_vector_free(B); gsl_vector_free(x); gsl_vector_free(y); gsl_matrix_free(X); gsl_vector_free(c); gsl_vector_free(w); gsl_matrix_free(cov); gsl_multifit_linear_free(mw); TGraph *gr = LoadGraphFromVectors(xControl, yControl); TGraph *grFit = LoadGraphFromVectors(xFit, yFit); gr->SetMarkerColor(kRed); TCanvas *c1 = new TCanvas("c1", "Graph", 200, 10, 700, 500); gr->Draw("apz"); grFit->Draw("SAME"); c1->Update(); }
//spline locations held fixed in Mpc^-1; CMB basically fixed P(k) in these units void dopksmoothbspline_(double *kvals, double *lnpklinear, double *lnpksmooth, int *npts) { double kmaxsuppress = 0.01*0.7; size_t n, ncoeffs, nbreak; gsl_bspline_workspace *bw; gsl_vector *B; gsl_vector *c, *w, *x, *y; gsl_matrix *X, *cov; gsl_multifit_linear_workspace *mw; double deltak,lastk; int i,j,countkeep; nbreak = 9; gsl_vector *mybreaks = gsl_vector_alloc(nbreak); gsl_vector_set(mybreaks,0,(0.001*0.7)); gsl_vector_set(mybreaks,1,(0.025*0.7)); gsl_vector_set(mybreaks,2,(0.075*0.7)); gsl_vector_set(mybreaks,3,(0.125*0.7)); gsl_vector_set(mybreaks,4,(0.175*0.7)); gsl_vector_set(mybreaks,5,(0.225*0.7)); gsl_vector_set(mybreaks,6,(0.275*0.7)); gsl_vector_set(mybreaks,7,(0.325*0.7)); gsl_vector_set(mybreaks,8,(0.375*0.7)); countkeep = 0; for(i=0;i<(*npts);i++) { if((kvals[i]) >= gsl_vector_get(mybreaks,0) && (kvals[i]) <= gsl_vector_get(mybreaks,nbreak-1)) { countkeep += 1; } } n = countkeep; ncoeffs = nbreak + 2; /* allocate a cubic bspline workspace (k = 4) */ bw = gsl_bspline_alloc(4, nbreak); B = gsl_vector_alloc(ncoeffs); x = gsl_vector_alloc(n); y = gsl_vector_alloc(n); X = gsl_matrix_alloc(n, ncoeffs); c = gsl_vector_alloc(ncoeffs); w = gsl_vector_alloc(n); cov = gsl_matrix_alloc(ncoeffs, ncoeffs); mw = gsl_multifit_linear_alloc(n, ncoeffs); i=0; for(j=0;j<(*npts);j++) { if((kvals[j]) >= gsl_vector_get(mybreaks,0) && (kvals[j]) <= gsl_vector_get(mybreaks,nbreak-1)) { gsl_vector_set(x,i,(kvals[j])); gsl_vector_set(y,i,exp(lnpklinear[j])*pow(kvals[j],1.5)); if(j>0) { deltak = kvals[j] - kvals[j-1]; } else { deltak = kvals[0]; if(kvals[1] - kvals[0] < deltak) { deltak = kvals[1]-kvals[0]; } } gsl_vector_set(w,i,deltak); i+=1; } } gsl_bspline_knots(mybreaks,bw); for(i=0;i<n;i++) { double xi = gsl_vector_get(x,i); gsl_bspline_eval(xi,B,bw); for(j=0;j<ncoeffs;j++) { double Bj = gsl_vector_get(B,j); gsl_matrix_set(X,i,j,Bj); } } //do fit double yi,yierr,chisq; gsl_multifit_wlinear(X,w,y,c,cov,&chisq,mw); i = 0; for(j=0;j<(*npts);j++) { if((kvals[j]) >= gsl_vector_get(mybreaks,0) && (kvals[j]) <= gsl_vector_get(mybreaks,nbreak-1)) { gsl_bspline_eval(gsl_vector_get(x,i),B,bw); gsl_multifit_linear_est(B,c,cov,&yi,&yierr); lnpksmooth[j] = log(yi*pow(kvals[j],-1.5)); i += 1; } else { lnpksmooth[j] = lnpklinear[j]; } //spline is wacky at small k -- suppress difference at k < 0.01 if(kvals[j] < kmaxsuppress) { lnpksmooth[j] = lnpklinear[j]; } } assert(i==n); gsl_bspline_free(bw); gsl_vector_free(B); gsl_vector_free(x); gsl_vector_free(y); gsl_vector_free(mybreaks); gsl_matrix_free(X); gsl_vector_free(c); gsl_vector_free(w); gsl_matrix_free(cov); gsl_multifit_linear_free(mw); }
/*============================================================================= * FITTING CODE *=============================================================================*/ int find_best_alpha(){ //double alpha_2pcf[num_alpha][nr], trials_2pcf[num_alpha][ntrials][total_nr], alpha_err[num_alpha][nr]; double **alpha_2pcf, ***trials_2pcf, **alpha_err; double low, high, da; long i,nend,k,j,ir,jk; double chi2; double yi,yerr,xi,minerr; int nbreak, iii,ind,min_ind,max_ind; long thisseed[Nalpha*num_alpha*ntrials]; #ifdef ALLOUT char Output2PCF[LINELENGTH]; char ThisFile[15]; #endif ncoeffs = num_alpha-1; nbreak =ncoeffs-2; // Allocate alphavec, which is our result //alphavec = (double *) calloc(Nalpha,sizeof(double)); //betavec = (double *) calloc(Nalpha,sizeof(double)); alpha_2pcf = (double **) calloc(num_alpha,sizeof(double *)); alpha_err = (double **) calloc(num_alpha,sizeof(double *)); trials_2pcf = (double ***) calloc(num_alpha,sizeof(double **)); for (i=0;i<num_alpha;i++){ alpha_2pcf[i] = (double *) calloc(nr,sizeof(double)); alpha_err[i] = (double *) calloc(nr,sizeof(double)); trials_2pcf[i] = (double **) calloc(ntrials,sizeof(double*)); for (j=0;j<ntrials;j++) trials_2pcf[i][j] = (double *) calloc(total_nr,sizeof(double)); } // allocate a cubic bspline workspace (k = 4) bw = gsl_bspline_alloc(4, nbreak); B = gsl_vector_alloc(ncoeffs); alpha_grid = gsl_vector_alloc(num_alpha); chi2_alpha = gsl_vector_alloc(num_alpha); X = gsl_matrix_alloc(num_alpha,ncoeffs); c = gsl_vector_alloc(ncoeffs); weights = gsl_vector_alloc(num_alpha); cov = gsl_matrix_alloc(ncoeffs, ncoeffs); mw = gsl_multifit_linear_alloc(num_alpha, ncoeffs); // Loop through each mass bin nend = 0; iii = 0; seed = time(NULL); for (i=0;i<Nalpha;i++){ for(j=0;j<num_alpha;j++){ for(k=0;k<ntrials;k++){ thisseed[iii] = seed + iii; iii++; } } } fprintf(stderr,"STARTING LOOPS...\n"); iii = 0; for (i=0;i<Nalpha;i++){ // Get where to place halos to nend += ncuts[i]; // Calculate a more optimum alpha_grid for this bin if (i < 2) low = alpha_ratio_1*best_alpha; else{ low = alpha_ratio*best_alpha; } high = 1.05*best_alpha; da = (high-low)/(num_alpha-1); fprintf(stderr,"STARTING THREADS\n"); #ifndef NO_PAR_FIT #pragma omp parallel for num_threads(nthreads) private(jk,j,k) \ shared(num_alpha,ntrials,i,alpha_grid,low,da,stderr,Nalpha,alphavec,iii,mcuts,ListOfParticles,\ NPartPerCell,x,y,z,Lbox,Npart,Nlin,HaloMass,nend,mpart,recalc_frac,betavec,thisseed,trials_2pcf,rho,maxr,\ total_nr,Nhalos) default(none) #endif for(jk=0;jk<num_alpha*ntrials;jk++){ fprintf(stderr,"Thread %d/%d\n",omp_get_thread_num(),omp_get_num_threads()); float *hx,*hy,*hz,*hR; double *thisalphavec; double *ercorr; unsigned long long *DD; hx = (float *) calloc(Nhalos,sizeof(float)); hy = (float *) calloc(Nhalos,sizeof(float)); hz = (float *) calloc(Nhalos,sizeof(float)); hR = (float *) calloc(Nhalos,sizeof(float)); thisalphavec = (double *) calloc(Nalpha,sizeof(double)); DD = (unsigned long long *) calloc(total_nr,sizeof(unsigned long long)); ercorr = (double *) calloc(total_nr,sizeof(double)); k=jk%ntrials; j=jk/ntrials; fprintf(stderr,"MOVED MEMORY\n"); fprintf(stderr,"GOT k,j: %ld, %ld\n",k,j); fprintf(stderr,"sizeof M : %f MB\n",(Nlin*Nlin*Nlin*sizeof(double)/1024./1024.)); //define the alpha grid for this mass bin gsl_vector_set(alpha_grid,j,low+j*da); // create a local alphavec, to which we add the current gridded alpha int itemp; for (itemp=0;itemp<Nalpha;itemp++) thisalphavec[itemp] = alphavec[itemp]; //fprintf(stderr,"mem copied\n"); thisalphavec[i] = gsl_vector_get(alpha_grid,j); // Place the halos #ifdef NO_PAR_FIT place_halos(nend,HaloMass, Nlin, Npart, x, y, z, NULL,NULL,NULL,Lbox, rho,thisseed[jk+i*num_alpha*ntrials], mpart,nthreads,thisalphavec, betavec, mcuts, Nalpha, recalc_frac,hx, hy, hz, NULL,NULL,NULL,hR,ListOfParticles,NPartPerCell); #else place_halos(nend,HaloMass, Nlin, Npart, x, y, z, NULL,NULL,NULL,Lbox, rho,thisseed[jk+i*num_alpha*ntrials], mpart,1,thisalphavec, betavec, mcuts, Nalpha, recalc_frac,hx, hy, hz, NULL,NULL,NULL,hR,ListOfParticles,NPartPerCell); #endif fprintf(stderr,"correlating...\n"); //Get the 2PCF correlate(nend, Lbox,hx,hy,hz,trials_2pcf[j][k], ercorr, DD,total_nr,maxr,1); fprintf(stderr,"...correlated\n"); free(hx); free(hy); free(hz); free(hR); free(thisalphavec); free(ercorr); free(DD); } for (jk=0;jk<num_alpha*ntrials;jk++){ k=jk%ntrials; j=jk/ntrials; fprintf(stderr,"RAWCORR %ld, %ld: %e\n",j,k,trials_2pcf[j][k][0]); } // #pragma omp parallel for private(ir,j,chi2,k) shared(num_alpha,stderr,i,nr,alpha_2pcf) default(none) fprintf(stderr,"GOT CORRELATIONS , GETTING CHI2...\n"); for(j=0;j<num_alpha;j++){ //Get mean and stdev of trials_2pcf chi2 = 0.0; for (ir=0;ir<nr;ir++){ alpha_2pcf[j][ir] = 0.0; for(k=0;k<ntrials;k++){ alpha_2pcf[j][ir] += trials_2pcf[j][k][ir+total_nr-nr-2]; } alpha_2pcf[j][ir] = alpha_2pcf[j][ir]/ntrials; alpha_err[j][ir] = 0.0; for(k=0;k<ntrials;k++){ alpha_err[j][ir] += pow((trials_2pcf[j][k][ir+total_nr-nr-2]-alpha_2pcf[j][ir]),2); } alpha_err[j][ir] = pow((alpha_err[j][ir]/(ntrials-1)),0.5); // Now get chi^2 values #ifdef REL_CHI2 chi2 += pow(((alpha_2pcf[j][ir]-nbody_2pcf[i][ir+total_nr-nr-2])/nbody_2pcf[i][ir+total_nr-nr-2]),2); #else chi2 += pow(((alpha_2pcf[j][ir]-nbody_2pcf[i][ir+total_nr-nr-2])/alpha_err[j][ir]),2); #endif fprintf(stderr,"%ld, %ld, %e, %e, %e, %e\n",j,ir,alpha_2pcf[j][ir],nbody_2pcf[i][ir+total_nr-nr-2],alpha_err[j][ir],chi2); } gsl_vector_set(chi2_alpha,j,chi2/nr); gsl_vector_set(weights,j,nr/chi2); } // #endif //NO_PARALLEL_FIT //*/ #ifdef ALLOUT //OUTPUT SOME THINGS FOR CHECKING sprintf(ThisFile,"/raw.2pcf.%ld",i); strcpy(Output2PCF,OutputDir); strcat(Output2PCF,ThisFile); FILE* output_2pcf; output_2pcf = fopen(Output2PCF,"w"); //header fprintf(output_2pcf,"# r, "); for (k=0;k<num_alpha;k++){ fprintf(output_2pcf,"%e\t",gsl_vector_get(alpha_grid,k)); } fprintf(output_2pcf,"\n"); //table for (ir=0;ir<nr;ir++){ fprintf(output_2pcf,"%e\t",(ir+total_nr-nr+0.5)*maxr/total_nr); for(k=0;k<num_alpha-1;k++){ fprintf(output_2pcf,"%e\t",alpha_2pcf[k][ir]); } fprintf(output_2pcf,"%e\n",alpha_2pcf[num_alpha-1][ir]); } fclose(output_2pcf); sprintf(ThisFile,"/raw.err.%ld",i); strcpy(Output2PCF,OutputDir); strcat(Output2PCF,ThisFile); FILE* output_err; output_err = fopen(Output2PCF,"w"); //header fprintf(output_err,"# r, "); for (k=0;k<num_alpha;k++){ fprintf(output_err,"%e\t",gsl_vector_get(alpha_grid,k)); } fprintf(output_err,"\n"); //table for (ir=0;ir<nr;ir++){ fprintf(output_err,"%e\t",(ir+total_nr-nr+0.5)*maxr/total_nr); for(k=0;k<num_alpha-1;k++){ fprintf(output_err,"%e\t",alpha_err[k][ir]); } fprintf(output_err,"%e\n",alpha_err[num_alpha-1][ir]); } fclose(output_err); sprintf(ThisFile,"/chi2.%ld",i); strcpy(Output2PCF,OutputDir); strcat(Output2PCF,ThisFile); FILE* chifile; chifile = fopen(Output2PCF,"w"); fprintf(chifile,"# alpha, chi2, weight\n"); for (k=0;k<num_alpha;k++){ fprintf(chifile,"%e\t%e\t%e\n",gsl_vector_get(alpha_grid,k),gsl_vector_get(chi2_alpha,k), gsl_vector_get(weights,k)); } fclose(chifile); #endif // Check if final value or initial value is the smallest minerr = gsl_vector_get(chi2_alpha,0); ind = 0; for(k=1;k<num_alpha;k++){ if(minerr>gsl_vector_get(chi2_alpha,k)){ minerr = gsl_vector_get(chi2_alpha,k); ind = k; } } if(ind==0){ fprintf(stderr,"ERROR: alpha_grid doesn't extend low enough, set alpha_ratio lower"); } if(ind==num_alpha-1){ fprintf(stderr,"ERROR: alpha_grid doesn't extend high enough, set best_alpha higher"); } if (ind>=2){ min_ind = ind-2; }else{ min_ind = 0; } if (ind<=num_alpha-3){ max_ind = ind+2; }else{ max_ind = num_alpha-1; } /* use uniform breakpoints on interval */ gsl_bspline_knots_uniform(gsl_vector_get(alpha_grid,0), gsl_vector_get(alpha_grid,num_alpha-1), bw); /* construct the fit matrix X */ for (k = 0; k < num_alpha; ++k){ double xi = gsl_vector_get(alpha_grid, k); /* compute B_j(xi) for all j */ gsl_bspline_eval(xi, B, bw); /* fill in row i of X */ for (j = 0; j < ncoeffs; ++j){ double Bj = gsl_vector_get(B, j); gsl_matrix_set(X, k, j, Bj); } } fprintf(stderr,"Got to the fit part\n"); /* do the fit */ gsl_multifit_wlinear(X, weights, chi2_alpha, c, cov, &chisq, mw); // PRINT OUT EVERYTHING WE HAVE SO FAR fprintf(stderr,"alpha\tchi2_alpha\t\n"); for (k=0;k<num_alpha;k++){ fprintf(stderr,"%e\t%e\t\n",gsl_vector_get(alpha_grid,k), gsl_vector_get(chi2_alpha,k)); } #ifdef VERB dof = num_alpha - ncoeffs; tss = gsl_stats_wtss(weights->data, 1, chi2_alpha->data, 1, chi2_alpha->size); Rsq = 1.0 - chisq / tss; fprintf(stderr, "chisq/dof = %e, Rsq = %f\n",chisq / dof, Rsq); #endif for (xi=gsl_vector_get(alpha_grid,0);xi<gsl_vector_get(alpha_grid,num_alpha-1);xi+=0.01){ gsl_bspline_eval(xi, B, bw); gsl_multifit_linear_est(B, c, cov, &yi, &yerr); fprintf(stderr,"%e\t%e\t%e\n",xi,yi,gsl_vector_get(B,0)); } //DO THE MINIMIZATION alphavec[i] = minimize(gsl_vector_get(alpha_grid,min_ind), gsl_vector_get(alpha_grid,max_ind), gsl_vector_get(alpha_grid,ind)); best_alpha = alphavec[i]; fprintf(stderr,"\n Best alpha: %f\n\n",best_alpha); } return 0; }
int main (void) { const size_t n = N; const size_t ncoeffs = NCOEFFS; const size_t nbreak = NBREAK; size_t i, j; gsl_bspline_workspace *bw; gsl_vector *B; double dy; gsl_rng *r; gsl_vector *c, *w; gsl_vector *x, *y; gsl_matrix *X, *cov; gsl_multifit_linear_workspace *mw; double chisq; double Rsq; double dof; gsl_rng_env_setup(); r = gsl_rng_alloc(gsl_rng_default); /* allocate a cubic bspline workspace (k = 4) */ bw = gsl_bspline_alloc(4, nbreak); B = gsl_vector_alloc(ncoeffs); x = gsl_vector_alloc(n); y = gsl_vector_alloc(n); X = gsl_matrix_alloc(n, ncoeffs); c = gsl_vector_alloc(ncoeffs); w = gsl_vector_alloc(n); cov = gsl_matrix_alloc(ncoeffs, ncoeffs); mw = gsl_multifit_linear_alloc(n, ncoeffs); printf("#m=0,S=0\n"); /* this is the data to be fitted */ for (i = 0; i < n; ++i) { double sigma; double xi = (15.0 / (N - 1)) * i; double yi = cos(xi) * exp(-0.1 * xi); sigma = 0.1 * yi; dy = gsl_ran_gaussian(r, sigma); yi += dy; gsl_vector_set(x, i, xi); gsl_vector_set(y, i, yi); gsl_vector_set(w, i, 1.0 / (sigma * sigma)); printf("%f %f\n", xi, yi); } /* use uniform breakpoints on [0, 15] */ gsl_bspline_knots_uniform(0.0, 15.0, bw); /* construct the fit matrix X */ for (i = 0; i < n; ++i) { double xi = gsl_vector_get(x, i); /* compute B_j(xi) for all j */ gsl_bspline_eval(xi, B, bw); /* fill in row i of X */ for (j = 0; j < ncoeffs; ++j) { double Bj = gsl_vector_get(B, j); gsl_matrix_set(X, i, j, Bj); } } /* do the fit */ gsl_multifit_wlinear(X, w, y, c, cov, &chisq, mw); dof = n - ncoeffs; Rsq = 1.0 - chisq / gsl_stats_wtss(w->data, 1, y->data, 1, y->size); fprintf(stderr, "chisq/dof = %e, Rsq = %f\n", chisq / dof, Rsq); /* output the smoothed curve */ { double xi, yi, yerr; printf("#m=1,S=0\n"); for (xi = 0.0; xi < 15.0; xi += 0.1) { gsl_bspline_eval(xi, B, bw); gsl_multifit_linear_est(B, c, cov, &yi, &yerr); printf("%f %f\n", xi, yi); } } gsl_rng_free(r); gsl_bspline_free(bw); gsl_vector_free(B); gsl_vector_free(x); gsl_vector_free(y); gsl_matrix_free(X); gsl_vector_free(c); gsl_vector_free(w); gsl_matrix_free(cov); gsl_multifit_linear_free(mw); return 0; } /* main() */
int main(int argc, char **argv) { size_t order, breakpoints, i; gsl_ieee_env_setup(); argc = 0; /* prevent warnings about unused parameters */ argv = 0; for (order = 1; order < 10; order++) { for (breakpoints = 2; breakpoints < 100; breakpoints++) { double a = -1.23 * order, b = 45.6 * order; gsl_bspline_workspace *bw = gsl_bspline_alloc(order, breakpoints); gsl_bspline_deriv_workspace *dbw = gsl_bspline_deriv_alloc(order); gsl_bspline_knots_uniform(a, b, bw); test_bspline(bw, dbw); gsl_bspline_deriv_free(dbw); gsl_bspline_free(bw); } } for (order = 1; order < 10; order++) { for (breakpoints = 2; breakpoints < 100; breakpoints++) { double a = -1.23 * order, b = 45.6 * order; gsl_bspline_workspace *bw = gsl_bspline_alloc(order, breakpoints); gsl_bspline_deriv_workspace *dbw = gsl_bspline_deriv_alloc(order); gsl_vector *k = gsl_vector_alloc(breakpoints); for (i = 0; i < breakpoints; i++) { double f, x; f = sqrt(i / (breakpoints - 1.0)); x = (1 - f) * a + f * b; gsl_vector_set(k, i, x); }; gsl_bspline_knots(k, bw); test_bspline(bw, dbw); gsl_vector_free(k); gsl_bspline_deriv_free(dbw); gsl_bspline_free(bw); } } /* Spot check known 0th, 1st, 2nd derivative evaluations for a particular k = 2 case. */ { size_t i, j; /* looping */ const double xloc[4] = { 0.0, 1.0, 6.0, 7.0}; const double deriv[4][3] = { { -1.0/2.0, 1.0/2.0, 0.0 }, { -1.0/2.0, 1.0/2.0, 0.0 }, { 0.0, -1.0/5.0, 1.0/5.0 }, { 0.0, -1.0/5.0, 1.0/5.0 } }; gsl_bspline_workspace *bw = gsl_bspline_alloc(2, 3); gsl_bspline_deriv_workspace *dbw = gsl_bspline_deriv_alloc(2); gsl_matrix *dB = gsl_matrix_alloc(gsl_bspline_ncoeffs(bw), gsl_bspline_order(bw) + 1); gsl_vector *breakpts = gsl_vector_alloc(3); gsl_vector_set(breakpts, 0, 0.0); gsl_vector_set(breakpts, 1, 2.0); gsl_vector_set(breakpts, 2, 7.0); gsl_bspline_knots(breakpts, bw); for (i = 0; i < 4; ++i) /* at each location */ { /* Initialize dB with poison to ensure we overwrite it */ gsl_matrix_set_all(dB, GSL_NAN); gsl_bspline_deriv_eval(xloc[i], gsl_bspline_order(bw), dB, bw, dbw); for (j = 0; j < gsl_bspline_ncoeffs(bw) ; ++j) { /* check basis function 1st deriv */ gsl_test_abs(gsl_matrix_get(dB, j, 1), deriv[i][j], GSL_DBL_EPSILON, "b-spline k=%d basis #%d derivative %d at x = %f", gsl_bspline_order(bw), j, 1, xloc[i]); } for (j = 0; j < gsl_bspline_ncoeffs(bw); ++j) { /* check k order basis function has k-th deriv equal to 0 */ gsl_test_abs(gsl_matrix_get(dB, j, gsl_bspline_order(bw)), 0.0, GSL_DBL_EPSILON, "b-spline k=%d basis #%d derivative %d at x = %f", gsl_bspline_order(bw), j, gsl_bspline_order(bw), xloc[i]); } } gsl_matrix_free(dB); gsl_bspline_deriv_free(dbw); gsl_bspline_free(bw); gsl_vector_free(breakpts); } /* Spot check known 0th, 1st, 2nd derivative evaluations for a particular k = 3 case. */ { size_t i, j; /* looping */ const double xloc[5] = { 0.0, 5.0, 9.0, 12.0, 15.0 }; const double eval[5][6] = { { 4./25., 69./100., 3./ 20. , 0. , 0. , 0. }, { 0. , 4./21. , 143./210. , 9./70., 0. , 0. }, { 0. , 0. , 3./ 10. , 7./10., 0. , 0. }, { 0. , 0. , 0. , 3./4. , 1./4., 0. }, { 0. , 0. , 0. , 1./3. , 5./9., 1./9. } }; const double deriv[5][6] = { { -4./25., 3./50., 1./ 10., 0. , 0. , 0. }, { 0. , -2./21., 1./105., 3./35., 0. , 0. }, { 0. , 0. , -1./5. , 1./ 5., 0. , 0. }, { 0. , 0. , 0. , -1./ 6., 1./6. , 0. }, { 0. , 0. , 0. , -1./ 9., 1./27., 2./27. } }; const double deriv2[5][6] = { { 2./25., -17./150., 1.0/30.0 , 0.0 , 0. , 0. }, { 0. , 1./ 42., -11.0/210.0, 1.0/35.0, 0. , 0. }, { 0. , 0. , 1.0/15.0 ,-11.0/90.0, 1./18. , 0. }, { 0. , 0. , 0.0 , 1.0/54.0, -7./162., 2./81. }, { 0. , 0. , 0.0 , 1.0/54.0, -7./162., 2./81. } }; gsl_bspline_workspace *bw = gsl_bspline_alloc(3, 5); gsl_bspline_deriv_workspace *dbw = gsl_bspline_deriv_alloc(3); gsl_matrix *dB = gsl_matrix_alloc(gsl_bspline_ncoeffs(bw), gsl_bspline_order(bw) + 1); gsl_vector *breakpts = gsl_vector_alloc(5); gsl_vector_set(breakpts, 0, -3.0); gsl_vector_set(breakpts, 1, 2.0); gsl_vector_set(breakpts, 2, 9.0); gsl_vector_set(breakpts, 3, 12.0); gsl_vector_set(breakpts, 4, 21.0); gsl_bspline_knots(breakpts, bw); for (i = 0; i < 5; ++i) /* at each location */ { /* Initialize dB with poison to ensure we overwrite it */ gsl_matrix_set_all(dB, GSL_NAN); gsl_bspline_deriv_eval(xloc[i], gsl_bspline_order(bw), dB, bw, dbw); /* check basis function evaluation */ for (j = 0; j < gsl_bspline_ncoeffs(bw); ++j) { gsl_test_abs(gsl_matrix_get(dB, j, 0), eval[i][j], GSL_DBL_EPSILON, "b-spline k=%d basis #%d derivative %d at x = %f", gsl_bspline_order(bw), j, 0, xloc[i]); } /* check 1st derivative evaluation */ for (j = 0; j < gsl_bspline_ncoeffs(bw); ++j) { gsl_test_abs(gsl_matrix_get(dB, j, 1), deriv[i][j], GSL_DBL_EPSILON, "b-spline k=%d basis #%d derivative %d at x = %f", gsl_bspline_order(bw), j, 1, xloc[i]); } /* check 2nd derivative evaluation */ for (j = 0; j < gsl_bspline_ncoeffs(bw); ++j) { gsl_test_abs(gsl_matrix_get(dB, j, 2), deriv2[i][j], GSL_DBL_EPSILON, "b-spline k=%d basis #%d derivative %d at x = %f", gsl_bspline_order(bw), j, 2, xloc[i]); } } gsl_matrix_free(dB); gsl_bspline_deriv_free(dbw); gsl_bspline_free(bw); gsl_vector_free(breakpts); } /* Check Greville abscissae functionality on a non-uniform k=1 */ { size_t i; /* looping */ /* Test parameters */ const size_t k = 1; const double bpoint_data[] = { 0.0, 0.2, 0.5, 0.75, 1.0 }; const size_t nbreak = sizeof(bpoint_data)/sizeof(bpoint_data[0]); /* Expected results */ const double abscissae_data[] = { 0.1, 0.35, 0.625, 0.875 }; const size_t nabscissae = sizeof(abscissae_data)/sizeof(abscissae_data[0]); gsl_vector_const_view bpoints = gsl_vector_const_view_array(bpoint_data, nbreak); gsl_bspline_workspace *w = gsl_bspline_alloc(k, nbreak); gsl_bspline_knots((const gsl_vector *) &bpoints, w); gsl_test_int(nabscissae, gsl_bspline_ncoeffs(w), "b-spline k=%d number of abscissae", k); for (i = 0; i < nabscissae; ++i) { gsl_test_abs(gsl_bspline_greville_abscissa(i, w), abscissae_data[i], 2*k*GSL_DBL_EPSILON, "b-spline k=%d Greville abscissa #%d at x = %f", k, i, abscissae_data[i]); } gsl_bspline_free(w); } /* Check Greville abscissae functionality on a non-uniform k=2 */ { size_t i; /* looping */ /* Test parameters */ const size_t k = 2; const double bpoint_data[] = { 0.0, 0.2, 0.5, 0.75, 1.0 }; const size_t nbreak = sizeof(bpoint_data)/sizeof(bpoint_data[0]); /* Expected results */ const double abscissae_data[] = { 0.0, 0.2, 0.5, 0.75, 1.0 }; const size_t nabscissae = sizeof(abscissae_data)/sizeof(abscissae_data[0]); gsl_vector_const_view bpoints = gsl_vector_const_view_array(bpoint_data, nbreak); gsl_bspline_workspace *w = gsl_bspline_alloc(k, nbreak); gsl_bspline_knots((const gsl_vector *) &bpoints, w); gsl_test_int(nabscissae, gsl_bspline_ncoeffs(w), "b-spline k=%d number of abscissae", k); for (i = 0; i < nabscissae; ++i) { gsl_test_abs(gsl_bspline_greville_abscissa(i, w), abscissae_data[i], 2*k*GSL_DBL_EPSILON, "b-spline k=%d Greville abscissa #%d at x = %f", k, i, abscissae_data[i]); } gsl_bspline_free(w); } /* Check Greville abscissae functionality on non-uniform k=3 */ { size_t i; /* looping */ /* Test parameters */ const size_t k = 3; const double bpoint_data[] = { 0.0, 0.2, 0.5, 0.75, 1.0 }; const size_t nbreak = sizeof(bpoint_data)/sizeof(bpoint_data[0]); /* Expected results */ const double abscissae_data[] = { 0.0, 1.0/10.0, 7.0/20.0, 5.0/ 8.0, 7.0/ 8.0, 1.0 }; const size_t nabscissae = sizeof(abscissae_data)/sizeof(abscissae_data[0]); gsl_vector_const_view bpoints = gsl_vector_const_view_array(bpoint_data, nbreak); gsl_bspline_workspace *w = gsl_bspline_alloc(k, nbreak); gsl_bspline_knots((const gsl_vector *) &bpoints, w); gsl_test_int(nabscissae, gsl_bspline_ncoeffs(w), "b-spline k=%d number of abscissae", k); for (i = 0; i < nabscissae; ++i) { gsl_test_abs(gsl_bspline_greville_abscissa(i, w), abscissae_data[i], 2*k*GSL_DBL_EPSILON, "b-spline k=%d Greville abscissa #%d at x = %f", k, i, abscissae_data[i]); } gsl_bspline_free(w); } /* Check Greville abscissae functionality on non-uniform k=4 */ { size_t i; /* looping */ /* Test parameters */ const size_t k = 4; const double bpoint_data[] = { 0.0, 0.2, 0.5, 0.75, 1.0 }; const size_t nbreak = sizeof(bpoint_data)/sizeof(bpoint_data[0]); /* Expected results */ const double abscissae_data[] = { 0.0, 1.0/15.0, 7.0/30.0, 29.0/60.0, 3.0/ 4.0, 11.0/12.0, 1.0 }; const size_t nabscissae = sizeof(abscissae_data)/sizeof(abscissae_data[0]); gsl_vector_const_view bpoints = gsl_vector_const_view_array(bpoint_data, nbreak); gsl_bspline_workspace *w = gsl_bspline_alloc(k, nbreak); gsl_bspline_knots((const gsl_vector *) &bpoints, w); gsl_test_int(nabscissae, gsl_bspline_ncoeffs(w), "b-spline k=%d number of abscissae", k); for (i = 0; i < nabscissae; ++i) { gsl_test_abs(gsl_bspline_greville_abscissa(i, w), abscissae_data[i], 2*k*GSL_DBL_EPSILON, "b-spline k=%d Greville abscissa #%d at x = %f", k, i, abscissae_data[i]); } gsl_bspline_free(w); } exit(gsl_test_summary()); }