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;
106 inline VectorT(
const Scalar v0,
const Scalar v1,
const Scalar v2) {
108 Base::values_[0]=v0; Base::values_[1]=v1; Base::values_[2]=v2;
113 inline VectorT(
const Scalar v0,
const Scalar v1,
115 const Scalar v2,
const Scalar v3) {
116 Base::values_[0]=v0; Base::values_[1]=v1; Base::values_[2]=v2; Base::values_[3]=v3;
121 inline VectorT(
const Scalar v0,
const Scalar v1,
const Scalar v2,
123 const Scalar v3,
const Scalar v4) {
124 Base::values_[0]=v0; Base::values_[1]=v1;Base::values_[2]=v2; Base::values_[3]=v3; Base::values_[4]=v4;
129 inline VectorT(
const Scalar v0,
const Scalar v1,
const Scalar v2,
131 const Scalar v3,
const Scalar v4,
const Scalar v5) {
132 Base::values_[0]=v0; Base::values_[1]=v1; Base::values_[2]=v2;
133 Base::values_[3]=v3; Base::values_[4]=v4; Base::values_[5]=v5;
138 explicit inline VectorT(
const Scalar _values[DIM]) {
139 memcpy(Base::values_, _values, DIM*
sizeof(Scalar));
146 inline vector_type& operator=(
const vector_type& _rhs) {
147 memcpy(Base::values_, _rhs.Base::values_, DIM*
sizeof(Scalar));
154 template<
typename otherScalarType>
165 template<
typename otherScalarType>
167 #define expr(i) Base::values_[i] = (Scalar)_rhs[i];
180 inline Scalar*
data() {
return Base::values_; }
183 inline const Scalar*
data()
const {
return Base::values_; }
202 assert(_i<DIM);
return Base::values_[_i];
207 assert(_i<DIM);
return Base::values_[_i];
217 #define expr(i) if(Base::values_[i]!=_rhs.Base::values_[i]) return false;
225 return !(*
this == _rhs);
235 #define expr(i) Base::values_[i] *= _s;
244 #define expr(i) Base::values_[i] /= _s;
254 return vector_type(*
this) *= _s;
256 #define expr(i) Base::values_[i] * _s
257 return vector_type(unroll_csv(expr));
266 return vector_type(*
this) /= _s;
268 #define expr(i) Base::values_[i] / _s
269 return vector_type(unroll_csv(expr));
283 #define expr(i) Base::values_[i] *= _rhs[i];
291 #define expr(i) Base::values_[i] /= _rhs[i];
299 #define expr(i) Base::values_[i] -= _rhs[i];
307 #define expr(i) Base::values_[i] += _rhs[i];
315 inline vector_type
operator*(
const vector_type& _v)
const {
317 return vector_type(*
this) *= _v;
319 #define expr(i) Base::values_[i] * _v.Base::values_[i]
320 return vector_type(unroll_csv(expr));
327 inline vector_type
operator/(
const vector_type& _v)
const {
329 return vector_type(*
this) /= _v;
331 #define expr(i) Base::values_[i] / _v.Base::values_[i]
332 return vector_type(unroll_csv(expr));
339 inline vector_type
operator+(
const vector_type& _v)
const {
341 return vector_type(*
this) += _v;
343 #define expr(i) Base::values_[i] + _v.Base::values_[i]
344 return vector_type(unroll_csv(expr));
351 inline vector_type
operator-(
const vector_type& _v)
const {
353 return vector_type(*
this) -= _v;
355 #define expr(i) Base::values_[i] - _v.Base::values_[i]
356 return vector_type(unroll_csv(expr));
365 #define expr(i) v.Base::values_[i] = -Base::values_[i];
378 VectorT<Scalar,3>(Base::values_[1]*_rhs.Base::values_[2]-Base::values_[2]*_rhs.Base::values_[1],
379 Base::values_[2]*_rhs.Base::values_[0]-Base::values_[0]*_rhs.Base::values_[2],
380 Base::values_[0]*_rhs.Base::values_[1]-Base::values_[1]*_rhs.Base::values_[0]);
389 inline Scalar
operator|(
const vector_type& _rhs)
const {
391 #define expr(i) p += Base::values_[i] * _rhs.Base::values_[i];
405 inline Scalar norm()
const {
return (Scalar)sqrt(sqrnorm()); }
407 inline Scalar
length()
const {
return norm(); }
414 #define expr(i) s += Base::values_[i] * Base::values_[i];
419 #define expr(i) Base::values_[i]*Base::values_[i]
420 return (unroll_comb(expr, +));
439 return *
this / norm();
447 if (n != (Scalar)0.0)
466 #define expr(i) s += std::abs(Base::values_[i]);
471 #define expr(i) std::abs(Base::values_[i])
472 return (unroll_comb(expr, +));
493 Scalar m(Base::values_[0]);
494 for(
int i=1; i<DIM; ++i) if(Base::values_[i]>m) m=Base::values_[i];
501 Scalar m(std::abs(Base::values_[0]));
502 for(
int i=1; i<DIM; ++i)
503 if(std::abs(Base::values_[i])>m)
504 m=std::abs(Base::values_[i]);
512 Scalar m(Base::values_[0]);
513 for(
int i=1; i<DIM; ++i)
if(Base::values_[i]<m) m=Base::values_[i];
520 Scalar m(std::abs(Base::values_[0]));
521 for(
int i=1; i<DIM; ++i)
522 if(std::abs(Base::values_[i])<m)
523 m=std::abs(Base::values_[i]);
529 Scalar m(Base::values_[0]);
530 for(
int i=1; i<DIM; ++i) m+=Base::values_[i];
531 return m/Scalar(DIM);
536 Scalar m(std::abs(Base::values_[0]));
537 for(
int i=1; i<DIM; ++i) m+=std::abs(Base::values_[i]);
538 return m/Scalar(DIM);
543 inline vector_type&
minimize(
const vector_type& _rhs) {
544 #define expr(i) if (_rhs[i] < Base::values_[i]) Base::values_[i] = _rhs[i];
553 #define expr(i) if (_rhs[i] < Base::values_[i]) { Base::values_[i] = _rhs[i]; result = true; }
560 inline vector_type&
maximize(
const vector_type& _rhs) {
561 #define expr(i) if (_rhs[i] > Base::values_[i]) Base::values_[i] = _rhs[i];
570 #define expr(i) if (_rhs[i] > Base::values_[i]) { Base::values_[i] =_rhs[i]; result = true; }
577 inline vector_type
min(
const vector_type& _rhs)
const {
578 return vector_type(*this).
minimize(_rhs);
582 inline vector_type
max(
const vector_type& _rhs)
const {
583 return vector_type(*this).
maximize(_rhs);
591 template<
typename Functor>
592 inline vector_type
apply(
const Functor& _func)
const {
594 #define expr(i) result[i] = _func(Base::values_[i]);
602 #define expr(i) Base::values_[i] = _s;
617 #define expr(i) if (Base::values_[i] != _rhs.Base::values_[i]) \
618 return (Base::values_[i] < _rhs.Base::values_[i]);
632 #define expr(i) is >> vec[i];
642 operator<<(std::ostream& os, const VectorT<Scalar,DIM>& vec)
645 for(
int i=0; i<N-1; ++i) os << vec[i] <<
" ";
648 #define expr(i) vec[i]
649 os << unroll_comb(expr, <<
" " <<);
658 #endif // included by VectorT.hh
vector_type min(const vector_type &_rhs) const
component-wise min
Definition: VectorT_inc.hh:577
vector_type max(const vector_type &_rhs) const
component-wise max
Definition: VectorT_inc.hh:582
vector_type operator*(const Scalar &_s) const
component-wise multiplication with scalar
Definition: VectorT_inc.hh:252
Scalar length() const
compute euclidean norm
Definition: VectorT_inc.hh:407
vector_type & normalize_cond()
normalize vector, return normalized vector and avoids div by zero
Definition: VectorT_inc.hh:444
vector_type & operator/=(const Scalar &_s)
component-wise self-division by scalar
Definition: VectorT_inc.hh:243
Scalar operator|(const vector_type &_rhs) const
compute scalar product
Definition: VectorT_inc.hh:389
Scalar max() const
return the maximal component
Definition: VectorT_inc.hh:491
vector_type & maximize(const vector_type &_rhs)
maximize values: same as *this = max(*this, _rhs), but faster
Definition: VectorT_inc.hh:560
Scalar mean_abs() const
return absolute arithmetic mean
Definition: VectorT_inc.hh:535
Scalar l8_norm() const
compute l8_norm
Definition: VectorT_inc.hh:478
Scalar mean() const
return arithmetic mean
Definition: VectorT_inc.hh:528
static int dim()
returns dimension of the vector (deprecated)
Definition: VectorT_inc.hh:78
VectorT(const VectorT< otherScalarType, N > &_rhs)
copy & cast constructor (explicit)
Definition: VectorT_inc.hh:155
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:601
Definition: VectorT_inc.hh:63
bool operator<(const vector_type &_rhs) const
lexicographical comparison
Definition: VectorT_inc.hh:616
bool minimized(const vector_type &_rhs)
minimize values and signalize coordinate minimization
Definition: VectorT_inc.hh:551
vector_type operator/(const vector_type &_v) const
component-wise vector division
Definition: VectorT_inc.hh:327
Scalar l1_norm() const
compute L1 (Manhattan) norm
Definition: VectorT_inc.hh:462
VectorT(const Scalar _values[N])
construct from a value array (explicit)
Definition: VectorT_inc.hh:138
bool maximized(const vector_type &_rhs)
maximize values and signalize coordinate maximization
Definition: VectorT_inc.hh:568
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:166
vector_type & operator*=(const Scalar &_s)
component-wise self-multiplication with scalar
Definition: VectorT_inc.hh:234
const Scalar * data() const
access to const Scalar array
Definition: VectorT_inc.hh:183
vector_type & normalize()
normalize vector, return normalized vector
Definition: VectorT_inc.hh:428
Scalar min_abs() const
return the minimal absolute component
Definition: VectorT_inc.hh:518
VectorT(const Scalar &v)
special constructor for 1D vectors
Definition: VectorT_inc.hh:92
Scalar sqrnorm() const
compute squared euclidean norm
Definition: VectorT_inc.hh:410
vector_type operator-(void) const
unary minus
Definition: VectorT_inc.hh:363
bool operator==(const vector_type &_rhs) const
component-wise comparison
Definition: VectorT_inc.hh:216
vector_type operator-(const vector_type &_v) const
component-wise vector difference
Definition: VectorT_inc.hh:351
static vector_type vectorized(const Scalar &_s)
store the same value in each component
Definition: VectorT_inc.hh:610
vector_type apply(const Functor &_func) const
component-wise apply function object with Scalar operator()(Scalar).
Definition: VectorT_inc.hh:592
VectorT()
default constructor creates uninitialized values.
Definition: VectorT_inc.hh:89
vector_type operator*(const vector_type &_v) const
component-wise vector multiplication
Definition: VectorT_inc.hh:315
Scalar max_abs() const
return the maximal absolute component
Definition: VectorT_inc.hh:499
Scalar value_type
the type of the scalar used in this template
Definition: VectorT_inc.hh:72
const vector_type normalized() const
return normalized vector
Definition: VectorT_inc.hh:437
Scalar * data()
access to Scalar array
Definition: VectorT_inc.hh:180
vector_type & operator+=(const vector_type &_rhs)
vector self-addition
Definition: VectorT_inc.hh:306
vector_type operator+(const vector_type &_v) const
component-wise vector addition
Definition: VectorT_inc.hh:339
vector_type operator/(const Scalar &_s) const
component-wise division by with scalar
Definition: VectorT_inc.hh:264
Scalar & operator[](size_t _i)
get i'th element read-write
Definition: VectorT_inc.hh:201
const Scalar & operator[](size_t _i) const
get i'th element read-only
Definition: VectorT_inc.hh:206
bool operator!=(const vector_type &_rhs) const
component-wise comparison
Definition: VectorT_inc.hh:224
vector_type & operator-=(const vector_type &_rhs)
vector difference from this
Definition: VectorT_inc.hh:298
Scalar min() const
return the minimal component
Definition: VectorT_inc.hh:510
vector_type & operator/=(const vector_type &_rhs)
component-wise self-division
Definition: VectorT_inc.hh:290
vector_type & operator*=(const vector_type &_rhs)
component-wise self-multiplication
Definition: VectorT_inc.hh:282
vector_type & minimize(const vector_type &_rhs)
minimize values: same as *this = min(*this, _rhs), but faster
Definition: VectorT_inc.hh:543