Vector2< T > Class Template Reference

#include <vector2.h>

Collaboration diagram for Vector2< T >:

[legend]List of all members.

Public Member Functions
	Vector2 ()
	Vector2 (T x, T y)
T	GetX () const
T	GetY () const
bool	IsZero (T val) const
bool	operator== (const Vector2< T > &p2) const
bool	operator!= (const Vector2< T > &p2) const
bool	operator>= (const Vector2< T > &p2) const
bool	operator<= (const Vector2< T > &p2) const
Vector2< T >	operator+ (const Vector2< T > &p2) const
Vector2< T >	operator- (const Vector2< T > &p2) const
Vector2< T >	operator- () const
Vector2< T >	operator * (const Vector2< T > &p2) const
Vector2< T >	operator/ (const Vector2< T > &p2) const
Vector2< T >	operator% (const Vector2< T > &p2) const
Vector2< T >	operator+ (const T val) const
Vector2< T >	operator- (const T val) const
Vector2< T >	operator * (const T val) const
Vector2< T >	operator/ (const T val) const
void	operator+= (const T val)
void	operator-= (const T val)
void	operator *= (const T val)
void	operator+= (const Vector2< T > &p2)
void	operator-= (const Vector2< T > &p2)
Vector2< T >	operator * (const Vector2< double > &p2)
Vector2< T >	inf (const Vector2< T > &p2)
Vector2< T >	min (const Vector2< T > &p2) const
Vector2< T >	max (const Vector2< T > &p2) const
Vector2< T >	clamp (const Vector2< T > &min, const Vector2< T > &max) const
double	Distance (const Vector2< T > p2) const
double	Norm () const
void	Clear ()
void	SetValues (T xx, T yy)
void	SetValues (Vector2< T > v2)
bool	IsXNull () const
bool	IsYNull () const
bool	IsNull () const
double	ComputeAngle () const
double	ComputeAngle (const Vector2< T > v2) const
Public Attributes
T	x
T	y
Static Private Attributes
static const double	EPS_ZERO = 0.05

---

Detailed Description

template<class T>
class Vector2< T >

Class for storing a vector of two points x, y.

Definition at line 10 of file vector2.h.

---

Constructor & Destructor Documentation

template<class T>

Vector2< T >::Vector2

(

)

[inline]

Default constructor that will be a vector null (0, 0)

Definition at line 21 of file vector2.h.

                                {
                        x = 0;
                        y = 0;
                }

Here is the caller graph for this function:

template<class T>

Vector2< T >::Vector2	(	T	x,
		T	y
	)			[inline]

Constructor that build a new vector from two values, x and y.

Parameters:

	x
	y

Definition at line 32 of file vector2.h.

                                        {
                        this->x = x;
                        this->y = y;
                }

---

Member Function Documentation

template<class T>

Vector2<T> Vector2< T >::clamp	(	const Vector2< T > &	min,
		const Vector2< T > &	max
	)			const [inline]

Definition at line 265 of file vector2.h.

                                                                                           {
                        Vector2<T> r = *this;
                        r = r.max(min);
                        return r.min(max);
                }

Here is the caller graph for this function:

template<class T>

void Vector2< T >::Clear

(

)

[inline]

Definition at line 290 of file vector2.h.

                            {
                        x = 0;
                        y = 0;
                }

Here is the caller graph for this function:

template<class T>

double Vector2< T >::ComputeAngle

(

const Vector2< T >

v2

)

const [inline]

Parameters:

v2

Definition at line 374 of file vector2.h.

                                                              {
                        Vector2<T> veq( v2.x - x, v2.y - y);

                        return veq.ComputeAngle();
                }

template<class T>

double Vector2< T >::ComputeAngle

(

)

const [inline]

Calcule l'angle en radian du point M dans le repère de centre O

Pour O=(0,0) :

• M=(10,10) -> PI/4 (0.78)
• M=(0,10) -> PI/2 (1.57)
• M=(-10,10) -> 3*PI/4 (2.35)
• M=(10,-10) -> -PI/4 (-0.78)
• M=O -> 0

Definition at line 342 of file vector2.h.

                                           {
                  double angle;

                  if( !IsZero( x ) )
                    if( !IsZero( y ) ){
                      angle = atan(double(y)/double(x));
                      if( x < 0 )
                        if( y > 0 )
                          angle += M_PI;
                        else
                          angle -= M_PI;
                    }
                    else
                      if( x > 0)
                        angle = 0;
                      else
                        angle = M_PI;
                  else
                    if( y > 0 )
                      angle = M_PI_2;
                    else if(y < 0)
                      angle = -M_PI_2;
                    else
                      angle = 0;

                  return angle;
                }

