+// MEFISTO : library to compute 2D triangulation from segmented boundaries
+//
+// Copyright (C) 2006 Laboratoire J.-L. Lions UPMC Paris
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library 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
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.ann.jussieu.fr/~perronne or email Perronnet@ann.jussieu.fr
+// or email Hecht@ann.jussieu.fr
+//
+//
+// File : Rn.h
+// Module : SMESH
+// Authors: Frederic HECHT & Alain PERRONNET
+// Date : 13 novembre 2006
+
#ifndef Rn__h
#define Rn__h
#include <iostream>
#include <cmath>
-using namespace std;
template<class T> inline T Abs (const T &a){return a <0 ? -a : a;}
template<class T> inline void Echange (T& a,T& b) {T c=a;a=b;b=c;}
//le type N des nombres entiers positifs
//=========
+#ifndef PCLINUX64
typedef unsigned long int N;
+#else
+typedef unsigned int N;
+#endif
//le type Z des nombres entiers relatifs
//=========
+#ifndef PCLINUX64
typedef long int Z;
+#else
+typedef int Z;
+#endif
//le type R des nombres "reels"
//=========
//============
class R2
{
- friend ostream& operator << (ostream& f, const R2 & P)
+ friend std::ostream& operator << (std::ostream& f, const R2 & P)
{ f << P.x << ' ' << P.y ; return f; }
- friend istream& operator >> (istream& f, R2 & P)
+ friend std::istream& operator >> (std::istream& f, R2 & P)
{ f >> P.x >> P.y ; return f; }
- friend ostream& operator << (ostream& f, const R2 * P)
+ friend std::ostream& operator << (std::ostream& f, const R2 * P)
{ f << P->x << ' ' << P->y ; return f; }
- friend istream& operator >> (istream& f, R2 * P)
+ friend std::istream& operator >> (std::istream& f, R2 * P)
{ f >> P->x >> P->y ; return f; }
public:
//============
class R3
{
- friend ostream& operator << (ostream& f, const R3 & P)
+ friend std::ostream& operator << (std::ostream& f, const R3 & P)
{ f << P.x << ' ' << P.y << ' ' << P.z ; return f; }
- friend istream& operator >> (istream& f, R3 & P)
+ friend std::istream& operator >> (std::istream& f, R3 & P)
{ f >> P.x >> P.y >> P.z ; return f; }
- friend ostream& operator << (ostream& f, const R3 * P)
+ friend std::ostream& operator << (std::ostream& f, const R3 * P)
{ f << P->x << ' ' << P->y << ' ' << P->z ; return f; }
- friend istream& operator >> (istream& f, R3 * P)
+ friend std::istream& operator >> (std::istream& f, R3 * P)
{ f >> P->x >> P->y >> P->z ; return f; }
public:
bool DansPave( R3 & xyzMin, R3 & xyzMax )
{ return xyzMin.x<=x && x<=xyzMax.x &&
- xyzMin.y<=y && y<=xyzMax.y &&
- xyzMin.z<=z && z<=xyzMax.z; }
+ xyzMin.y<=y && y<=xyzMax.y &&
+ xyzMin.z<=z && z<=xyzMax.z; }
};
//la classe R4
//============
class R4: public R3
{
- friend ostream& operator <<(ostream& f, const R4 & P )
+ friend std::ostream& operator <<(std::ostream& f, const R4 & P )
{ f << P.x << ' ' << P.y << ' ' << P.z << ' ' << P.omega; return f; }
friend istream& operator >>(istream& f, R4 & P)
{ f >> P.x >> P.y >> P.z >> P.omega ; return f; }
- friend ostream& operator <<(ostream& f, const R4 * P )
+ friend std::ostream& operator <<(std::ostream& f, const R4 * P )
{ f << P->x << ' ' << P->y << ' ' << P->z << ' ' << P->omega; return f; }
friend istream& operator >>(istream& f, R4 * P)
{ f >> P->x >> P->y >> P->z >> P->omega ; return f; }