operators.h

#ifndef COTILA_VECTOR_OPERATORS_H_
#define COTILA_VECTOR_OPERATORS_H_

#include <cotila/vector/vector.h>

namespace cotila {

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

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

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

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

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

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

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

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

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

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

} // namespace cotila

#endif // COTILA_VECTOR_OPERATORS_H_