Main Page | Modules | Namespace List | Class Hierarchy | Class List | File List | Namespace Members | Class Members | File Members | Related Pages

OpenMesh::VectorT< Scalar, N > Class Template Reference

A vector is an array of N values of type Scalar. More...

#include <OpenMesh/Core/Math/VectorT.hh>

Inheritance diagram for OpenMesh::VectorT< Scalar, N >:

OpenMesh::VectorDataT< Scalar, N > List of all members.

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 &v0, const Scalar &v1)
 special constructor for 2D vectors

 VectorT (const Scalar &v0, const Scalar &v1, const Scalar &v2)
 special constructor for 3D vectors

 VectorT (const Scalar &v0, const Scalar &v1, const Scalar &v2, const Scalar &v3)
 special constructor for 4D vectors

 VectorT (const Scalar &v0, const Scalar &v1, const Scalar &v2, const Scalar &v3, const Scalar &v4)
 special constructor for 5D vectors

 VectorT (const Scalar &v0, const Scalar &v1, const Scalar &v2, const Scalar &v3, const Scalar &v4, const Scalar &v5)
 special constructor for 6D 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_typeoperator= (const VectorT< otherScalarType, N > &_rhs)
 cast from vector with a different scalar type

 operator Scalar * ()
 cast to Scalar array

 operator const Scalar * () const
 cast to const Scalar array

Scalar & operator[] (int _i)
 get i'th element read-write

const Scalar & operator[] (int _i) const
 get i'th element read-only

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_typeoperator *= (const Scalar &_s)
 component-wise self-multiplication with scalar

vector_typeoperator/= (const Scalar &_s)
 component-wise self-division by scalar
Attention:
v *= (1/_s) is much faster than this


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_typeoperator *= (const vector_type &_rhs)
 component-wise self-multiplication

vector_typeoperator/= (const vector_type &_rhs)
 component-wise self-division

vector_typeoperator-= (const vector_type &_rhs)
 vector difference from this

vector_typeoperator+= (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

Scalar operator| (const vector_type &_rhs) const
 compute scalar product

vector_typenormalize ()
 normalize vector, return normalized vector
Attention:
avoids div by zero only in debug mode


Scalar max () const
 return the maximal component

Scalar min () const
 return the minimal component

Scalar mean () const
 return arithmetic mean

vector_typeminimize (const vector_type &_rhs)
 minimize values: same as *this = min(*this, _rhs), but faster

vector_typemaximize (const vector_type &_rhs)
 maximize values: same as *this = max(*this, _rhs), but faster

vector_type min (const vector_type &_rhs)
 component-wise min

vector_type max (const vector_type &_rhs)
 component-wise max

template<typename Functor> vector_type apply (const Functor &_func) const
 component-wise apply function object with Scalar operator()(Scalar).

vector_typevectorize (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


Static Public Member Functions

int dim ()
 returns dimension of the vector (deprecated)

size_t size ()
 returns dimension of the vector

vector_type vectorized (const Scalar &_s)
 store the same value in each component


Related Functions

(Note that these are not member functions.)

VectorT< Scalar, N > operator * (Scalar _s, const VectorT< Scalar, N > &_v)
 scalar * vector

Scalar dot (const VectorT< Scalar, N > &_v1, const VectorT< Scalar, N > &_v2)
 symmetric version of the dot product

VectorT< Scalar, N > cross (const VectorT< Scalar, N > &_v1, const VectorT< Scalar, N > &_v2)
 symmetric version of the cross product


Detailed Description

template<typename Scalar, int N>
class OpenMesh::VectorT< Scalar, N >

A vector is an array of N values of type Scalar.

The actual data is stored in an VectorDataT, this class just adds the necessary operators.


Member Function Documentation

template<typename Scalar, int N>
VectorT<Scalar,3> OpenMesh::VectorT< Scalar, N >::operator% const VectorT< Scalar, 3 > &  _rhs  )  const [inline]
 

cross product: only defined for Vec3* as specialization

See also:
OpenMesh::cross

template<typename Scalar, int N>
Scalar OpenMesh::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:
acg pic Project OpenMesh, ©  Computer Graphics Group, RWTH Aachen. Documentation generated using doxygen .