vect.h

Go to the documentation of this file.

#pragma once

#include "basedef.h"
#include "to.h"
#include <cmath>
#include <array>

#ifdef _LINUX
namespace std {
    template <class T> T abs(const T &t) {
        if (t<0) return -t;
        return t;
    }
    template <class T> T max0(const T &t1,const T &t2) {
        if (t2>t1) return t2;
        return t1;
    }
    template <class T> T min0(const T &t1,const T &t2) {
        if (t2<t1) return t1;
        return t1;
    }
} // namespace std
#endif

template <class T> class Vector2 {
public:
    // Creators
#ifdef _DEBUG
    Vector2() { fill(initVal<T>()); }
#else
#pragma warning(push)
#pragma warning(disable:26495) // Init warning- not initializing on purpose
    Vector2() {  }
#pragma warning(pop)
#endif
    Vector2(const Vector2<T> &v) : a_(v.a_) { }
    Vector2(const T &x,const T &y) : a_({x,y}) {  }
    explicit Vector2(const T &t) : a_({t,t}) { }
    static Vector2<T> nothing() { Vector2<T> v(limits<T>::max(),-limits<T>::max());  return v; }

    // Accessors
    const T &x() const { return c_.x_; }
    const T &y() const { return c_.y_; }
    const T &dof(unsigned u) const { return a_[u]; }
    T &rx() { return c_.x_; }
    T &ry() { return c_.y_; }
    T &rdof(unsigned u) { return a_[u]; }
    const T &operator[](unsigned u) const { return dof(u); }
    T &      operator[](unsigned u) { return rdof(u); } 
    template <std::size_t N> decltype(auto) get() const {
        static_assert(N<2,"Index out of range");
        return a_[N];
    }

    // Various norms
    T fsum() const { return (std::abs(x())+std::abs(y())); }
    T sum() const { return x() + y(); }
    T mag2() const { return (x()*x()+y()*y()); }
    T mag() const { return to<T>(std::sqrt(to<Double>(mag2()))); }
    T area() const { return (x()*y()); }
    T volume() const { return area(); }
    T spread() const { return (y() -x()); }
    Vector2<T> unit() const { Vector2<T> v(*this); T m(v.mag()); if (m) v/=m; return v; }
    Vector2<T> abs() const { Vector2<T> v(std::abs(x()),std::abs(y())); return v; }
    void fill(const T &d) { rx()=d; ry()=d; }
    T maxComp() const { return std::max(x(),y()); }
    T minComp() const { return std::min(x(),y()); }
    unsigned maxCompIndex() const { return x() > y() ? 0 : 1; }
    unsigned minCompIndex() const { return x() < y() ? 0 : 1; }
    const Vector2<T> &safeDivE(const Vector2<T> &v) { rx()=::safeDiv(x(),v.x());  ry() = ::safeDiv(y(),v.y());  return *this;  }
    const Vector2<T>  safeDiv(const Vector2<T> &v) { Vector2<T> ret(::safeDiv(x(),v.x()),::safeDiv(y(),v.y()));  return ret; }

    bool operator==(const Vector2<T> &v) const { return ((x()==v.x())&&(y()==v.y())); }
    bool operator!=(const Vector2<T> &v) const { return ((x()!=v.x())||(y()!=v.y())); }
    bool operator<(const Vector2<T> &v) const { if (x()!=v.x()) return x()<v.x();  return y()<v.y();  }
    bool operator>(const Vector2<T> &v) const { if (x()!=v.x()) return x()>v.x();  return y()>v.y();  }

    // In-place operators
    const Vector2<T> &operator+=(const Vector2<T> &v) { rx()+=v.x();  ry()+=v.y();  return *this; }
    const Vector2<T> &operator-=(const Vector2<T> &v) { rx()-=v.x();  ry()-=v.y();  return *this; } 
    const Vector2<T> &operator*=(const Vector2<T> &v) { rx()*=v.x();  ry()*=v.y();  return *this; } 
    const Vector2<T> &operator*=(const T &t)          { rx()*=t;      ry()*=t;      return *this; } 
    const Vector2<T> &operator/=(const Vector2<T> &v) { rx()/=v.x();  ry()/=v.y();  return *this; } 
    const Vector2<T> &operator/=(const T &t)          { rx()/=t;      ry()/=t;      return *this; } 

    // Binary operators - require temp (ugh)
    Vector2<T> operator+(const Vector2<T> &v) const { Vector2<T> out(x()+v.x(),y()+v.y());  return out; } 
    Vector2<T> operator-(const Vector2<T> &v) const { Vector2<T> out(x()-v.x(),y()-v.y());  return out; } 
    Vector2<T> operator*(const Vector2<T> &v) const { Vector2<T> out(x()*v.x(),y()*v.y());  return out; } 
    Vector2<T> operator*(const T &t)          const { Vector2<T> out(x()*t,y()*t);        return out; } 
    Vector2<T> operator/(const Vector2<T> &v) const { Vector2<T> out(x()/v.x(),y()/v.y());  return out; } 
    Vector2<T> operator/(const T &t)          const { Vector2<T> out(x()/t,y()/t);        return out; } 
    //   Cross Product (see DAVect)
    T          operator|(const Vector2<T> &v) const { return (x()*v.x()+y()*v.y()); }

    // Support for use of a Vect2 as a range (min,max)
    const Vector2<T> &expandToInclude(const T &t) { rx() = std::min(x(),t);  ry() = std::max(y(),t);  return *this; }
    const Vector2<T> &expandToInclude(const Vector2<T> &v) { rx() = std::min(x(),v.minComp());  ry() = std::max(y(),v.maxComp());  return *this; }
    Vector2<T>        expandedToInclude(const T &t) const { Vector2<T> ret(*this);  ret.expandToInclude(t);  return ret; }
    Vector2<T>        expandedToInclude(const Vector2<T> &v) const { Vector2<T> ret(*this);  ret.expandToInclude(v);  return ret; }
    bool              contains(const T &t) const { if (t<x()) return false;  if (t>y()) return false;  return true; }

private:
    union {
        struct {
            T x_;
            T y_;
        } c_;
        std::array<T,2> a_;
    };
};

