operators.h

#ifndef COTILA_MATRIX_OPERATORS_H_
#define COTILA_MATRIX_OPERATORS_H_

#include <cotila/vector/vector.h>

namespace cotila {

template <typename T, std::size_t N, std::size_t M>
constexpr bool operator==(const matrix<T, N, M> &a,
                          const matrix<T, N, M> &b) {
  for (std::size_t i = 0; i < N; ++i) {
    for (std::size_t j = 0; j < M; ++j) {
      if (a[i][j] != b[i][j])
        return false;
    }
  }
  return true;
}

template <typename T, std::size_t N, std::size_t M>
constexpr bool operator!=(const matrix<T, N, M> &a,
                          const matrix<T, N, M> &b) {
  return !(a == b);
}

template <typename T, std::size_t N, std::size_t M>
constexpr matrix<T, N, M> operator+(const matrix<T, N, M> &m, T a) {
  return elementwise([a](T x) { return x + a; }, m);
}

template <typename T, std::size_t N, std::size_t M>
constexpr matrix<T, N, M> operator+(T a, const matrix<T, N, M> &m) {
  return elementwise([a](T x) { return a + x; }, m);
}

template <typename T, std::size_t N, std::size_t M>
constexpr matrix<T, N, M> operator+(const matrix<T, N, M> &a,
                                    const matrix<T, N, M> &b) {
  return elementwise(std::plus<T>(), a, b);
}

template <typename T, std::size_t N, std::size_t M>
constexpr matrix<T, N, M> operator*(const matrix<T, N, M> &m, T a) {
  return elementwise([a](T x) { return x * a; }, m);
}

template <typename T, std::size_t N, std::size_t M>
constexpr matrix<T, N, M> operator*(T a, const matrix<T, N, M> &m) {
  return elementwise([a](T x) { return a * x; }, m);
}

template <typename T, std::size_t N, std::size_t M>
constexpr matrix<T, N, M> operator*(const matrix<T, N, M> &a,
                                    const matrix<T, N, M> &b) {
  return elementwise(std::multiplies<T>(), a, b);
}

template <typename T, std::size_t N, std::size_t M>
constexpr matrix<T, N, M> operator/(T a, const matrix<T, N, M> &m) {
  return elementwise([a](T x) { return a / x; }, m);
}

template <typename T, std::size_t N, std::size_t M>
constexpr matrix<T, N, M> operator/(const matrix<T, N, M> &a,
                                    const matrix<T, N, M> &b) {
  return elementwise(std::divides<T>(), a, b);
}

} // namespace cotila

#endif // COTILA_VECTOR_OPERATORS_H_