|
| constexpr | Vec () |
| |
| | Vec (const std::initializer_list< T > &items) |
| |
| constexpr | Vec (const T a[N]) |
| |
template<index_t... M>
requires ((M + ...) == N) and (sizeof...(M) > 1) |
| constexpr | Vec (const Vec< T, M > &...vecs) |
| | Construct a new vector by concatenating two or more vectors.
|
| |
| template<typename U> |
| constexpr | Vec (const Vec< U, N-1 > &v, T a) |
| |
| template<typename Mx, typename Ref> |
| | Vec (detail::MtxColIterator< Mx, Ref > mtx_col) |
| |
| constexpr | Vec (T a) |
| |
| self_t | abs () const |
| | Element-wise absolute value.
|
| |
| self_t | add (const self_t &v) const |
| | Vector addition.
|
| |
|
self_t | align (const self_t &from, const self_t &to) const |
| | Apply a rotation to this which aligns the unit vectors from with to.
|
| |
| T | angle_to (const self_t &v) const |
| | Angle between vectors.
|
| |
|
index_t | argmax () const |
| | Return the index of the coordinate with the largest absolute value.
|
| |
|
index_t | argmin () const |
| | Return the index of the coordinate with the smallest absolute value.
|
| |
| T * | begin () |
| |
| const T * | begin () const |
| |
| self_t | bounce_on (const self_t &normal) const |
| | Elastic collision.
|
| |
| self_t | ceil () const |
| | Element-wise ceiling function.
|
| |
| self_t | clamp (const self_t &lo, const self_t &hi) const |
| | Element-wise clamp.
|
| |
| T | dist (const self_t &pt) const |
| | Distance between points.
|
| |
| T | dist2 (const self_t &pt) const |
| | Distance squared to a point.
|
| |
| T | dot (const self_t &v) const |
| | Dot product.
|
| |
| T * | end () |
| |
| const T * | end () const |
| |
| self_t | floor () const |
| | Element-wise floor function.
|
| |
| T | fraction_on (const self_t &axis) const |
| | Return the component of this that projects to axis, as a fraction of axis's length.
|
| |
| T & | get (index_t idx) |
| |
| const T & | get (index_t idx) const |
| |
|
bool | is_zero () const |
| | Return true if all elements are zero.
|
| |
| T | mag () const |
| | Euclidean norm (magnitude).
|
| |
| T | mag2 () const |
| | Squared magnitude.
|
| |
| T | max () const |
| | Maximum element.
|
| |
| self_t | max (const self_t &v) const |
| | Element-wise maximum of two Vecs.
|
| |
| T | min () const |
| | Minimum element.
|
| |
| self_t | min (const self_t &v) const |
| | Element-wise minimum of two Vecs.
|
| |
| self_t | mix (const self_t &v, T mix) const |
| | Linear interpolation.
|
| |
| | operator Vec< U, N > () const |
| | Element typecast.
|
| |
| bool | operator!= (const self_t &vv) const |
| | Inequality test.
|
| |
|
self_t & | operator*= (const self_t &vv) |
| | Element-wise multiplication and assignment.
|
| |
|
self_t & | operator*= (T s) |
| | Scalar multiplication and assignment.
|
| |
|
self_t | operator+ (const self_t &v) const |
| | Element-wise addition.
|
| |
|
self_t & | operator+= (const self_t &vv) |
| | Element-wise addition and assignment.
|
| |
| self_t | operator- () const |
| | Negation.
|
| |
|
self_t | operator- (const self_t &v) const |
| | Element-wise subtraction.
|
| |
|
self_t & | operator-= (const self_t &vv) |
| | Subtraction and assignment.
|
| |
|
self_t & | operator/= (T s) |
| | Scalar division and assignment.
|
| |
| bool | operator== (const self_t &vv) const |
| | Equality test.
|
| |
| T & | operator[] (index_t idx) |
| | Vector element access.
|
| |
| const T & | operator[] (index_t idx) const |
| | Vector element access.
|
| |
|
T | product () const |
| | Multiply all elements together.
|
| |
| self_t | project_on (const self_t &axis) const |
| | Orthogonal projection to an axis.
|
| |
| self_t | reflect_about (self_t normal) const |
| | Reflection about a normal.
|
| |
| PointType< T, M >::point_t | resized () const |
| | Resized copy of a vector.
|
| |
|
self_t | round () const |
| | Round each element to the nearest integer.
|
| |
| self_t | scale (const self_t &v) const |
| | Element-wise multiplication.
|
| |
| self_t | scale (T a) const |
| | Scalar multiple.
|
| |
|
index_t | size () const |
| | The number of elements in this vector. Always equal to N.
|
| |
| self_t | sub (const self_t &v) const |
| | Vector subtraction.
|
| |
|
T | sum () const |
| | Sum the elements of the vector.
|
| |
| self_t | unit () const |
| | Vector normalization.
|
| |
| self_t | with_length (T mag) const |
| | Compute a vector with the direction of this and a new magnitude mag.
|
| |
|
(Note that these are not member symbols.)
|
| template<typename T, index_t N> |
| geom::Vec< T, N > | abs (const geom::Vec< T, N > &v) |
| |
| template<typename T, index_t N> |
| geom::Vec< T, N > | ceil (const geom::Vec< T, N > &v) |
| |
| template<typename T, index_t N> |
| geom::Vec< T, N > | cos (const geom::Vec< T, N > &v) |
| |
| template<typename T, index_t N> |
| geom::Vec< T, N > | exp (const geom::Vec< T, N > &v) |
| |
| template<typename T, index_t N> |
| geom::Vec< T, N > | floor (const geom::Vec< T, N > &v) |
| |
| template<typename T, index_t N> |
| geom::Vec< T, N > | log (const geom::Vec< T, N > &v) |
| |
| template<typename T, index_t N> |
| geom::Vec< T, N > | max (const geom::Vec< T, N > &a, const geom::Vec< T, N > &b) |
| |
| template<typename T, index_t N> |
| geom::Vec< T, N > | min (const geom::Vec< T, N > &a, const geom::Vec< T, N > &b) |
| |
| template<typename T, index_t N> |
| const Vec< T, N > | operator* (const Vec< T, N > &a, const Vec< T, N > &b) |
| |
| template<typename T, index_t N, typename U> |
| Vec< T, N > | operator* (const Vec< T, N > &v, U d) |
| |
| template<typename T, index_t N, typename U> |
| Vec< T, N > | operator* (U d, const Vec< T, N > &v) |
| |
| template<typename T, index_t N> |
| const Vec< T, N > | operator/ (const Vec< T, N > &a, const Vec< T, N > &b) |
| |
| template<typename T, index_t N, typename U> |
| Vec< T, N > | operator/ (const Vec< T, N > &v, U d) |
| |
| template<typename T, index_t N, typename U> |
| Vec< T, N > | operator/ (const Vec< T, N > &v, U d) |
| |
| template<typename T, index_t N> |
| geom::Vec< T, N > | sin (const geom::Vec< T, N > &v) |
| |
| template<typename T, index_t N> |
| geom::Vec< T, N > | sqrt (const geom::Vec< T, N > &v) |
| |
| template<typename T, index_t N> |
| geom::Vec< T, N > | tan (const geom::Vec< T, N > &v) |
| |
template<typename T, index_t N>
class geom::Vec< T, N >
A tuple of N elements of type T.
Vectors are lightweight and generally perform as well as a bare array of their element type.
Geomc makes no type distinction between vectors, points, or normals; the distinction is to be made by the programmer based on usage.
Declaring a 3-dimensional vector of doubles:
Vec<double,3> v;
Basic arithmetic:
v3 = v1 + v2; // addition
v3 = v1 - v2; // subtraction
v3 = -v1; // negation
v3 = 2.71 * v1; // scalar mult
v3 = 1.61 / v1; // scalar div
v3 = v1 / 1.41; // scalar div
Element-wise multiplication / division:
v3 = v1 * v2;
v3 = v2 / v1;
Element access:
double z = v[2];
z = v.get(2);
Access to / iteration over internal array:
for (double *p = v.begin(); p != v.end(); p++) {
double a = f(*p, ...);
}
Cross product (3D only):
v3 = v1 ^ v2;
Compatibility with std:
// element-wise operations
std::min(v1, v2);
std::max(v1, v2);
std::abs(v1);
std::floor(v1);
std::ceil(v1);
Resizing:
Vec<double,3> v3d;
Vec<double,2> v2d = v3d.resized<2>(); // truncate the last coordinate
Vec<double,4> v4d = v3d.resized<4>(); // last coordinate is zero