glc_vector2d.h

Go to the documentation of this file.

/****************************************************************************

 This file is part of the GLC-lib library.
 Copyright (C) 2005-2008 Laurent Ribon (laumaya@users.sourceforge.net)
 Version 2.0.0 Beta 1, packaged on April 2010.

 http://glc-lib.sourceforge.net

 GLC-lib is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 GLC-lib is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with GLC-lib; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

*****************************************************************************/


#ifndef GLC_VECTOR2D_H_
#define GLC_VECTOR2D_H_

#include <QString>
#include "glc_utils_maths.h"
#include "glc_vector2df.h"

#include "glc_config.h"

// definition global




class GLC_LIB_EXPORT GLC_Vector2d
{
        friend class GLC_Vector4d;
        friend class GLC_Vector3d;

        inline friend GLC_Vector2d operator - (const GLC_Vector2d &Vect)
        {
                return GLC_Vector2d(-Vect.dVecteur[0], -Vect.dVecteur[1]);
        }




public:
        inline GLC_Vector2d()
        {
                dVecteur[0]= 0.0;
                dVecteur[1]= 0.0;
        }

        inline GLC_Vector2d(const double &dX, const double &dY)
        {
                dVecteur[0]= dX;
                dVecteur[1]= dY;
        }

        inline GLC_Vector2d(const GLC_Vector2d &Vect)
        {
                dVecteur[0]= Vect.dVecteur[0];
                dVecteur[1]= Vect.dVecteur[1];
        }



public:

        inline GLC_Vector2d operator + (const GLC_Vector2d &Vect) const
        {
                GLC_Vector2d VectResult(dVecteur[0] + Vect.dVecteur[0], dVecteur[1] + Vect.dVecteur[1]);

                return VectResult;
        }

        inline GLC_Vector2d& operator = (const GLC_Vector2d &Vect)
        {
                dVecteur[0]= Vect.dVecteur[0];
                dVecteur[1]= Vect.dVecteur[1];

                return *this;
        }

        inline GLC_Vector2d& operator = (const GLC_Vector2df &Vect)
        {
                dVecteur[0]= static_cast<double>(Vect.vector[0]);
                dVecteur[1]= static_cast<double>(Vect.vector[1]);

                return *this;
        }


        inline GLC_Vector2d* operator += (const GLC_Vector2d &Vect)
        {
                *this= *this + Vect;
                return this;
        }


        inline GLC_Vector2d operator - (const GLC_Vector2d &Vect) const
        {
                GLC_Vector2d VectResult(dVecteur[0] - Vect.dVecteur[0], dVecteur[1] - Vect.dVecteur[1]);

                return VectResult;
        }

        inline GLC_Vector2d* operator -= (const GLC_Vector2d &Vect)
        {
                *this= *this - Vect;
                return this;
        }

        inline double operator ^ (const GLC_Vector2d &Vect) const
        {
                return dVecteur[0] * Vect.dVecteur[1] - dVecteur[1] * Vect.dVecteur[0];
        }

        inline double operator * (const GLC_Vector2d &Vect) const
        {
                return dVecteur[0] * Vect.dVecteur[0] + dVecteur[1] * Vect.dVecteur[1];
        }

        inline GLC_Vector2d operator * (double Scalaire) const
        {
                return GLC_Vector2d(dVecteur[0] * Scalaire, dVecteur[1] * Scalaire);;
        }


        inline bool operator == (const GLC_Vector2d &Vect) const
        {
                bool bResult= qFuzzyCompare(dVecteur[0], Vect.dVecteur[0]);
                bResult= bResult && qFuzzyCompare(dVecteur[1], Vect.dVecteur[1]);

                return bResult;
        }

        inline bool operator != (const GLC_Vector2d &Vect) const
        {
                return !(*this == Vect);
        }




public:
        inline GLC_Vector2d& setX(const double &dX)
        {
                dVecteur[0]= dX;
                return *this;
        }

        inline GLC_Vector2d& setY(const double &dY)
        {
                dVecteur[1]= dY;
                return *this;
        }

        inline GLC_Vector2d& setVect(const double &dX, const double &dY)
        {
                dVecteur[0]= dX;
                dVecteur[1]= dY;
                return *this;
        }

        inline GLC_Vector2d& setVect(const GLC_Vector2d &Vect)
        {
                dVecteur[0]= Vect.dVecteur[0];
                dVecteur[1]= Vect.dVecteur[1];
                return *this;
        }




public:
        inline double getX(void) const
        {
                return dVecteur[0];
        }
        inline double getY(void) const
        {
                return dVecteur[1];
        }
        inline const double *return_dVect(void) const
        {
                return dVecteur;
        }
        inline bool isNull(void) const
        {
                return qFuzzyCompare(dVecteur[0], 0.0) && qFuzzyCompare(dVecteur[1], 0.0);
        }
        inline QString toString() const
        {
                return QString("[") + QString::number(dVecteur[0]) + QString(" , ") + QString::number(dVecteur[1]) + QString("]");
        }
        inline GLC_Vector2d perp() const
        {
                return GLC_Vector2d(-dVecteur[1], dVecteur[0]);
        }

//name Private attributes
private:
        double dVecteur[2];

}; //class GLC_Vector2d

typedef GLC_Vector2d GLC_Point2d;

#endif /*GLC_VECTOR2D_H_*/