|
template<typename... T, typename = typename std::enable_if<sizeof...(T) == DIM>::type, typename = typename std::enable_if< are_convertible_to<Scalar, T...>::value>::type> |
constexpr | VectorT (T...vs) |
|
constexpr | VectorT () |
| default constructor creates uninitialized values.
|
|
| VectorT (const Scalar &v) |
| Creates a vector with all components set to v.
|
|
| VectorT (const VectorT &rhs)=default |
|
| VectorT (VectorT &&rhs)=default |
|
VectorT & | operator= (const VectorT &rhs)=default |
|
VectorT & | operator= (VectorT &&rhs)=default |
|
template<typename S = Scalar, int D = DIM> |
auto | homogenized () const -> typename std::enable_if< D==4, VectorT< decltype(std::declval< S >()/std::declval< S >()), DIM >>::type |
| Only for 4-component vectors with division operator on their Scalar: Dehomogenization.
|
|
template<typename Iterator , typename = decltype( *std::declval<Iterator&>(), void(), ++std::declval<Iterator&>(), void())> |
| VectorT (Iterator it) |
| construct from a value array or any other iterator
|
|
template<typename otherScalarType , typename = typename std::enable_if< std::is_convertible<otherScalarType, Scalar>::value>> |
| VectorT (const VectorT< otherScalarType, DIM > &_rhs) |
| copy & cast constructor (explicit)
|
|
template<typename OtherScalar , typename = typename std::enable_if< std::is_convertible<OtherScalar, Scalar>::value>> |
vector_type & | operator= (const VectorT< OtherScalar, DIM > &_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
|
|
template<typename OtherScalar > |
auto | operator*= (const OtherScalar &_s) -> typename std::enable_if< std::is_convertible< decltype(this->values_[0]*_s), Scalar >::value, VectorT< Scalar, DIM > & >::type |
| component-wise self-multiplication with scalar
|
|
template<typename OtherScalar > |
auto | operator/= (const OtherScalar &_s) -> typename std::enable_if< std::is_convertible< decltype(this->values_[0]/_s), Scalar >::value, VectorT< Scalar, DIM > & >::type |
| component-wise self-division by scalar
|
|
template<typename OtherScalar > |
std::enable_if< std::is_convertible< decltype(std::declval< Scalar >)*std::declval< OtherScalar >)), Scalar >::value, VectorT< Scalar, DIM > >::type | operator* (const OtherScalar &_s) const |
| component-wise multiplication with scalar
|
|
template<typename OtherScalar > |
std::enable_if< std::is_convertible< decltype(std::declval< Scalar >)/std::declval< OtherScalar >)), Scalar >::value, VectorT< Scalar, DIM > >::type | operator/ (const OtherScalar &_s) const |
| component-wise division by with scalar
|
|
template<typename OtherScalar > |
auto | operator*= (const VectorT< OtherScalar, DIM > &_rhs) -> typename std::enable_if< sizeof(decltype(this->values_[0]**_rhs.data())) >=0 |
| component-wise self-multiplication
|
|
template<typename OtherScalar > |
auto | operator/= (const VectorT< OtherScalar, DIM > &_rhs) -> typename std::enable_if< sizeof(decltype(this->values_[0]/*_rhs.data())) >=0 |
| component-wise self-division
|
|
template<typename OtherScalar > |
auto | operator-= (const VectorT< OtherScalar, DIM > &_rhs) -> typename std::enable_if< sizeof(decltype(this->values_[0]-*_rhs.data())) >=0 |
| vector difference from this
|
|
template<typename OtherScalar > |
auto | operator+= (const VectorT< OtherScalar, DIM > &_rhs) -> typename std::enable_if< sizeof(decltype(this->values_[0]+*_rhs.data())) >=0 |
| vector self-addition
|
|
template<typename OtherScalar > |
auto | operator* (const VectorT< OtherScalar, DIM > &_rhs) const -> typename std::enable_if< sizeof(decltype(this->values_[0]**_rhs.data())) >=0 |
| component-wise vector multiplication
|
|
template<typename OtherScalar > |
auto | operator/ (const VectorT< OtherScalar, DIM > &_rhs) const -> typename std::enable_if< sizeof(decltype(this->values_[0]/*_rhs.data())) >=0 |
| component-wise vector division
|
|
template<typename OtherScalar > |
auto | operator+ (const VectorT< OtherScalar, DIM > &_rhs) const -> typename std::enable_if< sizeof(decltype(this->values_[0]+*_rhs.data())) >=0 |
| component-wise vector addition
|
|
template<typename OtherScalar > |
auto | operator- (const VectorT< OtherScalar, DIM > &_rhs) const -> typename std::enable_if< sizeof(decltype(this->values_[0]-*_rhs.data())) >=0 |
| component-wise vector difference
|
|
vector_type | operator- (void) const |
| unary minus
|
|
template<typename OtherScalar > |
auto | operator% (const VectorT< OtherScalar, DIM > &_rhs) const -> typename std::enable_if< DIM==3, VectorT< decltype((*this)[0]*_rhs[0]-(*this)[0]*_rhs[0]), DIM >>::type |
| cross product: only defined for Vec3* as specialization More...
|
|
template<typename OtherScalar > |
auto | operator| (const VectorT< OtherScalar, DIM > &_rhs) const -> decltype(*this->data()**_rhs.data()) |
| compute scalar product More...
|
|
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
|
|
void | swap (VectorT &_other) noexcept(noexcept(std::swap(values_, _other.values_))) |
| swap with another vector
|
|
|
template<typename S = Scalar> |
decltype(std::declval< S >()*std::declval< S >()) | sqrnorm () const |
| compute squared euclidean norm
|
|
template<typename S = Scalar> |
auto | norm () const -> decltype(std::sqrt(std::declval< VectorT< S, DIM >>().sqrnorm())) |
| compute euclidean norm
|
|
template<typename S = Scalar> |
auto | length () const -> decltype(std::declval< VectorT< S, DIM >>().norm()) |
| compute squared euclidean norm
|
|
template<typename S = Scalar> |
auto | normalize () -> decltype(*this/=std::declval< VectorT< S, DIM >>().norm()) |
| normalize vector, return normalized vector
|
|
template<typename S = Scalar> |
auto | normalized () const -> decltype(*this/std::declval< VectorT< S, DIM >>().norm()) |
| return normalized vector
|
|
template<typename S = Scalar> |
vector_type &::type | normalize_cond () |
| compute squared euclidean norm
|
|
|
Scalar | l1_norm () const |
| compute L1 (Manhattan) norm
|
|
Scalar | l8_norm () const |
| compute l8_norm
|
|
|
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
|
|