Here is the caller graph for this function:

template<class T>

double Vector2< T >::Distance

(

const Vector2< T >

p2

)

const [inline]

Parameters:

p2

Definition at line 275 of file vector2.h.

                                                                 {
                        double distPow2 = (p2.x-x)*(p2.x-x) + (p2.y-y)*(p2.y-y);
                        return sqrt( distPow2 );
                }

Here is the caller graph for this function:

template<class T>

T Vector2< T >::GetX

(

)

const [inline]

Return the x coordinate.

Definition at line 40 of file vector2.h.

                                     {
                        return x;
                }

Here is the caller graph for this function:

template<class T>

T Vector2< T >::GetY

(

)

const [inline]

Return the y coordinate.

Definition at line 47 of file vector2.h.

                                     {
                        return y;
                }

Here is the caller graph for this function:

template<class T>

Vector2<T> Vector2< T >::inf

(

const Vector2< T > &

p2

)

[inline]

Return the comparaison of two vector in the form of a vector.

Parameters:

p2

Returns:

A vector in which the elements are equal to 1 where the comparaison is true, 0 elsewhere.

Definition at line 239 of file vector2.h.

                                                           {
                        return Vector2<T>( x < p2.x ? 1:0,
                                        y < p2.y ? 1:0);
                }

Here is the caller graph for this function:

template<class T>

bool Vector2< T >::IsNull

(

)

const [inline]

Definition at line 328 of file vector2.h.

                                   {
                        return IsXNull() && IsYNull();
                }

Here is the caller graph for this function:

template<class T>

bool Vector2< T >::IsXNull

(

)

const [inline]

Definition at line 314 of file vector2.h.

                                           {
                        return IsZero( x );
                }

Here is the caller graph for this function:

template<class T>

bool Vector2< T >::IsYNull

(

)

const [inline]

Definition at line 321 of file vector2.h.

                                           {
                        return IsZero( y );
                }

Here is the caller graph for this function:

template<class T>

bool Vector2< T >::IsZero

(

T

val

)

const [inline]

Definition at line 54 of file vector2.h.

                                               {
                        return (val == 0 || val <= VECTOR2_EPS_ZERO) &&
                               (-val <= VECTOR2_EPS_ZERO);
                }

Here is the caller graph for this function:

template<class T>

Vector2<T> Vector2< T >::max

(

const Vector2< T > &

p2

)

const [inline]

Parameters:

p2

Returns:

Definition at line 260 of file vector2.h.

                                                                 {
                        return Vector2<T>( x > p2.x? x:p2.x,
                                               y > p2.y? y:p2.y );
                }

Here is the caller graph for this function:

template<class T>

Vector2<T> Vector2< T >::min

(

const Vector2< T > &

p2

)

const [inline]

Return a vector made of the minimum coordinate of the two vectors. Ce clair ne pas ?

Parameters:

p2

Returns:

Definition at line 251 of file vector2.h.

                                                                 {
                        return Vector2<T>( x < p2.x? x:p2.x,
                                        y < p2.y? y:p2.y );
                }

Here is the caller graph for this function:

template<class T>

double Vector2< T >::Norm

(

)

const [inline]

Definition at line 283 of file vector2.h.

                                   {
                        return Distance( Vector2(0,0) );
                }

Here is the caller graph for this function:

template<class T>

Vector2<T> Vector2< T >::operator *

(

const Vector2< double > &

p2

)

[inline]

Definition at line 224 of file vector2.h.

                                                                      {
                        Vector2<T> r;

                        r.x = (T)((double)x * p2.x);
                        r.y = (T)((double)y * p2.y);

                        return r;
                }

template<class T>

Vector2<T> Vector2< T >::operator *

(

const T

val

)

const [inline]

Definition at line 159 of file vector2.h.

                                                              {
                        return Vector2<T>(x * val, y * val);
                }

template<class T>

Vector2<T> Vector2< T >::operator *

(

const Vector2< T > &

p2

)

const [inline]

Parameters:

p2

Definition at line 122 of file vector2.h.

                                                                       {
                        return Vector2<T>(x * p2.x, y * p2.y);
                }

template<class T>

void Vector2< T >::operator *=

(

const T

val

)

[inline]

Definition at line 195 of file vector2.h.

                                                   {
                        x *= val;
                        y *= val;
                }

template<class T>

bool Vector2< T >::operator!=

(

const Vector2< T > &

p2

)

const [inline]

Parameters:

p2

Definition at line 72 of file vector2.h.

                                                                  {
                        return (x != p2.x) || (y != p2.y);
                }

