vector.h

Go to the documentation of this file.

#ifndef MU_VECTOR_H_
#define MU_VECTOR_H_

#include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <initializer_list>
#include <numeric>
#include <ostream>
#include <type_traits>
#include <utility>

#include "mu/typetraits.h"
#include "mu/utility.h"

namespace mu {

template <std::size_t X, std::size_t Y, typename Z>
class Matrix;

template <std::size_t N, typename T>
class Vector {
  static_assert(N != 0, "Vector dimension cannot be zero");
  static_assert(std::is_arithmetic<T>::value,
                "Vector type T must be an arithmetic type");

 public:
  /* value and size type from the underlying container */
  using value_type = typename std::array<T, N>::value_type;
  using size_type = typename std::array<T, N>::size_type;
  /* use iterators from the underlying container */
  using iterator = typename std::array<T, N>::iterator;
  using const_iterator = typename std::array<T, N>::const_iterator;

  constexpr Vector() = default;

  template <typename... TArgs,
            std::enable_if_t<
                sizeof...(TArgs) == N &&
                    (mu::conjunction<std::is_same<
                         T, std::remove_reference_t<TArgs>>::value...>::value),
                int> = 0>
  // NOLINTNEXTLINE(runtime/explicit) implicit to make copy-init. work
  Vector(TArgs &&... args) : data_{std::forward<TArgs>(args)...} {}

  template <std::size_t Nn, class U>
  // NOLINTNEXTLINE(runtime/explicit) implicit conversion is intentional
  Vector(const Vector<Nn, U> &v) {
    static_assert(N == Nn, "Vector size mismatch");
    std::transform(v.begin(), v.end(), begin(), [](U data) { return data; });
  }

  // NOLINTNEXTLINE(runtime/explicit) implicit to make copy-init. work
  Vector(const std::array<T, N> &a) : data_{a} {}

  template <typename U = T,
            std::enable_if_t<std::is_arithmetic<U>::value, int> = 0>
  // NOLINTNEXTLINE(runtime/explicit) implicit to make copy-init. work
  Vector(const std::array<U, N> &a) {
    std::transform(a.begin(), a.end(), begin(), [](U data) { return data; });
  }

  template <typename U = T,
            std::enable_if_t<std::is_arithmetic<U>::value, int> = 0>
  // NOLINTNEXTLINE(runtime/explicit) implicit to make copy-init. work
  Vector(const U &value) {
    data_.fill(value);
  }

  ~Vector() = default;

  Vector(const Vector &other) = default;

  Vector(Vector &&other) noexcept = default;

  Vector &operator=(const Vector &other) = default;

  Vector &operator=(Vector &&other) noexcept = default;

  T &operator[](size_type idx) noexcept { return data_[idx]; }

  const T &operator[](size_type idx) const noexcept { return data_[idx]; }

  T &at(size_type idx) { return data_.at(idx); }

  const T &at(size_type idx) const { return data_.at(idx); }

  constexpr size_type size() const noexcept { return N; }

  iterator begin() noexcept { return data_.begin(); }

  const_iterator begin() const noexcept { return data_.begin(); }

  iterator end() noexcept { return data_.end(); }

  const_iterator end() const noexcept { return data_.end(); }

  T min() const {
    T ret(data_[0]);
    for (std::size_t i = 1; i < N; i++) {
      ret = mu::min(ret, data_[i]);
    }
    return ret;
  }

  T max() const {
    T ret(data_[0]);
    for (std::size_t i = 1; i < N; i++) {
      ret = mu::max(ret, data_[i]);
    }
    return ret;
  }

  T sum() const {
    T ret{};
    for (const auto &item : data_) {
      ret += item;
    }
    return ret;
  }

  template <typename U = T>
  U mean() const {
    return U(sum()) / N;
  }

