point(3)

NAME

point - vertex of a mesh

DESCRIPTION

Defines geometrical vertex as an array of coordinates. This array is also used as a vector of the three dimensional physical space.

IMPLEMENTATION

template <class T>
class basic_point {

public:

// typedefs:

typedef size_t size_type;
typedef T float_type;

// allocators:

explicit basic_point (

const T& x0 = 0,
const T& x1 = 0,
const T& x2 = 0)

{ x_[0] = x0; x_[1] = x1; x_[2] = x2; }

template <class T1>
basic_point<T>(const basic_point<T1>& p)

{ x_[0] = p.x_[0]; x_[1] = p.x_[1]; x_[2] = p.x_[2]; }

template <class T1>
basic_point<T>& operator = (const basic_point<T1>& p)

{ x_[0] = p.x_[0]; x_[1] = p.x_[1]; x_[2] = p.x_[2]; return *this; }

// accessors:

T& operator[](int i_coord) { return x_[i_coord%3]; } const T& operator[](int i_coord) const { return x_[i_coord%3]; } T& operator()(int i_coord) { return x_[i_coord%3]; } const T& operator()(int i_coord) const { return x_[i_coord%3]; }

// inputs/outputs:

std::istream& get (std::istream& s, int d = 3)
{

switch (d) {
case 1 : x_[1] = x_[2] = 0; return s >> x_[0];
case 2 : x_[2] = 0; return s >> x_[0] >> x_[1];
default: return s >> x_[0] >> x_[1] >> x_[2];
}

}
// output
std::ostream& put (std::ostream& s, int d = 3) const;

// ccomparators: lexicographic order

template<int d>
friend bool lexicographically_less (

const basic_point<T>& a, const basic_point<T>& b) {

for (size_type i = 0; i < d; i++) {

if (a[i] < b[i]) return true;
if (a[i] > b[i]) return false;

}
return false; // equality

}

// algebra:

friend bool operator == (const basic_point<T>& u, const basic_point<T>& v)

{ return u[0] == v[0] && u[1] == v[1] && u[2] == v[2]; }

friend basic_point<T> operator + (const basic_point<T>& u, const basic_point<T>& v)

{ return basic_point<T> (u[0]+v[0], u[1]+v[1], u[2]+v[2]); }

friend basic_point<T> operator - (const basic_point<T>& u)

{ return basic_point<T> (-u[0], -u[1], -u[2]); }

friend basic_point<T> operator - (const basic_point<T>& u, const basic_point<T>& v)

{ return basic_point<T> (u[0]-v[0], u[1]-v[1], u[2]-v[2]); }

friend basic_point<T> operator * (T a, const basic_point<T>& u)

{ return basic_point<T> (a*u[0], a*u[1], a*u[2]); }

friend basic_point<T> operator * (const basic_point<T>& u, T a)

{ return basic_point<T> (a*u[0], a*u[1], a*u[2]); }

friend basic_point<T> operator / (const basic_point<T>& u, T a)

{ return basic_point<T> (u[0]/a, u[1]/a, u[2]/a); }

friend basic_point<T> operator / (const basic_point<T>& u, basic_point<T> v)

{ return basic_point<T> (u[0]/v[0], u[1]/v[1], u[2]/v[2]); }

friend basic_point<T> vect (const basic_point<T>& v, const basic_point<T>& w)

{ return basic_point<T> (

v[1]*w[2]-v[2]*w[1],
v[2]*w[0]-v[0]*w[2],
v[0]*w[1]-v[1]*w[0]); }

// metric:

// TODO: non-constant metric
friend T dot (const basic_point<T>& u, const basic_point<T>& v)

{ return u[0]*v[0]+u[1]*v[1]+u[2]*v[2]; }

friend T norm2 (const basic_point<T>& u)

{ return dot(u,u); }

friend T norm (const basic_point<T>& u)

{ return sqrt(norm2(u)); }

friend T dist2 (const basic_point<T>& x, const basic_point<T>& y)

{ return norm2(x-y); }

friend T dist (const basic_point<T>& x, const basic_point<T>& y)

{ return norm(x-y); }

friend T dist_infty (const basic_point<T>& x, const basic_point<T>& y)

{ return max(abs(x[0]-y[0]),

max(abs(x[1]-y[1]), abs(x[2]-y[2]))); }

// data:

T x_[3];

};
template <class T>
T vect2d (const basic_point<T>& v, const basic_point<T>& w);

template <class T>
T mixt (const basic_point<T>& u, const basic_point<T>& v, const basic_point<T>& w);

// robust(exact) floating point predicates: return value as (0, > 0, < 0) // formally: orient2d(a,b,x) = vect2d(a-x,b-x)
template <class T>
T orient2d(const basic_point<T>& a, const basic_point<T>& b,

const basic_point<T>& x = basic_point<T>());

// formally: orient3d(a,b,c,x) = mixt3d(a-x,b-x,c-x)
template <class T>
T orient3d(const basic_point<T>& a, const basic_point<T>& b,

const basic_point<T>& c, const basic_point<T>& x = basic_point<T>());

rheolef-5.89 point(3)