wrapper.h

Go to the documentation of this file.

#ifndef SOPT_WRAP
#define SOPT_WRAP
 
#include <array>
#include <type_traits>
#include <utility> // for std::move<>
 
#include "sopt/config.h"
#include "sopt/exception.h"
#include "sopt/maths.h"
#include "sopt/types.h"
 
namespace sopt::details {
template <typename FUNCTION, typename DERIVED>
class AppliedFunction : public Eigen::ReturnByValue<AppliedFunction<FUNCTION, DERIVED>> {
 public:
  using PlainObject = typename DERIVED::PlainObject;
  using Index = typename DERIVED::Index;
 
  AppliedFunction(FUNCTION const &func, DERIVED const &x, Index rows)
      : func(func), x(x), rows_(rows) {}
  AppliedFunction(FUNCTION const &func, DERIVED const &x) : func(func), x(x), rows_(x.rows()) {}
  AppliedFunction(AppliedFunction const &c) : func(c.func), x(c.x), rows_(c.rows_) {}
  AppliedFunction(AppliedFunction &&c) : func(std::move(c.func)), x(c.x), rows_(c.rows_) {}
 
  template <typename DESTINATION>
  void evalTo(DESTINATION &destination) const {
    func(destination, x);
  }
 
  Index rows() const { return rows_; }
  Index cols() const { return x.cols(); }
 
 private:
  FUNCTION const func;
  DERIVED const &x;
  Index const rows_;
};
 
template <typename VECTOR>
class WrapFunction {
 public:
  using t_Function = OperatorFunction<VECTOR>;
 
  WrapFunction(t_Function const &func, std::array<t_int, 3> sizes = {{1, 1, 0}})
      : func(func), sizes_(sizes) {
    // cannot devide by zero
    assert(sizes_[1] != 0);
  }
  WrapFunction(WrapFunction const &c) : func(c.func), sizes_(c.sizes_) {}
  WrapFunction(WrapFunction const &&c) : func(std::move(c.func)), sizes_(std::move(c.sizes_)) {}
  void operator=(WrapFunction const &c) {
    func = c.func;
    sizes_ = c.sizes_;
  }
  void operator=(WrapFunction &&c) {
    func = std::move(c.func);
    sizes_ = std::move(c.sizes_);
  }
 
  template <typename T0>
  AppliedFunction<t_Function const &, Eigen::ArrayBase<T0>> operator()(
      Eigen::ArrayBase<T0> const &x) const {
    return AppliedFunction<t_Function const &, Eigen::ArrayBase<T0>>(func, x, rows(x));
  }
 
  template <typename T0>
  AppliedFunction<t_Function const &, Eigen::ArrayBase<T0>> operator*(
      Eigen::ArrayBase<T0> const &x) const {
    return AppliedFunction<t_Function const &, Eigen::ArrayBase<T0>>(func, x, rows(x));
  }
 
  template <typename T0>
  AppliedFunction<t_Function const &, Eigen::MatrixBase<T0>> operator()(
      Eigen::MatrixBase<T0> const &x) const {
    return AppliedFunction<t_Function const &, Eigen::MatrixBase<T0>>(func, x, rows(x));
  }
 
  template <typename T0>
  AppliedFunction<t_Function const &, Eigen::MatrixBase<T0>> operator*(
      Eigen::MatrixBase<T0> const &x) const {
    return AppliedFunction<t_Function const &, Eigen::MatrixBase<T0>>(func, x, rows(x));
  }
 
  std::array<t_int, 3> const &sizes() const { return sizes_; }
 
  template <typename T>
  typename std::enable_if<std::is_integral<T>::value, T>::type rows(T xsize) const {
    auto const result = (static_cast<t_int>(xsize) * sizes_[0]) / sizes_[1] + sizes_[2];
    assert(result >= 0);
    return static_cast<T>(result);
  }
 
 protected:
  template <typename T>
  t_uint rows(Eigen::DenseBase<T> const &x) const {
    return rows(x.size());
  }
 
 private:
  t_Function func;
  std::array<t_int, 3> sizes_;
};
 
template <typename VECTOR>
WrapFunction<VECTOR> wrap(OperatorFunction<VECTOR> const &func,
                          std::array<t_int, 3> sizes = {{1, 1, 0}}) {
  return WrapFunction<VECTOR>(func, sizes);
}
} // namespace sopt::details
 
namespace Eigen::internal {
template <typename FUNCTION, typename VECTOR>
struct traits<sopt::details::AppliedFunction<FUNCTION, VECTOR>> {
  using ReturnType = typename VECTOR::PlainObject;
};
} // namespace Eigen::internal
#endif