template <class T> class Vector3 {
public:
    // Creators
#ifdef _DEBUG
    Vector3() { fill(initVal<T>()); }
#else
#pragma warning(push)
#pragma warning(disable:26495) // Init warning- not initializing on purpose
    Vector3() { }
#pragma warning(pop)
#endif
    Vector3(const Vector3<T> &v) : a_(v.a_) {  }
    Vector3(const T &x,const T &y,const T &z=0) : a_({x,y,z}) { }
    explicit Vector3(const T &t) : a_({t,t,t}) { }

    // Accessors
    const T &x() const { return c_.x_; }
    const T &y() const { return c_.y_; }
    const T &z() const { return c_.z_; }
    const T &dof(unsigned u) const { return a_[u]; }
    T &rx() { return c_.x_; }
    T &ry() { return c_.y_; }
    T &rz() { return c_.z_; }
    T &rdof(unsigned u) { return a_[u]; }
    const T &operator[](unsigned u) const { return dof(u); }
    T &operator[](unsigned u) { return rdof(u); }
    template <std::size_t N> T get() const {
        static_assert(N<3,"Index out of range");
        return a_[N];
    }

    // Various norms
    T fsum() const { return (std::abs(x())+std::abs(y())+std::abs(z())); }
    T sum() const { return x()+y()+z(); }
    T mag2() const { return (x()*x()+y()*y()+z()*z()); }
    T mag() const { return to<T>(std::sqrt(to<Double>(mag2()))); }
    T volume() const { return (x()*y()*z()); }
    Vector3<T> unit() const { Vector3<T> v(*this); T m(v.mag()); if (m) v/=m; return v; }
    Vector3<T> abs() const { Vector3<T> v(std::abs(x()),std::abs(y()),std::abs(z()));  return v; }
    void fill(const T &d) { rx()=d; ry()=d; rz()=d; }
    T maxComp() const { return std::max(x(),std::max(y(),z())); }
    T minComp() const { return std::min(x(),std::min(y(),z())); }
    unsigned maxCompIndex() const { return x() > y() ? (x() > z() ? 0 : 2) : (y() > z() ? 1 : 2); }
    unsigned minCompIndex() const { return x() < y() ? (x() < z() ? 0 : 2) : (y() < z() ? 1 : 2); }
    const Vector3<T> &safeDivE(const Vector3<T> &v) { rx()=::safeDiv(x(),v.x());  ry() = ::safeDiv(y(),v.y());  rz() = ::safeDiv(z(),v.z()); return *this;  }
    const Vector3<T>  safeDiv(const Vector3<T> &v) { Vector3<T> ret(::safeDiv(x(),v.x()),::safeDiv(y(),v.y()),::safeDiv(z(),v.z()));  return ret; }

    bool operator==(const Vector3<T> &v) const { return ((x()==v.x())&&(y()==v.y())&&(z()==v.z())); }
    bool operator!=(const Vector3<T> &v) const { return ((x()!=v.x())||(y()!=v.y())||(z()!=v.z())); }
    bool operator<(const Vector3<T> &v) const { if (x()!=v.x()) return x()<v.x();  if (y()!=v.y()) return y()<v.y();  return z()<v.z(); }
    bool operator>(const Vector3<T> &v) const { if (x()!=v.x()) return x()>v.x();  if (y()!=v.y()) return y()>v.y();  return z()>v.z(); }

    // In-place operators
    const Vector3<T> &operator+=(const Vector3<T> &v) { rx()+=v.x();  ry()+=v.y();  rz()+=v.z();  return *this; }
    const Vector3<T> &operator-=(const Vector3<T> &v) { rx()-=v.x();  ry()-=v.y();  rz()-=v.z();  return *this; } 
    const Vector3<T> &operator*=(const Vector3<T> &v) { rx()*=v.x();  ry()*=v.y();  rz()*=v.z();  return *this; } 
    const Vector3<T> &operator*=(const T &t)          { rx()*=t;      ry()*=t;      rz()*=t;      return *this; } 
    const Vector3<T> &operator/=(const Vector3<T> &v) { rx()/=v.x();  ry()/=v.y();  rz()/=v.z();  return *this; } 
    const Vector3<T> &operator/=(const T &t)          { rx()/=t;      ry()/=t;      rz()/=t;      return *this; } 

    // Binary operators - require temp (ugh)
    Vector3<T> operator+(const Vector3<T> &v) const { Vector3<T> out(x()+v.x(),y()+v.y(),z()+v.z());  return out; }
    Vector3<T> operator-(const Vector3<T> &v) const { Vector3<T> out(x()-v.x(),y()-v.y(),z()-v.z());  return out; } 
    Vector3<T> operator*(const Vector3<T> &v) const { Vector3<T> out(x()*v.x(),y()*v.y(),z()*v.z());  return out; } 
    Vector3<T> operator*(const T &t)          const { Vector3<T> out(x()*t,y()*t,z()*t);              return out; } 
    Vector3<T> operator/(const Vector3<T> &v) const { Vector3<T> out(x()/v.x(),y()/v.y(),z()/v.z());  return out; } 
    Vector3<T> operator/(const T &t)          const { Vector3<T> out(x()/t,y()/t,z()/t);              return out; } 
    Vector3<T> operator&(const Vector3<T> &v) const { 
        Vector3<T> out((y()*v.z())-(z()*v.y()),(z()*v.x())-(x()*v.z()),(x()*v.y())-(y()*v.x()));  
        return out; 
    }
    T          operator|(const Vector3<T> &v) const { return (x()*v.x()+y()*v.y()+z()*v.z()); }

private:
    union {
        struct {
            T x_;
            T y_;
            T z_;
        } c_;
        std::array<T,3> a_;
    };
};

