48 #define OPENMESH_VECTOR_HH
51 #define TEMPLATE_HEADER template <typename Scalar, int N>
52 #define CLASSNAME VectorT
53 #define DERIVED VectorDataT<Scalar,N>
54 #define unroll(expr) for (int i=0; i<N; ++i) expr(i)
58 #if defined( OPENMESH_VECTOR_HH )
63 class CLASSNAME :
public DERIVED
78 static inline int dim() {
return DIM; }
81 static inline size_t size() {
return DIM; }
83 static const size_t size_ = DIM;
92 explicit inline VectorT(
const Scalar& v) {
99 inline VectorT(
const Scalar& v0,
const Scalar& v1) {
101 Base::values_[0] = v0; Base::values_[1] = v1;
105 inline VectorT(
const Scalar& v0,
const Scalar& v1,
const Scalar& v2) {
107 Base::values_[0]=v0; Base::values_[1]=v1; Base::values_[2]=v2;
111 inline VectorT(
const Scalar& v0,
const Scalar& v1,
112 const Scalar& v2,
const Scalar& v3) {
114 Base::values_[0]=v0; Base::values_[1]=v1; Base::values_[2]=v2; Base::values_[3]=v3;
118 inline VectorT(
const Scalar& v0,
const Scalar& v1,
const Scalar& v2,
119 const Scalar& v3,
const Scalar& v4) {
121 Base::values_[0]=v0; Base::values_[1]=v1;Base::values_[2]=v2; Base::values_[3]=v3; Base::values_[4]=v4;
125 inline VectorT(
const Scalar& v0,
const Scalar& v1,
const Scalar& v2,
126 const Scalar& v3,
const Scalar& v4,
const Scalar& v5) {
128 Base::values_[0]=v0; Base::values_[1]=v1; Base::values_[2]=v2;
129 Base::values_[3]=v3; Base::values_[4]=v4; Base::values_[5]=v5;
133 explicit inline VectorT(
const Scalar _values[DIM]) {
134 memcpy(Base::values_, _values, DIM*
sizeof(Scalar));
141 inline vector_type& operator=(
const vector_type& _rhs) {
142 memcpy(Base::values_, _rhs.Base::values_, DIM*
sizeof(Scalar));
149 template<
typename otherScalarType>
160 template<
typename otherScalarType>
162 #define expr(i) Base::values_[i] = (Scalar)_rhs[i];
175 inline Scalar*
data() {
return Base::values_; }
178 inline const Scalar*
data()
const {
return Base::values_; }
197 assert(_i<DIM);
return Base::values_[_i];
202 assert(_i<DIM);
return Base::values_[_i];
212 #define expr(i) if(Base::values_[i]!=_rhs.Base::values_[i]) return false;
220 return !(*
this == _rhs);
230 #define expr(i) Base::values_[i] *= _s;
239 #define expr(i) Base::values_[i] /= _s;
251 #define expr(i) Base::values_[i] * _s
263 #define expr(i) Base::values_[i] / _s
278 #define expr(i) Base::values_[i] *= _rhs[i];
286 #define expr(i) Base::values_[i] /= _rhs[i];
294 #define expr(i) Base::values_[i] -= _rhs[i];
302 #define expr(i) Base::values_[i] += _rhs[i];
314 #define expr(i) Base::values_[i] * _v.Base::values_[i]
326 #define expr(i) Base::values_[i] / _v.Base::values_[i]
338 #define expr(i) Base::values_[i] + _v.Base::values_[i]
350 #define expr(i) Base::values_[i] - _v.Base::values_[i]
360 #define expr(i) v.Base::values_[i] = -Base::values_[i];
373 VectorT<Scalar,3>(Base::values_[1]*_rhs.Base::values_[2]-Base::values_[2]*_rhs.Base::values_[1],
374 Base::values_[2]*_rhs.Base::values_[0]-Base::values_[0]*_rhs.Base::values_[2],
375 Base::values_[0]*_rhs.Base::values_[1]-Base::values_[1]*_rhs.Base::values_[0]);
386 #define expr(i) p += Base::values_[i] * _rhs.Base::values_[i];
400 inline Scalar norm()
const {
return (Scalar)sqrt(sqrnorm()); }
402 inline Scalar
length()
const {
return norm(); }
409 #define expr(i) s += Base::values_[i] * Base::values_[i];
414 #define expr(i) Base::values_[i]*Base::values_[i]
415 return (unroll_comb(expr, +));
434 return *
this / norm();
442 if (n != (Scalar)0.0)
461 #define expr(i) s += std::abs(Base::values_[i]);
466 #define expr(i) std::abs(Base::values_[i])
467 return (unroll_comb(expr, +));
488 Scalar m(Base::values_[0]);
489 for(
int i=1; i<DIM; ++i) if(Base::values_[i]>m) m=Base::values_[i];
496 Scalar m(std::abs(Base::values_[0]));
497 for(
int i=1; i<DIM; ++i)
498 if(std::abs(Base::values_[i])>m)
499 m=std::abs(Base::values_[i]);
507 Scalar m(Base::values_[0]);
508 for(
int i=1; i<DIM; ++i)
if(Base::values_[i]<m) m=Base::values_[i];
515 Scalar m(std::abs(Base::values_[0]));
516 for(
int i=1; i<DIM; ++i)
517 if(std::abs(Base::values_[i])<m)
518 m=std::abs(Base::values_[i]);
524 Scalar m(Base::values_[0]);
525 for(
int i=1; i<DIM; ++i) m+=Base::values_[i];
526 return m/Scalar(DIM);
531 Scalar m(std::abs(Base::values_[0]));
532 for(
int i=1; i<DIM; ++i) m+=std::abs(Base::values_[i]);
533 return m/Scalar(DIM);
539 #define expr(i) if (_rhs[i] < Base::values_[i]) Base::values_[i] = _rhs[i];
548 #define expr(i) if (_rhs[i] < Base::values_[i]) { Base::values_[i] = _rhs[i]; result = true; }
556 #define expr(i) if (_rhs[i] > Base::values_[i]) Base::values_[i] = _rhs[i];
565 #define expr(i) if (_rhs[i] > Base::values_[i]) { Base::values_[i] =_rhs[i]; result = true; }
586 template<
typename Functor>
589 #define expr(i) result[i] = _func(Base::values_[i]);
597 #define expr(i) Base::values_[i] = _s;
612 #define expr(i) if (Base::values_[i] != _rhs.Base::values_[i]) \
613 return (Base::values_[i] < _rhs.Base::values_[i]);
627 #define expr(i) is >> vec[i];
637 operator<<(std::ostream& os, const VectorT<Scalar,DIM>& vec)
640 for(
int i=0; i<N-1; ++i) os << vec[i] <<
" ";
643 #define expr(i) vec[i]
644 os << unroll_comb(expr, <<
" " <<);
653 #endif // included by VectorT.hh
VectorT< Scalar, N > vector_type
type of this vector
Definition: VectorT_inc.hh:75
vector_type & vectorize(const Scalar &_s)
store the same value in each component (e.g. to clear all entries)
Definition: VectorT_inc.hh:596
Definition: VectorT_inc.hh:63
bool operator<(const vector_type &_rhs) const
lexicographical comparison
Definition: VectorT_inc.hh:611
VectorT(const Scalar &v0, const Scalar &v1, const Scalar &v2, const Scalar &v3, const Scalar &v4)
special constructor for 5D vectors
Definition: VectorT_inc.hh:118
const vector_type normalized() const
return normalized vector
Definition: VectorT_inc.hh:432
vector_type & operator+=(const vector_type &_rhs)
vector self-addition
Definition: VectorT_inc.hh:301
VectorT(const Scalar &v0, const Scalar &v1, const Scalar &v2, const Scalar &v3)
special constructor for 4D vectors
Definition: VectorT_inc.hh:111
const Scalar & operator[](size_t _i) const
get i'th element read-only
Definition: VectorT_inc.hh:201
bool operator!=(const vector_type &_rhs) const
component-wise comparison
Definition: VectorT_inc.hh:219
VectorT(const Scalar _values[N])
construct from a value array (explicit)
Definition: VectorT_inc.hh:133
vector_type & operator*=(const vector_type &_rhs)
component-wise self-multiplication
Definition: VectorT_inc.hh:277
vector_type & minimize(const vector_type &_rhs)
minimize values: same as *this = min(*this, _rhs), but faster
Definition: VectorT_inc.hh:538
vector_type & operator*=(const Scalar &_s)
component-wise self-multiplication with scalar
Definition: VectorT_inc.hh:229
const Scalar * data() const
access to const Scalar array
Definition: VectorT_inc.hh:178
vector_type & normalize()
normalize vector, return normalized vector
Definition: VectorT_inc.hh:423
Scalar min_abs() const
return the minimal absolute component
Definition: VectorT_inc.hh:513
vector_type operator*(const Scalar &_s) const
component-wise multiplication with scalar
Definition: VectorT_inc.hh:247
VectorT(const Scalar &v)
special constructor for 1D vectors
Definition: VectorT_inc.hh:92
Scalar length() const
compute euclidean norm
Definition: VectorT_inc.hh:402
bool operator==(const vector_type &_rhs) const
component-wise comparison
Definition: VectorT_inc.hh:211
static vector_type vectorized(const Scalar &_s)
store the same value in each component
Definition: VectorT_inc.hh:605
vector_type apply(const Functor &_func) const
component-wise apply function object with Scalar operator()(Scalar).
Definition: VectorT_inc.hh:587
Scalar max() const
return the maximal component
Definition: VectorT_inc.hh:486
vector_type & maximize(const vector_type &_rhs)
maximize values: same as *this = max(*this, _rhs), but faster
Definition: VectorT_inc.hh:555
VectorT()
default constructor creates uninitialized values.
Definition: VectorT_inc.hh:89
VectorT(const VectorT< otherScalarType, N > &_rhs)
copy & cast constructor (explicit)
Definition: VectorT_inc.hh:150
vector_type operator*(const vector_type &_v) const
component-wise vector multiplication
Definition: VectorT_inc.hh:310
Scalar max_abs() const
return the maximal absolute component
Definition: VectorT_inc.hh:494
Scalar value_type
the type of the scalar used in this template
Definition: VectorT_inc.hh:72
Scalar * data()
access to Scalar array
Definition: VectorT_inc.hh:175
vector_type operator+(const vector_type &_v) const
component-wise vector addition
Definition: VectorT_inc.hh:334
vector_type operator/(const Scalar &_s) const
component-wise division by with scalar
Definition: VectorT_inc.hh:259
Scalar & operator[](size_t _i)
get i'th element read-write
Definition: VectorT_inc.hh:196
bool minimized(const vector_type &_rhs)
minimize values and signalize coordinate minimization
Definition: VectorT_inc.hh:546
VectorT(const Scalar &v0, const Scalar &v1)
special constructor for 2D vectors
Definition: VectorT_inc.hh:99
vector_type & operator-=(const vector_type &_rhs)
vector difference from this
Definition: VectorT_inc.hh:293
vector_type operator/(const vector_type &_v) const
component-wise vector division
Definition: VectorT_inc.hh:322
Scalar min() const
return the minimal component
Definition: VectorT_inc.hh:505
vector_type & operator/=(const vector_type &_rhs)
component-wise self-division
Definition: VectorT_inc.hh:285
VectorT(const Scalar &v0, const Scalar &v1, const Scalar &v2, const Scalar &v3, const Scalar &v4, const Scalar &v5)
special constructor for 6D vectors
Definition: VectorT_inc.hh:125
Scalar l1_norm() const
compute L1 (Manhattan) norm
Definition: VectorT_inc.hh:457
vector_type min(const vector_type &_rhs) const
component-wise min
Definition: VectorT_inc.hh:572
vector_type max(const vector_type &_rhs) const
component-wise max
Definition: VectorT_inc.hh:577
bool maximized(const vector_type &_rhs)
maximize values and signalize coordinate maximization
Definition: VectorT_inc.hh:563
static size_t size()
returns dimension of the vector
Definition: VectorT_inc.hh:81
vector_type & operator=(const VectorT< otherScalarType, N > &_rhs)
cast from vector with a different scalar type
Definition: VectorT_inc.hh:161
vector_type & normalize_cond()
normalize vector, return normalized vector and avoids div by zero
Definition: VectorT_inc.hh:439
vector_type & operator/=(const Scalar &_s)
component-wise self-division by scalar
Definition: VectorT_inc.hh:238
VectorT(const Scalar &v0, const Scalar &v1, const Scalar &v2)
special constructor for 3D vectors
Definition: VectorT_inc.hh:105
Scalar operator|(const vector_type &_rhs) const
compute scalar product
Definition: VectorT_inc.hh:384
Scalar sqrnorm() const
compute squared euclidean norm
Definition: VectorT_inc.hh:405
Scalar mean_abs() const
return absolute arithmetic mean
Definition: VectorT_inc.hh:530
vector_type operator-(void) const
unary minus
Definition: VectorT_inc.hh:358
Scalar l8_norm() const
compute l8_norm
Definition: VectorT_inc.hh:473
Scalar mean() const
return arithmetic mean
Definition: VectorT_inc.hh:523
static int dim()
returns dimension of the vector (deprecated)
Definition: VectorT_inc.hh:78
vector_type operator-(const vector_type &_v) const
component-wise vector difference
Definition: VectorT_inc.hh:346