vect2.hpp

//
// Copyright (c) Singular Inversions Inc. 1998.
//
// 2D vector class of templated type. All member functions except
// rotate can be defined for 'int', 'float' or 'double'.
//
// Objects of this class were designed to act like built-ins with respect
// to operators, with 2 differences: 1. Operators which modify the object
// (+=,-=,*=,/=) do not return an instance as well, for efficiency. 2.
// Operators which return an object (all others) return it const to avoid
// silly things like (a + b) += c;
//
// Design Decisions: 'const' member functions are used whenever member
// values remain unchanged. 'const' return values are used throughout,
// as described in [Meyers 98] Item 22. Pass by reference is not used
// for the arguments since 1. Most functions are inline and have no
// passing, and 2. The data type is almost as small as a pointer anyway.
 
#ifndef FR2_VECT2_HPP
#define FR2_VECT2_HPP
 
#include "FgSerial.hpp"
 
namespace Fg {
 
template<class T> class FR2Vect2TC
{
public:
    T      x1,x2;
 
                // Constructors:
    FR2Vect2TC() : x1(T(0)), x2(T(0)) {};                       // default.
        FR2Vect2TC(const FR2Vect2TC &v) = default;
    FR2Vect2TC &            operator=(FR2Vect2TC const &) = default;
        explicit FR2Vect2TC(T a) : x1(a), x2(a) {};             // initialize to single val.
        FR2Vect2TC(T y1,T y2) : x1(y1), x2(y2) {};              // initialize all vals.
    template<class U> 
    explicit FR2Vect2TC(const FR2Vect2TC<U>& v) {futConvert(v.x1,x1); futConvert(v.x2,x2); }
 
        T&                                              operator[](unsigned int n)
                                                        {FGASSERT_FAST(n < 2);return (&x1)[n];}
        T const&                                operator[](unsigned int n) const
                                                        {FGASSERT_FAST(n < 2);return (&x1)[n];}
 
        void                                    set(T a) {x1 = a;x2 = a;}
    inline const FR2Vect2TC operator-() const;
    inline void                         operator-=(FR2Vect2TC);
    inline void                         operator+=(FR2Vect2TC);
    inline const FR2Vect2TC     operator+(const FR2Vect2TC&) const;
    inline const FR2Vect2TC     operator-(const FR2Vect2TC&) const;
    inline const FR2Vect2TC     operator*(T) const;
    inline const FR2Vect2TC     operator/(T) const;
    inline void                         operator/=(T);
    inline void                         operator*=(T);
    inline bool                 operator==(const FR2Vect2TC &v) const
                                                        {return (x1==v.x1 && x2==v.x2);}
    inline bool                 operator!=(const FR2Vect2TC &v) const
                                                        {return (x1!=v.x1 || x2!=v.x2);}
                // Note that the MS-specific _hypot is faster for len() and
                // could be used within an #ifdef WIN32 if speedup is required.
        inline T const                  len() const {return((T)sqrt(x1*x1 + x2*x2));}
    inline T const                      mag() const {return(x1*x1 + x2*x2);}
    const FR2Vect2TC        rotate(T) const;    // This function is only actually
                                                                                                // defined for float and double,
                                                                                                // not int.
        inline T const                  dot(FR2Vect2TC) const;  // Dot product.
    inline T const          cross(FR2Vect2TC) const; // Returns Z component
                                                     // of cross product
};
 
// **********************************************************************
// **********************************************************************
 
typedef FR2Vect2TC<int>         FR2Vect2IC;
typedef FR2Vect2TC<float>       FR2Vect2FC;
typedef FR2Vect2TC<double>      FR2Vect2DC;
typedef FR2Vect2TC<int>         FutVect2IC;             // convention.
typedef FR2Vect2TC<float>       FutVect2FC;
 
std::ostream& operator<<(std::ostream& s,FR2Vect2IC vec);
std::ostream& operator<<(std::ostream& s,FR2Vect2FC vec);
std::ostream& operator<<(std::ostream& s,FR2Vect2DC vec);
 
template <class T>
struct FgVect2LessThanByAxisT
{
    bool operator()(const FR2Vect2TC<T> &x, const FR2Vect2TC<T> &y) const
            { return ((x.x2 < y.x2) ||
                      (x.x2 == y.x2 && x.x1 < y.x1)); }
};
 
typedef FgVect2LessThanByAxisT<short>  FgVect2SLess;
typedef FgVect2LessThanByAxisT<int>    FgVect2ILess;
typedef FgVect2LessThanByAxisT<float>  FutVect2LessFC;
typedef FgVect2LessThanByAxisT<double> FutVect2LessDC;
 
template<class T>
const inline FR2Vect2TC<T> FR2Vect2TC<T>::operator-() const
{
    return FR2Vect2TC<T>(-x1,-x2);
}
 
template<class T>
const inline FR2Vect2TC<T> FR2Vect2TC<T>::operator+(
    const FR2Vect2TC<T>   &v1)
        const
{
    return FR2Vect2TC<T>(x1 + v1.x1,
                         x2 + v1.x2);
}
 
template<class T>
const inline FR2Vect2TC<T> FR2Vect2TC<T>::operator-(
    const FR2Vect2TC<T>   &v1)
        const
{
    return FR2Vect2TC<T>(x1 - v1.x1,
                         x2 - v1.x2);
}
 
template<class T>
inline void FR2Vect2TC<T>::operator-=(
    FR2Vect2TC<T>   v)
{
    x1 -= v.x1;
    x2 -= v.x2;
}
 
template<class T>
inline void FR2Vect2TC<T>::operator+=(
    FR2Vect2TC<T>   v)
{
    x1 += v.x1;
    x2 += v.x2;
}
 
template<class T>
const inline FR2Vect2TC<T> FR2Vect2TC<T>::operator*(
    T      val)
        const
{
    return FR2Vect2TC<T>(x1*val, x2*val);
}
 
template<class T>
const inline FR2Vect2TC<T> FR2Vect2TC<T>::operator/(
    T      val)
        const
{
        FGASSERT_FAST(val != (T)0);
 
    return FR2Vect2TC<T>(x1/val, x2/val);
}
 
template<class T>
inline void FR2Vect2TC<T>::operator/=(
    T      val)
{
        FGASSERT_FAST(val != (T)0);
    x1 /= val;
    x2 /= val;
}
 
template<class T>
inline void FR2Vect2TC<T>::operator*=(
    T           val)
{
    x1 *= val;
    x2 *= val;
}
 
template<class T>
inline T const  FR2Vect2TC<T>::dot(
    FR2Vect2TC<T>   operand)
        const
{
    return(x1*operand.x1 + x2*operand.x2);
}
 
template<class T>
inline T const FR2Vect2TC<T>::cross(
    FR2Vect2TC<T>   v2)
    const
{
    return (x1*v2.x2 - x2*v2.x1);
}
 
}
 
#endif