---
name: "point"
section: "2rheolef"
platform: "linux"
package: "librheolef-dev"
version: "7.2-4"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/point/2rheolef"
---

# point(2rheolef)

d-dimensional physical point or vector (rheolef-7.2)

## NAME

point - d-dimensional physical point or vector (rheolef-7.2)

## DESCRIPTION

The `point` defines a vertex or vector in the physical d-dimensional space, d=1,2,3. It is represented as an array of coordinates. The coordinate index starts at zero and finishes at `d-1`, e.g. `x[0]`, `x[1]` and `x[2]`.

The default constructor set all components to zero:

```
    point x;
```

 and this default could be overridden:

```
    point x (1, 2, 3.14);
```

 or alternatively:

```
    point x = {1, 2, 3.14};
```

 The standard linear algebra for vectors is supported by the `point` class.

## IMPLEMENTATION

This documentation has been generated from file fem/geo\_element/point.h

The `point` class is simply an alias to the **point\_basic class**

```
typedef point_basic<Float> point;
```

**The point\_basic class is a template class with the floating type as parameter:**

```
template <class T>
class point_basic {
public:
// typedefs:
  typedef size_t size_type;
  typedef T      element_type;
  typedef T      scalar_type;
  typedef T      float_type;
// allocators:
  explicit point_basic();
  explicit point_basic (const T& x0, const T& x1 = 0, const T& x2 = 0);
  template <class T1>
  point_basic<T>(const point_basic<T1>& p);
  template <class T1>
  point_basic<T>& operator= (const point_basic<T1>& p);
  point_basic (const std::initializer_list<T>& il);
// accessors:
  T& operator[](int i_coord)              { 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]; }
  const T&  operator()(int i_coord) const { return _x[i_coord%3]; }
// algebra:
  bool operator== (const point_basic<T>& v) const;
  bool operator!= (const point_basic<T>& v) const;
  point_basic<T> operator+ (const point_basic<T>& v) const;
  point_basic<T> operator- (const point_basic<T>& v) const;
  point_basic<T> operator- () const;
  point_basic<T>& operator+= (const point_basic<T>& v);
  point_basic<T>& operator-= (const point_basic<T>& v);
  point_basic<T>& operator*= (const T& a);
  point_basic<T>& operator/= (const T& a);
  template <class U>
  typename
  std::enable_if<
    details::is_rheolef_arithmetic<U>::value
    ,point_basic<T>
  >::type
  operator* (const U& a) const;
  point_basic<T> operator/ (const T& a) const;
  point_basic<T> operator/ (point_basic<T> v) const;
// i/o:
  std::istream& get (std::istream& s, int d = 3);
  std::ostream& put (std::ostream& s, int d = 3) const;
```

```
};
```

**These linear and nonlinear functions are completed by some usual functions:**

```
template<class T>
std::istream& operator >> (std::istream& s, point_basic<T>& p);
template<class T>
std::ostream& operator << (std::ostream& s, const point_basic<T>& p);
template <class T, class U>
typename
std::enable_if<
  details::is_rheolef_arithmetic<U>::value
 ,point_basic<T>
>::type
operator* (const U& a, const point_basic<T>& u);
template<class T>
point_basic<T>
vect (const point_basic<T>& v, const point_basic<T>& w);
// metrics:
template<class T>
T dot (const point_basic<T>& x, const point_basic<T>& y);
template<class T>
T norm2 (const point_basic<T>& x);
template<class T>
T norm (const point_basic<T>& x);
template<class T>
T dist2 (const point_basic<T>& x,  const point_basic<T>& y);
template<class T>
T dist (const point_basic<T>& x,  const point_basic<T>& y);
template<class T>
T dist_infty (const point_basic<T>& x,  const point_basic<T>& y);
template <class T>
T vect2d (const point_basic<T>& v, const point_basic<T>& w);
template <class T>
T mixt (const point_basic<T>& u, const point_basic<T>& v, const point_basic<T>& w);
// robust(exact) floating point predicates: return the sign of the value as (0, > 0, < 0)
// formally: orient2d(a,b,x) = vect2d(a-x,b-x)
template <class T>
int sign_orient2d (
  const point_basic<T>& a,
  const point_basic<T>& b,
  const point_basic<T>& c);
template <class T>
int sign_orient3d (
  const point_basic<T>& a,
  const point_basic<T>& b,
  const point_basic<T>& c,
  const point_basic<T>& d);
// compute also the value:
template <class T>
T orient2d(
  const point_basic<T>& a,
  const point_basic<T>& b,
  const point_basic<T>& c);
// formally: orient3d(a,b,c,x) = mixt3d(a-x,b-x,c-x)
template <class T>
T orient3d(
  const point_basic<T>& a,
  const point_basic<T>& b,
  const point_basic<T>& c,
  const point_basic<T>& d);
template <class T>
std::string ptos (const point_basic<T>& x, int d = 3);
// ccomparators: lexicographic order
template<class T, size_t d>
bool lexicographically_less (const point_basic<T>& a, const point_basic<T>& b);
```

## AUTHOR

**Pierre  Saramito  \<Pierre.Saramito@imag.fr\>**

## COPYRIGHT

**Copyright   (C)  2000-2018  Pierre  Saramito  \<Pierre.Saramito@imag.fr\>** **GPLv3+: GNU GPL version 3 or later  \<http://gnu.org/licenses/gpl.html\>.** **This  is  free  software:  you  are free to change and redistribute it.** **There is NO WARRANTY, to the extent permitted by law.**