vec2.h

Go to the documentation of this file.

/*
 * $Id: vec2.h,v 1.7 2003/09/15 17:15:31 jmk Exp $
 */
///////////////////////////////////////////////////////////////////////////
//              _____________  ______________________    __   __  _____
//             /  ________  |  |   ___   ________   /   |  \ /  \   |
//            |  |       |  |_ |  |_ |  |       /  /    \__  |      |
//            |  |  ___  |  || |  || |  |      /  /        | |      |
//            |  | |   \ |  || |  || |  |     /  /      \__/ \__/ __|__
//            |  | |_@  ||  || |  || |  |    /  /          Institute
//            |  |___/  ||  ||_|  || |  |   /  /_____________________
//             \_______/  \______/ | |__|  /___________________________
//                        |  |__|  |
//                         \______/
//                    University of Utah       
//                           2002
///////////////////////////////////////////////////////////////////////////

// vec2.h

#ifndef GUTZ_VEC2_H
#define GUTZ_VEC2_H

#include "mm.h"
#include <iostream>
#include <sstream>

namespace gutz
{
template <class T>
class vec3;

template <class T>
class vec4;

template <class T>
class mat2;

template <class T>
class vec2
{
public:
        inline vec2 ();
    inline vec2 (const T );
    inline vec2 (const T, const T);
    inline vec2 (const vec2&); 
    inline vec2 (const vec3<T>&);
    inline vec2 (const vec4<T>&);
    inline ~vec2 () {}

    inline vec2& operator= (const vec2&);
    inline vec2& operator+= (const vec2&);
    inline vec2& operator-= (const vec2&);
    inline vec2& operator*= (const T);
    inline vec2& operator/= (const T);
    inline vec2& operator*= (const vec2&); // Component wise
    inline vec2& operator/= (const vec2&);
    inline vec2& operator*= (const mat2<T>&);
  
    inline vec2 operator+ (const vec2&) const;
    inline vec2 operator- (const vec2&) const;
    inline vec2 operator- () const;
    inline vec2 operator* (const T) const;
    inline vec2 operator/ (const T) const;
    inline vec2 operator* (const vec2&) const; // Component wise
    inline vec2 operator/ (const vec2&) const;

    inline bool operator== (const vec2&) const;
    inline bool operator!= (const vec2&) const;
    inline bool operator< (const vec2&) const;
    inline bool operator> (const vec2&) const;
    inline bool operator<= (const vec2&) const;
    inline bool operator>= (const vec2&) const;

    inline T* v ();
        inline const T* v () const;
    inline void set(const T, const T);
    inline T& operator[] (const int);
        inline const T& operator[] (const int) const;

    inline T norm () const;
    inline T norm2 () const;
    inline T normalize ();

    inline vec2 abs () const;
    inline T dot (const vec2&) const;

