I highlighted in bold the remarks of most interest to boost users. The rest just shows you what I have done, and provides the context in which my problem arises.

I commented out the problem code below, in an effort to determine why the core dump happened, only to see another problem, with the execution path not even entering my regressionPCA constructor.

My program is short and simple, designed to test my PCA regression class. My basicGenerator, declared in data.generator.h, is already known to work flawlessly. This program is the unti test for my regressionPCA class.

#include <iostream>

#include <vector>

#include "data.generator.h"

#include "reg.class.h"

int main(int argc, char* argv[]) {

std::cout << "Flag A" << std::endl;

basicGenerator bg;

std::cout << "Sample size: " << bg.get_sampleSize() << std::endl;

bg.makeData();

std::cout << "Flag B" << std::endl;

std::vector<std::vector<double> > x;

std::vector<double> y;

bg.getDataForRegression(x,y);

unsigned int imax = y.size();

for (unsigned int i = 0 ; i < imax ; i++) {

std::cout << i << "\t" << y[i] << "\t" << x[i][0] << "\t" << x[i][1] << std::endl;

}

std::cout << "Flag C" << std::endl;

regressionPCA rpca(x,y);

return 0;

}

Here is the tail end of the output it produces:

89 0.416356 0.565407 -0.114605

90 -0.258883 -0.585597 -0.183372

91 0.833355 0.914344 0.81171

92 -0.0338814 -0.00264442 -0.118973

93 1.13764 0.41599 1.33175

94 -1.86323 -1.90867 -1.35118

95 0.907604 1.14917 0.621669

96 2.1166 1.06194 1.1703

97 0.159543 0.14446 -0.665135

98 -0.508617 -0.370597 -0.703225

99 2.69086 2.75267 1.40633

Flag C

Ted@Ted-acer-i7w7 ~/New.System/tests

As you can see, the last output is from the flag I set immediately before creating my instance of regressionPCA on the stack.

Here is the declaration of that class.

#ifndef REG_CLASS_H

#define REG_CLASS_H

#include <iosfwd>

#include <vector>

//#include <boost/smart_ptr/shared_array.hpp>

#include <gsl/gsl_linalg.h>

class regressionPCA {

private:

unsigned int nrows, ncols;

// boost::shared_array<double> B, Y, U, V, S;

regressionPCA(void) {}; // makes default construction impossible

public:

regressionPCA(const std::vector<std::vector<double> >&, const std::vector<double>&);

void Reset(const std::vector<std::vector<double> >&, const std::vector<double>&);

inline void setNrows(unsigned int v) { nrows = v;};

inline void setNcols(unsigned int v) { ncols = v;};

inline unsigned int getNrows(void) const { return nrows; };

inline unsigned int getNcols(void) const { return ncols; };

};

#endif

Please note that instead of just dying without producing output, the program died most ungracefully with a core dump when I included boost's shared_array. I have no idea why.

Here is the implementation of the regressionPCA class:

#include "reg.class.h"

#include <iostream>

#include <algorithm>

#include <gsl/gsl_linalg.h>

regressionPCA::regressionPCA(const std::vector<std::vector<double> >&data,

const std::vector<double>& Ydata) {

std::cout << "Flag ALPHA" << std::endl;

Reset(data,Ydata);

}

void regressionPCA::Reset(const std::vector<std::vector<double> >&data,

const std::vector<double>& Ydata) {

unsigned int r(0),c(0),n(0);

std::cout << "r: " << r << "\tc: " << c << "\tn: " << n << std::endl;

c = data.size();

std::cout << "r: " << r << "\tc: " << c << "\tn: " << n << std::endl;

r = data[0].size();

std::cout << "r: " << r << "\tc: " << c << "\tn: " << n << std::endl;

setNrows(r);

setNcols(c);

n = r * c;

std::cout << "r: " << r << "\tc: " << c << "\tn: " << n << std::endl;

double* B = new double[c];

double* Y = new double[r];

double* U = new double[n];

double* V = new double[c*c];

double* S = new double[c];

/* boost::shared_array<double> B(new double[c]),

boost::shared_array<double> B(new double[c]),

Y(new double[r]),

U(new double[n]),

V(new double[c*c]),

S(new double[c]);

B = Btmp;

Y = Ytmp;

U = Utmp;

V = Vtmp;

S = Stmp;*/

double *bptr = U.get();

std::cout << "Flag1" << std::endl;

std::vector<std::vector<double> >::const_iterator it = data.begin(), end = data.end();

while (it != end) {

bptr = std::copy(it->begin(), it->end(),bptr);

++it;

}

std::cout << "Flag2" << std::endl;

bptr = Y.get();

std::copy(Ydata.begin(),Ydata.end(),bptr);

gsl_matrix_view Um = gsl_matrix_view_array(U.get(), getNrows(), getNcols());

gsl_matrix_view Ym = gsl_vector_view_array(Y.get(), getNrows());

gsl_matrix_view Bm = gsl_vector_view_array(B.get(), getNcols());

gsl_matrix_view Sm = gsl_vector_view_array(S.get(), getNcols());

gsl_matrix_view Vm = gsl_matrix_view_array(U.get(), getNcols(), getNcols());

std::cout << "Flag3" << std::endl;

gsl_linalg_SV_decomp_jacobi(Um,Vm,Sm);

std::cout << "Flag4" << std::endl;

gsl_linalg_SV_solve(Um,Vm,Sm,Ym,Bm);

std::cout << std::endl << std::endl << "Sv = " << gsl_vector_get(Sm,0) << "\t" << gsl_vector_get(Sm,1) << std::endl;

std::cout << std::endl << std::endl << "V = " << std::endl;

std::cout << "\t" << gsl_matrix_get(Vm,0,0) << "\t" << gsl_matrix_get(Vm,0,1) << std::endl;

std::cout << "\t" << gsl_matrix_get(Vm,1,0) << "\t" << gsl_matrix_get(Vm,1,1) << std::endl;

std::cout << std::endl << std::endl << "Beta = " << gsl_vector_get(Bm,0) << "\t" << gsl_vector_get(Bm,1) << std::endl;

};

Note, I know the execution path does not get into the constructor becuase the line "std::cout << "Flag ALPHA" << std::endl;" does not produce output.

So, a couple mysteries.

1) Why does merely including boost's shared_array cause a core dump?

2) when I resort to naked array pointers (yes, I know about the memory leak, but that is the least of my troubles right now, and I would have avoided that had boost's shared array worked for me), why does execution not enter my constructor?

Any insights would be appreciated.

BTW: If you notice me doing something silly with GSL, I'd appreciate knowing about it, even though my problems do not appear to be related to GSL.