avect.h

Go to the documentation of this file.

#pragma once
#include "vect.h"
 
 
namespace AVector2Util {
    static const double nullValue_ = 0.0;
}
 
 
template <class T> class AVector2 {
public:
    // Creators
    constexpr AVector2()=default;
    constexpr AVector2(const AVector2 &av)=default;
    constexpr AVector2<T> &operator=(const AVector2<T> &v) =default;
 
    explicit AVector2(const T &t) : z_(t) { }
    explicit AVector2(const Vector2<T> &) : z_(0) { }
    explicit AVector2(const Vector3<T> &v) : z_(v.z_) { }
 
    const T &x() const { return AVector2Util::nullValue_; }
    const T &y() const { return AVector2Util::nullValue_; }
    const T &z() const { return z_; }
    const T &dof(uint32 u) const {
#ifdef _DEBUG
        if (u>2) throw std::runtime_error("Vector index out of range.");
#endif
        if (u==2) return z_;
        return AVector2Util::nullValue_;
    }
 
    T &rz() { return z_; }
    T &rdof([[maybe_unused]] uint32 u) {
#ifdef _DEBUG
        if (u!=2) throw std::runtime_error("Vector index out of range.");
#endif
        return z_;
    }
 
    const T &operator[](uint32 u) const { return dof(u); } 
    T &operator[](uint32 u) { return rdof(u); } 
 
    T fsum() const { return std::abs(z_); }   
    T mag2() const { return z_*z_; }          
    constexpr T mag() const { return std::abs(z_); }    
    T area() const { return 0; }              
    T volume() const { return 0; }            
    constexpr AVector2<T> unit() const { AVector2<T> v(*this); if (z_) { v.z_ = z_ < static_cast<T>(0) ? static_cast<T>(-1) : static_cast<T>(1); } return v; } 
    AVector2<T> abs() const { return std::abs(z_); } 
    void fill(const T &d) { z_=d; } 
    constexpr T maxComp() const { return std::max(0.0,z_); }   
    constexpr T minComp() const { return std::min(0.0,z_); }   
 
    bool operator==(const AVector2<T> &av) const { return z_==av.z_; } 
    bool operator!=(const AVector2<T> &av) const { return z_!=av.z_; } 
    bool operator<(const AVector2<T> &av) const { return z_ < av.z_; } 
    bool operator>(const AVector2<T> &av) const { return z_ > av.z_; } 
 
    const AVector2<T> &operator+=(const AVector2<T> &v) { z_ += v.z_; return *this; } 
    const AVector2<T> &operator-=(const AVector2<T> &v) { z_ -= v.z_; return *this; } 
    const AVector2<T> &operator*=(const AVector2<T> &v) { z_ *= v.z_; return *this; } 
    const AVector2<T> &operator*=(const T &t) { z_ *= t; return *this; }              
    const AVector2<T> &operator/=(const AVector2<T> &v) { z_ /= v.z_; return *this; } 
    const AVector2<T> &operator/=(const T &t) { z_ /= t; return *this; }              
 
    AVector2<T> operator+(const AVector2<T> &av) const { AVector2<T> out(z_+av.z_);  return out; } 
    AVector2<T> operator-(const AVector2<T> &av) const { AVector2<T> out(z_-av.z_);  return out; } 
    AVector2<T> operator*(const AVector2<T> &av) const { AVector2<T> out(z_*av.z_);  return out; } 
    AVector2<T> operator*(const T &t) const { AVector2<T> out(z_*t);  return out; }                
    AVector2<T> operator/(const AVector2<T> &av) const { AVector2<T> out(z_/av.z_);  return out; } 
    AVector2<T> operator/(const T &t) const { AVector2<T> out(z_/t);  return out; }                 
 
    T operator&(const AVector2<T> &) const { return 0; }   
    Vector2<T> operator&(const Vector2<T> &v) const { Vector2<T> out(-z_*v.y(),z_*v.x()); return out; } 
    Vector3<T> operator&(const Vector3<T> &v) const { Vector3<T> out(-z_*v.y(),z_*v.x(),0); return out; } 
 
    T operator|(const AVector2<T> &v) const { return z_*v.z(); } 
    T operator|(const Vector2<T> &) const { return 0; }         
    T operator|(const Vector3<T> &v) const { return z_*v.z(); }  
 
    Vector2<T> toVector2() const { return Vector2<T>(0); }      
    Vector3<T> toVector3() const { return Vector3<T>(0,0,z_); } 
 
private:
    T z_=T{};
};
 
