void compute(const QUESO::FullEnvironment& env) {
// Step 1 of 5: Instantiate the parameter space
QUESO::VectorSpace<QUESO::GslVector,QUESO::GslMatrix>
paramSpace(env, "param_", 2, NULL);
// Step 2 of 5: Instantiate the parameter domain
QUESO::GslVector paramMins(paramSpace.zeroVector());
paramMins.cwSet(-INFINITY);
QUESO::GslVector paramMaxs(paramSpace.zeroVector());
paramMaxs.cwSet( INFINITY);
QUESO::BoxSubset<QUESO::GslVector,QUESO::GslMatrix>
paramDomain("param_",paramSpace,paramMins,paramMaxs);
// Step 3 of 5: Instantiate the likelihood function object
QUESO::GslVector meanVector(paramSpace.zeroVector());
meanVector[0] = -1;
meanVector[1] = 2;
QUESO::GslMatrix covMatrix(paramSpace.zeroVector());
covMatrix(0,0) = 4.; covMatrix(0,1) = 0.;
covMatrix(1,0) = 0.; covMatrix(1,1) = 1.;
likelihoodRoutine_DataType likelihoodRoutine_Data;
likelihoodRoutine_Data.meanVector = &meanVector;
likelihoodRoutine_Data.covMatrix = &covMatrix;
QUESO::GenericScalarFunction<QUESO::GslVector,QUESO::GslMatrix>
likelihoodFunctionObj("like_",
paramDomain,
likelihoodRoutine,
(void *) &likelihoodRoutine_Data,
true); // routine computes [ln(function)]
// Step 4 of 5: Instantiate the inverse problem
QUESO::UniformVectorRV<QUESO::GslVector,QUESO::GslMatrix>
priorRv("prior_", paramDomain);
QUESO::GenericVectorRV<QUESO::GslVector,QUESO::GslMatrix>
postRv("post_", paramSpace);
QUESO::StatisticalInverseProblem<QUESO::GslVector,QUESO::GslMatrix>
ip("", NULL, priorRv, likelihoodFunctionObj, postRv);
// Step 5 of 5: Solve the inverse problem
QUESO::GslVector paramInitials(paramSpace.zeroVector());
paramInitials[0] = 0.1;
paramInitials[1] = -1.4;
QUESO::GslMatrix proposalCovMatrix(paramSpace.zeroVector());
proposalCovMatrix(0,0) = 8.; proposalCovMatrix(0,1) = 4.;
proposalCovMatrix(1,0) = 4.; proposalCovMatrix(1,1) = 16.;
ip.solveWithBayesMetropolisHastings(NULL,paramInitials, &proposalCovMatrix);
return;
}
BlackLittermanPortfolio::BlackLittermanPortfolio(Matrix priceMatrix, Matrix Q, Matrix P, double tau, double riskAversion)
{
Matrix returnMatrix(priceMatrix.numRows() - 1, priceMatrix.numColumns());
for (unsigned int assetIndex = 0; assetIndex < returnMatrix.numColumns(); ++assetIndex)
{
for (unsigned int priceIndex = 0; priceIndex < returnMatrix.numRows(); ++priceIndex)
{
returnMatrix(priceIndex, assetIndex) = priceMatrix(priceIndex + 1, assetIndex) / priceMatrix(priceIndex, assetIndex) - 1.0;
}
}
this->returnMatrix = returnMatrix;
Matrix expectedReturns(returnMatrix.numColumns(), 1);
for (unsigned int assetIndex = 0; assetIndex < returnMatrix.numColumns(); ++assetIndex)
{
for (unsigned int priceIndex = 0; priceIndex < returnMatrix.numRows(); ++priceIndex)
{
expectedReturns(assetIndex, 0) += returnMatrix(priceIndex, assetIndex);
}
}
expectedReturns = expectedReturns * (1.0 / returnMatrix.numRows());
this->expectedReturns = expectedReturns;
Matrix covMatrix(priceMatrix.numColumns(), priceMatrix.numColumns());
for (unsigned int i = 0; i < covMatrix.numRows(); ++i)
{
for (unsigned int j = i; j < covMatrix.numColumns(); ++j)
{
for (unsigned int k = 0; k < returnMatrix.numRows(); ++k)
{
covMatrix(i, j) += (returnMatrix(k, i) - expectedReturns(i, 0))*(returnMatrix(k, j) - expectedReturns(j, 0)) / (double)returnMatrix.numRows();
}
covMatrix(j, i) = covMatrix(i, j);
}
}
this->covMatrix = covMatrix;
this->P = P;
this->Q = Q;
Matrix Omega = this->P * covMatrix * this->P.transpose();
this->Omega = Omega;
this->riskAversion = riskAversion;
this->tau = tau;
this->Pi = riskAversion * this->covMatrix * this->getGobalMinimumVariancePortfolioWeights().transpose();
}
Asymmetry estimateAsymmetry(
const TH1* hist, const TH2* cov,
const char * minName = "Minuit2",
const char *algoName = "" )
{
TH1* normHist=(TH1*)hist->Clone("normHist");
TH2* normCov=(TH2*)cov->Clone("normCov");
normHist->Scale(1.0/hist->Integral());
normCov->Scale(1.0/hist->Integral()/hist->Integral());
const int N = hist->GetNbinsX();
TMatrixD covMatrix(N,N);
for (int i=0; i<N;++i)
{
for (int j=0; j<N;++j)
{
covMatrix[i][j]=normCov->GetBinContent(i+1,j+1);
}
}
TMatrixD invCovMatrix = TMatrixD(TMatrixD::kInverted,covMatrix);
ROOT::Math::Minimizer* min = ROOT::Math::Factory::CreateMinimizer(minName, algoName);
// set tolerance , etc...
min->SetMaxFunctionCalls(1000000); // for Minuit/Minuit2
min->SetMaxIterations(10000); // for GSL
min->SetTolerance(0.001);
min->SetPrintLevel(1);
//const double xx[1] = {0.5};
std::function<double(const TH1*, const TMatrixD*, const double*)> unboundFct = chi2A;
std::function<double(const double*)> boundFct = std::bind(unboundFct,normHist, &invCovMatrix, std::placeholders::_1);
//boundFct(xx);
ROOT::Math::Functor fct(boundFct,1);
min->SetFunction(fct);
min->SetVariable(0,"A",0.2, 0.01);
min->Minimize();
const double *xs = min->X();
const double *error = min->Errors();
log(INFO,"min: %f\n",xs[0]);
log(INFO,"err: %f\n",error[0]);
Asymmetry res;
res.mean=xs[0];
res.uncertainty=error[0];
return res;
}
MatrixDouble MatrixDouble::getCovarianceMatrix() const{
vector<double> mean = getMean();
MatrixDouble covMatrix(cols,cols);
for(unsigned int j=0; j<cols; j++){
for(unsigned int k=0; k<cols; k++){
covMatrix[j][k] = 0;
for(unsigned int i=0; i<rows; i++){
covMatrix[j][k] += (dataPtr[i][j]-mean[j]) * (dataPtr[i][k]-mean[k]);
}
covMatrix[j][k] /= double(rows-1);
}
}
return covMatrix;
}
MatrixFloat MatrixFloat::getCovarianceMatrix() const{
Vector<Float> mean = getMean();
MatrixFloat covMatrix(cols,cols);
for(unsigned int j=0; j<cols; j++){
for(unsigned int k=0; k<cols; k++){
covMatrix[j][k] = 0;
for(unsigned int i=0; i<rows; i++){
covMatrix[j][k] += (dataPtr[i*cols+j]-mean[j]) * (dataPtr[i*cols+k]-mean[k]);
}
covMatrix[j][k] /= Float(rows-1);
}
}
return covMatrix;
}
void
GaussianJointPdf<V,M>::distributionVariance(M & covMatrix) const
{
queso_assert_equal_to (covMatrix.numCols(), covMatrix.numRowsGlobal());
if (m_diagonalCovMatrix) {
covMatrix.zeroLower();
covMatrix.zeroUpper();
unsigned int n_comp = this->lawVarVector().sizeLocal();
queso_assert_equal_to (n_comp, covMatrix.numCols());
for (unsigned int i = 0; i < n_comp; ++i) {
covMatrix(i,i) = this->lawVarVector()[i];
}
} else {
covMatrix = *this->m_lawCovMatrix;
}
}
TMatrixD Chol (TVectorD& covV)
{
int nCov = covV.GetNrows();
int n = int((sqrt(8*nCov+1.)-1.)/2.+0.5);
if ( nCov != n*(n+1)/2. ) {
std::cout << "Chol: length of vector " << nCov << " is not n*(n+1)/2" << std::endl;
return TMatrixD();
}
// get diagonal elements
int ind(0);
TVectorD sigmas(n);
for ( int i=0; i<n; ++i ) {
for ( int j=0; j<=i; ++j ) {
if ( j == i ) sigmas[i] = covV(ind);
++ind;
}
}
// fill cov matrix (could be more elegant ...)
ind = 0;
TMatrixDSym covMatrix(n);
for ( int i=0; i<n; ++i ) {
for ( int j=0; j<=i; ++j ) {
if ( j == i )
covMatrix(i,i) = sigmas(i)*sigmas(i);
else
covMatrix(i,j) = covMatrix(j,i) = covV(ind)*sigmas(i)*sigmas(j);
++ind;
}
}
covMatrix.Print();
TDecompChol tdc(covMatrix);
bool worked = tdc.Decompose();
if ( !worked ) {
std::cout << "Decomposition failed" << std::endl;
return TMatrixD();
}
TMatrixD matU = tdc.GetU();
return matU;
// //
// // cross check with random generation
// //
// double sum0(0.);
// TVectorD sum1(n);
// TMatrixDSym sum2(n);
// TRandom2 rgen;
// TVectorD xrnd(n);
// TVectorD xrndRot(n);
// for ( unsigned int i=0; i<1000000; ++i ) {
// for ( unsigned int j=0; j<n; ++j ) xrnd(j) = 0.;
// for ( unsigned int j=0; j<n; ++j ) {
// TVectorD aux(n);
// for ( int k=0; k<n; ++k ) aux(k) = matU(j,k);
// xrnd += rgen.Gaus(0.,1.)*aux;
// }
// // xrnd *= matUT;
// sum0 += 1.;
// for ( unsigned int j0=0; j0<n; ++j0 ) {
// sum1(j0) += xrnd(j0);
// for ( unsigned int j1=0; j1<n; ++j1 ) {
// sum2(j0,j1) += xrnd(j0)*xrnd(j1);
// }
// }
// }
// for ( unsigned int j0=0; j0<n; ++j0 ) {
// printf("%10.3g",sum1(j0)/sum0);
// }
// printf(" sum1 \n");
// printf("\n");
// for ( unsigned int j0=0; j0<n; ++j0 ) {
// for ( unsigned int j1=0; j1<n; ++j1 ) {
// printf("%10.3g",sum2(j0,j1)/sum0);
// }
// printf(" sum2 \n");
// }
// return matU;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Coordinate is a struct of x,y,z
// component is the model to calculate the PCA for
// eVectors are the eigen vectors and values for the three axes
// the longest axis is in eVectors[0]
void PCA(vector<Coordinate> &component, vector<Coordinate> &eVectors, vector<float> &eValues){
int i,j,k;
/*
//find the boundary voxels
vector<Coordinate>voxels;
for (i=0; i<component.size(); i++){
int cntr=0;
for (j=0; j<component.size(); j++){
if (getDistance(component[i], component[j])<1.05)
cntr++;
}
if (cntr<7 && cntr>3)
voxels.push_back(component[i]);
}
*/
vector<Coordinate>voxels (component);
//cout<<endl<<"Number of boundary voxels: "<<voxels.size()<<endl;
//calculate the centroid
Coordinate centroid = getCentroid(voxels);
vector<Coordinate> newVoxels (voxels.size());
float covXX=0.0, covYY=0.0, covZZ=0.0, covXY=0.0, covXZ=0.0, covYZ=0.0;
for (i=0; i<voxels.size(); i++){
newVoxels[i].x = voxels[i].x-centroid.x;
newVoxels[i].y = voxels[i].y-centroid.y;
newVoxels[i].z = voxels[i].z-centroid.z;
covXX += newVoxels[i].x*newVoxels[i].x;
covYY += newVoxels[i].y*newVoxels[i].y;
covZZ += newVoxels[i].z*newVoxels[i].z;
covXY += newVoxels[i].x*newVoxels[i].y;
covXZ += newVoxels[i].x*newVoxels[i].z;
covYZ += newVoxels[i].y*newVoxels[i].z;
}
covXX /= voxels.size()-1;
covYY /= voxels.size()-1;
covZZ /= voxels.size()-1;
covXY /= voxels.size()-1;
covXZ /= voxels.size()-1;
covYZ /= voxels.size()-1;
vector<vector<float> > covMatrix(3, vector<float> (3));
covMatrix[0][0] = covXX;
covMatrix[0][1] = covXY;
covMatrix[0][2] = covXZ;
covMatrix[1][0] = covXY;
covMatrix[1][1] = covYY;
covMatrix[1][2] = covYZ;
covMatrix[2][0] = covXZ;
covMatrix[2][1] = covYZ;
covMatrix[2][2] = covZZ;
/*
//print covMatrix
cout<<"covMatrix: "<<endl;
for (i=0; i<3; i++){
for (j=0; j<3; j++)
cout<<covMatrix[i][j]<<" ";
cout<<endl;
}
*/
Jacobi J;
J.matrix.resize(3);
for (i=0; i<3; i++)
J.matrix[i].resize(3);
J.matrix = covMatrix;
J.dimen = 3;
J.eigenvalues.resize(J.dimen);
J.eigenvectors.resize(J.dimen);
J.e = 1e-8;
J.jacobi();
eValues.clear();
eValues.resize(3);
eVectors.clear();
eVectors.resize(3);
vector<vector<float> > Evector(3, vector<float> (3));
eValues = J.getEigenvalues();
Evector = J.getEigenvectors();
for (i=0; i<3; i++){
eVectors[i].x = Evector[i][0];
eVectors[i].y = Evector[i][1];
eVectors[i].z = Evector[i][2];
}
//cout<<endl<<"PCA..."<<endl;
//J.printEigen();
}
double
GPMSAEmulator<V, M>::lnValue(const V & domainVector,
const V * domainDirection,
V * gradVector,
M * hessianMatrix,
V * hessianEffect) const
{
// Components of domainVector:
// theta(1)
// theta(2)
// ...
// theta(dimParameterSpace)
// emulator_mean
// emulator_precision
// emulator_corr_strength(1)
// ...
// emulator_corr_strength(dimScenario + dimParameter)
// discrepancy_precision
// discrepancy_corr_strength(1)
// ...
// discrepancy_corr_strength(dimScenario)
// emulator_data_precision(1)
// Construct covariance matrix
unsigned int totalDim = this->m_numExperiments + this->m_numSimulations;
double prodScenario = 1.0;
double prodParameter = 1.0;
double prodDiscrepancy = 1.0;
unsigned int dimScenario = (this->m_scenarioSpace).dimLocal();
unsigned int dimParameter = (this->m_parameterSpace).dimLocal();
// This is cumbersome. All I want is a matrix.
VectorSpace<V, M> gpSpace(this->m_scenarioSpace.env(), "", totalDim, NULL);
V residual(gpSpace.zeroVector());
M covMatrix(residual);
V *scenario1;
V *scenario2;
V *parameter1;
V *parameter2;
// This for loop is a disaster and could do with a *lot* of optimisation
for (unsigned int i = 0; i < totalDim; i++) {
for (unsigned int j = 0; j < totalDim; j++) {
// Decide whether to do experiment part of the covariance matrix
// Get i-th simulation-parameter pair
if (i < this->m_numExperiments) {
// Experiment scenario (known)
scenario1 = new V(*((this->m_experimentScenarios)[i]));
// Experiment parameter (unknown)
parameter1 = new V(*((this->m_simulationParameters)[0]));
for (unsigned int k = 0; k < dimParameter; k++) {
(*parameter1)[k] = domainVector[k];
}
}
else {
scenario1 =
new V(*((this->m_simulationScenarios)[i-this->m_numExperiments]));
parameter1 =
new V(*((this->m_simulationParameters)[i-this->m_numExperiments]));
}
if (j < this->m_numExperiments) {
scenario2 = new V(*((this->m_experimentScenarios)[j]));
parameter2 = new V(*((this->m_simulationParameters)[0]));
for (unsigned int k = 0; k < dimParameter; k++) {
(*parameter2)[k] = domainVector[k];
}
}
else {
scenario2 =
new V(*((this->m_simulationScenarios)[j-this->m_numExperiments]));
parameter2 =
new V(*((this->m_simulationParameters)[j-this->m_numExperiments]));
}
// Emulator component
prodScenario = 1.0;
prodParameter = 1.0;
unsigned int emulatorCorrStrStart = dimParameter + 2;
for (unsigned int k = 0; k < dimScenario; k++) {
prodScenario *= std::pow(domainVector[emulatorCorrStrStart+k],
4.0 * ((*scenario1)[k] - (*scenario2)[k]) *
((*scenario1)[k] - (*scenario2)[k]));
}
for (unsigned int k = 0; k < dimParameter; k++) {
prodParameter *= std::pow(
domainVector[emulatorCorrStrStart+dimScenario+k],
4.0 * ((*parameter1)[k] - (*parameter2)[k]) *
((*parameter1)[k] - (*parameter2)[k]));
}
double emPrecision = domainVector[dimParameter+1];
covMatrix(i, j) = prodScenario * prodParameter /
emPrecision; // emulator precision
delete scenario1;
delete scenario2;
delete parameter1;
delete parameter2;
// If we're in the experiment cross correlation part, need extra foo
if (i < this->m_numExperiments && j < this->m_numExperiments) {
scenario1 = new V(*((this->m_simulationScenarios)[i]));
scenario2 = new V(*((this->m_simulationScenarios)[j]));
prodDiscrepancy = 1.0;
unsigned int discrepancyCorrStrStart = dimParameter +
dimParameter +
dimScenario + 3;
for (unsigned int k = 0; k < dimScenario; k++) {
prodDiscrepancy *= std::pow(domainVector[discrepancyCorrStrStart+k],
4.0 * ((*scenario1)[k] - (*scenario2)[k]) *
((*scenario1)[k] - (*scenario2)[k]));
}
covMatrix(i, j) += prodDiscrepancy /
domainVector[discrepancyCorrStrStart-1];
covMatrix(i, j) += (this->m_experimentErrors)(i, j);
delete scenario1;
delete scenario2;
}
}
// Add small white noise component to diagonal to make stuff +ve def
unsigned int dimSum = 4 +
dimParameter +
dimParameter +
dimScenario +
dimScenario; // yum
double nugget = 1.0 / domainVector[dimSum-1];
covMatrix(i, i) += nugget;
}
// Form residual = D - mean
for (unsigned int i = 0; i < this->m_numExperiments; i++) {
// Scalar so ok -- will need updating for nonscalar case
residual[i] = (*((this->m_experimentOutputs)[i]))[0];
}
for (unsigned int i = 0; i < this->m_numSimulations; i++) {
// Scalar so ok -- will need updating for nonscalar case
residual[i+this->m_numExperiments] = (*((this->m_simulationOutputs)[i]))[0];
}
// Solve covMatrix * sol = residual
V sol(covMatrix.invertMultiply(residual));
// There's no dot product function in GslVector.
double minus_2_log_lhd = 0.0;
for (unsigned int i = 0; i < totalDim; i++) {
minus_2_log_lhd += sol[i] * residual[i];
}
return -0.5 * minus_2_log_lhd;
}
void compute(const QUESO::FullEnvironment& env) {
struct timeval timevalNow;
gettimeofday(&timevalNow, NULL);
std::cout << std::endl << "Beginning run of 'Hysteretic' example at "
<< ctime(&timevalNow.tv_sec);
//------------------------------------------------------
// Step 1 of 5: Instantiate the parameter space
//------------------------------------------------------
QUESO::VectorSpace<> paramSpaceA(env, "paramA_", 1, NULL);
QUESO::VectorSpace<> paramSpaceB(env, "paramB_", 14, NULL);
QUESO::VectorSpace<> paramSpace (env, "param_", 15, NULL);
//------------------------------------------------------
// Step 2 of 5: Instantiate the parameter domain
//------------------------------------------------------
QUESO::GslVector paramMinsA(paramSpaceA.zeroVector());
paramMinsA.cwSet(0);
QUESO::GslVector paramMaxsA(paramSpaceA.zeroVector());
paramMaxsA.cwSet(5);
QUESO::BoxSubset<> paramDomainA("paramA_",paramSpaceA,paramMinsA,paramMaxsA);
QUESO::GslVector paramMinsB(paramSpaceB.zeroVector());
paramMinsB.cwSet(-INFINITY);
QUESO::GslVector paramMaxsB(paramSpaceB.zeroVector());
paramMaxsB.cwSet( INFINITY);
QUESO::BoxSubset<> paramDomainB("paramB_",paramSpaceB,paramMinsB,paramMaxsB);
QUESO::ConcatenationSubset<> paramDomain("",paramSpace,paramDomainA,paramDomainB);
//------------------------------------------------------
// Step 3 of 5: Instantiate the likelihood function object
//------------------------------------------------------
std::cout << "\tInstantiating the Likelihood; calling internally the hysteretic model"
<< std::endl;
Likelihood<> likelihood("like_", paramDomain);
likelihood.floor.resize(4,NULL);
unsigned int numTimeSteps = 401;
for (unsigned int i = 0; i < 4; ++i) {
likelihood.floor[i] = new std::vector<double>(numTimeSteps,0.);
}
likelihood.accel.resize(numTimeSteps,0.);
FILE *inp;
inp = fopen("an.txt","r");
unsigned int numObservations = 0;
double tmpA;
while (fscanf(inp,"%lf",&tmpA) != EOF) {
likelihood.accel[numObservations] = tmpA;
numObservations++;
}
numObservations=1;
FILE *inp1_1;
inp1_1=fopen("measured_data1_1.txt","r");
while (fscanf(inp1_1,"%lf",&tmpA) != EOF) {
(*likelihood.floor[0])[numObservations]=tmpA;
numObservations++;
}
numObservations=0;
FILE *inp1_2;
inp1_2=fopen("measured_data1_2.txt","r");
while (fscanf(inp1_2,"%lf",&tmpA) != EOF) {
(*likelihood.floor[1])[numObservations]=tmpA;
numObservations++;
}
numObservations=0;
FILE *inp1_3;
inp1_3=fopen("measured_data1_3.txt","r");
while (fscanf(inp1_3,"%lf",&tmpA) != EOF) {
(*likelihood.floor[2])[numObservations]=tmpA;
numObservations++;
}
numObservations=0;
FILE *inp1_4;
inp1_4=fopen("measured_data1_4.txt","r");
while (fscanf(inp1_4,"%lf",&tmpA) != EOF) {
(*likelihood.floor[3])[numObservations]=tmpA;
numObservations++;
}
//------------------------------------------------------
// Step 4 of 5: Instantiate the inverse problem
//------------------------------------------------------
std::cout << "\tInstantiating the SIP" << std::endl;
QUESO::UniformVectorRV<> priorRvA("priorA_", paramDomainA);
QUESO::GslVector meanVec(paramSpaceB.zeroVector());
QUESO::GslVector diagVec(paramSpaceB.zeroVector());
diagVec.cwSet(0.6*0.6);
QUESO::GslMatrix covMatrix(diagVec);
QUESO::GaussianVectorRV<> priorRvB("priorB_", paramDomainB,meanVec,covMatrix);
QUESO::ConcatenatedVectorRV<> priorRv("prior_", priorRvA, priorRvB, paramDomain);
QUESO::GenericVectorRV<> postRv("post_", paramSpace);
QUESO::StatisticalInverseProblem<> ip("", NULL, priorRv, likelihood, postRv);
//------------------------------------------------------
// Step 5 of 5: Solve the inverse problem
//------------------------------------------------------
std::cout << "\tSolving the SIP with Multilevel method" << std::endl;
ip.solveWithBayesMLSampling();
gettimeofday(&timevalNow, NULL);
std::cout << "Ending run of 'Hysteretic' example at "
<< ctime(&timevalNow.tv_sec) << std::endl;
return;
}
PCA&
PCA::fit( const std::vector< std::vector< double > >& data )
{
const size_t nSamples = data.size();
const size_t nFeatures = data.front().size();
// Calculate the means vector
arma::mat meansVector( nFeatures, 1 );
for ( size_t iFeature = 0; iFeature < nFeatures; ++iFeature ) {
double sx = 0;
for ( size_t iSample = 0; iSample < nSamples; ++iSample ) {
const double value = data[iSample][iFeature];
if ( std::isnan(value) )
throw std::runtime_error( "PCA::fit : nan value encountered at input!" );
sx += value;
}
meansVector(iFeature, 0) = sx / nSamples;
}
// Construct the covariance matrix from the scatter matrix
arma::mat covMatrix( nFeatures, nFeatures, arma::fill::zeros );
for ( size_t iSample = 0; iSample < nSamples; ++iSample ) {
arma::mat sampleData( data[iSample ] );
arma::mat d = sampleData - meansVector;
covMatrix += d * d.t();
}
covMatrix /= nSamples;
// Now find the eigenvalues and eigenvectors
arma::cx_vec eigval;
arma::cx_mat eigvec;
bool result = arma::eig_gen(eigval, eigvec, covMatrix );
if (! result ) {
throw std::runtime_error("PCA::fit : eigenvalue decomposition failed!");
}
// Normalise the eigenvalues
m_eigPairs.clear();
m_eigPairs.reserve( nFeatures );
double eigSum = 0;
for ( size_t iFeature = 0; iFeature < nFeatures; ++iFeature ) {
const double eigMagnitude = std::abs( eigval(iFeature) );
arma::cx_vec eigenVectorFromCalculation = eigvec.row( iFeature );
std::vector<double> eigenVector( nFeatures, 0.0 );
for (size_t j = 0; j < nFeatures; ++j ) eigenVector[j] = eigenVectorFromCalculation(j).real();
m_eigPairs.push_back( std::make_pair( eigMagnitude,
eigenVector ) );
eigSum += eigMagnitude;
}
for ( size_t iFeature = 0; iFeature < nFeatures; ++iFeature ) {
m_eigPairs[iFeature].first /= eigSum;
}
// Sort the eigenValues
std::sort( m_eigPairs.begin(), m_eigPairs.end(),
[] (const std::pair<double, std::vector<double> >&a,
const std::pair<double, std::vector<double> >&b ) { return a.first > b.first; } );
return *this;
}