  template <typename U = void, std::size_t N2, typename T2>
  std::conditional_t<std::is_same<U, void>::value, T, U> dot(
      const Vector<N2, T2> &rhs) const {
    static_assert(N == N2, "Vector size mismatch");
    using U_ = std::conditional_t<!std::is_same<T, T2>::value, U, T>;
    static_assert(!std::is_same<U_, void>::value,
                  "Vector types are different. please specify the return "
                  "type. e.g. \"vec1.dot<float>(vec2);\"");
    U_ ret{};
    for (std::size_t i = 0; i < N; i++) {
      ret += data_[i] * rhs[i];
    }
    return ret;
  }

  template <typename U = void, std::size_t N2, std::size_t M2, typename T2>
  std::conditional_t<std::is_same<U, void>::value, Vector<M2, T>, Vector<M2, U>>
  dot(const Matrix<N2, M2, T2> &rhs) const {
    static_assert(N == N2,
                  "Vector-Matrix dimension mismatch. Vector size must be equal "
                  "to the first dimension of the matrix");
    using U_ = std::conditional_t<!std::is_same<T, T2>::value, U, T>;
    static_assert(
        !std::is_same<U_, void>::value,
        "Vector and Matrix types are different. please specify the return "
        "type. e.g. \"vec.dot<float>(mat);\"");
    Vector<M2, U_> ret;
    for (std::size_t i = 0; i < M2; i++) {
      U_ sum{0};
      for (std::size_t k = 0; k < N; k++) {
        sum += (data_[k] * rhs[k][i]);
      }
      ret[i] = sum;
    }
    return ret;
  }

  template <class U = T>
  U std() const {
    U sum{0};
    U m = mean<U>();
    for (const auto &item : data_) {
      sum += mu::pow(item - m, 2);
    }
    return U(mu::sqrt(sum / N));
  }

  template <class U = T>
  U length() const {
    return U(mu::sqrt(dot(*this)));
  }

  void normalize() { *this /= length(); }

  Vector<N, T> normalized() {
    Vector<N, T> ret(*this);
    ret.normalize();
    return ret;
  }

  void flip() { mu::reverse(begin(), end()); }

  Vector<N, T> flipped() const {
    Vector<N, T> ret(*this);
    ret.flip();
    return ret;
  }

  void sort() { mu::sort(begin(), end()); }

  template <typename Compare>
  void sort(const Compare &comp) {
    mu::sort(begin(), end(), comp);
  }

  Vector<N, T> sorted() const {
    Vector<N, T> ret(*this);
    ret.sort();
    return ret;
  }

  template <typename Compare>
  Vector<N, T> sorted(const Compare &comp) const {
    Vector<N, T> ret(*this);
    ret.sort(comp);
    return ret;
  }

  /********************************* I/O ***********************************/

  template <std::size_t Nn, class U>
  friend std::ostream &operator<<(std::ostream &os, const Vector<Nn, U> &v);

  /*************************** vector <> vector ****************************/

  template <typename U = T>
  bool operator==(const Vector<N, U> &rhs) const {
    for (std::size_t i = 0; i < N; i++) {
      if (!mu::TypeTraits<T>::equals(data_[i], rhs[i]) ||
          !mu::TypeTraits<U>::equals(data_[i], rhs[i])) {
        return false;
      }
    }
    return true;
  }

  template <typename U = T>
  bool operator!=(const Vector<N, U> &rhs) const {
    return !operator==(rhs);
  }

  template <typename U = T>
  Vector<N, T> &operator+=(const Vector<N, U> &rhs) {
    for (std::size_t i = 0; i < N; i++) {
      data_[i] += rhs[i];
    }
    return *this;
  }

  template <typename U = T>
  Vector<N, T> &operator-=(const Vector<N, U> &rhs) {
    for (std::size_t i = 0; i < N; i++) {
      data_[i] -= rhs[i];
    }
    return *this;
  }

  template <typename U = T>
  Vector<N, T> &operator*=(const Vector<N, U> &rhs) {
    for (std::size_t i = 0; i < N; i++) {
      data_[i] *= rhs[i];
    }
    return *this;
  }