template <class T> inline Vector2<T> operator&(const Vector2<T> &v,const AVector2<T> &av) {
    Vector2<T> out(v.y()*av.z(),-v.x()*av.z());
    return out;
}
 
template <class T> inline Vector3<T> operator&(const Vector3<T> &v,const AVector2<T> &av) {
    Vector3<T> out(v.y()*av.z(),-v.x()*av.z(),0);
    return out;
}
 
template <class T> inline AVector2<T> operator&(const Vector2<T> &v1,const Vector2<T> &v2) {
    AVector2<T> out((v1.x()*v2.y()) - (v1.y()*v2.x()));
    return out;
}
 
template <class T> inline T operator|(const Vector2<T> &,const AVector2<T> &) { return 0; }
 
 
 
 
 
template <class T> class AVector3 : public Vector3<T> {
public:
    using Vector3<T>::Vector3;
    constexpr AVector3()=default;
    constexpr AVector3(const AVector3<T> &)=default;
    constexpr AVector3<T> &operator=(const AVector3<T> &)=default;
 
    AVector3(const Vector3<T> &v) : Vector3<T>(v) { }
    explicit AVector3(const AVector2<T> &v) : Vector3<T>(0,0,v.z()) { }
 
    Vector2<T> toVector2() const { return Vector2<T>(this->x(),this->y()); }
    const Vector3<T> &toVector3() const { return *this; }
};
 
// Naming convention for most commonly used types.
using DAVect2 = AVector2<double>; 
using FAVect2 = AVector2<float>; 
using IAVect2 = AVector2<int32>; 
using UAVect2 = AVector2<uint32>; 
using DAVect3 = AVector3<double>; 
using FAVect3 = AVector3<float>; 
using IAVect3 = AVector3<int32>; 
using UAVect3 = AVector3<uint32>  ; 
 
// Conversion routines.
template <class T> inline DAVect2 toDAVect2(const AVector2<T> &v) { DAVect2 dv2(to<double>(v.z()));  return dv2; }
template <class T> inline FAVect2 toFAVect2(const AVector2<T> &v) { FAVect2 fv2(to<float>(v.z()));  return fv2; }
template <class T> inline IAVect2 toIAVect2(const AVector2<T> &v) { IAVect2 iv2(to<int32>(v.z()));  return iv2; }
template <class T> inline UAVect2 toUAVect2(const AVector2<T> &v) { UAVect2 uv2(to<uint32>(v.z()));  return uv2; }
 
template <class T> inline DAVect3 toDAVect3(const Vector3<T> &v) {
    DAVect3 dv3(to<double>(v.x()),to<double>(v.y()),to<double>(v.z()));
    return dv3;
}
 
template <class T> inline FAVect3 toFAVect3(const Vector3<T> &v) {
    FAVect3 fv3(to<float>(v.x()),to<float>(v.y()),to<float>(v.z()));
    return fv3;
}
 
template <class T> inline IAVect3 toAIVect3(const Vector3<T> &v) {
    IAVect3 iv3(to<int32>(v.x()),to<int32>(v.y()),to<int32>(v.z()));
    return iv3;
}
 
template <class T> inline UAVect3 toAUVect3(const Vector3<T> &v) {
    UAVect3 uv3(to<uint32>(v.x()),to<uint32>(v.y()),to<uint32>(v.z()));
    return uv3;
}
 
