An Object Finite Element Library

Point2D.h

Go to the documentation of this file.

/*==============================================================================

                                    O  F  E  L  I

                           Object  Finite  Element  Library

  ==============================================================================

   Copyright (C) 1998 - 2008 Rachid Touzani

   This program 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; Version 2 of the License.

   This program 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 this program; if not, write to the :

   Free Software Foundation
   Inc., 59 Temple Place - Suite 330
   Boston, MA  02111-1307, USA

  ==============================================================================

                Definition and Implementation of template class 'Point2D'

  ==============================================================================*/

#ifndef __POINT_2D_H
#define __POINT_2D_H

#include "OFELI_Config.h"
#include "Point.h"

namespace OFELI {

template<class T_>
struct Point2D {

    Point2D() { x = y = T_(0); }

    Point2D(T_ a, T_ b=T_(0)) { x = a; y = b; }

    Point2D(T_ *a) { x = a[0]; y = a[1]; }

    Point2D(const Point2D<T_> &pt) { x = pt.x; y = pt.y; }

    Point2D(const Point<T_> &pt) { x = pt.x; y = pt.y; }

    T_ &operator()(size_t i) 
    {
       if (i==2)
          return y;
       else
          return x;
    }

    const T_ &operator()(size_t i) const
    {
       if (i==2)
          return y;
       else
          return x;
    }

    T_ &operator[](size_t i)
    {
       if (i==1)
          return y;
       else
          return x;
    }

    const T_ &operator[](size_t i) const
    {
       if (i==1)
          return y;
       else
          return x;
    }

    Point2D<T_> & operator=(const Point2D<T_> &p) { x = p.x; y = p.y; return *this; }

    Point2D<T_> & operator+=(const Point2D<T_> &p) { x+=p.x; y+=p.y; return *this; }

    Point2D<T_> & operator-=(const Point2D<T_> &p) { x-=p.x; y-=p.y; return *this; }

    Point2D<T_> & operator=(const T_ &a)  { x = y = a; return *this; }

    Point2D<T_> & operator+=(const T_ &a) { x+=a; y+=a; return *this; }

    Point2D<T_> & operator-=(const T_ &a) { x-=a; y-=a; return *this; }

    Point2D<T_> & operator*=(const T_ &a) { x*=a; y*=a; return *this; }

    Point2D<T_> & operator/=(const T_ &a) { x/=a; y/=a; return *this; }

    bool operator==(const Point2D<T_> &p)
    {
       if (p.x!=x && p.y!=y)
          return false;
       return true;
    }

    bool operator!=(const Point2D<T_> &p)
    {
       if (p.x!=x && p.y!=y)
          return true;
       return false;
    }

    double CrossProduct(const Point2D<double> &lp, const Point2D<double> &rp)
    {
       return (lp.x*rp.y - lp.y*rp.x);
    }

    double NNorm() const { return (x*x + y*y); }

    double Norm() const { return sqrt(NNorm()); }

    Point2D<double> Director(const Point2D<double> &p) const
    {
       double n = p.Norm();
       return Point2D<double>(p.x/n,p.y/n);
    }

    bool isCloseTo(const Point2D<double> &a, double toler=OFELI_TOLERANCE) const
    {
       return (*this,a,toler);
    }

    T_ x;

    T_ y;

};



//-----------------------------------------------------------------------------
// Associated functions
//-----------------------------------------------------------------------------


template <class T_>
bool operator== (const Point2D<T_> &a, const Point2D<T_> &b) { 
   return (a.x==b.x && a.y==b.y);
}

template <class T_>
Point2D<T_> operator+ (const Point2D<T_> &a, const Point2D<T_> &b) { return Point2D<T_>(a.x+b.x,a.y+b.y,a.z+b.z); }

template <class T_>
Point2D<T_> operator+ (const Point2D<T_> &a, const T_ &x) { return Point2D<T_>(a.x+x,a.y+x,a.z+x); }


template <class T_>
Point2D<T_> operator- (const Point2D<T_> &a) { return Point2D<T_>(-a.x,-a.y); }


template <class T_>
Point2D<T_> operator- (const Point2D<T_> &a, const Point2D<T_> &b) { return Point2D<T_>(a.x-b.x,a.y-b.y); }


template <class T_>
Point2D<T_> operator- (const Point2D<T_> &a, const T_ &x) { return Point2D<T_>(a.x-x,a.y-x); }


template <class T_>
Point2D<T_> operator* (const T_ &a, const Point2D<T_> &b) { return Point2D<T_>(a*b.x,a*b.y); }


template <class T_>
Point2D<T_> operator* (const int &a, const Point2D<T_> &b) { return Point2D<T_>(a*b.x,a*b.y); }


template <class T_>
Point2D<T_> operator* (const Point2D<T_> &b, const T_ &a) { return Point2D<T_>(a*b.x,a*b.y);}


template <class T_>
Point2D<T_> operator* (const Point2D<T_> &b, const int &a) { return Point2D<T_>(a*b.x,a*b.y);}

template <class T_>
T_ operator* (const Point2D<T_> &b, const Point2D<T_> &a) { return (a.x*b.x+a.y*b.y); }

template <class T_>
Point2D<T_> operator/ (const Point2D<T_> &b, const T_ &a) { return Point2D<T_>(b.x/a,b.y/a);}

inline bool areClose(const Point2D<double> &a, const Point2D<double> &b, double toler=OFELI_TOLERANCE)
{
   if (((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)) < toler*toler)
      return true;
   else
      return false;
}

inline double SqrDistance(const Point2D<double> &a, const Point2D<double> &b)
{
   return ((a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y));
}

inline double Distance(const Point2D<double> &a, const Point2D<double> &b)
{
   return sqrt(SqrDistance(a,b));
}

template <class T_>
std::ostream & operator<<(std::ostream &s, const Point2D<T_> &a)
{
   s.setf(ios::scientific);
   s << "( " << std::setprecision(8) << setw(12) << a.x << " , ";
   s << setw(12) << a.y << " , " << " )";
   return s;
}

} /* namespace OFELI */

#endif

Copyright © 1998-2007 Rachid Touzani