GenericOperators.h

/*
 * ########################################################################
 * The contents of this file is free and unencumbered software released into the
 * public domain. For more information, please refer to <http://unlicense.org/>
 * ########################################################################
 */
 
#ifndef BSPLINE_OPERATORS_GENERICOPERATORS_H
#define BSPLINE_OPERATORS_GENERICOPERATORS_H
 
#include <bspline/Spline.h>
 
namespace bspline::operators {
 
class Operator {};
 
template <typename O>
inline constexpr bool is_operator_v =
    std::is_base_of_v<Operator, std::remove_cv_t<std::remove_reference_t<O>>>;
 
template <typename O1, typename O2>
inline constexpr bool are_operators_v = is_operator_v<O1> &&is_operator_v<O2>;
 
template <typename T, size_t order, typename O,
          std::enable_if_t<is_operator_v<O>, bool> = true>
auto transformSpline(const O &op, const Spline<T, order> &spline) {
  constexpr size_t OUTPUT_SIZE = O::outputOrder(order) + 1;
 
  const auto &oldCoefficients = spline.getCoefficients();
 
  std::vector<std::array<T, OUTPUT_SIZE>> newCoefficients;
  newCoefficients.reserve(oldCoefficients.size());
 
  const auto &support = spline.getSupport();
 
  for (size_t i = 0; i < oldCoefficients.size(); i++) {
    const size_t absIndex = support.absoluteFromRelative(i);
    newCoefficients.push_back(
        op.transform(oldCoefficients[i], support.getGrid(), absIndex));
  }
 
  return Spline(spline.getSupport(), std::move(newCoefficients));
}
 
// ################## Generic Operator Definitions #######################
// #######################################################################
 
// #######################################################################
// ########################## IdentityOperator ##############################
 
class IdentityOperator final : public Operator {
 public:
  static constexpr size_t outputOrder(size_t inputOrder) { return inputOrder; }
 
  template <typename T, size_t size>
  std::array<T, size> transform(const std::array<T, size> &input,
                                [[maybe_unused]] const support::Grid<T> &grid,
                                [[maybe_unused]] size_t intervalIndex) const {
    return input;
  }
};
 
template <typename O, typename S,
          std::enable_if_t<is_operator_v<O> && is_spline_v<S>, bool> = true>
auto operator*(const O &o, const S &s) {
  return transformSpline(o, s);
}
}  // namespace bspline::operators
#endif  // BSPLINE_OPERATORS_GENERICOPERATORS_H