An Object Finite Element Library

Point.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 'Point'

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

#ifndef __POINT_H
#define __POINT_H

#include "OFELI_Config.h"

#include <iostream>
using std::ostream;

#include <iomanip>
using std::setw;
using std::ios;

#include <math.h>


namespace OFELI {

template<class T_>
struct Point {

    Point() { x = y = z = T_(0); }

    Point(T_ a, T_ b=T_(0), T_ c=T_(0)) { x = a; y = b; z = c; }

    Point(T_ *a) { x = a[0]; y = a[1]; z = a[2]; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    void Normalize()
            {
               double n = Norm();
               x /= n;
               y /= n;
               z /= n;
            }

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

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

    T_ x;

    T_ y;

    T_ z;

};


//                             ASSOCIATED  FUNCTIONS                         //

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

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

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


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


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


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


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


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


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


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


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


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

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

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

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

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

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

} /* namespace OFELI */

#endif

Copyright © 1998-2007 Rachid Touzani