math.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <proxsuite-nlp/math.hpp>
 
#define ALIGATOR_DYNAMIC_TYPEDEFS(Scalar) PROXSUITE_NLP_DYNAMIC_TYPEDEFS(Scalar)
 
#define ALIGATOR_DYNAMIC_TYPEDEFS_WITH_ROW_TYPES(Scalar)                       \
  ALIGATOR_DYNAMIC_TYPEDEFS(Scalar);                                           \
  using RowMatrixXs = typename Eigen::Transpose<MatrixXs>::PlainObject;        \
  using RowMatrixRef = Eigen::Ref<RowMatrixXs>;                                \
  using ConstRowMatrixRef = Eigen::Ref<const RowMatrixXs>
 
namespace aligator {
 
// NOLINTBEGIN(misc-unused-using-decls)
using proxsuite::nlp::math_types;
// NOLINTEND(misc-unused-using-decls)
 
template <typename D>
auto eigenPrintWithPreamble(const Eigen::EigenBase<D> &mat,
                            const std::string &text) {
  Eigen::IOFormat ft = EIGEN_DEFAULT_IO_FORMAT;
  ft.matPrefix = text;
  ft.rowSpacer = "";
  int i = int(text.length()) - 1;
  while (i >= 0) {
    if (text[size_t(i)] != '\n')
      ft.rowSpacer += ' ';
    i--;
  }
  return mat.derived().format(ft);
}
 
namespace math {
 
// NOLINTBEGIN(misc-unused-using-decls)
using proxsuite::nlp::math::check_scalar;
using proxsuite::nlp::math::check_value;
using proxsuite::nlp::math::infty_norm;
using proxsuite::nlp::math::scalar_close;
// NOLINTEND(misc-unused-using-decls)
 
template <typename T> bool check_value(const std::vector<T> &xs) {
  const std::size_t n = xs.size();
  for (std::size_t i = 0; i < n; i++) {
    if (check_value<T>(xs[i]))
      return true;
  }
  return false;
}
 
template <typename T> void setZero(std::vector<T> &mats) {
  for (std::size_t i = 0; i < mats.size(); i++) {
    mats[i].setZero();
  }
}
 
template <typename A, typename B, typename OutType, typename Scalar>
void vectorMultiplyAdd(const std::vector<A> &a, const std::vector<B> &b,
                       std::vector<OutType> &c, const Scalar alpha) {
  assert(a.size() == b.size());
  assert(a.size() == c.size());
  const std::size_t N = a.size();
  for (std::size_t i = 0; i < N; i++) {
    c[i] = a[i] + alpha * b[i];
  }
}
 
} // namespace math
} // namespace aligator