// Naming convention for most commonly used types.
typedef Vector2<Double>  DVect2; 
typedef Vector2<Float>   FVect2; 
typedef Vector2<Int>     IVect2; 
typedef Vector2<UInt>    UVect2; 
typedef Vector2<Long>    LVect2; 
typedef Vector2<ULong>   ULVect2; 

typedef Vector3<Double>  DVect3; 
typedef Vector3<Float>   FVect3; 
typedef Vector3<Int>     IVect3; 
typedef Vector3<UInt>    UVect3; 
typedef Vector3<Long>    LVect3; 
typedef Vector3<ULong>   ULVect3; 

// Conversion routines.
template <class T> inline DVect2 toDVect2(const Vector2<T> &v) { DVect2 dv2(to<Double>(v.x()),to<Double>(v.y()));  return dv2; }
template <class T> inline FVect2 toFVect2(const Vector2<T> &v) { FVect2 fv2(to<Float>(v.x()),to<Float>(v.y()));  return fv2; }
template <class T> inline IVect2 toIVect2(const Vector2<T> &v) { IVect2 iv2(to<Int>(v.x()),to<Int>(v.y()));  return iv2; }    
template <class T> inline UVect2 toUVect2(const Vector2<T> &v) { UVect2 uv2(to<UInt>(v.x()),to<UInt>(v.y()));  return uv2; }  

template <class T> inline DVect3 toDVect3(const Vector3<T> &v) { 
    DVect3 dv3(to<Double>(v.x()),to<Double>(v.y()),to<Double>(v.z()));  
    return dv3; 
}
template <class T> inline FVect3 toFVect3(const Vector3<T> &v) { 
    FVect3 fv3(to<Float>(v.x()),to<Float>(v.y()),to<Float>(v.z()));  
    return fv3; 
} 
template <class T> inline IVect3 toIVect3(const Vector3<T> &v) { 
    IVect3 iv3(to<Int>(v.x()),to<Int>(v.y()),to<Int>(v.z()));  
    return iv3; 
}
template <class T> inline UVect3 toUVect3(const Vector3<T> &v) { 
    UVect3 uv3(to<UInt>(v.x()),to<UInt>(v.y()),to<UInt>(v.z()));  
    return uv3; 
}