  template <typename U = T>
  Vector<N, T> &operator/=(const Vector<N, U> &rhs) {
    for (std::size_t i = 0; i < N; i++) {
      data_[i] /= rhs[i];
    }
    return *this;
  }

  /*************************** vector <> scalar ****************************/

  /*
   * enable_if's are used to check for an arithmetic type at compile time
   * since it's the only type "family" that is allowed inside a Vector.
   *
   * the vector elements and the scalar can be of different types. c++ usual
   * conversion rules apply.
   *
   * placed inside this class because write access to member data is required
   */

  template <class TScalar>
  typename std::enable_if_t<std::is_arithmetic<TScalar>::value, Vector<N, T> &>
  operator+=(const TScalar &scalar) {
    for (auto &item : data_) {
      item += scalar;
    }
    return *this;
  }

  template <class TScalar>
  typename std::enable_if_t<std::is_arithmetic<TScalar>::value, Vector<N, T> &>
  operator-=(const TScalar &scalar) {
    for (auto &item : data_) {
      item -= scalar;
    }
    return *this;
  }

  template <class TScalar>
  typename std::enable_if_t<std::is_arithmetic<TScalar>::value, Vector<N, T> &>
  operator*=(const TScalar &scalar) {
    for (auto &item : data_) {
      item *= scalar;
    }
    return *this;
  }

  template <class TScalar>
  typename std::enable_if_t<std::is_arithmetic<TScalar>::value, Vector<N, T> &>
  operator/=(const TScalar &scalar) {
    /* a division by zero of an integral type is undefined in standard c++
     * however, in the context of this Vector class, it is seen as rather
     * harmful and can become the source of bugs. debug mode only */
    if (std::is_integral<TScalar>::value) {
      assert(scalar != static_cast<TScalar>(0));
    }
    for (auto &item : data_) {
      item /= scalar;
    }
    return *this;
  }

  /*************************************************************************/