    inline bool equal (const vec2&, const T) const;

public:
        //data element names, (w) as in (w,h) is not allowed
        //   since "w" is taken by the (x,y,z,w) of vec4
    union { T x; T R; T s; T v0;};
    union { T y; T G; T t; T v1;};
};


//-----------------------------------------------------------------------------
// Usefull typedefs
//-----------------------------------------------------------------------------
typedef vec2<char> vec2b;
typedef vec2<uchar> vec2ub;
typedef vec2<char> vec2c;
typedef vec2<uchar> vec2uc;
typedef vec2<short> vec2s;
typedef vec2<ushort> vec2us;
typedef vec2<int> vec2i;
typedef vec2<uint> vec2ui;
typedef vec2<llong> vec2ll;
typedef vec2<ullong> vec2ull;
typedef vec2<float> vec2f;
typedef vec2<double> vec2d;

#define str2vec2b str2vec2<char>
#define str2vec2ub str2vec2<uchar>
#define str2vec2c str2vec2<char>
#define str2vec2uc str2vec2<uchar>
#define str2vec2s str2vec2<short>
#define str2vec2us str2vec2<ushort>
#define str2vec2i str2vec2<int>
#define str2vec2ui str2vec2<uint>
#define str2vec2l str2vec2<long>
#define str2vec2ul str2vec2<ulong>
#define str2vec2ll str2vec2<llong>
#define str2vec2ull str2vec2<ullong>
#define str2vec2f str2vec2<float>
#define str2vec2d str2vec2<double>

//-----------------------------------------------------------------------------
// external functions
//-----------------------------------------------------------------------------

template <class T>
inline
vec2<T>
operator* (const T, const vec2<T>&);

template <class T>
std::ostream&
operator<< (std::ostream& os, const vec2<T>& v)
{
    os << v.x << " " << v.y;
    return os;
}

template <class T>
std::istream&
operator>> (std::istream& is, vec2<T>& v)
{
    is >> v.x;
    is >> v.y;
    return is;
}

template <class T>
bool
str2vec2 (const std::string& s, vec2<T>& v)
{
    std::istringstream z(s);
    vec2<T> w;
    bool status = z.eof();
    z >> w.x;
    status = status || z.fail() || z.eof();
    z >> w.y;
    status = status || z.fail();
    if (!status) v = w;
    return status;
}

template <class T>
bool
str2vec2 (const std::string*, vec2<T>&);

//-----------------------------------------------------------------------------
// Implementation
//-----------------------------------------------------------------------------

template <class T>
vec2<T>::vec2 ()
    : x(0), y(0) {}


template <class T>
vec2<T>::vec2 (const T v0)
    : x(v0), y(v0) {}

template <class T>
vec2<T>::vec2 (const T x0, const T y0)
    : x(x0), y(y0) {}

template <class T>
vec2<T>::vec2 (const vec2& v)
: x(v.x), y(v.y) {}

template <class T>
vec2<T>::vec2 (const vec3<T>& v)
    : x(v.x), y(v.y) {}

template <class T>
vec2<T>::vec2 (const vec4<T>& v)
    : x(v.x), y(v.y) {}

template <class T>
vec2<T>&
vec2<T>::operator= (const vec2& v)
{
        if( v != *this ) {
                x = v.x; y = v.y;
        }
        return *this;
}

template <class T>
vec2<T>&
vec2<T>::operator+= (const vec2& v)
{
    x += v.x; y += v.y;
    return *this;
}

template <class T>
vec2<T>&
vec2<T>::operator-= (const vec2& v)
{
    x -= v.x; y -= v.y;
    return *this;
}

template <class T>
vec2<T>&
vec2<T>::operator*= (const T c)
{
    x *= c; y *= c;
    return *this;
}

template <class T>
vec2<T>&
vec2<T>::operator/= (const T c)
{
    x /= c; y /= c;
    return *this;
}

template <class T>
vec2<T>&
vec2<T>::operator*= (const vec2& v)
{
    x *= v.x; y *= v.y;
    return *this;
}

template <class T>
vec2<T>&
vec2<T>::operator/= (const vec2& v)
{
    x /= v.x; y /= v.y;
    return *this;
}

template <class T>
vec2<T>
vec2<T>::operator+ (const vec2& v) const
{
    return vec2(x + v.x, y + v.y);
}

template <class T>
vec2<T>
vec2<T>::operator- (const vec2& v) const
{
    return vec2(x - v.x, y - v.y);
}

template <class T>
vec2<T>
vec2<T>::operator- () const
{
    return vec2(-x, -y);
}

template <class T>
vec2<T>
vec2<T>::operator* (const T c) const
{
    return vec2(c*x, c*y);
}

template <class T>
vec2<T>
vec2<T>::operator/ (const T c) const
{
    return vec2(x/c, y/c);
}

template <class T>
vec2<T>
operator/(const T c, const vec2<T> &v)
{
   return vec2<T>(c/v.x, c/v.y);
}

template <class T>
vec2<T>
vec2<T>::operator* (const vec2& v) const
{
    return vec2(v.x*x, v.y*y);
}

template <class T>
vec2<T>
vec2<T>::operator/ (const vec2& v) const
{
    return vec2(x/v.x, y/v.y);
}

template <class T>
bool
vec2<T>::operator== (const vec2<T>& v) const
{
    return (x == v.x && y == v.y);
}

template <class T>
bool
vec2<T>::operator!= (const vec2<T>& v) const
{
    return (x != v.x || y != v.y);
}

template <class T>
bool
vec2<T>::operator< (const vec2<T>& v) const
{
    return (x < v.x && y < v.y);
}

template <class T>
bool
vec2<T>::operator> (const vec2<T>& v) const
{
    return (x > v.x && y > v.y);
}

template <class T>
bool
vec2<T>::operator<= (const vec2<T>& v) const
{
    return (x <= v.x && y <= v.y);
}

template <class T>
bool
vec2<T>::operator>= (const vec2<T>& v) const
{
    return (x >= v.x && y >= v.y);
}

template <class T>
T*
vec2<T>::v ()
{
    return &x;
}

template <class T>
const T*
vec2<T>::v () const
{
    return &x;
}

template <class T>
void
vec2<T>::set (const T x0, const T y0)
{
    x = x0; y = y0;
}

template <class T>
T&
vec2<T>::operator[] (const int i)
{
    return v()[i];
}

template <class T>
const T&
vec2<T>::operator[] (const int i) const
{
        return v()[i];
}

template <class T>
T
vec2<T>::norm () const
{
    return sqrt(x*x + y*y);
}

template <class T>
T
vec2<T>::norm2 () const
{
    return x*x + y*y;
}

template <class T>
T
vec2<T>::normalize ()
{
    T norm = sqrt(x*x + y*y);
    T d = 1/norm;
    x *= d; y *= d;
    return norm;
}

template <class T>
vec2<T>
vec2<T>::abs () const
{
    return vec2<T>(mm_abs(x), mm_abs(y));
}

template <class T>
T
vec2<T>::dot (const vec2& v) const
{
    return x*v.x + y*v.y;
}

template <class T>
bool
vec2<T>::equal (const vec2& v, const T tol) const
{
    T dx = x - v.x;
    T dy = y - v.y;
    return (dx*dx + dy*dy) <= tol*tol;
}

template <class T>
vec2<T>
operator* (const T c, const vec2<T>& v)
{
    return vec2<T> (v.x*c, v.y*c);
}

template <class T>
bool
str2vec2 (const std::string* s, vec2<T>& v)
{
    if (!s) return true;
    return str2vec2(*s, v);
}


#if __win32
inline 
vec2d
mm_castf2d (vec2f v)
{
    return vec2d(v.x, v.y);
}

inline 
vec2f
mm_castd2f (vec2d v)
{
    return vec2f((float)v.x, (float)v.y);
}
#else //__real_os
template <class T1, class T2>
vec2<T2>
mm_cast (vec2<T1> v)
{
    return vec2<T2>(v.x, v.y);
}
#endif

}// End of namespace gutz

#endif // vec2_h

---

Send questions, comments, and bug reports to: