Inheritance diagram for VectorT< Scalar, N >:

Collaboration diagram for VectorT< Scalar, N >:

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

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

Static Public Member Functions
static int	dim ()
	returns dimension of the vector (deprecated)

static size_t	size ()
	returns dimension of the vector

Static Public Attributes
static const size_t	size_ = N

Minimum maximum and mean
static vector_type	vectorized (const Scalar &_s)
	store the same value in each component

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

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

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

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Minimum maximum and mean

Member Function Documentation

◆ operator%()

◆ operator/=()

◆ operator|()