template<class T>

Vector2<T> Vector2< T >::operator%

(

const Vector2< T > &

p2

)

const [inline]

Definition at line 134 of file vector2.h.

                                                                       {
                        return Vector2<T>(x % p2.x, y % p2.y);
                }

template<class T>

Vector2<T> Vector2< T >::operator+

(

const T

val

)

const [inline]

Parameters:

val

Definition at line 144 of file vector2.h.

                                                              {
                        return Vector2<T>(x + val, y + val);
                }

template<class T>

Vector2<T> Vector2< T >::operator+

(

const Vector2< T > &

p2

)

const [inline]

Parameters:

p2

Definition at line 98 of file vector2.h.

                                                                       {
                        return Vector2<T>(x + p2.x, y + p2.y);
                }

template<class T>

void Vector2< T >::operator+=

(

const Vector2< T > &

p2

)

[inline]

Parameters:

p2

Definition at line 206 of file vector2.h.

                                                            {
                        x += p2.x;
                        y += p2.y;
                }

template<class T>

void Vector2< T >::operator+=

(

const T

val

)

[inline]

Parameters:

val

Definition at line 178 of file vector2.h.

                                                   {
                        x += val;
                        y += val;
                }

template<class T>

Vector2<T> Vector2< T >::operator-

(

const T

val

)

const [inline]

Parameters:

val

Definition at line 152 of file vector2.h.

                                                              {
                        return Vector2<T>(x - val, y - val);
                }

template<class T>

Vector2<T> Vector2< T >::operator-

(

)

const [inline]

Returns:

the negative value of ourself

Definition at line 114 of file vector2.h.

                                                   {
                        return Vector2<T>(-x, -y);
                }

template<class T>

Vector2<T> Vector2< T >::operator-

(

const Vector2< T > &

p2

)

const [inline]

Parameters:

p2

Definition at line 106 of file vector2.h.

                                                                       {
                        return Vector2<T>(x - p2.x, y - p2.y);
                }

template<class T>

void Vector2< T >::operator-=

(

const Vector2< T > &

p2

)

[inline]

Parameters:

p2

Definition at line 214 of file vector2.h.

                                                            {
                        x -= p2.x;
                        y -= p2.y;
                }

template<class T>

void Vector2< T >::operator-=

(

const T

val

)

[inline]

Parameters:

val

Definition at line 187 of file vector2.h.

                                                   {
                        x -= val;
                        y += val;
                }

template<class T>

Vector2<T> Vector2< T >::operator/

(

const T

val

)

const [inline]

Parameters:

val

Definition at line 167 of file vector2.h.

                                                              {
                        return Vector2<T>(x / val, y / val);
        }

template<class T>

Vector2<T> Vector2< T >::operator/

(

const Vector2< T > &

p2

)

const [inline]

Parameters:

p2

Definition at line 130 of file vector2.h.

                                                                       {
                        return Vector2<T>(x / p2.x, y / p2.y);
                }

template<class T>

bool Vector2< T >::operator<=

(

const Vector2< T > &

p2

)

const [inline]

Parameters:

p2

Definition at line 88 of file vector2.h.

                                                                  {
                        return (x <= p2.x) && (y <= p2.y);
                }

template<class T>

bool Vector2< T >::operator==

(

const Vector2< T > &

p2

)

const [inline]

Definition at line 64 of file vector2.h.

                                                                  {
                        return IsZero(x - p2.x) && IsZero(y - p2.y);
                }

template<class T>

bool Vector2< T >::operator>=

(

const Vector2< T > &

p2

)

const [inline]

Parameters:

p2

Definition at line 80 of file vector2.h.

                                                                  {
                        return (x >= p2.x) && (y >= p2.y);
                }

template<class T>

void Vector2< T >::SetValues

(

Vector2< T >

v2

)

[inline]

Definition at line 306 of file vector2.h.

                                              {
                        x = v2.x;
                        y = v2.y;
                }

template<class T>

void Vector2< T >::SetValues	(	T	xx,
		T	yy
	)			[inline]

Definition at line 298 of file vector2.h.

                                            {
                        x = xx;
                        y = yy;
                }

Here is the caller graph for this function:

---

Member Data Documentation

template<class T>

const double Vector2< T >::EPS_ZERO = 0.05 [static, private]

Definition at line 13 of file vector2.h.

template<class T>

T Vector2< T >::x

Definition at line 16 of file vector2.h.

template<class T>

T Vector2< T >::y

Definition at line 16 of file vector2.h.

---

The documentation for this class was generated from the following file:

• src/tool/vector2.h

---