 protected:
  std::array<T, N> data_;
};

/********************************** I/O ************************************/

template <std::size_t Nn, class U>
std::ostream &operator<<(std::ostream &os, const Vector<Nn, U> &v) {
  os << "[ ";
  for (std::size_t i = 0; i < Nn; i++) {
    os << v.data_[i];
    if (i < (Nn - 1)) {
      os << ", ";
    } else {
      os << " ";
    }
  }
  os << "]";
  return os;
}

/**************************** vector <> vector *****************************/

template <std::size_t N, class T, class U = T>
inline Vector<N, T> operator+(const Vector<N, T> &lhs,
                              const Vector<N, U> &rhs) {
  return Vector<N, T>(lhs) += rhs;
}

template <std::size_t N, class T, class U = T>
inline Vector<N, T> operator-(const Vector<N, T> &lhs,
                              const Vector<N, U> &rhs) {
  return Vector<N, T>(lhs) -= rhs;
}

template <std::size_t N, class T, class U = T>
inline Vector<N, T> operator*(const Vector<N, T> &lhs,
                              const Vector<N, U> &rhs) {
  return Vector<N, T>(lhs) *= rhs;
}

template <std::size_t N, class T, class U = T>
inline Vector<N, T> operator/(const Vector<N, T> &lhs,
                              const Vector<N, U> &rhs) {
  return Vector<N, T>(lhs) /= rhs;
}

/**************************** vector <> scalar *****************************/

template <std::size_t N, class T, class TScalar>
typename std::enable_if_t<std::is_arithmetic<TScalar>::value,
                          Vector<N, T>> inline
operator+(const Vector<N, T> &lhs, const TScalar &rhs) {
  return Vector<N, T>(lhs) += rhs;
}

template <std::size_t N, class T, class TScalar>
typename std::enable_if_t<std::is_arithmetic<TScalar>::value,
                          Vector<N, T>> inline
operator+(const TScalar &lhs, const Vector<N, T> &rhs) {
  return Vector<N, T>(rhs) += lhs;
}

template <std::size_t N, class T, class TScalar>
typename std::enable_if_t<std::is_arithmetic<TScalar>::value,
                          Vector<N, T>> inline
operator-(const Vector<N, T> &lhs, const TScalar &rhs) {
  return Vector<N, T>(lhs) -= rhs;
}

template <std::size_t N, class T, class TScalar>
typename std::enable_if_t<std::is_arithmetic<TScalar>::value,
                          Vector<N, T>> inline
operator*(const Vector<N, T> &lhs, const TScalar &rhs) {
  return Vector<N, T>(lhs) *= rhs;
}

template <std::size_t N, class T, class TScalar>
typename std::enable_if_t<std::is_arithmetic<TScalar>::value,
                          Vector<N, T>> inline
operator*(const TScalar &lhs, const Vector<N, T> &rhs) {
  return Vector<N, T>(rhs) *= lhs;
}

template <std::size_t N, class T, class TScalar>
typename std::enable_if_t<std::is_arithmetic<TScalar>::value,
                          Vector<N, T>> inline
operator/(const Vector<N, T> &lhs, const TScalar &rhs) {
  return Vector<N, T>(lhs) /= rhs;
}

/************************* convenience functions ***************************/

template <std::size_t N, class T>
inline T min(const Vector<N, T> &v) {
  return v.min();
}

template <std::size_t N, class T>
inline T max(const Vector<N, T> &v) {
  return v.max();
}

template <std::size_t N, class T>
inline T sum(const Vector<N, T> &v) {
  return v.sum();
}

template <class U = void, std::size_t N, typename T>
inline std::conditional_t<std::is_same<U, void>::value, T, U> mean(
    const Vector<N, T> &v) {
  return v
      .template mean<std::conditional_t<std::is_same<U, void>::value, T, U>>();
}

template <class U = void, std::size_t N1, class T1, std::size_t N2, class T2>
inline std::conditional_t<std::is_same<U, void>::value, T1, U> dot(
    const Vector<N1, T1> &lhs, const Vector<N2, T2> &rhs) {
  return lhs.template dot<U>(rhs);
}

template <typename U = void, std::size_t N, typename T, std::size_t N2,
          std::size_t M2, typename T2>
std::conditional_t<std::is_same<U, void>::value, Vector<M2, T>, Vector<M2, U>>
dot(const Vector<N, T> &lhs, const Matrix<N2, M2, T2> &rhs) {
  return lhs.template dot<U>(rhs);
}

template <std::size_t N, class T>
// NOLINTNEXTLINE(runtime/references) intentional non-const reference
inline void flip(Vector<N, T> &v) {
  v.flip();
}

template <std::size_t N, class T>
inline Vector<N, T> flipped(const Vector<N, T> &v) {
  return v.flipped();
}

template <std::size_t N, class T>
// NOLINTNEXTLINE(runtime/references) intentional non-const reference
inline void sort(Vector<N, T> &v) {
  v.sort();
}

template <std::size_t N, class T, typename Compare>
// NOLINTNEXTLINE(runtime/references) intentional non-const reference
inline void sort(Vector<N, T> &v, const Compare &compare) {
  v.sort(compare);
}

template <std::size_t N, class T>
inline Vector<N, T> sorted(const Vector<N, T> &v) {
  return v.sorted();
}

template <std::size_t N, class T, typename Compare>
inline Vector<N, T> sorted(const Vector<N, T> &v, const Compare &compare) {
  return v.sorted(compare);
}

template <std::size_t N, typename T = int>
inline Vector<N, T> ones() {
  return Vector<N, T>{T{1}};
}

template <std::size_t N, typename T = int>
inline Vector<N, T> zeros() {
  return Vector<N, T>{T{0}};
}

}  // namespace mu
#endif  // MU_VECTOR_H_