void TransformationModelBSpline::computeFit_() { // construct the fit matrix: gsl_matrix * fit_matrix = gsl_matrix_alloc(size_, ncoeffs_); bsplines_ = gsl_vector_alloc(ncoeffs_); for (size_t i = 0; i < size_; ++i) { double xi = gsl_vector_get(x_, i); gsl_bspline_eval(xi, bsplines_, workspace_); for (size_t j = 0; j < ncoeffs_; ++j) { double bspline = gsl_vector_get(bsplines_, j); gsl_matrix_set(fit_matrix, i, j, bspline); } } // do the fit: gsl_multifit_linear_workspace * multifit = gsl_multifit_linear_alloc( size_, ncoeffs_); coeffs_ = gsl_vector_alloc(ncoeffs_); cov_ = gsl_matrix_alloc(ncoeffs_, ncoeffs_); double chisq; gsl_multifit_wlinear(fit_matrix, w_, y_, coeffs_, cov_, &chisq, multifit); // clean-up: gsl_matrix_free(fit_matrix); gsl_multifit_linear_free(multifit); // for linear extrapolation (natural spline): computeLinear_(xmin_, slope_min_, offset_min_, sd_err_left_); computeLinear_(xmax_, slope_max_, offset_max_, sd_err_right_); }
//-------------------------------------------------------------- bool polynomialfit(int obs, int degree, double *dx, double *dy, double *store){ /* n, p */ gsl_multifit_linear_workspace *ws; gsl_matrix *cov, *X; gsl_vector *y, *c; double chisq; X = gsl_matrix_alloc(obs, degree); y = gsl_vector_alloc(obs); c = gsl_vector_alloc(degree); cov = gsl_matrix_alloc(degree, degree); for(int i=0; i<obs; i++){ gsl_matrix_set(X, i, 0, 1.0); for(int j=0; j<degree; j++){ gsl_matrix_set(X, i, j, pow(dx[i], j)); } gsl_vector_set(y, i, dy[i]); } ws = gsl_multifit_linear_alloc(obs, degree); gsl_multifit_linear(X, y, c, cov, &chisq, ws); /* store result ... */ for(int i=0; i< degree; i++){ store[i] = gsl_vector_get(c, i); } gsl_multifit_linear_free(ws); gsl_matrix_free(X); gsl_matrix_free(cov); gsl_vector_free(y); gsl_vector_free(c); return true; /* we do not "analyse" the result (cov matrix mainly) to know if the fit is "good" */ }
/** \brief Estimate by ML the effect size of the genotype, the std deviation * of the errors and the std error of the estimated effect size in the * multiple linear regression Y = XB + E with E~MVN(0,sigma^2I) * \note genotype supposed to be 2nd column of X */ void FitSingleGeneWithSingleSnp(const gsl_matrix * X, const gsl_vector * y, double & pve, double & sigmahat, double & betahat_geno, double & sebetahat_geno, double & betapval_geno) { size_t N = X->size1, P = X->size2, rank; double rss; gsl_vector * Bhat = gsl_vector_alloc(P); gsl_matrix * covBhat = gsl_matrix_alloc(P, P); gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc(N, P); gsl_multifit_linear_svd(X, y, GSL_DBL_EPSILON, &rank, Bhat, covBhat, &rss, work); pve = 1 - rss / gsl_stats_tss(y->data, y->stride, y->size); sigmahat = sqrt(rss / (double)(N-rank)); betahat_geno = gsl_vector_get(Bhat, 1); sebetahat_geno = sqrt(gsl_matrix_get (covBhat, 1, 1)); betapval_geno = 2 * gsl_cdf_tdist_Q(fabs(betahat_geno / sebetahat_geno), N-rank); gsl_vector_free(Bhat); gsl_matrix_free(covBhat); gsl_multifit_linear_free(work); }
QVector<Quadric2D> fittingGLOBAL_flivre(gsl_matrix * A, gsl_vector * B) { gsl_matrix *cov = gsl_matrix_alloc (A->size2, A->size2); gsl_vector * x = gsl_vector_alloc(A->size2); gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc (A->size1,A->size2); real chisq = 0.0; real tol = 0.000001 ; size_t rank = 0 ; gsl_multifit_linear_svd( A,B, tol, &rank, x, cov, &chisq, work); //gsl_multifit_linear(A,B, x, cov, &chisq, work); gsl_multifit_linear_free (work); //qDebug() << chisq; //qDebug() << rank ; QVector<Quadric2D> resp; for(unsigned int i = 0; i < A->size2/6; ++i) { float x1 = gsl_vector_get(x, i*6); float x2 = gsl_vector_get(x, i*6 + 1);// b/2 float x3 = gsl_vector_get(x, i*6 + 2);// c/2 float x4 = gsl_vector_get(x, i*6 + 3); float x5 = gsl_vector_get(x, i*6 + 4);// e/2 float x6 = gsl_vector_get(x, i*6 + 5); resp.push_back(Quadric2D(x1,x2,x3,x4,x5,x6)); } gsl_vector_free (x); gsl_matrix_free (cov); return resp; }
static void secs2d_free(void * vstate) { secs2d_state_t *state = (secs2d_state_t *) vstate; if (state->X) gsl_matrix_free(state->X); if (state->c) gsl_vector_free(state->c); if (state->rhs) gsl_vector_free(state->rhs); if (state->wts) gsl_vector_free(state->wts); if (state->cov) gsl_matrix_free(state->cov); if (state->theta0) free(state->theta0); if (state->phi0) free(state->phi0); if (state->multifit_p) gsl_multifit_linear_free(state->multifit_p); free(state); }
double polynomialfit(int obs, int degree, double *dx, double *dy, double *store) { gsl_multifit_linear_workspace *ws; gsl_matrix *cov, *X; gsl_vector *y, *c; double chisq; int i, j; X = gsl_matrix_alloc(obs, degree); y = gsl_vector_alloc(obs); c = gsl_vector_alloc(degree); cov = gsl_matrix_alloc(degree, degree); for(i=0; i < obs; i++) { gsl_matrix_set(X, i, 0, 1.0); for(j=0; j < degree; j++) { gsl_matrix_set(X, i, j, pow(dx[i], j)); } gsl_vector_set(y, i, dy[i]); } ws = gsl_multifit_linear_alloc(obs, degree); gsl_multifit_linear(X, y, c, cov, &chisq, ws); for(i=0; i < degree; i++) { store[i] = gsl_vector_get(c, i); } gsl_multifit_linear_free(ws); gsl_matrix_free(X); gsl_matrix_free(cov); gsl_vector_free(y); gsl_vector_free(c); return chisq; // return error }
void gsl_multifit_robust_free(gsl_multifit_robust_workspace *w) { if (w->multifit_p) gsl_multifit_linear_free(w->multifit_p); if (w->r) gsl_vector_free(w->r); if (w->weights) gsl_vector_free(w->weights); if (w->c_prev) gsl_vector_free(w->c_prev); if (w->resfac) gsl_vector_free(w->resfac); if (w->psi) gsl_vector_free(w->psi); if (w->dpsi) gsl_vector_free(w->dpsi); if (w->QSI) gsl_matrix_free(w->QSI); if (w->D) gsl_vector_free(w->D); if (w->workn) gsl_vector_free(w->workn); free(w); } /* gsl_multifit_robust_free() */
void quadratic_fit(void) { int i, n; double xi, yi, ei, chisq; gsl_matrix *X, *cov; gsl_vector *y, *w, *c; n = 7; double x_vec[] = { 0, 100, 200, 300, 400, 500, 600 }; double y_vec[] = { 0, 12.5, 50.0, 112.5, 200.0, 312.5, 450.0 }; double e_vec[] = { 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 }; X = gsl_matrix_alloc(n, 3); y = gsl_vector_alloc(n); w = gsl_vector_alloc(n); c = gsl_vector_alloc(3); cov = gsl_matrix_alloc(3, 3); for (i = 0; i < n; i++) { xi = x_vec[i]; yi = y_vec[i]; ei = e_vec[i]; printf("%g %g +/- %g\n", xi, yi, ei); gsl_matrix_set(X, i, 0, 1.0); gsl_matrix_set(X, i, 1, xi); gsl_matrix_set(X, i, 2, xi * xi); gsl_vector_set(y, i, yi); gsl_vector_set(w, i, 1.0 / (ei * ei)); } { gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc(n, 3); gsl_multifit_wlinear(X, w, y, c, cov, &chisq, work); gsl_multifit_linear_free(work); } #define C(i) (gsl_vector_get(c,(i))) #define COV(i,j) (gsl_matrix_get(cov,(i),(j))) { printf("# best fit: Y = %g + %g X + %g X^2\n", C(0), C(1), C(2)); printf("# covariance matrix:\n"); printf("[ %+.5e, %+.5e, %+.5e \n", COV(0,0), COV(0,1), COV(0,2)); printf(" %+.5e, %+.5e, %+.5e \n", COV(1,0), COV(1,1), COV(1,2)); printf(" %+.5e, %+.5e, %+.5e ]\n", COV(2,0), COV(2,1), COV(2,2)); printf("# chisq = %g\n", chisq); } gsl_matrix_free(X); gsl_vector_free(y); gsl_vector_free(w); gsl_vector_free(c); gsl_matrix_free(cov); }
sonar_quadfit::~sonar_quadfit() { gsl_multifit_linear_free(workspace); gsl_matrix_free(X); gsl_matrix_free(cov); gsl_vector_free(c); delete chisq; }
int curve_fit_quad(uint8_t count, FittingData f_data[], double *aa, double *bb, double *cc) { int i, n; double xi, yi, chisq; gsl_matrix *X, *cov; gsl_vector *y, *c; n = count; X = gsl_matrix_alloc (n, 3); y = gsl_vector_alloc (n); c = gsl_vector_alloc (3); cov = gsl_matrix_alloc (3, 3); for (i = 0; i < n; i++) { xi = f_data[i].x; yi = f_data[i].y; ////printf ("%g %g\n", xi, yi); gsl_matrix_set (X, i, 0, 1.0); gsl_matrix_set (X, i, 1, xi); gsl_matrix_set (X, i, 2, xi*xi); gsl_vector_set (y, i, yi); } gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc (n, 3); gsl_multifit_linear (X, y, c, cov, &chisq, work); gsl_multifit_linear_free (work); //printf ("# best fit: Y = %g + %g X + %g X^2\n", // C(0), C(1), C(2)); //printf ("# covariance matrix:\n"); //printf ("[ %+.5e, %+.5e, %+.5e \n", // COV(0,0), COV(0,1), COV(0,2)); //printf (" %+.5e, %+.5e, %+.5e \n", // COV(1,0), COV(1,1), COV(1,2)); //printf (" %+.5e, %+.5e, %+.5e ]\n", // COV(2,0), COV(2,1), COV(2,2)); //printf ("# chisq = %g\n", chisq); *aa = C(0); *bb = C(1); *cc = C(2); gsl_matrix_free (X); gsl_vector_free (y); gsl_vector_free (c); gsl_matrix_free (cov); return 0; }
QVector<Quadric2D> processa(const QMatrix4x4& vInverse) { gsl_matrix * A = gsl_matrix_calloc (n, 3*5); real bary[3]; for (int i = 0; i < n; ++i) { QVector4D b(points[0][i], points[1][i], 1.0, 1.0); b = vInverse * b; bary[0] = b.x(); bary[1] = b.y(); bary[2] = b.z(); for (int j = 0; j < 3; ++j) { gsl_matrix_set (A, i, j*5 , points[0][i]*points[0][i]*bary[j]); //x^2 gsl_matrix_set (A, i, j*5 + 1, 2.0*points[0][i]*points[1][i]*bary[j]); //2xy gsl_matrix_set (A, i, j*5 + 2, 2.0*points[0][i] *bary[j]); //2x gsl_matrix_set (A, i, j*5 + 3, points[1][i]*points[1][i]*bary[j]); //y^2 gsl_matrix_set (A, i, j*5 + 4, 2.0*points[1][i] *bary[j]); //2y } } gsl_matrix *cov = gsl_matrix_alloc (15, 15); gsl_vector * B = gsl_vector_alloc(n); gsl_vector * x = gsl_vector_alloc(15); gsl_vector_set_all(B, 1.0); gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc (n,15); real chisq = 0.0; // gsl_multifit_linear (A, B, x, cov, &chisq, work); real tol = 0.0001 ; size_t rank = 0 ; gsl_multifit_linear_svd( A,B, tol, &rank, x, cov, &chisq, work); gsl_multifit_linear_free (work); //qDebug() << chisq; //qDebug() << rank ; QVector<Quadric2D> resp; for(int i = 0; i < 3; ++i) { float x1 = gsl_vector_get(x, i*5); float x2 = gsl_vector_get(x, i*5 + 1); float x3 = gsl_vector_get(x, i*5 + 2); float x4 = gsl_vector_get(x, i*5 + 3); float x5 = gsl_vector_get(x, i*5 + 4); resp.push_back(Quadric2D(x1,x2,x3,x4,x5,-1.0)); } gsl_matrix_free (A); gsl_vector_free (B); gsl_vector_free (x); gsl_matrix_free (cov); return resp; }
void BSplineInterpolation::fitFromData(const Samples &samples) { /* preprocess samples and extract some info */ Samples ssamples = samples; std::sort(ssamples.begin(), ssamples.end()); const int numSamples = ssamples.size(); const float minSampleX = ssamples[0].first; const float maxSampleX = ssamples.back().first; /* prepare fitting data */ gsl_vector *x = gsl_vector_alloc(ssamples.size()); gsl_vector *y = gsl_vector_alloc(ssamples.size()); for (int i=0; i<ssamples.size(); i++) { gsl_vector_set(x, i, ssamples[i].first); gsl_vector_set(y, i, ssamples[i].second); } /* uniform knots distributed in sample range */ gsl_bspline_knots_uniform(minSampleX, maxSampleX, bSplineWorkspace); /* construct a fit matrix */ gsl_matrix *fitMatrix = gsl_matrix_alloc(numSamples, nCoeffs); for (int i=0; i<numSamples; i++) { /* compute B_j(xi) for all j */ double xi = gsl_vector_get(x, i); gsl_bspline_eval(xi, bSpline, bSplineWorkspace); /* fill in row i */ for (int j=0; j<nCoeffs; j++) { double Bj = gsl_vector_get(bSpline, j); gsl_matrix_set(fitMatrix, i, j, Bj); } } /* fit spline to data */ gsl_multifit_linear_workspace *mws = gsl_multifit_linear_alloc(numSamples, nCoeffs); double chisq; size_t rank; double tol = 0.1; gsl_multifit_linear(fitMatrix, y, cParameters, covMatrix, &chisq, mws); //gsl_multifit_linear_svd(fitMatrix, y, tol, // &rank, cParameters, covMatrix, &chisq, mws); splineMinX = minSampleX; splineMaxX = maxSampleX; /* clean up */ gsl_vector_free(x); gsl_vector_free(y); gsl_matrix_free(fitMatrix); gsl_multifit_linear_free(mws); }
int fit(double image1[], double image2[], double error[], float factors[], int n) { /* if (gsl_fit_wlinear (image1, 1, error, 1, image2, 1, n, &beta, &alpha, &cov00, &cov01, &cov11, &chisq)) { fprintf(stderr, "Linear Fitting Failed!\n"); return (1); } factors[0] = alpha; factors[1] = beta; */ /*SECOND SET OF VARIABLES!!!*/ int i; double chisq; gsl_matrix *X, *cov; gsl_vector *y, *w, *c; X = gsl_matrix_alloc(n, 2); y = gsl_vector_alloc(n); w = gsl_vector_alloc(n); c = gsl_vector_alloc(2); cov = gsl_matrix_alloc(2, 2); for (i = 0; i < n; i++) { gsl_matrix_set(X, i, 0, 1.0); gsl_matrix_set(X, i, 1, image1[i]); gsl_vector_set(y, i, image2[i]); gsl_vector_set(w, i, error[i]); } gsl_multifit_linear_workspace *work = gsl_multifit_linear_alloc(n, 2); gsl_multifit_wlinear(X, w, y, c, cov, &chisq, work); gsl_multifit_linear_free(work); #define C(i) (gsl_vector_get(c,(i))) // printf("# best fit: Y = %g + %g X\n", C(0), C(1)); gsl_matrix_free(X); gsl_vector_free(y); gsl_vector_free(w); gsl_vector_free(c); gsl_matrix_free(cov); factors[0] = C(1); factors[1] = C(0); return 0; }
const QVector<double> TimeSeriesMotion::baselineFit( const int term, const QVector<double> & series ) const { Q_ASSERT(term >= 3); // Create the matrix of terms. The first column is x_i^0 (1), second // column is x_i^1 (x), third is x_i^2, etc. gsl_matrix* X = gsl_matrix_alloc(series.size(), term); gsl_vector* y = gsl_vector_alloc(series.size()); for (int i = 0; i < series.size(); ++i) { gsl_vector_set( y, i, series.at(i)); for (int j = 0; j < term; ++j) { if ( j < 2 ) { // Don't use the first two terms in the fitting gsl_matrix_set(X, i, j, 0); } else { gsl_matrix_set(X, i, j, pow(m_timeStep * i, j)); } } } // Co-variance matrix gsl_matrix * cov = gsl_matrix_alloc(term, term); // Coefficients gsl_vector * c = gsl_vector_alloc(term); // Fit the data series gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc(series.size(), term); double chisq = 0; gsl_multifit_linear(X, y, c, cov, &chisq, work); // Copy coefficients over to m_coeffs QVector<double> coeffs(term); for ( int i = 0; i < term; ++i ) coeffs[i] = gsl_vector_get(c, i); // Clear the variables gsl_matrix_free(X); gsl_vector_free(y); gsl_vector_free(c); gsl_matrix_free(cov); gsl_multifit_linear_free (work); return coeffs; }
gsl_vector* simpleFitting(gsl_matrix * A, gsl_vector * B) { gsl_matrix *cov = gsl_matrix_alloc (A->size2, A->size2); gsl_vector * x = gsl_vector_alloc(A->size2); gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc (A->size1,A->size2); real chisq = 0.0; real tol = 0.000001 ; size_t rank = 0 ; gsl_multifit_linear_svd( A,B, tol, &rank, x, cov, &chisq, work); qDebug() << "rank: " << rank << ", chisq: " << chisq; //gsl_multifit_linear(A,B, x, cov, &chisq, work); gsl_multifit_linear_free (work); return x; }
/* * adapted from http://rosettacode.org/wiki/Polynomial_regression * * @return m_coeffs[0] + m_coeffs[1]*x + m_coeffs[2]*x^2 + ... * */ std::vector<double> polynomialfit(int degree, std::vector<double> dx, std::vector<double> dy) { std::vector<double> store(degree); gsl_multifit_linear_workspace *ws; gsl_matrix *cov, *X; gsl_vector *y, *c; double chisq; int i, j; if (dx.size() != dx.size()) throw; int obs = dx.size(); // number of values X = gsl_matrix_alloc(obs, degree); y = gsl_vector_alloc(obs); c = gsl_vector_alloc(degree); cov = gsl_matrix_alloc(degree, degree); for (i = 0; i < obs; i++) { gsl_matrix_set(X, i, 0, 1.0); for (j = 0; j < degree; j++) { gsl_matrix_set(X, i, j, pow(dx[i], j)); } gsl_vector_set(y, i, dy[i]); } ws = gsl_multifit_linear_alloc(obs, degree); gsl_multifit_linear(X, y, c, cov, &chisq, ws); /* store result ... */ for (i = 0; i < degree; i++) { store[i] = gsl_vector_get(c, i); } gsl_multifit_linear_free(ws); gsl_matrix_free(X); gsl_matrix_free(cov); gsl_vector_free(y); gsl_vector_free(c); return store; }
QVector<Quadric2D> processaQUAD() { gsl_matrix * A = gsl_matrix_alloc (n, 5); for (int i = 0; i < n; ++i) { gsl_matrix_set (A, i, 0, points[0][i]*points[0][i]); //x^2 gsl_matrix_set (A, i, 1, 2.0*points[0][i]*points[1][i]); //2xy gsl_matrix_set (A, i, 2, 2.0*points[0][i] ); //2x gsl_matrix_set (A, i, 3, points[1][i]*points[1][i]); //y^2 gsl_matrix_set (A, i, 4, 2.0*points[1][i] ); //2y } gsl_matrix *cov = gsl_matrix_alloc (5, 5); gsl_vector * B = gsl_vector_alloc(n); gsl_vector * x = gsl_vector_alloc(5); gsl_vector_set_all(B, 1.0); real chisq = 0.0; gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc (n,5); gsl_multifit_linear (A, B, x, cov, &chisq, work); gsl_multifit_linear_free (work); //qDebug() << chisq; QVector<Quadric2D> resp; float x1 = gsl_vector_get(x, 0); float x2 = gsl_vector_get(x, 1); float x3 = gsl_vector_get(x, 2); float x4 = gsl_vector_get(x, 3); float x5 = gsl_vector_get(x, 4); resp.push_back(Quadric2D(x1,x2,x3,x4,x5,-1.0)); resp.push_back(Quadric2D(x1,x2,x3,x4,x5,-1.0)); resp.push_back(Quadric2D(x1,x2,x3,x4,x5,-1.0)); gsl_matrix_free (A); gsl_vector_free (B); gsl_vector_free (x); gsl_matrix_free (cov); return resp; }
void linear_fit_quadratic(const std::vector<double> &Xin, const std::vector<double> &Yin, double &c_0, double &c_1, double &c_2) { assert (Xin.size() == Yin.size()); int i, n; double xi, yi, ei, chisq; gsl_matrix *X, *cov; gsl_vector *y, *c; n = Xin.size(); X = gsl_matrix_alloc (n, 3); y = gsl_vector_alloc (n); c = gsl_vector_alloc (3); cov = gsl_matrix_alloc (3, 3); for (i = 0; i < n; i++) { double xi = Xin[i], yi = Yin[i]; gsl_matrix_set (X, i, 0, 1.0); gsl_matrix_set (X, i, 1, xi); gsl_matrix_set (X, i, 2, xi*xi); gsl_vector_set (y, i, yi); } // do the actual fitting gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc (n, 3); gsl_multifit_linear (X, y, c, cov, &chisq, work); gsl_multifit_linear_free (work); c_0 = gsl_vector_get(c,0); c_1 = gsl_vector_get(c,1); c_2 = gsl_vector_get(c,2); gsl_matrix_free (X); gsl_vector_free (y); gsl_vector_free (c); gsl_matrix_free (cov); }
void PolynomialFit::fit() { if (d_init_err) return; if (d_p > d_n){ QMessageBox::critical((ApplicationWindow *)parent(), tr("QtiPlot - Fit Error"), tr("You need at least %1 data points for this fit operation. Operation aborted!").arg(d_p)); return; } gsl_matrix *X = gsl_matrix_alloc (d_n, d_p); for (int i = 0; i <d_n; i++){ for (int j= 0; j < d_p; j++) gsl_matrix_set (X, i, j, pow(d_x[i],j)); } gsl_vector_view y = gsl_vector_view_array (d_y, d_n); gsl_vector_view w = gsl_vector_view_array (d_w, d_n); gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc (d_n, d_p); if (d_weighting == NoWeighting) gsl_multifit_linear (X, &y.vector, d_param_init, covar, &chi_2, work); else gsl_multifit_wlinear (X, &w.vector, &y.vector, d_param_init, covar, &chi_2, work); for (int i = 0; i < d_p; i++) d_results[i] = gsl_vector_get(d_param_init, i); gsl_multifit_linear_free (work); gsl_matrix_free (X); generateFitCurve(); if (show_legend) showLegend(); ApplicationWindow *app = (ApplicationWindow *)parent(); if (app->writeFitResultsToLog) app->updateLog(logFitInfo(0, 0)); }
void gslpolyfit(double *x,double *y0,int n,int d,double *c0) { #ifdef HAVE_GSL_LIB int i; double chisq; gsl_matrix *X,*cov; gsl_vector *y,*w,*c; gsl_multifit_linear_workspace *work; X=gsl_matrix_alloc(n,d+1); y=gsl_vector_alloc(n); w=gsl_vector_alloc(n); c=gsl_vector_alloc(d+1); cov=gsl_matrix_alloc(d+1,d+1); for (i=0;i<n;i++) { int j; double xi; for (j=0,xi=1.;j<=d;j++,xi*=x[i]) gsl_matrix_set(X,i,j,xi); gsl_vector_set(y,i,y0[i]); gsl_vector_set(w,i,1.0); } work = gsl_multifit_linear_alloc(n,d+1); gsl_multifit_wlinear(X,w,y,c,cov,&chisq,work); gsl_multifit_linear_free(work); for (i=0;i<=d;i++) c0[i]=gsl_vector_get(c,i); gsl_matrix_free(cov); gsl_vector_free(c); gsl_vector_free(w); gsl_vector_free(y); gsl_matrix_free(X); #else printf("\n\n\a*** Support for Gnu Scientic Library required but not available! ***\n\n" "*** Contact author. ***\n\n"); exit(10); #endif }
// Linear 2D fit void lfit2d(float *x,float *y,float *z,int n,float *a) { int i,j,m; double chisq; gsl_matrix *X,*cov; gsl_vector *yy,*w,*c; X=gsl_matrix_alloc(n,3); yy=gsl_vector_alloc(n); w=gsl_vector_alloc(n); c=gsl_vector_alloc(3); cov=gsl_matrix_alloc(3,3); // Fill matrices for(i=0;i<n;i++) { gsl_matrix_set(X,i,0,1.0); gsl_matrix_set(X,i,1,x[i]); gsl_matrix_set(X,i,2,y[i]); gsl_vector_set(yy,i,z[i]); gsl_vector_set(w,i,1.0); } // Do fit gsl_multifit_linear_workspace *work=gsl_multifit_linear_alloc(n,3); gsl_multifit_wlinear(X,w,yy,c,cov,&chisq,work); gsl_multifit_linear_free(work); // Save parameters for (i=0;i<3;i++) a[i]=gsl_vector_get(c,(i)); gsl_matrix_free(X); gsl_vector_free(yy); gsl_vector_free(w); gsl_vector_free(c); gsl_matrix_free(cov); return; }
double *LinearModelFitTwoIndependentWeighted(int n, double *y, double *x1, double *x2, double *weights) { #define NPARAMS 2 // Allocate gsl_matrix *matrixX = gsl_matrix_alloc(n, NPARAMS); gsl_vector *vectorW = gsl_vector_alloc(n); gsl_vector *vectorY = gsl_vector_alloc(n); gsl_vector *vectorC = gsl_vector_alloc(1 + NPARAMS); // Copy data int i; for (i = 0; i < n; i++) { // NPARAMS gsl_matrix_set(matrixX, i, 0, x1[i]); gsl_matrix_set(matrixX, i, 1, x2[i]); gsl_vector_set(vectorW, i, weights[i]); gsl_vector_set(vectorY, i, y[i]); } // Compute gsl_multifit_linear_workspace *work = gsl_multifit_linear_alloc(n, NPARAMS); int ret = gsl_multifit_wlinear(matrixX, vectorW, vectorY, vectorC, /*gsl_matrix * cov*/ NULL, /*double * chisq*/ NULL, work); gsl_multifit_linear_free(work); static double coef[NPARAMS + 1]; // NPARAMS+1 coef[0] = gsl_vector_get(vectorC, 0); coef[1] = gsl_vector_get(vectorC, 1); coef[2] = gsl_vector_get(vectorC, 2); // Free gsl_matrix_free(matrixX); gsl_vector_free(vectorW); gsl_vector_free(vectorY); gsl_vector_free(vectorC); return coef; }
pure_expr* wrap_gsl_multifit_linear(gsl_matrix* X, gsl_matrix* y) { int i; double chisq; pure_expr *cx[X->size1]; double *p; gsl_vector* c = gsl_vector_alloc(X->size1); gsl_vector* yt = gsl_vector_alloc(X->size1); gsl_matrix_get_row(yt, y, 0); gsl_matrix* cov = gsl_matrix_alloc(X->size1, X->size2); gsl_multifit_linear_workspace* w; w = gsl_multifit_linear_alloc(X->size1, X->size2); gsl_multifit_linear(X, yt, c, cov, &chisq, w); gsl_multifit_linear_free(w); gsl_vector_free(yt); p = c->data; for (i = 0; i < X->size1; ++i) { cx[i] = pure_double(*p); ++p; } return pure_listl(3, pure_matrix_columnsv(X->size1, cx), pure_double_matrix(cov), pure_double(chisq)); }
void test_longley () { gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc (longley_n, longley_p); gsl_multifit_robust_workspace * work_rob = gsl_multifit_robust_alloc (gsl_multifit_robust_ols, longley_n, longley_p); gsl_matrix_view X = gsl_matrix_view_array (longley_x, longley_n, longley_p); gsl_vector_view y = gsl_vector_view_array (longley_y, longley_n); gsl_vector * c = gsl_vector_alloc (longley_p); gsl_vector * r = gsl_vector_alloc (longley_n); gsl_matrix * cov = gsl_matrix_alloc (longley_p, longley_p); double chisq, chisq_res; double expected_c[7] = { -3482258.63459582, 15.0618722713733, -0.358191792925910E-01, -2.02022980381683, -1.03322686717359, -0.511041056535807E-01, 1829.15146461355 }; double expected_sd[7] = { 890420.383607373, 84.9149257747669, 0.334910077722432E-01, 0.488399681651699, 0.214274163161675, 0.226073200069370, 455.478499142212 } ; double expected_chisq = 836424.055505915; gsl_vector_view diag = gsl_matrix_diagonal (cov); gsl_vector_view exp_c = gsl_vector_view_array(expected_c, longley_p); gsl_vector_view exp_sd = gsl_vector_view_array(expected_sd, longley_p); /* test unweighted least squares */ gsl_multifit_linear (&X.matrix, &y.vector, c, cov, &chisq, work); gsl_multifit_linear_residuals(&X.matrix, &y.vector, c, r); gsl_blas_ddot(r, r, &chisq_res); test_longley_results("longley gsl_multifit_linear", c, &exp_c.vector, &diag.vector, &exp_sd.vector, chisq, chisq_res, expected_chisq); /* test robust least squares */ gsl_multifit_robust (&X.matrix, &y.vector, c, cov, work_rob); test_longley_results("longley gsl_multifit_robust", c, &exp_c.vector, &diag.vector, &exp_sd.vector, 1.0, 1.0, 1.0); /* test weighted least squares */ { size_t i, j; gsl_vector * w = gsl_vector_alloc (longley_n); double expected_cov[7][7] = { { 8531122.56783558, -166.727799925578, 0.261873708176346, 3.91188317230983, 1.1285582054705, -0.889550869422687, -4362.58709870581}, {-166.727799925578, 0.0775861253030891, -1.98725210399982e-05, -0.000247667096727256, -6.82911920718824e-05, 0.000136160797527761, 0.0775255245956248}, {0.261873708176346, -1.98725210399982e-05, 1.20690316701888e-08, 1.66429546772984e-07, 3.61843600487847e-08, -6.78805814483582e-08, -0.00013158719037715}, {3.91188317230983, -0.000247667096727256, 1.66429546772984e-07, 2.56665052544717e-06, 6.96541409215597e-07, -9.00858307771567e-07, -0.00197260370663974}, {1.1285582054705, -6.82911920718824e-05, 3.61843600487847e-08, 6.96541409215597e-07, 4.94032602583969e-07, -9.8469143760973e-08, -0.000576921112208274}, {-0.889550869422687, 0.000136160797527761, -6.78805814483582e-08, -9.00858307771567e-07, -9.8469143760973e-08, 5.49938542664952e-07, 0.000430074434198215}, {-4362.58709870581, 0.0775255245956248, -0.00013158719037715, -0.00197260370663974, -0.000576921112208274, 0.000430074434198215, 2.23229587481535 }} ; gsl_vector_set_all (w, 1.0); gsl_multifit_wlinear (&X.matrix, w, &y.vector, c, cov, &chisq, work); gsl_multifit_linear_residuals(&X.matrix, &y.vector, c, r); gsl_blas_ddot(r, r, &chisq_res); test_longley_results("longley gsl_multifit_wlinear", c, &exp_c.vector, NULL, NULL, chisq, chisq_res, expected_chisq); for (i = 0; i < longley_p; i++) { for (j = 0; j < longley_p; j++) { gsl_test_rel (gsl_matrix_get(cov,i,j), expected_cov[i][j], 1e-7, "longley gsl_multifit_wlinear cov(%d,%d)", i, j) ; } } gsl_vector_free(w); } gsl_vector_free(c); gsl_vector_free(r); gsl_matrix_free(cov); gsl_multifit_linear_free (work); gsl_multifit_robust_free (work_rob); } /* test_longley() */
void LowessSmoothing::smoothData(const DoubleVector & input_x, const DoubleVector & input_y, DoubleVector & smoothed_output) { if (input_x.size() != input_y.size()) { throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Sizes of x and y values not equal! Aborting... ", String(input_x.size())); } // unable to smooth over 2 or less data points (we need at least 3) if (input_x.size() <= 2) { smoothed_output = input_y; return; } Size input_size = input_y.size(); // alpha_ = 1 / ( input_size / window_size_ ); // const Size q = floor( input_size * alpha ); const Size q = (window_size_ < input_size) ? window_size_ : input_size - 1; DoubleVector distances(input_size, 0.0); DoubleVector sortedDistances(input_size, 0.0); // DoubleVector smooth_yvals_Vec(input_size); gsl_matrix * X = gsl_matrix_alloc(input_size, 3); gsl_matrix * cov = gsl_matrix_alloc(3, 3); gsl_vector * weights = gsl_vector_alloc(input_size); gsl_vector * c = gsl_vector_alloc(3); gsl_vector * x = gsl_vector_alloc(3); gsl_vector * yvals_ = gsl_vector_alloc(input_size); DoubleReal y, yErr, chisq; // Setup the model matrix X for a quadratic fit. // yvals_ = new double[input_size]; // Size idx = 0; for (Size p_idx = 0; p_idx < input_y.size(); ++p_idx) { DoubleReal rt = input_x[p_idx]; gsl_matrix_set(X, p_idx, 0, 1.0); gsl_matrix_set(X, p_idx, 1, rt); gsl_matrix_set(X, p_idx, 2, rt * rt); gsl_vector_set(yvals_, p_idx, input_y[p_idx]); // ++idx; } //for(DoubleVector::const_iterator outer_peak_it = input_y.begin(); outer_peak_it != input_y.end(); ++outer_peak_it ) for (Size outer_idx = 0; outer_idx < input_y.size(); ++outer_idx) { // Compute distances. // Size inner_idx = 0; for (Size inner_idx = 0; inner_idx < input_y.size(); ++inner_idx) { distances[inner_idx] = std::fabs(input_x[outer_idx] - input_x[inner_idx]); sortedDistances[inner_idx] = distances[inner_idx]; // ++inner_idx; } // Sort distances in order from smallest to largest. // std::sort(sortedDistances, sortedDistances + input_size); std::sort(sortedDistances.begin(), sortedDistances.end()); // Compute weights. for (Size inner_idx = 0; inner_idx < input_size; ++inner_idx) { gsl_vector_set(weights, inner_idx, tricube_(distances[inner_idx], sortedDistances[q])); } gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc(input_size, 3); gsl_multifit_wlinear(X, weights, yvals_, c, cov, &chisq, work); gsl_multifit_linear_free(work); DoubleReal rt = input_x[outer_idx]; gsl_vector_set(x, 0, 1.0); gsl_vector_set(x, 1, rt); gsl_vector_set(x, 2, rt * rt); gsl_multifit_linear_est(x, c, cov, &y, &yErr); smoothed_output.push_back(y); } gsl_matrix_free(X); gsl_vector_free(weights); gsl_vector_free(c); gsl_matrix_free(cov); return; }
/** 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); }
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() */
bool Reference::recalculateStationHeadingCurvature() { if (this->numOfPoints <= 1) { return false; } // Recalculate s for(int i = 0; i < this->numOfPoints ; i++) { if(i == 0) { this->s[0] = 0; } else { double ds = hypot(this->x[i] - this->x[i-1], this->y[i] - this->y[i-1]); this->s[i] = this->s[i-1] + ds; } } // Recalculate theta, k and dk if(this->numOfPoints < NUM_FIT_FRONT + NUM_FIT_BACK + 1) { int i = 0; for( i = 0; i < this->numOfPoints; i++) { if(i == this->numOfPoints - 1) { this->theta[i] = this->theta[i-1]; this->k[i] = 0; break; } this->theta[i] = atan2(this->y[i+1] - this->y[i], this->x[i+1] - this->x[i]); this->k[i] = 0; } } else { for(int i = 0; i < this->numOfPoints; i++) { int id0 = (i-NUM_FIT_FRONT >= 0) ? (i-NUM_FIT_FRONT):(0); int id1 = (i+NUM_FIT_BACK < this->numOfPoints) ? (i+NUM_FIT_BACK):(this->numOfPoints-1); double si, xi, yi, /*ei,*/ chisq; gsl_matrix *S, *cov; gsl_vector *x, *y, *w, *cx, *cy; int n = id1-id0+1; S = gsl_matrix_alloc (n, 3); x = gsl_vector_alloc (n); y = gsl_vector_alloc (n); w = gsl_vector_alloc (n); cx = gsl_vector_alloc (3); cy = gsl_vector_alloc (3); cov = gsl_matrix_alloc (3, 3); for (int j = 0; j < n; j++) { si = this->s[id0+j]; xi = this->x[id0+j]; yi = this->y[id0+j]; gsl_matrix_set (S, j, 0, 1.0); gsl_matrix_set (S, j, 1, si); gsl_matrix_set (S, j, 2, si*si); gsl_vector_set (x, j, xi); gsl_vector_set (y, j, yi); gsl_vector_set (w, j, 1.0); } gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc (n, 3); gsl_multifit_wlinear (S, w, x, cx, cov, &chisq, work); gsl_multifit_linear_free (work); work = gsl_multifit_linear_alloc (n, 3); gsl_multifit_wlinear (S, w, y, cy, cov, &chisq, work); gsl_multifit_linear_free (work); #define Cx(i) (gsl_vector_get(cx,(i))) #define Cy(i) (gsl_vector_get(cy,(i))) double s_ = this->s[i]; // double x_ = Cx(2) * s_ * s_ + Cx(1) * s_ + Cx(0); double xd_ = 2 * Cx(2) * s_ + Cx(1); double xdd_ = 2 * Cx(2); // double y_ = Cy(2) * s_ * s_ + Cy(1) * s_ + Cy(0); double yd_ = 2 * Cy(2) * s_ + Cy(1); double ydd_ = 2 * Cy(2); this->theta[i] = atan2(yd_, xd_); this->k[i] = (xd_ * ydd_ - yd_ * xdd_) / ( sqrt( (xd_*xd_ + yd_*yd_)*(xd_*xd_ + yd_*yd_)*(xd_*xd_ + yd_*yd_) ) ); gsl_matrix_free(S); gsl_vector_free (x); gsl_vector_free (y); gsl_vector_free (w); gsl_vector_free (cx); gsl_vector_free (cy); gsl_matrix_free (cov); } } return true; }
void test_pontius () { size_t i, j; gsl_multifit_linear_workspace * work = gsl_multifit_linear_alloc (pontius_n, pontius_p); gsl_multifit_robust_workspace * work_rob = gsl_multifit_robust_alloc (gsl_multifit_robust_ols, pontius_n, pontius_p); gsl_matrix * X = gsl_matrix_alloc (pontius_n, pontius_p); gsl_vector_view y = gsl_vector_view_array (pontius_y, pontius_n); gsl_vector * c = gsl_vector_alloc (pontius_p); gsl_vector * r = gsl_vector_alloc (pontius_n); gsl_matrix * cov = gsl_matrix_alloc (pontius_p, pontius_p); double chisq, chisq_res; double expected_c[3] = { 0.673565789473684E-03, 0.732059160401003E-06, -0.316081871345029E-14}; double expected_sd[3] = { 0.107938612033077E-03, 0.157817399981659E-09, 0.486652849992036E-16 }; double expected_chisq = 0.155761768796992E-05; gsl_vector_view diag = gsl_matrix_diagonal (cov); gsl_vector_view exp_c = gsl_vector_view_array(expected_c, pontius_p); gsl_vector_view exp_sd = gsl_vector_view_array(expected_sd, pontius_p); for (i = 0 ; i < pontius_n; i++) { for (j = 0; j < pontius_p; j++) { gsl_matrix_set(X, i, j, pow(pontius_x[i], j)); } } /* test unweighted least squares */ gsl_multifit_linear (X, &y.vector, c, cov, &chisq, work); gsl_multifit_linear_residuals(X, &y.vector, c, r); gsl_blas_ddot(r, r, &chisq_res); test_pontius_results("pontius gsl_multifit_linear", c, &exp_c.vector, &diag.vector, &exp_sd.vector, chisq, chisq_res, expected_chisq); /* test robust least squares */ gsl_multifit_robust (X, &y.vector, c, cov, work_rob); test_pontius_results("pontius gsl_multifit_robust", c, &exp_c.vector, &diag.vector, &exp_sd.vector, 1.0, 1.0, 1.0); /* test weighted least squares */ { gsl_vector * w = gsl_vector_alloc (pontius_n); double expected_cov[3][3] ={ {2.76754385964916e-01 , -3.59649122807024e-07, 9.74658869395731e-14}, {-3.59649122807024e-07, 5.91630591630603e-13, -1.77210703526497e-19}, {9.74658869395731e-14, -1.77210703526497e-19, 5.62573661988878e-26} }; gsl_vector_set_all (w, 1.0); gsl_multifit_wlinear (X, w, &y.vector, c, cov, &chisq, work); gsl_multifit_linear_residuals(X, &y.vector, c, r); gsl_blas_ddot(r, r, &chisq_res); test_pontius_results("pontius gsl_multifit_wlinear", c, &exp_c.vector, NULL, NULL, chisq, chisq_res, expected_chisq); for (i = 0; i < pontius_p; i++) { for (j = 0; j < pontius_p; j++) { gsl_test_rel (gsl_matrix_get(cov,i,j), expected_cov[i][j], 1e-10, "pontius gsl_multifit_wlinear cov(%d,%d)", i, j) ; } } gsl_vector_free(w); } gsl_vector_free(c); gsl_vector_free(r); gsl_matrix_free(cov); gsl_matrix_free(X); gsl_multifit_linear_free (work); gsl_multifit_robust_free (work_rob); }
int main() { const size_t n = 1000; /* number of observations */ const size_t p = 2; /* number of model parameters */ size_t i; gsl_rng *r = gsl_rng_alloc(gsl_rng_default); gsl_matrix *X = gsl_matrix_alloc(n, p); gsl_vector *y = gsl_vector_alloc(n); for (i = 0; i < n; ++i) { /* generate first random variable u */ double ui = 5.0 * gsl_ran_gaussian(r, 1.0); /* set v = u + noise */ double vi = ui + gsl_ran_gaussian(r, 0.001); /* set y = u + v + noise */ double yi = ui + vi + gsl_ran_gaussian(r, 1.0); /* since u =~ v, the matrix X is ill-conditioned */ gsl_matrix_set(X, i, 0, ui); gsl_matrix_set(X, i, 1, vi); /* rhs vector */ gsl_vector_set(y, i, yi); } { const size_t nL = 200; /* number of points on L-curve */ gsl_multifit_linear_workspace *w = gsl_multifit_linear_alloc(n, p); gsl_vector *c = gsl_vector_alloc(p); /* OLS solution */ gsl_vector *c_reg = gsl_vector_alloc(p); /* regularized solution */ gsl_vector *reg_param = gsl_vector_alloc(nL); gsl_vector *rho = gsl_vector_alloc(nL); /* residual norms */ gsl_vector *eta = gsl_vector_alloc(nL); /* solution norms */ double lambda; /* optimal regularization parameter */ size_t reg_idx; /* index of optimal lambda */ double chisq, rnorm, snorm; /* compute SVD of X */ gsl_multifit_linear_svd(X, w); /* unregularized (standard) least squares fit, lambda = 0 */ gsl_multifit_linear_solve(0.0, X, y, c, &rnorm, &snorm, w); chisq = pow(rnorm, 2.0); fprintf(stderr, "=== Unregularized fit ===\n"); fprintf(stderr, "best fit: y = %g u + %g v\n", gsl_vector_get(c, 0), gsl_vector_get(c, 1)); fprintf(stderr, "chisq/dof = %g\n", chisq / (n - p)); /* calculate L-curve and find its corner */ gsl_multifit_linear_lcurve(y, reg_param, rho, eta, w); gsl_multifit_linear_lcorner(rho, eta, ®_idx); /* store optimal regularization parameter */ lambda = gsl_vector_get(reg_param, reg_idx); /* output L-curve */ for (i = 0; i < nL; ++i) printf("%f %f\n", gsl_vector_get(rho, i), gsl_vector_get(eta, i)); /* output L-curve corner point */ printf("\n\n%f %f\n", gsl_vector_get(rho, reg_idx), gsl_vector_get(eta, reg_idx)); /* regularize with lambda */ gsl_multifit_linear_solve(lambda, X, y, c_reg, &rnorm, &snorm, w); chisq = pow(rnorm, 2.0) + pow(lambda * snorm, 2.0); fprintf(stderr, "=== Regularized fit ===\n"); fprintf(stderr, "optimal lambda: %g\n", lambda); fprintf(stderr, "best fit: y = %g u + %g v\n", gsl_vector_get(c_reg, 0), gsl_vector_get(c_reg, 1)); fprintf(stderr, "chisq/dof = %g\n", chisq / (n - p)); gsl_multifit_linear_free(w); gsl_vector_free(c); gsl_vector_free(c_reg); gsl_vector_free(reg_param); gsl_vector_free(rho); gsl_vector_free(eta); } gsl_rng_free(r); gsl_matrix_free(X); gsl_vector_free(y); return 0; }