|
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 Vec s.
|
|
T | min () const |
| Minimum element.
|
|
self_t | min (const self_t &v) const |
| Element-wise minimum of two Vec s.
|
|
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