template <class T> inline const Vector2<T> &toVect2(const Vector2<T> &v) { return v; }
template <class T> inline Vector2<T>        toVect2(const Vector3<T> &v) { return Vector2<T>(v.x(),v.y()); } 
template <class T> inline Vector3<T>        toVect3(const Vector2<T> &v,const T &t=0) { return Vector3<T>(v.x(),v.y(),t); }  
template <class T> inline const Vector3<T> &toVect3(const Vector3<T> &v) { return v; } 


template <class T> inline Vector2<T> vmax(const Vector2<T> &v1,const Vector2<T> &v2) { 
    Vector2<T> out(std::max<T>(v1.x(),v2.x()),std::max<T>(v1.y(),v2.y()));  
    return out; 
}
template <class T> inline Vector2<T> vmin(const Vector2<T> &v1,const Vector2<T> &v2) { 
    Vector2<T> out(std::min<T>(v1.x(),v2.x()),std::min<T>(v1.y(),v2.y()));  
    return out; 
} 

template <class T> inline Vector2<T> vsign(const Vector2<T> &v1,const Vector2<T> &v2) { 
    Vector2<T> out(v2.x() < 0 ? -qAbs(v1.x()) : qAbs(v1.x()) ,v2.y() < 0 ? -qAbs(v1.y()) : qAbs(v1.y()));  
    return out; 
} 

template <class T> inline Vector3<T> vmax(const Vector3<T> &v1,const Vector3<T> &v2) {
    Vector3<T> out(std::max<T>(v1.x(),v2.x()),std::max<T>(v1.y(),v2.y()),std::max<T>(v1.z(),v2.z()));  
    return out; 
}
template <class T> inline Vector3<T> vmin(const Vector3<T> &v1,const Vector3<T> &v2) { 
    Vector3<T> out(std::min<T>(v1.x(),v2.x()),std::min<T>(v1.y(),v2.y()),std::min<T>(v1.z(),v2.z()));  
    return out; 
}

template <class T> inline Vector3<T> vsign(const Vector3<T> &v1,const Vector3<T> &v2) { 
    Vector3<T> out(v2.x() < 0 ? -qAbs(v1.x()) : qAbs(v1.x()), v2.y() < 0 ? -qAbs(v1.y()) : qAbs(v1.y()), v2.z() < 0 ? -qAbs(v1.z()) : qAbs(v1.z()));  
    return out; 
} 

template <class T> inline Vector2<T> vceil(const Vector2<T> &v) {
    Vector2<T> out(ceil(v.x()),ceil(v.y()));
    return out;
}

template <class T> inline Vector3<T> vceil(const Vector3<T> &v) {
    Vector3<T> out(ceil(v.x()),ceil(v.y()),ceil(v.z()));
    return out;
}

template <class T> inline Vector2<T> vfloor(const Vector2<T> &v) {
    Vector2<T> out(floor(v.x()),floor(v.y()));
    return out;
}

template <class T> inline Vector3<T> vfloor(const Vector3<T> &v) {
    Vector3<T> out(floor(v.x()),floor(v.y()),floor(v.z()));
    return out;
}

template <class T> IVect2 vround(const Vector2<T> &v) {
    IVect2 out(qRound(v.x()),qRound(v.y()));
    return out;
}

template <class T> IVect3 vround(const Vector3<T> &v) {
    IVect3 out(qRound(v.x()),qRound(v.y()),qRound(v.z()));
    return out;
}

namespace std {
    template <class T> Vector2<T> max(const Vector2<T> &v1,const Vector2<T> &v2) { return vmax(v1,v2); }
    template <class T> Vector2<T> min(const Vector2<T> &v1,const Vector2<T> &v2) { return vmin(v1,v2); }
    template <class T> Vector3<T> max(const Vector3<T> &v1,const Vector3<T> &v2) { return vmax(v1,v2); }
    template <class T> Vector3<T> min(const Vector3<T> &v1,const Vector3<T> &v2) { return vmin(v1,v2); }

    template <class T> struct tuple_size<Vector2<T>> : std::integral_constant<std::size_t, 2> {};
    template <class T> struct tuple_size<Vector3<T>> : std::integral_constant<std::size_t, 3> {};
    template <std::size_t N,class T> struct tuple_element<N, Vector2<T>> { using type = T; };
    template <std::size_t N,class T> struct tuple_element<N, Vector3<T>> { using type = T; };
}

// EoF