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 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_);
}
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;
}
//--------------------------------------------------------------
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);
}
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);
}
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;
}
sonar_quadfit::sonar_quadfit(int nn)
{
n=nn; //n needs to be odd!!!
if(n%2 == 0) //if not odd, at least reduce it to something better
{
cerr<<"n = "<<n<<", which is not odd in quadfit!";
n=n-1;
}
workspace = gsl_multifit_linear_alloc(n, 3);
X = gsl_matrix_alloc(n, 3);
for(int k=0;k<n; k++)
gsl_matrix_set(X,k,0,1); //it is 1 for all cases
c = gsl_vector_alloc(3);
cov = gsl_matrix_alloc(3, 3);
chisq = new double;
}
/*
* 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;
}
void MlSldaState::InitializeRegression() {
regression_space_.space_.reset
(gsl_multifit_linear_alloc(corpus_->num_train(), num_topics_),
gsl_multifit_linear_free);
regression_space_.covariance_.reset(gsl_matrix_alloc(num_topics_,
num_topics_),
gsl_matrix_free);
regression_space_.x_.reset(gsl_matrix_alloc(corpus_->num_train(),
num_topics_),
gsl_matrix_free);
// This initialization of chi_quared_ makes it so the first estimator of
// sigma_squared_ is 1.0
regression_space_.chi_squared_ = corpus_->num_train() - num_topics_;
nu_.reset(gsl_vector_alloc(num_topics_));
double increment = 2.0 / (double)num_topics_;
double current_nu = -1.0;
for (int ii = 0; ii < num_topics_; ++ii) {
gsl_vector_set(nu_.get(), ii, current_nu);
current_nu += increment;
}
sigma_squared_ = FLAGS_variance;
}
void linfit_order(int order, int n, float *x, float *y, float *w, float **params) {
int i,j;
double chisq;
gsl_matrix *X, *cov;
gsl_vector *Y, *W, *c;
gsl_multifit_linear_workspace *work;
X = gsl_matrix_alloc(n, order);
Y = gsl_vector_alloc(n);
W = gsl_vector_alloc(n);
c = gsl_vector_alloc(order);
cov = gsl_matrix_alloc(order, order);
for (i=0; i<n; i++) {
for (j=0; j<order; j++) {
gsl_matrix_set(X, i, j, pow((double)x[i], (double)j));
}
gsl_vector_set(Y, i, (double)y[i]);
gsl_vector_set(W, i, (double)w[i]);
}
work = gsl_multifit_linear_alloc(n, order);
gsl_multifit_wlinear(X, W, Y, c, cov, &chisq, work);
*params = malloc(order * sizeof(float));
for (j=0; j<order; j++) {
(*params)[j] = (float)(gsl_vector_get(c, j));
}
gsl_matrix_free(X);
gsl_vector_free(Y);
gsl_vector_free(W);
gsl_vector_free(c);
gsl_matrix_free(cov);
}
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_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 (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() */
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;
}
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;
}
// ${LSHKIT_HOME}/tools/fitdata.cpp
void fitdata_example()
{
const std::string data_file("./data/search_algorithm/lshkit/audio.data");
const unsigned N = 0; // number of points to use.
const unsigned P = 50000; // number of pairs to sample.
unsigned Q = 1000; // number of queries to sample.
unsigned K = 100; // search for K nearest neighbors.
const unsigned F = 10; // divide the sample to F folds.
// load matrix.
lshkit::Matrix<float> data(data_file);
std::vector<unsigned> idx(data.getSize());
for (unsigned i = 0; i < idx.size(); ++i) idx[i] = i;
random_shuffle(idx.begin(), idx.end());
if (N > 0 && N < data.getSize()) idx.resize(N);
lshkit::metric::l2sqr<float> l2sqr(data.getDim());
lshkit::DefaultRng rng;
boost::variate_generator<lshkit::DefaultRng &, lshkit::UniformUnsigned> gen(rng, lshkit::UniformUnsigned(0, idx.size()-1));
double gM = 0.0;
double gG = 0.0;
{
// sample P pairs of points
for (unsigned k = 0; k < P; ++k)
{
double dist, logdist;
for (;;)
{
unsigned i = gen();
unsigned j = gen();
if (i == j) continue;
dist = l2sqr(data[idx[i]], data[idx[j]]);
logdist = std::log(dist);
if (local::is_good_value(logdist)) break;
}
gM += dist;
gG += logdist;
}
gM /= P;
gG /= P;
gG = std::exp(gG);
}
if (Q > idx.size()) Q = idx.size();
if (K > idx.size() - Q) K = idx.size() - Q;
// sample query.
std::vector<unsigned> qry(Q);
lshkit::SampleQueries(&qry, idx.size(), rng);
// do the queries.
std::vector<lshkit::Topk<unsigned> > topks(Q);
for (unsigned i = 0; i < Q; ++i) topks[i].reset(K);
/* ... */
gsl_matrix *X = gsl_matrix_alloc(F * K, 3);
gsl_vector *yM = gsl_vector_alloc(F * K);
gsl_vector *yG = gsl_vector_alloc(F * K);
gsl_vector *pM = gsl_vector_alloc(3);
gsl_vector *pG = gsl_vector_alloc(3);
gsl_matrix *cov = gsl_matrix_alloc(3,3);
std::vector<double> M(K);
std::vector<double> G(K);
boost::progress_display progress(F, std::cerr);
unsigned m = 0;
for (unsigned l = 0; l < F; l++)
{
// Scan
for (unsigned i = l; i< idx.size(); i += F)
{
for (unsigned j = 0; j < Q; j++)
{
int id = qry[j];
if (i != id)
{
float d = l2sqr(data[idx[id]], data[idx[i]]);
if (local::is_good_value(std::log(double(d)))) topks[j] << lshkit::Topk<unsigned>::Element(i, d);
}
}
}
std::fill(M.begin(), M.end(), 0.0);
std::fill(G.begin(), G.end(), 0.0);
for (unsigned i = 0; i < Q; i++)
{
for (unsigned k = 0; k < K; k++)
{
M[k] += topks[i][k].dist;
G[k] += std::log(topks[i][k].dist);
}
}
for (unsigned k = 0; k < K; k++)
{
M[k] = std::log(M[k]/Q);
G[k] /= Q;
gsl_matrix_set(X, m, 0, 1.0);
gsl_matrix_set(X, m, 1, std::log(double(data.getSize() * (l + 1)) / double(F)));
gsl_matrix_set(X, m, 2, std::log(double(k + 1)));
gsl_vector_set(yM, m, M[k]);
gsl_vector_set(yG, m, G[k]);
++m;
}
++progress;
}
gsl_multifit_linear_workspace *work = gsl_multifit_linear_alloc(F * K, 3);
double chisq;
gsl_multifit_linear(X, yM, pM, cov, &chisq, work);
gsl_multifit_linear(X, yG, pG, cov, &chisq, work);
std::cout << gM << '\t' << gG << std::endl;
std::cout << gsl_vector_get(pM, 0) << '\t'
<< gsl_vector_get(pM, 1) << '\t'
<< gsl_vector_get(pM, 2) << std::endl;
std::cout << gsl_vector_get(pG, 0) << '\t'
<< gsl_vector_get(pG, 1) << '\t'
<< gsl_vector_get(pG, 2) << std::endl;
gsl_matrix_free(X);
gsl_matrix_free(cov);
gsl_vector_free(pM);
gsl_vector_free(pG);
gsl_vector_free(yM);
gsl_vector_free(yG);
}
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;
}
/** 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);
}
