This is a fixed-length column vector designed for no-overhead inline computation.
More...
|
|
These are obscure members of Vec that are used for template metaprogramming and can be ignored by most users.
|
| enum | {
NRows = M,
NCols = 1,
NPackedElements = M,
NActualElements = M * STRIDE,
NActualScalars = CNT<E>::NActualScalars * NActualElements,
RowSpacing = STRIDE,
ColSpacing = NActualElements,
ImagOffset = NTraits<ENumber>::ImagOffset,
RealStrideFactor = 1,
ArgDepth,
IsScalar = 0,
IsULessScalar = 0,
IsNumber = 0,
IsStdNumber = 0,
IsPrecision = 0,
SignInterpretation = CNT<E>::SignInterpretation
} |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef ELT | E |
| | Element type of this Vec. More...
|
| |
| typedef CNT< E >::TNeg | ENeg |
| | Negated version of this Vec's element type; ENeg==negator< E >. More...
|
| |
| typedef CNT< E >::TWithoutNegator | EWithoutNegator |
| | Element type, stripped of negator<> if it has one. More...
|
| |
| typedef CNT< E >::TReal | EReal |
| | Type showing just the real part of an element of this Vec if elements are complex; otherwise just the element type. More...
|
| |
| typedef CNT< E >::TImag | EImag |
| | Type showing the imaginary part of an element of this Vec as real, if elements are complex; otherwise a type that can hold a zero of the element type. More...
|
| |
| typedef CNT< E >::TComplex | EComplex |
| | Type that elements would have if complex, if E is currently real; otherwise just the element type E. More...
|
| |
| typedef CNT< E >::THerm | EHerm |
| | Type of the Hermitian transpose of an element of this Vec. More...
|
| |
| typedef CNT< E >::TPosTrans | EPosTrans |
| | Type of a positional transpose of an element of this Vec. More...
|
| |
| typedef CNT< E >::TSqHermT | ESqHermT |
| | Type of the expression ~E*E (default vector and matrix square; symmetric). More...
|
| |
| typedef CNT< E >::TSqTHerm | ESqTHerm |
| | Type of the expression E*~E ("row square"; symmetric). More...
|
| |
| typedef CNT< E >::TSqrt | ESqrt |
| | Type required to hold the result of sqrt(E). More...
|
| |
| typedef CNT< E >::TAbs | EAbs |
| | Type required to hold the result of abs(E). More...
|
| |
| typedef CNT< E >::TStandard | EStandard |
| | Return type of standardize(E) method; a packed type that can hold the value of an element after eliminating negator and conjugate types. More...
|
| |
| typedef CNT< E >::TInvert | EInvert |
| | Packed type that can hold the value returned from invert(E), the inverse type of an element. More...
|
| |
| typedef CNT< E >::TNormalize | ENormalize |
| | Packed type that can hold the value returned from normalize(E). More...
|
| |
| typedef CNT< E >::Scalar | EScalar |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef CNT< E >::ULessScalar | EULessScalar |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef CNT< E >::Number | ENumber |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef CNT< E >::StdNumber | EStdNumber |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef CNT< E >::Precision | EPrecision |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef CNT< E >::ScalarNormSq | EScalarNormSq |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef Vec< M, E, STRIDE > | T |
| | The type of this Vec. More...
|
| |
| typedef Vec< M, ENeg, STRIDE > | TNeg |
| | Type this Vec would have if its elements were interpreted as negated. More...
|
| |
typedef Vec< M,
EWithoutNegator, STRIDE > | TWithoutNegator |
| | Type of this Vec with negator removed from its element type, if the element is negated. More...
|
| |
typedef Vec< M, EReal, STRIDE
*CNT< E >::RealStrideFactor > | TReal |
| | Type of this Vec cast to show only the real part of its element; this might affect the stride. More...
|
| |
typedef Vec< M, EImag, STRIDE
*CNT< E >::RealStrideFactor > | TImag |
| | Type of this Vec cast to show only the imaginary part of its element; this might affect the stride. More...
|
| |
| typedef Vec< M, EComplex, STRIDE > | TComplex |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef Row< M, EHerm, STRIDE > | THerm |
| | Type of this Vec after casting to its Hermitian transpose; that is, the Vec turns into a Row and each element turns into its Hermitian transpose. More...
|
| |
| typedef Row< M, E, STRIDE > | TPosTrans |
| | Type of this Vec after casting to its positional transpose; that is, the Vec turns into a Row but the element type remains unchanged. More...
|
| |
| typedef E | TElement |
| | Element type of this Vec. More...
|
| |
| typedef E | TRow |
| | Type of a row of this CNT object (for a Vec, just its element type). More...
|
| |
| typedef Vec | TCol |
| | Type of a column of this CNT object (for a Vec, the whole thing). More...
|
| |
| typedef Vec< M, ESqrt, 1 > | TSqrt |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef Vec< M, EAbs, 1 > | TAbs |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef Vec< M, EStandard, 1 > | TStandard |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef Row< M, EInvert, 1 > | TInvert |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef Vec< M, ENormalize, 1 > | TNormalize |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef ESqHermT | TSqHermT |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef SymMat< M, ESqTHerm > | TSqTHerm |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef EScalar | Scalar |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef EULessScalar | ULessScalar |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef ENumber | Number |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef EStdNumber | StdNumber |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef EPrecision | Precision |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
| typedef EScalarNormSq | ScalarNormSq |
| | These compile-time constants are required of every Composite Numerical Type (CNT). More...
|
| |
|
| ScalarNormSq | scalarNormSqr () const |
| | Scalar norm square is sum( conjugate squares of all underlying scalars ), where conjugate square of scalar s is conj(s)*s. More...
|
| |
| TSqrt | sqrt () const |
| | Elementwise square root; that is, the return value has the same length as this Vec but with each element replaced by whatever it thinks its square root is. More...
|
| |
| TAbs | abs () const |
| | Elementwise absolute value; that is, the return value has the same dimension as this Vec but with each element replaced by whatever it thinks its absolute value is. More...
|
| |
| TStandard | standardize () const |
| | Return a copy of this Vec but with the underlying scalar type converted (if necessary) to one of the C++ standard real or complex floating point types. More...
|
| |
| EStandard | sum () const |
| | Sum just adds up all the elements into a single return element that is the same type as this Vec's elements except standardized to use one of the C++ built-in real or complex types as its underlying scalars. More...
|
| |
| | Vec () |
| | Default construction initializes Vec's elements to NaN when debugging but leaves them uninitialized garbage otherwise, so declarations have zero cost in Release builds. More...
|
| |
| | Vec (const Vec &src) |
| | Copy constructor copies the logically-included elements from the source Vec; gaps due to stride are not accessed in either source or destination. More...
|
| |
| Vec & | operator= (const Vec &src) |
| | Copy assignment operator copies the logically-included elements from the source Vec; gaps due to stride are not accessed in either source or destination. More...
|
| |
| template<int SS> |
| | Vec (const Vec< M, E, SS > &src) |
| | This is an implicit conversion from a Vec of the same length and element type but with a different stride. More...
|
| |
| template<int SS> |
| | Vec (const Vec< M, ENeg, SS > &src) |
| | This is an implicit conversion from a Vec of the same length and negated element type (possibly with a different stride). More...
|
| |
| template<class EE , int SS> |
| | Vec (const Vec< M, EE, SS > &src) |
| | Construct a Vec from a Vec of the same length, with any stride. More...
|
| |
| | Vec (const E &e) |
| | Construction from a single value of this Vec's element type assigns that value to each element. More...
|
| |
| | Vec (const ENeg &ne) |
| | Construction from a single value of this Vec's negated element type assigns that value to each element, requiring floating point negation to be performed once to compute the type-E representation of the type negator<E> value provided. More...
|
| |
| | Vec (int i) |
| | Given an int value, turn it into a suitable floating point number, convert that to element type E and then feed that to the above single-element constructor. More...
|
| |
| | Vec (const E &e0, const E &e1) |
| | Construct a Vec<2,E> from two elements of type E, etc. More...
|
| |
| | Vec (const E &e0, const E &e1, const E &e2) |
| |
| | Vec (const E &e0, const E &e1, const E &e2, const E &e3) |
| |
| | Vec (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4) |
| |
| | Vec (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5) |
| |
| | Vec (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6) |
| |
| | Vec (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7) |
| |
| | Vec (const E &e0, const E &e1, const E &e2, const E &e3, const E &e4, const E &e5, const E &e6, const E &e7, const E &e8) |
| |
| template<class EE > |
| | Vec (const EE *p) |
| | Construction from a pointer to elements of any type EE assumes we're pointing at a C++ array of EE's of the right length, and that EE is assignment compatible with this Vec's element type E. More...
|
| |
| template<class EE > |
| Vec & | operator= (const EE *p) |
| | Assignment to a pointer to elements of any type EE assumes we're pointing at a C++ array of EE's of the right length, and that EE is assignment compatible with this Vec's element type E. More...
|
| |
| template<class EE , int SS> |
| Vec & | operator= (const Vec< M, EE, SS > &vv) |
| | Assignment to a conforming Vec, of any element type and stride, provided that the element types are assignment-compatible. More...
|
| |
| template<class EE , int SS> |
| Vec & | operator+= (const Vec< M, EE, SS > &r) |
| | Add in a conforming Vec, of any element type and stride, provided that the element types are addition-compatible. More...
|
| |
| template<class EE , int SS> |
| Vec & | operator+= (const Vec< M, negator< EE >, SS > &r) |
| | Add in a conforming Vec, of any negated element type and stride, provided that the element types are addition-compatible. More...
|
| |
| template<class EE , int SS> |
| Vec & | operator-= (const Vec< M, EE, SS > &r) |
| | Subtract off a conforming Vec, of any element type and stride, provided that the element types are addition-compatible. More...
|
| |
| template<class EE , int SS> |
| Vec & | operator-= (const Vec< M, negator< EE >, SS > &r) |
| | Subtract off a conforming Vec, of any negated element type and stride, provided that the element types are addition-compatible. More...
|
| |
| template<class EE , int SS> |
Vec< M, typename CNT< E >
::template Result< EE >::Add > | conformingAdd (const Vec< M, EE, SS > &r) const |
| | Vector addition – use operator+ instead. More...
|
| |
| template<class EE , int SS> |
Vec< M, typename CNT< E >
::template Result< EE >::Sub > | conformingSubtract (const Vec< M, EE, SS > &r) const |
| | Vector subtraction – use operator- instead. More...
|
| |
| template<class EE , int SS> |
Mat< M, M, typename CNT< E >
::template Result< EE >::Mul > | conformingMultiply (const Row< M, EE, SS > &r) const |
| | Same as outer product (m = col*row) – use operator* or outer() instead. More...
|
| |
| template<class EE , int SS> |
Vec< M, typename CNT< E >
::template Result< EE >::Mul > | elementwiseMultiply (const Vec< M, EE, SS > &r) const |
| | Elementwise multiply (Matlab " .* " operator). More...
|
| |
| template<class EE , int SS> |
Vec< M, typename CNT< E >
::template Result< EE >::Dvd > | elementwiseDivide (const Vec< M, EE, SS > &r) const |
| | Elementwise divide (Matlab " ./ " operator). More...
|
| |
| const E & | operator[] (int i) const |
| | Select an element of this Vec and return a const reference to it. More...
|
| |
| const E & | operator() (int i) const |
| | Same as const operator[] above. More...
|
| |
| E & | operator[] (int i) |
| | Select an element of this Vec and return a writable reference to it. More...
|
| |
| E & | operator() (int i) |
| | Same as non-const operator[] above. More...
|
| |
| ScalarNormSq | normSqr () const |
| |
| CNT< ScalarNormSq >::TSqrt | norm () const |
| |
| TNormalize | normalize () const |
| | If the elements of this Vec are scalars, the result is what you get by dividing each element by the norm() calculated above. More...
|
| |
| TInvert | invert () const |
| | This method is not supported for Vec objects. More...
|
| |
| const Vec & | operator+ () const |
| | Unary plus does nothing. More...
|
| |
| const TNeg & | operator- () const |
| | Unary minus recasts this Vec to a type that has the opposite interpretation of the sign but is otherwise identical, so no computation or copying is performed here. More...
|
| |
| TNeg & | operator- () |
| | Recast to negated type and return a writable reference; writing to this will cause the negated result to be placed in the original Vec. More...
|
| |
| const THerm & | operator~ () const |
| | The Hermitian transpose operator recasts this Vec to a type that specifies the opposite storage order (row vs. column) then returns a reference, so no computation or copying is performed here. More...
|
| |
| THerm & | operator~ () |
| | Recast to Hermitian transposed type and return a writable reference; the effect is that writing to elements of the result affects the transposed element of the original Vec. More...
|
| |
| const TNeg & | negate () const |
| | Non-operator version of unary negation; just a recast. More...
|
| |
| TNeg & | updNegate () |
| | Non-operator version of unary negation; recasts and returns a writable reference. More...
|
| |
| const THerm & | transpose () const |
| | Non-operator version of Hermitian transpose; just a recast. More...
|
| |
| THerm & | updTranspose () |
| | Non-operator version of Hermitian transpose; recasts and returns a writable reference. More...
|
| |
| const TPosTrans & | positionalTranspose () const |
| | Positional transpose turns this Vec into a Row but does not transpose the individual elements. More...
|
| |
| TPosTrans & | updPositionalTranspose () |
| | Positional transpose returning a writable reference. More...
|
| |
| const TReal & | real () const |
| | Return a reference to the real portion of this Vec if it has complex elements; otherwise the type doesn't change. More...
|
| |
| TReal & | real () |
| | Recast to show only the real portion of this Vec and return a writable reference. More...
|
| |
| const TImag & | imag () const |
| | Return a reference to the imaginary portion of this Vec if it has complex elements; otherwise the type doesn't change. More...
|
| |
| TImag & | imag () |
| | Recast to show only the imaginary portion of this Vec and return a writable reference. More...
|
| |
| const TWithoutNegator & | castAwayNegatorIfAny () const |
| | Recast to remove negators from this Vec's type if present; this is handy for simplifying operations where we know the sign can be ignored such as squaring. More...
|
| |
| TWithoutNegator & | updCastAwayNegatorIfAny () |
| | Recast to remove negators from this Vec's type if present and return a writable reference. More...
|
| |
| template<class EE > |
Vec< M, typename CNT< E >
::template Result< EE >::Mul > | scalarMultiply (const EE &e) const |
| |
| template<class EE > |
Vec< M, typename CNT< EE >
::template Result< E >::Mul > | scalarMultiplyFromLeft (const EE &e) const |
| |
| template<class EE > |
Vec< M, typename CNT< E >
::template Result< EE >::Dvd > | scalarDivide (const EE &e) const |
| |
| template<class EE > |
Vec< M, typename CNT< EE >
::template Result< E >::Dvd > | scalarDivideFromLeft (const EE &e) const |
| |
| template<class EE > |
Vec< M, typename CNT< E >
::template Result< EE >::Add > | scalarAdd (const EE &e) const |
| |
| template<class EE > |
Vec< M, typename CNT< E >
::template Result< EE >::Sub > | scalarSubtract (const EE &e) const |
| |
| template<class EE > |
Vec< M, typename CNT< EE >
::template Result< E >::Sub > | scalarSubtractFromLeft (const EE &e) const |
| |
| template<class EE > |
| Vec & | operator= (const EE &e) |
| |
| template<class EE > |
| Vec & | operator+= (const EE &e) |
| |
| template<class EE > |
| Vec & | operator-= (const EE &e) |
| |
| template<class EE > |
| Vec & | operator*= (const EE &e) |
| |
| template<class EE > |
| Vec & | operator/= (const EE &e) |
| |
| template<class EE > |
| Vec & | scalarEq (const EE &ee) |
| |
| template<class EE > |
| Vec & | scalarPlusEq (const EE &ee) |
| |
| template<class EE > |
| Vec & | scalarMinusEq (const EE &ee) |
| |
| template<class EE > |
| Vec & | scalarMinusEqFromLeft (const EE &ee) |
| |
| template<class EE > |
| Vec & | scalarTimesEq (const EE &ee) |
| |
| template<class EE > |
| Vec & | scalarTimesEqFromLeft (const EE &ee) |
| |
| template<class EE > |
| Vec & | scalarDivideEq (const EE &ee) |
| |
| template<class EE > |
| Vec & | scalarDivideEqFromLeft (const EE &ee) |
| |
| Vec & | scalarEq (int ee) |
| |
| Vec & | scalarPlusEq (int ee) |
| |
| Vec & | scalarMinusEq (int ee) |
| |
| Vec & | scalarTimesEq (int ee) |
| |
| Vec & | scalarDivideEq (int ee) |
| |
| Vec & | scalarMinusEqFromLeft (int ee) |
| |
| Vec & | scalarTimesEqFromLeft (int ee) |
| |
| Vec & | scalarDivideEqFromLeft (int ee) |
| |
| void | setToNaN () |
| | Set every scalar in this Vec to NaN; this is the default initial value in Debug builds, but not in Release. More...
|
| |
| void | setToZero () |
| | Set every scalar in this Vec to zero. More...
|
| |
| template<int MM> |
| const Vec< MM, ELT, STRIDE > & | getSubVec (int i) const |
| | Extract a const reference to a sub-Vec with size known at compile time. More...
|
| |
| template<int MM> |
| Vec< MM, ELT, STRIDE > & | updSubVec (int i) |
| | Extract a writable reference to a sub-Vec with size known at compile time. More...
|
| |
| Vec< M-1, ELT, 1 > | drop1 (int p) const |
| | Return a vector one smaller than this one by dropping the element at the indicated position p. More...
|
| |
| template<class EE > |
| Vec< M+1, ELT, 1 > | append1 (const EE &v) const |
| | Return a vector one larger than this one by adding an element to the end. More...
|
| |
| template<class EE > |
| Vec< M+1, ELT, 1 > | insert1 (int p, const EE &v) const |
| | Return a vector one larger than this one by inserting an element before the indicated one. More...
|
| |
| bool | isNaN () const |
| | Return true if any element of this Vec contains a NaN anywhere. More...
|
| |
| bool | isInf () const |
| | Return true if any element of this Vec contains a +Infinity or -Infinity somewhere but no element contains a NaN anywhere. More...
|
| |
| bool | isFinite () const |
| | Return true if no element of this Vec contains an Infinity or a NaN anywhere. More...
|
| |
| template<class E2 , int RS2> |
| bool | isNumericallyEqual (const Vec< M, E2, RS2 > &v, double tol) const |
| | Test whether this vector is numerically equal to some other vector with the same shape, using a specified tolerance. More...
|
| |
| template<class E2 , int RS2> |
| bool | isNumericallyEqual (const Vec< M, E2, RS2 > &v) const |
| | Test whether this vector is numerically equal to some other vector with the same shape, using a default tolerance which is the looser of the default tolerances of the two objects being compared. More...
|
| |
| bool | isNumericallyEqual (const ELT &e, double tol=getDefaultTolerance()) const |
| | Test whether every element of this vector is numerically equal to the given element, using either a specified tolerance or the vector's default tolerance (which is always the same or looser than the default tolerance for one of its elements). More...
|
| |
| std::string | toString () const |
| | Print Vec into a string and return it. More...
|
| |
| void | set (int i, const E &value) |
| | Variant of operator[] that's scripting friendly to set ith entry. More...
|
| |
| const E & | get (int i) const |
| | Variant of operator[] that's scripting friendly to get const reference to ith entry. More...
|
| |
template<int M, class ELT, int STRIDE>
class SimTK::Vec< M, ELT, STRIDE >
This is a fixed-length column vector designed for no-overhead inline computation.
- Template Parameters
-
| M | The number of rows in the vector. |
| ELT | The element type. Must be a composite numerical type (CNT). The default is ELT=Real. |
| STRIDE | The spacing from one element to the next in memory, as an integer number of elements of type ELT. The default is STRIDE=1. |
Usage
The Vec and Vector classes are commonly used to represent tuples of Real values, and have methods like norm() to calculate the vector 2-norm. Use Vec for a small vector whose length is known at compile time; otherwise, use Vector. To collect elements of the same type that do not constitute a tuple, it is more appropriate to use the Array_ container. Some common Vec use cases are provided below.
Construction
The 3-tuple ~[0,0,0] can be created in the following ways:
Note that the default element type is Real, and that Vec3 is a typedef for Vec<3>; analogous typedefs exist for vectors of up to 9 elements.
Manipulation
Standard arithmetic operators can be used, as well as methods like sum() and normalize(). Here are some usage examples, each of which returns ~[1,2,3]:
Vec9(0,0,0,0,0,1,2,3,0).getSubVec<3>(5);
Conversion
It may be necessary to convert between a Vec and a Vector (to interface with FactorQTZ, for instance). In the example below, we print a Vec3 created from a 3-element Vector:
for (int i=0; i<myVector.size(); ++i) myVector[i]=i+1;
std::cout <<
Vec3(&myVector[0]) << std::endl;
Converting from a Vec3 to a Vector is also straightforward:
std::cout <<
Vector(myVec3) << std::endl;
- See also
- Vector_ for handling of large or variable-sized vectors.
-
Array_, Mat, Matrix_
1.8.8 
