utils.h

Go to the documentation of this file.

 
#pragma once
 
#include <Eigen/Core>
#include <Eigen/SparseCore>
#include <algorithm>
#include <numeric>
#include <set>
#include <string>
#include <unordered_set>
#include <vector>
 
namespace slope {
 
template<typename T>
void
sort(T& v, const bool descending = false)
{
  if (descending) {
    std::sort(v.data(), v.data() + v.size(), std::greater<double>());
  } else {
    std::sort(v.data(), v.data() + v.size(), std::less<double>());
  }
}
 
template<typename T>
std::vector<int>
which(const T& x)
{
  std::vector<int> out;
  for (int i = 0; i < x.size(); i++) {
    if (x[i]) {
      out.emplace_back(i);
    }
  }
 
  return out;
}
 
template<typename T>
std::vector<int>
sortIndex(T& v, const bool descending = false)
{
  using namespace std;
 
  vector<int> idx(v.size());
  iota(idx.begin(), idx.end(), 0);
 
  if (descending) {
    sort(idx.begin(), idx.end(), [&v](int i, int j) { return v[i] > v[j]; });
  } else {
    sort(idx.begin(), idx.end(), [&v](int i, int j) { return v[i] < v[j]; });
  }
 
  return idx;
}
 
template<typename T>
void
permute(T& values, const std::vector<int>& ind)
{
  T out(values.size());
 
  for (int i = 0; i < values.size(); ++i)
    out[i] = std::move(values[ind[i]]);
 
  values = std::move(out);
}
 
template<typename T>
void
inversePermute(T& values, const std::vector<int>& ind)
{
  T out(values.size()); 
  for (int i = 0; i < values.size(); ++i)
    out[ind[i]] = std::move(values[i]);
 
  values = std::move(out);
}
 
template<typename T>
void
move_elements(std::vector<T>& v, const int from, const int to, const int size)
{
  if (from > to) {
    std::rotate(v.begin() + to, v.begin() + from, v.begin() + from + size);
  } else {
    std::rotate(v.begin() + from, v.begin() + from + size, v.begin() + to + 1);
  }
}
 
void
validateOption(const std::string& value,
               const std::set<std::string>& valid_options,
               const std::string& parameter_name);
 
Eigen::MatrixXd
subset(const Eigen::MatrixXd& x, const std::vector<int>& indices);
 
Eigen::SparseMatrix<double>
subset(const Eigen::SparseMatrix<double>& x, const std::vector<int>& indices);
 
template<typename MatrixType>
Eigen::MatrixXd
subsetCols(const MatrixType& x, const std::vector<int>& indices)
{
  if (indices.empty()) {
    return Eigen::MatrixXd(x.rows(), 0);
  }
 
  Eigen::MatrixXd result(x.rows(), indices.size());
  for (size_t i = 0; i < indices.size(); ++i) {
    result.col(i) = x.col(indices[i]);
  }
  return result;
}
 
inline std::unordered_set<double>
unique(const Eigen::MatrixXd& x)
{
  std::unordered_set<double> unique;
  for (Eigen::Index j = 0; j < x.cols(); j++) {
    for (Eigen::Index i = 0; i < x.rows(); i++) {
      unique.insert(x(i, j));
    }
  }
 
  return unique;
}
 
} // namespace slope