ScalarOperators.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_SCALAROPERATORS_H
#define BSPLINE_OPERATORS_SCALAROPERATORS_H
 
#include <bspline/Spline.h>
#include <bspline/operators/CompoundOperators.h>
 
namespace bspline::operators {
 
template <typename T, typename O>
inline constexpr bool are_scalar_multiplication_types_v =
    !is_spline_v<T> && !is_operator_v<T> && is_operator_v<O>;
 
template <typename S, typename O,
          std::enable_if_t<are_scalar_multiplication_types_v<S, O>, bool> =
              true>
class ScalarMultiplication final : public Operator {
 private:
  S _s;
  O _o;
 
 public:
  ScalarMultiplication(S s, O o) : _s(std::move(s)), _o(std::move(o)){};
 
  ScalarMultiplication(S s) : _s(s), _o(O{}){};
 
  static constexpr size_t outputOrder(size_t inputOrder) {
    return O::outputOrder(inputOrder);
  }
 
  template <typename T, size_t size>
  auto transform(const std::array<T, size> &input, const support::Grid<T> &grid,
                 size_t intervalIndex) const {
    auto a = _o.transform(input, grid, intervalIndex);
 
    // Multiply a.
    for (T &el : a) {
      el *= static_cast<T>(_s);
    }
    return a;
  }
};
 
template <typename S>
ScalarMultiplication(S s) -> ScalarMultiplication<S, IdentityOperator>;
 
template <
    typename S, typename O,
    std::enable_if_t<are_scalar_multiplication_types_v<S, O>, bool> = true>
ScalarMultiplication<S, O> operator*(const S &s, O &&o) {
  return ScalarMultiplication(s, std::forward<O>(o));
}
 
template <
    typename S, typename O,
    std::enable_if_t<are_scalar_multiplication_types_v<S, O>, bool> = true>
ScalarMultiplication<S, O> operator*(O &&o, const S &s) {
  return ScalarMultiplication(s, std::forward<O>(o));
}
 
template <
    typename S, typename O,
    std::enable_if_t<are_scalar_multiplication_types_v<S, O>, bool> = true>
ScalarMultiplication<S, O> operator/(O &&o, const S &s) {
  return ScalarMultiplication(static_cast<S>(1) / s, std::forward<O>(o));
}
 
template <
    typename S, typename O,
    std::enable_if_t<are_scalar_multiplication_types_v<S, O>, bool> = true>
auto operator+(O &&o, const S &s) {
  return std::forward<O>(o) + ScalarMultiplication{s};
}
 
template <
    typename S, typename O,
    std::enable_if_t<are_scalar_multiplication_types_v<S, O>, bool> = true>
auto operator+(const S &s, O &&o) {
  return ScalarMultiplication{s} + std::forward<O>(o);
}
 
template <
    typename S, typename O,
    std::enable_if_t<are_scalar_multiplication_types_v<S, O>, bool> = true>
auto operator-(O &&o, const S &s) {
  return std::forward<O>(o) - ScalarMultiplication{s};
}
 
template <
    typename S, typename O,
    std::enable_if_t<are_scalar_multiplication_types_v<S, O>, bool> = true>
auto operator-(const S &s, O &&o) {
  return ScalarMultiplication{s} - std::forward<O>(o);
}
 
template <typename O, std::enable_if_t<is_operator_v<O>, bool> = true>
ScalarMultiplication<int, O> operator-(O &&o) {
  return ScalarMultiplication<int, O>(-1, std::forward<O>(o));
}
}  // namespace bspline::operators
#endif  // BSPLINE_OPERATORS_SCALAROPERATORS_H