CovarianceMatrix.h

Go to the documentation of this file.

/********************************************************************
 *  Copyright (C) 2014 by Federico Marulli and Alfonso Veropalumbo  *
 *  federico.marulli3@unibo.it                                      *
 *                                                                  *
 *  This program is free software; you can redistribute it and/or   *
 *  modify it under the terms of the GNU General Public License as  *
 *  published by the Free Software Foundation; either version 2 of  *
 *  the License, or (at your option) any later version.             *
 *                                                                  *
 *  This program is distributed in the hope that it will be useful, *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of  *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   *
 *  GNU General Public License for more details.                    *
 *                                                                  *
 *  You should have received a copy of the GNU General Public       *
 *  License along with this program; if not, write to the Free      *
 *  Software Foundation, Inc.,                                      *
 *  59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.       *
 ********************************************************************/
 
#ifndef __COVMAT__
#define __COVMAT__
 
#include "Func.h"
 
namespace cbl {
 
  namespace data {
 
     
    class CovarianceMatrix
    {
      
    protected:
 
      size_t m_order;
 
      Eigen::MatrixXd m_matrix;
      
      Eigen::MatrixXd m_precision;
      
      Eigen::MatrixXd m_correlation;
 
      Eigen::VectorXd m_variance;
 
      Eigen::VectorXd m_std;
      
      double m_determinant;
 
      // the covariance is measured from multiple dataset
      double m_hartlap_factor;
 
      void m_set_default ();
 
      virtual void m_set (const std::vector<double> matrix, const double nmeasures=-1, const double prec=1.e-10);
 
      inline double hartlap_factor (const double order, const double nmeasures=-1) { return (nmeasures>1) ? 1-(order+1)/(nmeasures-1) : 1; }
 
    public:
 
 
      CovarianceMatrix () { m_set_default(); }
      
      CovarianceMatrix (std::vector<std::vector<double>> covariance_matrix, const double nmeasures=-1, const double prec=1.e-10) 
      { set_from_matrix(covariance_matrix, nmeasures, prec); }
 
      CovarianceMatrix (std::vector<double> standard_deviation, const double nmeasures=-1)
      {set_from_standard_deviation(standard_deviation, nmeasures);}
 
      CovarianceMatrix (const std::string filename, const int cov_col=2, const int skipped_lines=0, const double nmeasures=-1, const double prec=1.e-10) 
      {read(filename, cov_col, skipped_lines, prec, nmeasures); }
 
 
      virtual ~CovarianceMatrix () = default;
 
 
 
      double operator() (const int i, const int j) const {return m_matrix(i, j);}
 
      std::vector<std::vector<double>> operator() () const;
      
      double correlation (const int i, const int j) const {return m_correlation(i, j);}
 
      std::vector<std::vector<double>> correlation () const;
      
      double precision (const int i, const int j) const {return m_precision(i, j);} 
 
      std::vector<std::vector<double>> precision () const; 
      
      double determinant () const {return m_determinant;}; 
 
      double precision_hartlap (const int i, const int j) const {return m_hartlap_factor*m_precision(i, j);} 
 
      std::vector<std::vector<double>> precision_hartlap () const; 
 
       double standard_deviation (const int i) const { return m_std(i); }
 
      std::vector<double> standard_deviation () const;
 
      double variance (const int i) const { return m_variance(i); }
 
      std::vector<double> variance () const;
 
      size_t order () const { return m_order; }
 
      
 
      
      void set_from_matrix (const std::vector<std::vector<double>> covariance, const double nmeasures=-1, const double prec=1.e-10) 
      { m_set(cbl::flatten(covariance), nmeasures, prec); }
 
      void set_from_standard_deviation (const std::vector<double> standard_deviation, const double nmeasures=-1);
 
      void measure (const std::vector<std::shared_ptr<Data>> dataset, const double normalization=1, const double prec=1.e-10);
 
      void measure (const std::vector<std::vector<std::shared_ptr<Data>>> dataset, const double normalization=1, const double prec=1.e-10);
      
 
 
      void read (const std::string filename, const int cov_col=2, const int skipped_lines=0, const double nmeasures=-1, const double prec=1.e-10);
      
      void write (const std::string dir, const std::string file, const int precision=4, const int rank=0) const;
 
      
 
      CovarianceMatrix cut (const std::vector<bool> mask) const;
 
 
      
      CovarianceMatrix operator += (const CovarianceMatrix covariance) const;
 
      CovarianceMatrix operator += (const std::shared_ptr<CovarianceMatrix> covariance) const;
 
      CovarianceMatrix operator += (const std::vector<CovarianceMatrix> covariance) const;
 
      CovarianceMatrix operator += (const std::vector<std::shared_ptr<CovarianceMatrix>> covariance) const;
 
      
      
    };
 
 
  }
}
 
#endif