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;
}
예제 #3
0
파일: mlgsl_bspline.c 프로젝트: ptrf/LCDE
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;
}
예제 #4
0
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 ());
}
예제 #5
0
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() */
예제 #6
0
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);
}
예제 #7
0
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() */
예제 #8
0
/**
 * 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();
}
예제 #9
0
/** 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);

}
예제 #10
0
// [[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);   
}
예제 #11
0
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);
}
예제 #12
0
  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_();
  }
예제 #13
0
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();
} 
예제 #14
0
//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);
	}
예제 #15
0
파일: fit.c 프로젝트: savila/HALOGEN
/*=============================================================================
 *                              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;

}
예제 #16
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() */
예제 #17
0
파일: test.c 프로젝트: lemahdi/mglib
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());
}