57 #define OPENMESH_VECTOR_HH
60 #define TEMPLATE_HEADER template <typename Scalar, int N>
61 #define CLASSNAME VectorT
62 #define DERIVED VectorDataT<Scalar,N>
63 #define unroll(expr) for (int i=0; i<N; ++i) expr(i)
67 #if defined( OPENMESH_VECTOR_HH )
72 class CLASSNAME :
public DERIVED
87 static inline int dim() {
return DIM; }
90 static inline size_t size() {
return DIM; }
92 static const size_t size_ = DIM;
100 #if __cplusplus > 199711L || defined(__GXX_EXPERIMENTAL_CXX0X__)
101 explicit inline VectorT(
const Scalar &v) {
105 template<
typename... T,
106 typename =
typename std::enable_if<
sizeof...(T) == DIM>::type,
107 typename =
typename std::enable_if<are_convertible_to<Scalar, T...>::value>::type>
108 constexpr
VectorT(T... vs) : Base {
static_cast<Scalar
>(vs)...}
111 template<int D = DIM, typename = typename std::enable_if<D == DIM>::type>
112 typename std::enable_if<D==4, VectorT>::type
113 homogenized()
const {
115 Base::values_[0]/Base::values_[3],
116 Base::values_[1]/Base::values_[3],
117 Base::values_[2]/Base::values_[3],
122 explicit inline VectorT(
const Scalar& v) {
130 inline VectorT(
const Scalar v0,
const Scalar v1) {
132 Base::values_[0] = v0; Base::values_[1] = v1;
137 inline VectorT(
const Scalar v0,
const Scalar v1,
const Scalar v2) {
139 Base::values_[0]=v0; Base::values_[1]=v1; Base::values_[2]=v2;
144 inline VectorT(
const Scalar v0,
const Scalar v1,
146 const Scalar v2,
const Scalar v3) {
147 Base::values_[0]=v0; Base::values_[1]=v1; Base::values_[2]=v2; Base::values_[3]=v3;
150 VectorT homogenized()
const {
return VectorT(Base::values_[0]/Base::values_[3], Base::values_[1]/Base::values_[3], Base::values_[2]/Base::values_[3], 1); }
154 inline VectorT(
const Scalar v0,
const Scalar v1,
const Scalar v2,
156 const Scalar v3,
const Scalar v4) {
157 Base::values_[0]=v0; Base::values_[1]=v1;Base::values_[2]=v2; Base::values_[3]=v3; Base::values_[4]=v4;
162 inline VectorT(
const Scalar v0,
const Scalar v1,
const Scalar v2,
164 const Scalar v3,
const Scalar v4,
const Scalar v5) {
165 Base::values_[0]=v0; Base::values_[1]=v1; Base::values_[2]=v2;
166 Base::values_[3]=v3; Base::values_[4]=v4; Base::values_[5]=v5;
172 explicit inline VectorT(
const Scalar _values[DIM]) {
173 memcpy(data(), _values, DIM*
sizeof(Scalar));
180 inline vector_type& operator=(
const vector_type& _rhs) {
181 memcpy(Base::values_, _rhs.Base::values_, DIM*
sizeof(Scalar));
188 template<
typename otherScalarType>
199 template<
typename otherScalarType>
201 #define expr(i) Base::values_[i] = (Scalar)_rhs[i];
213 #if __cplusplus > 199711L || defined(__GXX_EXPERIMENTAL_CXX0X__)
214 inline Scalar* data() {
return Base::values_.data(); }
218 inline const Scalar*data()
const {
return Base::values_.data(); }
220 inline Scalar* data() {
return Base::values_; }
224 inline const Scalar*
data()
const {
return Base::values_; }
244 assert(_i<DIM);
return Base::values_[_i];
249 assert(_i<DIM);
return Base::values_[_i];
259 #define expr(i) if(Base::values_[i]!=_rhs.Base::values_[i]) return false;
267 return !(*
this == _rhs);
277 #define expr(i) Base::values_[i] *= _s;
286 #define expr(i) Base::values_[i] /= _s;
296 return vector_type(*
this) *= _s;
298 #define expr(i) Base::values_[i] * _s
299 return vector_type(unroll_csv(expr));
308 return vector_type(*
this) /= _s;
310 #define expr(i) Base::values_[i] / _s
311 return vector_type(unroll_csv(expr));
325 #define expr(i) Base::values_[i] *= _rhs[i];
333 #define expr(i) Base::values_[i] /= _rhs[i];
341 #define expr(i) Base::values_[i] -= _rhs[i];
349 #define expr(i) Base::values_[i] += _rhs[i];
357 inline vector_type
operator*(
const vector_type& _v)
const {
359 return vector_type(*
this) *= _v;
361 #define expr(i) Base::values_[i] * _v.Base::values_[i]
362 return vector_type(unroll_csv(expr));
369 inline vector_type
operator/(
const vector_type& _v)
const {
371 return vector_type(*
this) /= _v;
373 #define expr(i) Base::values_[i] / _v.Base::values_[i]
374 return vector_type(unroll_csv(expr));
381 inline vector_type
operator+(
const vector_type& _v)
const {
383 return vector_type(*
this) += _v;
385 #define expr(i) Base::values_[i] + _v.Base::values_[i]
386 return vector_type(unroll_csv(expr));
393 inline vector_type
operator-(
const vector_type& _v)
const {
395 return vector_type(*
this) -= _v;
397 #define expr(i) Base::values_[i] - _v.Base::values_[i]
398 return vector_type(unroll_csv(expr));
407 #define expr(i) v.Base::values_[i] = -Base::values_[i];
420 VectorT<Scalar,3>(Base::values_[1]*_rhs.Base::values_[2]-Base::values_[2]*_rhs.Base::values_[1],
421 Base::values_[2]*_rhs.Base::values_[0]-Base::values_[0]*_rhs.Base::values_[2],
422 Base::values_[0]*_rhs.Base::values_[1]-Base::values_[1]*_rhs.Base::values_[0]);
431 inline Scalar
operator|(
const vector_type& _rhs)
const {
433 #define expr(i) p += Base::values_[i] * _rhs.Base::values_[i];
447 inline Scalar norm()
const {
return (Scalar)sqrt(sqrnorm()); }
449 inline Scalar
length()
const {
return norm(); }
456 #define expr(i) s += Base::values_[i] * Base::values_[i];
461 #define expr(i) Base::values_[i]*Base::values_[i]
462 return (unroll_comb(expr, +));
481 return *
this / norm();
489 if (n != (Scalar)0.0)
508 #define expr(i) s += std::abs(Base::values_[i]);
513 #define expr(i) std::abs(Base::values_[i])
514 return (unroll_comb(expr, +));
535 Scalar m(Base::values_[0]);
536 for(
int i=1; i<DIM; ++i) if(Base::values_[i]>m) m=Base::values_[i];
543 Scalar m(std::abs(Base::values_[0]));
544 for(
int i=1; i<DIM; ++i)
545 if(std::abs(Base::values_[i])>m)
546 m=std::abs(Base::values_[i]);
554 Scalar m(Base::values_[0]);
555 for(
int i=1; i<DIM; ++i)
if(Base::values_[i]<m) m=Base::values_[i];
562 Scalar m(std::abs(Base::values_[0]));
563 for(
int i=1; i<DIM; ++i)
564 if(std::abs(Base::values_[i])<m)
565 m=std::abs(Base::values_[i]);
571 Scalar m(Base::values_[0]);
572 for(
int i=1; i<DIM; ++i) m+=Base::values_[i];
573 return m/Scalar(DIM);
578 Scalar m(std::abs(Base::values_[0]));
579 for(
int i=1; i<DIM; ++i) m+=std::abs(Base::values_[i]);
580 return m/Scalar(DIM);
585 inline vector_type&
minimize(
const vector_type& _rhs) {
586 #define expr(i) if (_rhs[i] < Base::values_[i]) Base::values_[i] = _rhs[i];
595 #define expr(i) if (_rhs[i] < Base::values_[i]) { Base::values_[i] = _rhs[i]; result = true; }
602 inline vector_type&
maximize(
const vector_type& _rhs) {
603 #define expr(i) if (_rhs[i] > Base::values_[i]) Base::values_[i] = _rhs[i];
612 #define expr(i) if (_rhs[i] > Base::values_[i]) { Base::values_[i] =_rhs[i]; result = true; }
619 inline vector_type
min(
const vector_type& _rhs)
const {
620 return vector_type(*this).
minimize(_rhs);
624 inline vector_type
max(
const vector_type& _rhs)
const {
625 return vector_type(*this).
maximize(_rhs);
633 template<
typename Functor>
634 inline vector_type
apply(
const Functor& _func)
const {
636 #define expr(i) result[i] = _func(Base::values_[i]);
644 #define expr(i) Base::values_[i] = _s;
659 #define expr(i) if (Base::values_[i] != _rhs.Base::values_[i]) \
660 return (Base::values_[i] < _rhs.Base::values_[i]);
674 #define expr(i) is >> vec[i];
684 operator<<(std::ostream& os, const VectorT<Scalar,DIM>& vec)
687 for(
int i=0; i<N-1; ++i) os << vec[i] <<
" ";
690 #define expr(i) vec[i]
691 os << unroll_comb(expr, <<
" " <<);
700 #endif // included by VectorT.hh
vector_type & normalize_cond()
normalize vector, return normalized vector and avoids div by zero
Definition: VectorT_inc.hh:486
vector_type min(const vector_type &_rhs) const
component-wise min
Definition: VectorT_inc.hh:619
bool operator!=(const vector_type &_rhs) const
component-wise comparison
Definition: VectorT_inc.hh:266
Scalar mean() const
return arithmetic mean
Definition: VectorT_inc.hh:570
VectorT()
default constructor creates uninitialized values.
Definition: VectorT_inc.hh:98
vector_type & operator+=(const vector_type &_rhs)
vector self-addition
Definition: VectorT_inc.hh:348
VectorT(const VectorT< otherScalarType, N > &_rhs)
copy & cast constructor (explicit)
Definition: VectorT_inc.hh:189
Scalar value_type
the type of the scalar used in this template
Definition: VectorT_inc.hh:81
const vector_type normalized() const
return normalized vector
Definition: VectorT_inc.hh:479
Scalar mean_abs() const
return absolute arithmetic mean
Definition: VectorT_inc.hh:577
vector_type & operator*=(const vector_type &_rhs)
component-wise self-multiplication
Definition: VectorT_inc.hh:324
static size_t size()
returns dimension of the vector
Definition: VectorT_inc.hh:90
vector_type & maximize(const vector_type &_rhs)
maximize values: same as *this = max(*this, _rhs), but faster
Definition: VectorT_inc.hh:602
Scalar sqrnorm() const
compute squared euclidean norm
Definition: VectorT_inc.hh:452
Scalar l8_norm() const
compute l8_norm
Definition: VectorT_inc.hh:520
vector_type & operator/=(const Scalar &_s)
component-wise self-division by scalar
Definition: VectorT_inc.hh:285
Scalar min_abs() const
return the minimal absolute component
Definition: VectorT_inc.hh:560
const Scalar & operator[](size_t _i) const
get i'th element read-only
Definition: VectorT_inc.hh:248
vector_type & operator/=(const vector_type &_rhs)
component-wise self-division
Definition: VectorT_inc.hh:332
Scalar max_abs() const
return the maximal absolute component
Definition: VectorT_inc.hh:541
Scalar max() const
return the maximal component
Definition: VectorT_inc.hh:533
bool operator==(const vector_type &_rhs) const
component-wise comparison
Definition: VectorT_inc.hh:258
vector_type apply(const Functor &_func) const
component-wise apply function object with Scalar operator()(Scalar).
Definition: VectorT_inc.hh:634
vector_type operator-(const vector_type &_v) const
component-wise vector difference
Definition: VectorT_inc.hh:393
const Scalar * data() const
access to const Scalar array
Definition: VectorT_inc.hh:224
Scalar & operator[](size_t _i)
get i'th element read-write
Definition: VectorT_inc.hh:243
Scalar length() const
compute euclidean norm
Definition: VectorT_inc.hh:449
static int dim()
returns dimension of the vector (deprecated)
Definition: VectorT_inc.hh:87
vector_type operator/(const Scalar &_s) const
component-wise division by with scalar
Definition: VectorT_inc.hh:306
static vector_type vectorized(const Scalar &_s)
store the same value in each component
Definition: VectorT_inc.hh:652
vector_type operator-(void) const
unary minus
Definition: VectorT_inc.hh:405
vector_type & operator-=(const vector_type &_rhs)
vector difference from this
Definition: VectorT_inc.hh:340
vector_type & minimize(const vector_type &_rhs)
minimize values: same as *this = min(*this, _rhs), but faster
Definition: VectorT_inc.hh:585
vector_type operator+(const vector_type &_v) const
component-wise vector addition
Definition: VectorT_inc.hh:381
vector_type operator/(const vector_type &_v) const
component-wise vector division
Definition: VectorT_inc.hh:369
bool maximized(const vector_type &_rhs)
maximize values and signalize coordinate maximization
Definition: VectorT_inc.hh:610
vector_type & normalize()
normalize vector, return normalized vector
Definition: VectorT_inc.hh:470
Scalar l1_norm() const
compute L1 (Manhattan) norm
Definition: VectorT_inc.hh:504
vector_type operator*(const Scalar &_s) const
component-wise multiplication with scalar
Definition: VectorT_inc.hh:294
vector_type & operator=(const VectorT< otherScalarType, N > &_rhs)
cast from vector with a different scalar type
Definition: VectorT_inc.hh:200
vector_type & operator*=(const Scalar &_s)
component-wise self-multiplication with scalar
Definition: VectorT_inc.hh:276
VectorT(const Scalar _values[N])
construct from a value array (explicit)
Definition: VectorT_inc.hh:172
bool minimized(const vector_type &_rhs)
minimize values and signalize coordinate minimization
Definition: VectorT_inc.hh:593
bool operator<(const vector_type &_rhs) const
lexicographical comparison
Definition: VectorT_inc.hh:658
VectorT< Scalar, N > vector_type
type of this vector
Definition: VectorT_inc.hh:84
vector_type max(const vector_type &_rhs) const
component-wise max
Definition: VectorT_inc.hh:624
Scalar operator|(const vector_type &_rhs) const
compute scalar product
Definition: VectorT_inc.hh:431
vector_type & vectorize(const Scalar &_s)
store the same value in each component (e.g. to clear all entries)
Definition: VectorT_inc.hh:643
vector_type operator*(const vector_type &_v) const
component-wise vector multiplication
Definition: VectorT_inc.hh:357
Scalar min() const
return the minimal component
Definition: VectorT_inc.hh:552
Definition: VectorT_inc.hh:72