template <class T> inline Vector2<T> toVect2(const AVector2<T> &) { return Vector2<T>(0); }
template <class T> inline Vector3<T> toVect3(const AVector2<T> &v) { return Vector3<T>(0,0,v.z()); }
template <class T> inline Vector2<T> toVect2(const AVector3<T> &v) { return Vector2<T>(v.x(),v.y()); }
template <class T> inline const Vector3<T> &toVect3(const AVector3<T> &v) { return v; }
 
template <class T> inline const AVector2<T> &toAVect2(const AVector2<T> &v) { return v; }
template <class T> inline AVector2<T>        toAVect2(const AVector3<T> &v) { return AVector2<T>(v.z()); }
template <class T> inline AVector3<T>        toAVect3(const AVector2<T> &v,const T &x=0,const T &y=0) { return Vector3<T>(x,y,v.z()); }
template <class T> inline const AVector3<T> &toAVect3(const AVector3<T> &v) { return v; }
 
template <class T> inline AVector3<T> vmax(const AVector3<T> &v1,const AVector3<T> &v2) {
    AVector3<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 AVector3<T> vmin(const AVector3<T> &v1,const AVector3<T> &v2) {
    AVector3<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 AVector3<T> vsign(const AVector3<T> &v1,const AVector3<T> &v2) {
    AVector3<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 AVector3<T> vceil(const AVector3<T> &v) {
    AVector3<T> out(ceil(v.x()),ceil(v.y()),ceil(v.z()));
    return out;
}
 
template <class T> inline AVector2<T> vmax(const AVector2<T> &v1,const AVector2<T> &v2) {
    AVector2<T> out(std::max<T>(v1.z(),v2.z()));
    return out;
}
 
template <class T> inline AVector2<T> vmin(const AVector2<T> &v1,const AVector2<T> &v2) {
    AVector2<T> out(std::min<T>(v1.z(),v2.z()));
    return out;
}
 
template <class T> inline AVector2<T> vsign(const AVector2<T> &v1,const AVector2<T> &v2) {
    AVector2<T> out(v2.z() < 0 ? -qAbs(v1.z()) : qAbs(v1.z()));
    return out;
}
 
template <class T> inline AVector2<T> vceil(const AVector2<T> &v) {
    AVector2<T> out(ceil(v.z()));
    return out;
}
 
template <typename T>
constexpr T safeMag2(const AVector2<T> &v) { return ::safeSquare(v.z()); }
 
template <typename T>
constexpr T safeMag(const AVector2<T> &v) { 
    return std::sqrt(safeMag2(v)); 
}
 
template <typename T>
constexpr AVector2<T> safeUnit(const AVector2<T> &v) { 
    return v.unit();
}
 
template <typename T>
constexpr const AVector2<T> safeDiv(const AVector2<T> &a,const AVector2<T> &b,const AVector2<T> &safe=AVector2<T>(0)) { 
    T ret(::safeDiv(a.z(),b.z(),safe.z()));  
    return AVector2<T>(ret); 
}
 
template <typename T>
constexpr const AVector2<T> safeDiv(const AVector2<T> &a,const T &v,const AVector2<T> &safe=AVector2<T>(0)) { 
    T ret(::safeDiv(a.z(),v,safe.z()));  
    return AVector2<T>(ret); 
}
 
template <typename T>
constexpr bool isFinite(const AVector2<T> &a) { 
    return std::isfinite(a.z());
}
 
namespace base {
    template <class T>
    inline string ts(const AVector2<T> &t, int width=0, char notation = '\0', int precision = -1, char fill = ' ') {
        return ts(t.z(), width, notation, precision, fill);
    }
 
    template <class T>
    inline string ts(const AVector3<T> &t, int width=0, char notation = '\0', int precision = -1, char fill = ' ') {
        return ts(toVect3(t), width, notation, precision, fill);
    }
}
 
// EOF