VectorT< Scalar, N > Class Template Reference
Inheritance diagram for VectorT< Scalar, N >:
[legend]
Collaboration diagram for VectorT< Scalar, N >:
[legend]

## Public Types

typedef Scalar | value_type
| the type of the scalar used in this template
typedef VectorT< Scalar, N > | vector_type
| type of this vector

## Public Member Functions

| VectorT ()
| default constructor creates uninitialized values.
| VectorT (const Scalar &v)
| special constructor for 1D vectors
| VectorT (const Scalar _values[N])
| construct from a value array (explicit)
template<typename otherScalarType >
| VectorT (const VectorT< otherScalarType, N > &_rhs)
| copy & cast constructor (explicit)
template<typename otherScalarType >
vector_type & | operator= (const VectorT< otherScalarType, N > &_rhs)
| cast from vector with a different scalar type
Scalar * | data ()
| access to Scalar array
const Scalar * | data () const
| access to const Scalar array
Scalar & | operator[] (size_t _i)
| get i'th element read-write
const Scalar & | operator[] (size_t _i) const
| get i'th element read-only
bool | operator== (const vector_type &_rhs) const
| component-wise comparison
bool | operator!= (const vector_type &_rhs) const
| component-wise comparison
vector_type & | operator*= (const Scalar &_s)
| component-wise self-multiplication with scalar
vector_type & | operator/= (const Scalar &_s)
| component-wise self-division by scalar More...
vector_type | operator* (const Scalar &_s) const
| component-wise multiplication with scalar
vector_type | operator/ (const Scalar &_s) const
| component-wise division by with scalar
vector_type & | operator*= (const vector_type &_rhs)
| component-wise self-multiplication
vector_type & | operator/= (const vector_type &_rhs)
| component-wise self-division
vector_type & | operator-= (const vector_type &_rhs)
| vector difference from this
vector_type & | operator+= (const vector_type &_rhs)
| vector self-addition
vector_type | operator* (const vector_type &_v) const
| component-wise vector multiplication
vector_type | operator/ (const vector_type &_v) const
| component-wise vector division
vector_type | operator+ (const vector_type &_v) const
| component-wise vector addition
vector_type | operator- (const vector_type &_v) const
| component-wise vector difference
vector_type | operator- (void) const
| unary minus
VectorT< Scalar, 3 > | operator% (const VectorT< Scalar, 3 > &_rhs) const
| cross product: only defined for Vec3* as specialization More...
Scalar | operator| (const vector_type &_rhs) const
| compute scalar product More...
template<typename Functor >
vector_type | apply (const Functor &_func) const
| component-wise apply function object with Scalar operator()(Scalar).
vector_type & | vectorize (const Scalar &_s)
| store the same value in each component (e.g. to clear all entries)
bool | operator< (const vector_type &_rhs) const
| lexicographical comparison
Euclidean norm calculations
Scalar | norm () const
| compute euclidean norm
Scalar | length () const
| compute euclidean norm
Scalar | sqrnorm () const
| compute squared euclidean norm
vector_type & | normalize ()
| normalize vector, return normalized vector
const vector_type | normalized () const
| return normalized vector
vector_type & | normalize_cond ()
| normalize vector, return normalized vector and avoids div by zero
Non-Euclidean norm calculations
Scalar | l1_norm () const
| compute L1 (Manhattan) norm
Scalar | l8_norm () const
| compute l8_norm
Minimum maximum and mean
Scalar | max () const
| return the maximal component
Scalar | max_abs () const
| return the maximal absolute component
Scalar | min () const
| return the minimal component
Scalar | min_abs () const
| return the minimal absolute component
Scalar | mean () const
| return arithmetic mean
Scalar | mean_abs () const
| return absolute arithmetic mean
vector_type & | minimize (const vector_type &_rhs)
| minimize values: same as *this = min(*this, _rhs), but faster
bool | minimized (const vector_type &_rhs)
| minimize values and signalize coordinate minimization
vector_type & | maximize (const vector_type &_rhs)
| maximize values: same as *this = max(*this, _rhs), but faster
bool | maximized (const vector_type &_rhs)
| maximize values and signalize coordinate maximization
vector_type | min (const vector_type &_rhs) const
| component-wise min
vector_type | max (const vector_type &_rhs) const
| component-wise max

## Static Public Member Functions

static int | dim ()
| returns dimension of the vector (deprecated)
static size_t | size ()
| returns dimension of the vector
static vector_type | vectorized (const Scalar &_s)
| store the same value in each component

## Static Public Attributes

static const size_t | size_ = N

## Member Function Documentation

## operator%()

template<typename Scalar, int N>

VectorT<Scalar,3> VectorT< Scalar, N >::operator% | ( | const VectorT< Scalar, 3 > & | _rhs | ) | const

inline

cross product: only defined for Vec3* as specialization

See also
  OpenMesh::cross

## operator/=()

template<typename Scalar, int N>

vector_type& VectorT< Scalar, N >::operator/= | ( | const Scalar & | _s | ) |

inline

component-wise self-division by scalar

Attention
  v *= (1/_s) is much faster than this

## operator|()

template<typename Scalar, int N>

Scalar VectorT< Scalar, N >::operator| | ( | const vector_type & | _rhs | ) | const

inline

compute scalar product

See also
  OpenMesh::dot

The documentation for this class was generated from the following file:

- OpenMesh/Core/Geometry/VectorT_inc.hh