Vec3.H

Go to the documentation of this file.

 
#ifndef _VEC3_H_
#define _VEC3_H_
 
#include <cassert>
#include <cmath>
#include <istream>
#include <ostream>
#include <type_traits>
#include <vector>
#include "Types.H"
 
namespace criptic {
 
  template<class T> class Vec3 {
 
  public:
 
    // Storage
    
    T v[3];            
    // Constructors
 
    Vec3() {
      v[0] = v[1] = v[2] = 0;
    }
 
    template<class U, class V, class W>
    Vec3(const U& v0,
     const V& v1,
     const W& v2) {
      v[0] = v0;
      v[1] = v1;
      v[2] = v2;
    }
 
    template<class U>
    Vec3(const U& v0) {
      v[0] = v[1] = v[2] = v0;
    }
 
    template<class U>
    Vec3(const Vec3<U>& a) {
      v[0] = a[0];
      v[1] = a[1];
      v[2] = a[2];
    }
 
    // Data access
    
    T& operator [] (int i) {
      assert(i >= 0 && i < 3);
      return v[i];
    }
    const T& operator [] (int i) const {
      assert(i >= 0 && i < 3);
      return v[i];
    }
    T& operator () (int i) {
      assert(i >= 0 && i < 3);
      return v[i];
    }
    const T& operator () (int i) const {
      assert(i >= 0 && i < 3);
      return v[i];
    }
    T *data() {
      return v;
    }
    const T *data() const {
      return v;
    }
 
    // Unary operators
 
    Vec3<T> operator-() {
      Vec3<T> rv;
      for (int i=0; i<3; i++) rv[i] = -v[i];
      return rv;
    }
  
    // Unary operators with scalars
 
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    Vec3<T>& operator+=(const U& a) {
      for (int i=0; i<3; i++) v[i] += a;
      return *this;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    Vec3<T>& operator-=(const U& a) {
      for (int i=0; i<3; i++) v[i] -= a;
      return *this;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    Vec3<T>& operator*=(const U& a) {
      for (int i=0; i<3; i++) v[i] *= a;
      return *this;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    Vec3<T>& operator/=(const U& a) {
      for (int i=0; i<3; i++) v[i] /= a;
      return *this;
    }    
    
    // Unary operators with vectors
 
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    Vec3<T>& operator+=(const Vec3<U>& a) {
      for (int i=0; i<3; i++) v[i] += a[i];
      return *this;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    Vec3<T>& operator-=(const Vec3<U>& a) {
      for (int i=0; i<3; i++) v[i] -= a[i];
      return *this;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    Vec3& operator*=(const Vec3<U>& a) {
      for (int i=0; i<3; i++) v[i] *= a[i];
      return *this;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    Vec3& operator/=(const Vec3<U>& a) {
      for (int i=0; i<3; i++) v[i] /= a[i];
      return *this;
    }
   
    // Binary operations with scalars
 
    Vec3<T>& operator=(const T& a) {
      for (int i=0; i<3; i++) v[i] = a;
      return *this;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    auto operator+(const U& a) const -> Vec3<decltype(this->v[0]+a)> {
      Vec3<decltype(a+v[0])> rv;
      for (int i=0; i<3; i++) rv[i] = v[i] + a;
      return rv;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    auto operator-(const U& a) const -> Vec3<decltype(this->v[0]-a)> {
      Vec3<decltype(a-v[0])> rv;
      for (int i=0; i<3; i++) rv[i] = v[i] - a;
      return rv;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    auto operator*(const U& a) const -> Vec3<decltype(this->v[0]*a)> {
      Vec3<decltype(a*v[0])> rv;
      for (int i=0; i<3; i++) rv[i] = v[i] * a;
      return rv;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    auto operator/(const U& a) const -> Vec3<decltype(this->v[0]/a)> {
      Vec3<decltype(v[0]/a)> rv;
      for (int i=0; i<3; i++) rv[i] = v[i] / a;
      return rv;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value ||
                  std::is_enum<T>::value, bool> = true >
    Vec3<bool> operator==(const U& a) const {
      Vec3<bool> rv;
      for (int i=0; i<3; i++) rv[i] = (v[i] == a);
      return rv;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value ||
                  std::is_enum<T>::value, bool> = true >
    Vec3<bool> operator!=(const U& a) const {
      Vec3<bool> rv;
      for (int i=0; i<3; i++) rv[i] = (v[i] != a);
      return rv;
    }
 
    // Binary operations with vectors
    
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    auto operator+(const Vec3<U>& a) const
      -> Vec3<decltype(this->v[0]+a[0])> {
      Vec3<decltype(v[0]+a[0])> rv;
      for (int i=0; i<3; i++) rv[i] = v[i] + a[i];
      return rv;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    auto operator-(const Vec3<U>& a) const
      -> Vec3<decltype(this->v[0]-a[0])> {
      Vec3<decltype(v[0]+a[0])> rv;
      for (int i=0; i<3; i++) rv[i] = v[i] - a[i];
      return rv;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    auto operator*(const Vec3<U>& a) const
      -> Vec3<decltype(this->v[0]*a[0])> {
      Vec3<decltype(v[0]*a[0])> rv;
      for (int i=0; i<3; i++) rv[i] = v[i] * a[i];
      return rv;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value, bool> = true >
    auto operator/(const Vec3<U>& a) const
      -> Vec3<decltype(this->v[0]/a[0])> {
      Vec3<decltype(v[0]/a[0])> rv;
      for (int i=0; i<3; i++) rv[i] = v[i] / a[i];
      return rv;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value ||
                  std::is_enum<T>::value, bool> = true >
    Vec3<bool> operator==(const Vec3<U>& a) const {
      Vec3<bool> rv;
      for (int i=0; i<3; i++) rv[i] = (v[i] == a[i]);
      return rv;
    }
    template<class U,
         std::enable_if_t<std::is_arithmetic<U>::value ||
                  std::is_enum<T>::value, bool> = true >
    Vec3<bool> operator!=(const Vec3<U>& a) const {
      Vec3<bool> rv;
      for (int i=0; i<3; i++) rv[i] = (v[i] != a[i]);
      return rv;
    }
 
    // Unary operations
    
    constexpr T mag2() const {
      return v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
    }
 
    Real mag() const {
      return std::sqrt(mag2());
    }
 
    Vec3<Real> unit() const {
      Real m = mag();
      if (m > 0)
    return (*this) / m;
      else
    return (*this) * 0.0;
    }
 
    void normalize() {
      Real m = mag();
      if (m > 0)
    (*this) /= m;
      else
    (*this) = 0.0;
    }
 
    T max() const {
      T m = v[0];
      if (v[1] > m) m = v[1];
      if (v[2] > m) m = v[2];
      return m;
    }
 
    int argmax() const {
      T m = v[0];
      int j = 0;
      if (v[1] > m) {
    m = v[1];
    j = 1;
      }
      if (v[2] > m) {
    m = v[2];
    j = 2;
      }
      return j;
    }
 
    T min() const {
      T m = v[0];
      if (v[1] < m) m = v[1];
      if (v[2] < m) m = v[2];
      return m;
    }
    
    int argmin() const {
      T m = v[0];
      int j = 0;
      if (v[1] < m) {
    m = v[1];
    j = 1;
      }
      if (v[2] < m) {
    m = v[2];
    j = 2;
      }
      return j;
    }
 
    T sum() const {
      return v[0] + v[1] + v[2];
    }
    
    // Binary vector operations
 
    template<class U>
    auto dot(const Vec3<U>& a) const {
      return a[0]*v[0] + a[1]*v[1] + a[2]*v[2];
    }
 
    template<class U>
    auto cross(const Vec3<U> &a) const -> Vec3<decltype(this->v[0]+a[0])> {
      Vec3<decltype(v[0]*a[0])> rv;
      rv[0] = v[1]*a[2] - v[2]*a[1];
      rv[1] = v[2]*a[0] - v[0]*a[2];
      rv[2] = v[0]*a[1] - v[1]*a[0];
      return rv;
    }
 
    // Other operations
 
    template<class U>
    Vec3<T>& operator=(const std::vector<U>& a) {
      assert(a.size() >= 3);
      for (int i=0; i<3; i++) v[i] = a[i];
      return *this;
    }
    
 
  };
 
  // Convenient typedefs
  typedef Vec3<Real> RealVec;  
  typedef Vec3<IdxType> IdxVec; 
  typedef Vec3<SignedIdxType> SIdxVec; 
  typedef Vec3<bool> BoolVec; 
  // Define various named Vec3 objects
  static const RealVec zeroVec(0,0,0);      
  static const RealVec identityVec(1,1,1);  
  static const RealVec xHat(1,0,0);         
  static const RealVec yHat(0,1,0);         
  static const RealVec zHat(0,0,1);         
  static const IdxVec  zeroIdxVec(0,0,0);   
  static const SIdxVec zeroSIdxVec(0,0,0);  
  static const BoolVec trueVec(1,1,1);      
  static const BoolVec falseVec(1,1,1);     
  // Overload some basic arithmetic operators and functions for Vec3's
  template<class T, class U,
       std::enable_if_t<std::is_arithmetic<T>::value, bool> = true >
  inline auto operator+(const T& a,
            const Vec3<U>& v) -> Vec3<decltype(a+v[0])>{
    Vec3<decltype(a+v[0])> rv;
    for (int i=0; i<3; i++) rv[i] = a + v[i];
    return rv;
  }
  template<class T, class U,
           std::enable_if_t<std::is_arithmetic<T>::value, bool> = true >
  inline auto operator-(const T& a,
            const Vec3<U>& v) -> Vec3<decltype(a-v[0])> {
    Vec3<decltype(a-v[0])> rv;
    for (int i=0; i<3; i++) rv[i] = a - v[i];
    return rv;
  }
  template<class T, class U,
       std::enable_if_t<std::is_arithmetic<T>::value, bool> = true >
  inline auto operator*(const T& a,
            const Vec3<U>& v) -> Vec3<decltype(a*v[0])> {
    Vec3<decltype(a*v[0])> rv;
    for (int i=0; i<3; i++) rv[i] = a * v[i];
    return rv;
  }
  template<class T, class U,
       std::enable_if_t<std::is_arithmetic<T>::value, bool> = true >
  inline auto operator/(const T& a,
            const Vec3<U>& v) -> Vec3<decltype(a/v[0])> {
    Vec3<decltype(a/v[0])> rv;
    for (int i=0; i<3; i++) rv[i] = a / v[i];
    return rv;
  }
  template<class T, class U,
       std::enable_if_t<std::is_arithmetic<T>::value ||
                std::is_enum<T>::value, bool> = true >
  inline Vec3<bool> operator==(const T& a,
                   const Vec3<U>& v) {
    Vec3<bool> rv;
    for (int i=0; i<3; i++) rv[i] = (a == v[i]);
    return rv;
  }
  template<class T, class U,
       std::enable_if_t<std::is_arithmetic<T>::value ||
                std::is_enum<T>::value, bool> = true >
  inline Vec3<bool> operator!=(const T& a,
                   const Vec3<U>& v) {
    Vec3<bool> rv;
    for (int i=0; i<3; i++) rv[i] = (a != v[i]);
    return rv;
  }
 
  // Define functions to return the elementwise min and max of a pair
  // of Vec3's
  template<class T, class U>
  inline auto min(const criptic::Vec3<T>& v1,
          const criptic::Vec3<U>& v2) -> Vec3<decltype(v1[0]+v2[0])>  {
    Vec3<decltype(v1[0]+v2[0])> rv;
    for (int i=0; i<3; i++) rv[i] = std::min(v1[i], v2[i]);
    return rv;
  }
 
  template<class T, class U>
  inline auto max(const criptic::Vec3<T>& v1,
          const criptic::Vec3<U>& v2) -> Vec3<decltype(v1[0]+v2[0])> {
    Vec3<decltype(v1[0]+v2[0])> rv;
    for (int i=0; i<3; i++) rv[i] = std::max(v1[i], v2[i]);
    return rv;
  }
 
  template<class T>
  inline Vec3<T> floor(const criptic::Vec3<T>& v) {
    Vec3<T> rv;
    for (int i=0; i<3; i++) rv[i] = std::floor(v[i]);
    return rv;
  }
}
 
// Overload the >> and << operators for convenience
template<class T>
std::istream& operator>>(std::istream& is,
             criptic::Vec3<T>& v);
 
template<class T>
std::ostream& operator<<(std::ostream& os,
             const criptic::Vec3<T>& v);
 
 
#endif
// _VEC3_H_