slope_path.h

Go to the documentation of this file.

 
#pragma once
 
#include "slope_fit.h"
#include <Eigen/Dense>
#include <Eigen/SparseCore>
 
namespace slope {
 
class SlopePath
{
private:
  std::vector<SlopeFit> fits;
 
public:
  SlopePath() = default;
 
  SlopePath(const std::vector<SlopeFit>& fits)
    : fits{ fits }
  {
  }
 
  const SlopeFit& operator()(const size_t step) const
  {
    assert(step < fits.size());
 
    return fits[step];
  }
 
  std::vector<Eigen::VectorXd> getIntercepts(
    const bool original_scale = true) const
  {
    std::vector<Eigen::VectorXd> intercepts;
 
    for (const auto& fit : fits) {
      intercepts.emplace_back(fit.getIntercepts(original_scale));
    }
 
    return intercepts;
  }
 
  std::vector<Eigen::SparseMatrix<double>> getCoefs(
    const bool original_scale = true) const
  {
    std::vector<Eigen::SparseMatrix<double>> coefs;
 
    for (const auto& fit : fits) {
      coefs.emplace_back(fit.getCoefs(original_scale));
    }
 
    return coefs;
  }
 
  std::vector<Clusters> getClusters() const
  {
    std::vector<Clusters> clusters;
 
    for (const auto& fit : fits) {
      clusters.emplace_back(fit.getClusters());
    }
 
    return clusters;
  }
 
  Eigen::ArrayXd getAlpha() const
  {
 
    Eigen::ArrayXd alphas(fits.size());
 
    for (size_t i = 0; i < fits.size(); i++) {
      alphas(i) = fits[i].getAlpha();
    }
 
    return alphas;
  }
 
  const Eigen::ArrayXd& getLambda() const { return fits.front().getLambda(); }
 
  std::vector<double> getDeviance() const
  {
    std::vector<double> deviances;
 
    for (const auto& fit : fits) {
      deviances.emplace_back(fit.getDeviance());
    }
 
    return deviances;
  }
 
  double getNullDeviance() const { return fits.front().getNullDeviance(); }
 
  std::vector<std::vector<double>> getPrimals() const
  {
    std::vector<std::vector<double>> primals;
 
    for (const auto& fit : fits) {
      primals.emplace_back(fit.getPrimals());
    }
 
    return primals;
  }
 
  std::vector<std::vector<double>> getDuals() const
  {
    std::vector<std::vector<double>> duals;
 
    for (const auto& fit : fits) {
      duals.emplace_back(fit.getDuals());
    }
 
    return duals;
  }
 
  std::vector<std::vector<double>> getTime() const
  {
    std::vector<std::vector<double>> time;
 
    for (const auto& fit : fits) {
      time.emplace_back(fit.getTime());
    }
 
    return time;
  }
 
  std::vector<int> getPasses() const
  {
    std::vector<int> passes;
 
    for (const auto& fit : fits) {
      passes.emplace_back(fit.getPasses());
    }
 
    return passes;
  }
 
  const std::vector<double> getDevianceRatios() const
  {
    std::vector<double> ratios;
 
    for (const auto& fit : fits) {
      ratios.emplace_back(fit.getDevianceRatio());
    }
 
    return ratios;
  }
 
  std::vector<std::vector<double>> getGaps() const
  {
    std::vector<std::vector<double>> gaps;
 
    for (const auto& fit : fits) {
      gaps.emplace_back(fit.getGaps());
    }
 
    return gaps;
  }
 
  std::size_t size() const { return fits.size(); }
};
 
} // namespace slope