This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with other symbols.
More...
|
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (AssemblyConditionIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (CableObstacleIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (CablePathIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (MobilizedBodyIndex) |
| |
| static const MobilizedBodyIndex | GroundIndex (0) |
| | This is the MobilizedBodyIndex corresponding to the unique Ground body; its index is always zero. More...
|
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ConstraintIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ParticleIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (AncestorConstrainedBodyPoolIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (USquaredIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (QuaternionPoolIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (MobodQPoolIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (PresQPoolIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (PresUPoolIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (PresUDotPoolIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (PresForcePoolIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (MobilizerQIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (MobilizerUIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ConstrainedBodyIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ConstrainedMobilizerIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ConstrainedQIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ConstrainedUIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ParticipatingQIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ParticipatingUIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (SubtreeBodyIndex) |
| |
| static const SubtreeBodyIndex | SubtreeAncestorIndex (0) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (SubtreeQIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (SubtreeUIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ForceIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactSetIndex) |
| |
| std::ostream & | operator<< (std::ostream &o, const ContactForce &f) |
| |
| std::ostream & | operator<< (std::ostream &o, const ContactDetail &d) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactCliqueId) |
| |
| std::ostream & | operator<< (std::ostream &o, const ContactSnapshot &cs) |
| |
| std::ostream & | operator<< (std::ostream &, const SimbodyMatterSubtree &) |
| |
| std::ostream & | operator<< (std::ostream &, const SimbodyMatterSubtreeResults &) |
| |
| template<class T > |
| static std::istream & | readVectorFromStreamHelper (std::istream &in, bool isFixedSize, Vector_< T > &out) |
| |
| std::ostream & | operator<< (std::ostream &o, const MatrixCharacter &) |
| | Output a textual description of a MatrixCharacter; handy for debugging. More...
|
| |
| std::ostream & | operator<< (std::ostream &o, const MatrixCommitment &) |
| | Output a textual description of a MatrixCommitment; handy for debugging. More...
|
| |
| template<class T , class X > |
| static std::istream & | readArrayFromStreamHelper (std::istream &in, bool isFixedSize, Array_< T, X > &out) |
| |
| std::ostream & | operator<< (std::ostream &stream, const AtomicInteger &value) |
| |
| template<class H , class IMPL , bool PTR> |
| std::ostream & | operator<< (std::ostream &o, const PIMPLHandle< H, IMPL, PTR > &h) |
| |
| template<class HANDLE , class IMPL , bool PTR> |
| std::ostream & | operator<< (std::ostream &o, const PIMPLHandle< HANDLE, IMPL, PTR > &h) |
| |
| template<class T > |
| void | writeUnformatted (std::ostream &o, const T &v) |
| | The default implementation of writeUnformatted<T> converts the object to a String using the templatized String constructor, and then writes that string to the stream using String::operator<<(). More...
|
| |
| template<class T > |
| void | writeUnformatted (std::ostream &o, const float &v) |
| | Specialize for float to help some compilers with template matching. More...
|
| |
| template<class T > |
| void | writeUnformatted (std::ostream &o, const double &v) |
| | Specialize for double to help some compilers with template matching. More...
|
| |
| template<class T > |
| void | writeUnformatted (std::ostream &o, const long double &v) |
| | Specialize for long double to help some compilers with template matching. More...
|
| |
| template<class T > |
| void | writeUnformatted (std::ostream &o, const negator< T > &v) |
| | Specialize for SimTK::negator<T>: convert to T and write. More...
|
| |
| template<class T > |
| void | writeUnformatted (std::ostream &o, const std::complex< T > &v) |
| | Specialize for std::complex<T>: just write two T's separated by a space; no parentheses or comma. More...
|
| |
| template<class T > |
| void | writeUnformatted (std::ostream &o, const conjugate< T > &v) |
| | Specialize for SimTK::conjugate<T>: same as std::complex<T>. More...
|
| |
| bool | readOneTokenUnformatted (std::istream &in, String &token) |
| | Read in the next whitespace-delimited token as a String, ignoring leading whitespace. More...
|
| |
| template<class T > |
| bool | readUnformatted (std::istream &in, T &v) |
| | The default implementation of readUnformatted<T> reads in the next whitespace-separated token and then attempts to convert the whole thing into one value of type T. More...
|
| |
| template<class T > |
| bool | readUnformatted (std::istream &in, float &v) |
| | Specialize for float to help some compilers with template matching. More...
|
| |
| template<class T > |
| bool | readUnformatted (std::istream &in, double &v) |
| | Specialize for double to help some compilers with template matching. More...
|
| |
| template<class T > |
| bool | readUnformatted (std::istream &in, long double &v) |
| | Specialize for long double to help some compilers with template matching. More...
|
| |
| template<class T > |
| bool | readUnformatted (std::istream &in, negator< T > &v) |
| | Specialization for negator<T>: read as type T and convert. More...
|
| |
| template<class T > |
| bool | readUnformatted (std::istream &in, std::complex< T > &v) |
| | Specialization for std::complex<T> (two space-separated T's). More...
|
| |
| template<class T > |
| bool | readUnformatted (std::istream &in, conjugate< T > &v) |
| | Specialization for SimTK::conjugate<T> (same as std::complex<T>). More...
|
| |
| template<> |
| bool | readUnformatted< String > (std::istream &in, String &v) |
| | Specialization for SimTK::String (just read token). More...
|
| |
| template<class T > |
| void | writeFormatted (std::ostream &o, const T &v) |
| | The default implementation of writeFormatted<T> converts the object to a String using the templatized String constructor, and then writes that string to the stream using String::operator<<(). More...
|
| |
| template<class T > |
| bool | readFormatted (std::istream &in, T &v) |
| | The default implementation of readFormatted<T>() uses readUnformatted<T>(). More...
|
| |
| template<class T > |
| static bool | tryConvertStringTo (const String &value, T &out) |
| |
| template<> |
| bool | tryConvertStringTo (const String &value, bool &out) |
| |
| template<> |
| bool | tryConvertStringTo (const String &value, float &out) |
| |
| template<> |
| bool | tryConvertStringTo (const String &value, double &out) |
| |
| template<> |
| bool | tryConvertStringTo (const String &value, long double &out) |
| |
| template<> |
| bool | tryConvertStringTo (const String &value, String &out) |
| |
| template<> |
| bool | tryConvertStringTo (const String &value, std::string &out) |
| |
| template<class T > |
| bool | tryConvertStringTo (const String &value, negator< T > &out) |
| | Partial specialization to read negator<T> as a T. More...
|
| |
| template<class T > |
| bool | tryConvertStringTo (const String &value, conjugate< T > &out) |
| | Partial specialization to read conjugate<T> as a std::complex<T>. More...
|
| |
| template<class T > |
| static bool | tryConvertStringTo (const String &value, T *&out) |
| |
| template<class T > |
| static void | cleanUpThreadLocalStorage (void *value) |
| |
| long long | timespecToNs (const timespec &ts) |
| | Convert a time stored in a timespec struct to the equivalent number of nanoseconds (as a signed quantity). More...
|
| |
| void | nsToTimespec (const long long &ns, timespec &ts) |
| | Given a signed number of nanoseconds, convert that into seconds and leftover nanoseconds in a timespec struct. More...
|
| |
| double | nsToSec (const long long &ns) |
| | Given a count of nanosecond ticks as a signed 64 bit integer, return the same time interval as a double precision floating point number of seconds. More...
|
| |
| long long | secToNs (const double &s) |
| | Given a signed time interval as a double precision floating point number of seconds, return the same time interval as a count of nanosecond ticks in a signed 64 bit integer. More...
|
| |
| double | cpuTime () |
| | Return the cumulative CPU time in seconds (both kernel and user time) that has been used so far by any of the threads in the currently executing process. More...
|
| |
| double | threadCpuTime () |
| | Return the total CPU time in seconds (both kernel and user time) that has been used so far by the currently executing thread. More...
|
| |
| long long | realTimeInNs () |
| | Return current time on the high-resolution interval timer in nanoseconds, as a 64-bit integer count. More...
|
| |
| double | realTime () |
| | Return current time on the high-resolution interval timer in seconds. More...
|
| |
| void | sleepInNs (const long long &ns) |
| | Sleep for the indicated number of nanoseconds, with the actual precision system dependent but intended to be the best achievable, hopefully less than 5ms in all cases. More...
|
| |
| void | sleepInSec (const double &seconds) |
| | Sleep for the indicated number of seconds, with the actual precision system dependent but intended to be the best achievable, hopefully less than 5ms in all cases. More...
|
| |
| std::ostream & | operator<< (std::ostream &o, const AbstractValue &v) |
| |
| | SimTK_ELEMENTWISE_FUNCTION (exp) SimTK_ELEMENTWISE_FUNCTION(log) SimTK_ELEMENTWISE_FUNCTION(sqrt) SimTK_ELEMENTWISE_FUNCTION(sin) SimTK_ELEMENTWISE_FUNCTION(cos) SimTK_ELEMENTWISE_FUNCTION(tan) SimTK_ELEMENTWISE_FUNCTION(asin) SimTK_ELEMENTWISE_FUNCTION(acos) SimTK_ELEMENTWISE_FUNCTION(atan) SimTK_ELEMENTWISE_FUNCTION(sinh) SimTK_ELEMENTWISE_FUNCTION(cosh) SimTK_ELEMENTWISE_FUNCTION(tanh) template< class ELEM > VectorBase< typename CNT< ELEM > |
| |
| template<class ELEM > |
RowVectorBase< typename CNT
< ELEM >::TAbs > | abs (const RowVectorBase< ELEM > &v) |
| |
| template<class ELEM > |
MatrixBase< typename CNT< ELEM >
::TAbs > | abs (const MatrixBase< ELEM > &v) |
| |
| template<int N, class ELEM > |
Vec< N, typename CNT< ELEM >
::TAbs > | abs (const Vec< N, ELEM > &v) |
| |
| template<int N, class ELEM > |
Row< N, typename CNT< ELEM >
::TAbs > | abs (const Row< N, ELEM > &v) |
| |
| template<int M, int N, class ELEM > |
Mat< M, N, typename CNT< ELEM >
::TAbs > | abs (const Mat< M, N, ELEM > &v) |
| |
| template<int N, class ELEM > |
SymMat< N, typename CNT< ELEM >
::TAbs > | abs (const SymMat< N, ELEM > &v) |
| |
| template<class ELEM > |
| ELEM | sum (const VectorBase< ELEM > &v) |
| |
| template<class ELEM > |
| ELEM | sum (const RowVectorBase< ELEM > &v) |
| |
| template<class ELEM > |
| RowVectorBase< ELEM > | sum (const MatrixBase< ELEM > &v) |
| |
| template<int N, class ELEM > |
| ELEM | sum (const Vec< N, ELEM > &v) |
| |
| template<int N, class ELEM > |
| ELEM | sum (const Row< N, ELEM > &v) |
| |
| template<int M, int N, class ELEM > |
| Row< N, ELEM > | sum (const Mat< M, N, ELEM > &v) |
| |
| template<int N, class ELEM > |
| Row< N, ELEM > | sum (const SymMat< N, ELEM > &v) |
| |
| template<class ELEM > |
| ELEM | min (const VectorBase< ELEM > &v) |
| |
| template<class ELEM > |
| ELEM | min (const RowVectorBase< ELEM > &v) |
| |
| template<class ELEM > |
| RowVectorBase< ELEM > | min (const MatrixBase< ELEM > &v) |
| |
| template<int N, class ELEM > |
| ELEM | min (const Vec< N, ELEM > &v) |
| |
| template<int N, class ELEM > |
| ELEM | min (const Row< N, ELEM > &v) |
| |
| template<int M, int N, class ELEM > |
| Row< N, ELEM > | min (const Mat< M, N, ELEM > &v) |
| |
| template<int N, class ELEM > |
| Row< N, ELEM > | min (const SymMat< N, ELEM > &v) |
| |
| template<class ELEM > |
| ELEM | max (const VectorBase< ELEM > &v) |
| |
| template<class ELEM > |
| ELEM | max (const RowVectorBase< ELEM > &v) |
| |
| template<class ELEM > |
| RowVectorBase< ELEM > | max (const MatrixBase< ELEM > &v) |
| |
| template<int N, class ELEM > |
| ELEM | max (const Vec< N, ELEM > &v) |
| |
| template<int N, class ELEM > |
| ELEM | max (const Row< N, ELEM > &v) |
| |
| template<int M, int N, class ELEM > |
| Row< N, ELEM > | max (const Mat< M, N, ELEM > &v) |
| |
| template<int N, class ELEM > |
| Row< N, ELEM > | max (const SymMat< N, ELEM > &v) |
| |
| template<class ELEM > |
| ELEM | mean (const VectorBase< ELEM > &v) |
| |
| template<class ELEM > |
| ELEM | mean (const RowVectorBase< ELEM > &v) |
| |
| template<class ELEM > |
| RowVectorBase< ELEM > | mean (const MatrixBase< ELEM > &v) |
| |
| template<int N, class ELEM > |
| ELEM | mean (const Vec< N, ELEM > &v) |
| |
| template<int N, class ELEM > |
| ELEM | mean (const Row< N, ELEM > &v) |
| |
| template<int M, int N, class ELEM > |
| Row< N, ELEM > | mean (const Mat< M, N, ELEM > &v) |
| |
| template<int N, class ELEM > |
| Row< N, ELEM > | mean (const SymMat< N, ELEM > &v) |
| |
| template<class ELEM > |
| VectorBase< ELEM > | sort (const VectorBase< ELEM > &v) |
| |
| template<class ELEM > |
| RowVectorBase< ELEM > | sort (const RowVectorBase< ELEM > &v) |
| |
| template<class ELEM > |
| MatrixBase< ELEM > | sort (const MatrixBase< ELEM > &v) |
| |
| template<int N, class ELEM > |
| Vec< N, ELEM > | sort (Vec< N, ELEM > v) |
| |
| template<int N, class ELEM > |
| Row< N, ELEM > | sort (Row< N, ELEM > v) |
| |
| template<int M, int N, class ELEM > |
| Mat< M, N, ELEM > | sort (Mat< M, N, ELEM > v) |
| |
| template<int N, class ELEM > |
| Mat< N, N, ELEM > | sort (const SymMat< N, ELEM > &v) |
| |
| template<class ELEM , class RandomAccessIterator > |
| ELEM | median (RandomAccessIterator start, RandomAccessIterator end) |
| |
| template<class ELEM > |
| ELEM | median (const VectorBase< ELEM > &v) |
| |
| template<class ELEM > |
| ELEM | median (const RowVectorBase< ELEM > &v) |
| |
| template<class ELEM > |
| RowVectorBase< ELEM > | median (const MatrixBase< ELEM > &v) |
| |
| template<int N, class ELEM > |
| ELEM | median (Vec< N, ELEM > v) |
| |
| template<int N, class ELEM > |
| ELEM | median (Row< N, ELEM > v) |
| |
| template<int M, int N, class ELEM > |
| Row< N, ELEM > | median (const Mat< M, N, ELEM > &v) |
| |
| template<int N, class ELEM > |
| Row< N, ELEM > | median (const SymMat< N, ELEM > &v) |
| |
| template<class P > |
| static std::ostream & | operator<< (std::ostream &o, const MassProperties_< P > &mp) |
| | Output a human-readable representation of a MassProperties object to the given output stream. More...
|
| |
| template<class P > |
| std::ostream & | operator<< (std::ostream &, const Rotation_< P > &) |
| | Write a Rotation matrix to an output stream by writing out its underlying Mat33. More...
|
| |
| template<class P > |
| std::ostream & | operator<< (std::ostream &, const InverseRotation_< P > &) |
| | Write an InverseRotation matrix to an output stream by writing out its underlying Mat33. More...
|
| |
| SpatialVec | findRelativeVelocity (const Transform &X_FA, const SpatialVec &V_FA, const Transform &X_FB, const SpatialVec &V_FB) |
| | Find the relative spatial velocity between two frames A and B whose individual spatial velocities are known with respect to a third frame F, with the result returned in A. More...
|
| |
| SpatialVec | findRelativeVelocityInF (const Vec3 &p_AB_F, const SpatialVec &V_FA, const SpatialVec &V_FB) |
| | Find the relative spatial velocity between two frames A and B whose individual spatial velocities are known in a third frame F, but leave the result in F. More...
|
| |
| SpatialVec | findRelativeAcceleration (const Transform &X_FA, const SpatialVec &V_FA, const SpatialVec &A_FA, const Transform &X_FB, const SpatialVec &V_FB, const SpatialVec &A_FB) |
| | Find the relative spatial acceleration between two frames A and B whose individual spatial accelerations are known with respect to a third frame F, with the result returned in A. More...
|
| |
| SpatialVec | findRelativeAccelerationInF (const Vec3 &p_AB_F, const SpatialVec &V_FA, const SpatialVec &A_FA, const SpatialVec &V_FB, const SpatialVec &A_FB) |
| | Find the relative spatial acceleration between two frames A and B whose individual spatial acceleration are known in a third frame F, but leave the result in F. More...
|
| |
| SpatialVec | reverseRelativeVelocity (const Transform &X_AB, const SpatialVec &V_AB) |
| | Given the relative velocity of frame B in frame A, reverse that to give the relative velocity of frame A in B. More...
|
| |
| SpatialVec | reverseRelativeVelocityInA (const Transform &X_AB, const SpatialVec &V_AB) |
| | Given the relative velocity of frame B in frame A, reverse that to give the relative velocity of frame A in B, but leave the result expressed in frame A. More...
|
| |
| SpatialVec | shiftVelocityBy (const SpatialVec &V_AB, const Vec3 &r_A) |
| | Shift a relative spatial velocity measured at some point to that same relative spatial quantity but measured at a new point given by an offset from the old one. More...
|
| |
| SpatialVec | shiftVelocityFromTo (const SpatialVec &V_A_BP, const Vec3 &fromP_A, const Vec3 &toQ_A) |
| | Shift a relative spatial velocity measured at some point P to that same relative spatial quantity but measured at a new point Q given the points P and Q. More...
|
| |
| SpatialVec | shiftForceBy (const SpatialVec &F_AP, const Vec3 &r_A) |
| | Shift a spatial force applied at some point of a body to that same spatial force applied at a new point given by an offset from the old one. More...
|
| |
| SpatialVec | shiftForceFromTo (const SpatialVec &F_AP, const Vec3 &fromP_A, const Vec3 &toQ_A) |
| | Shift a spatial force applied at some point P of a body to that same spatial force applied at a new point Q, given P and Q. More...
|
| |
| SpatialVec | shiftAccelerationBy (const SpatialVec &A_AB, const Vec3 &w_AB, const Vec3 &r_A) |
| | Shift a relative spatial acceleration measured at some point to that same relative spatial quantity but measured at a new point given by an offset from the old one. More...
|
| |
| SpatialVec | shiftAccelerationFromTo (const SpatialVec &A_A_BP, const Vec3 &w_AB, const Vec3 &fromP_A, const Vec3 &toQ_A) |
| | Shift a relative spatial acceleration measured at some point P to that same relative spatial quantity but measured at a new point Q given the points P and Q. More...
|
| |
| PhiMatrixTranspose | transpose (const PhiMatrix &phi) |
| |
| PhiMatrixTranspose | operator~ (const PhiMatrix &phi) |
| |
| SpatialVec | operator* (const PhiMatrix &phi, const SpatialVec &v) |
| |
| SpatialMat | operator* (const PhiMatrix &phi, const SpatialMat &m) |
| |
| SpatialVec | operator* (const PhiMatrixTranspose &phiT, const SpatialVec &v) |
| |
| SpatialMat | operator* (const SpatialMat::THerm &m, const PhiMatrixTranspose &phiT) |
| |
| SpatialMat | operator* (const SpatialMat &m, const PhiMatrixTranspose &phiT) |
| |
| bool | operator== (const PhiMatrix &p1, const PhiMatrix &p2) |
| |
| bool | operator== (const PhiMatrixTranspose &p1, const PhiMatrixTranspose &p2) |
| |
| template<class P , int S> |
| Vec< 3, P > | operator* (const InverseTransform_< P > &X_BF, const Vec< 3, P, S > &s_F) |
| |
| template<class P , int S> |
| Vec< 3, P > | operator* (const Transform_< P > &X_BF, const Vec< 3, negator< P >, S > &s_F) |
| |
| template<class P , int S> |
| Vec< 3, P > | operator* (const InverseTransform_< P > &X_BF, const Vec< 3, negator< P >, S > &s_F) |
| |
| template<class P , int S> |
| Vec< 4, P > | operator* (const InverseTransform_< P > &X_BF, const Vec< 4, P, S > &a_F) |
| |
| template<class P , int S> |
| Vec< 4, P > | operator* (const Transform_< P > &X_BF, const Vec< 4, negator< P >, S > &s_F) |
| |
| template<class P , int S> |
| Vec< 4, P > | operator* (const InverseTransform_< P > &X_BF, const Vec< 4, negator< P >, S > &s_F) |
| |
| template<class P , class E > |
| Vector_< E > | operator* (const VectorBase< E > &v, const Transform_< P > &X) |
| |
| template<class P , class E > |
| RowVector_< E > | operator* (const Transform_< P > &X, const RowVectorBase< E > &v) |
| |
| template<class P , class E > |
| RowVector_< E > | operator* (const RowVectorBase< E > &v, const Transform_< P > &X) |
| |
| template<class P , class E > |
| Matrix_< E > | operator* (const Transform_< P > &X, const MatrixBase< E > &v) |
| |
| template<class P , class E > |
| Matrix_< E > | operator* (const MatrixBase< E > &v, const Transform_< P > &X) |
| |
| template<class P , int N, class E , int S> |
| Vec< N, E > | operator* (const Transform_< P > &X, const Vec< N, E, S > &v) |
| |
| template<class P , int N, class E , int S> |
| Vec< N, E > | operator* (const Vec< N, E, S > &v, const Transform_< P > &X) |
| |
| template<class P , int N, class E , int S> |
| Row< N, E > | operator* (const Transform_< P > &X, const Row< N, E, S > &v) |
| |
| template<class P , int N, class E , int S> |
| Row< N, E > | operator* (const Row< N, E, S > &v, const Transform_< P > &X) |
| |
| template<class P , int M, int N, class E , int CS, int RS> |
| Mat< M, N, E > | operator* (const Transform_< P > &X, const Mat< M, N, E, CS, RS > &v) |
| |
| template<class P , int M, int N, class E , int CS, int RS> |
| Mat< M, N, E > | operator* (const Mat< M, N, E, CS, RS > &v, const Transform_< P > &X) |
| |
| template<class P > |
| Transform_< P > | operator* (const Transform_< P > &X1, const InverseTransform_< P > &X2) |
| |
| template<class P > |
| Transform_< P > | operator* (const InverseTransform_< P > &X1, const Transform_< P > &X2) |
| |
| template<class P > |
| Transform_< P > | operator* (const InverseTransform_< P > &X1, const InverseTransform_< P > &X2) |
| |
| template<class P > |
| bool | operator== (const InverseTransform_< P > &X1, const InverseTransform_< P > &X2) |
| |
| template<class P > |
| bool | operator== (const Transform_< P > &X1, const InverseTransform_< P > &X2) |
| |
| template<class P > |
| bool | operator== (const InverseTransform_< P > &X1, const Transform_< P > &X2) |
| |
| static Real | convertRadiansToDegrees (const Real rad) |
| |
| static Real | convertDegreesToRadians (const Real deg) |
| |
| complex< float > | operator* (const complex< float > &c, int r) |
| |
| complex< float > | operator* (int r, const complex< float > &c) |
| |
| complex< double > | operator* (const complex< float > &c, const double &r) |
| |
| complex< double > | operator* (const double &r, const complex< float > &c) |
| |
| complex< long double > | operator* (const complex< float > &c, const long double &r) |
| |
| complex< long double > | operator* (const long double &r, const complex< float > &c) |
| |
| complex< float > | operator/ (const complex< float > &c, int r) |
| |
| complex< float > | operator/ (int r, const complex< float > &c) |
| |
| complex< double > | operator/ (const complex< float > &c, const double &r) |
| |
| complex< double > | operator/ (const double &r, const complex< float > &c) |
| |
| complex< long double > | operator/ (const complex< float > &c, const long double &r) |
| |
| complex< long double > | operator/ (const long double &r, const complex< float > &c) |
| |
| complex< float > | operator+ (const complex< float > &c, int r) |
| |
| complex< float > | operator+ (int r, const complex< float > &c) |
| |
| complex< double > | operator+ (const complex< float > &c, const double &r) |
| |
| complex< double > | operator+ (const double &r, const complex< float > &c) |
| |
| complex< long double > | operator+ (const complex< float > &c, const long double &r) |
| |
| complex< long double > | operator+ (const long double &r, const complex< float > &c) |
| |
| complex< float > | operator- (const complex< float > &c, int r) |
| |
| complex< float > | operator- (int r, const complex< float > &c) |
| |
| complex< double > | operator- (const complex< float > &c, const double &r) |
| |
| complex< double > | operator- (const double &r, const complex< float > &c) |
| |
| complex< long double > | operator- (const complex< float > &c, const long double &r) |
| |
| complex< long double > | operator- (const long double &r, const complex< float > &c) |
| |
| complex< double > | operator* (const complex< double > &c, int r) |
| |
| complex< double > | operator* (int r, const complex< double > &c) |
| |
| complex< double > | operator* (const complex< double > &c, const float &r) |
| |
| complex< double > | operator* (const float &r, const complex< double > &c) |
| |
| complex< long double > | operator* (const complex< double > &c, const long double &r) |
| |
| complex< long double > | operator* (const long double &r, const complex< double > &c) |
| |
| complex< double > | operator/ (const complex< double > &c, int r) |
| |
| complex< double > | operator/ (int r, const complex< double > &c) |
| |
| complex< double > | operator/ (const complex< double > &c, const float &r) |
| |
| complex< double > | operator/ (const float &r, const complex< double > &c) |
| |
| complex< long double > | operator/ (const complex< double > &c, const long double &r) |
| |
| complex< long double > | operator/ (const long double &r, const complex< double > &c) |
| |
| complex< double > | operator+ (const complex< double > &c, int r) |
| |
| complex< double > | operator+ (int r, const complex< double > &c) |
| |
| complex< double > | operator+ (const complex< double > &c, const float &r) |
| |
| complex< double > | operator+ (const float &r, const complex< double > &c) |
| |
| complex< long double > | operator+ (const complex< double > &c, const long double &r) |
| |
| complex< long double > | operator+ (const long double &r, const complex< double > &c) |
| |
| complex< double > | operator- (const complex< double > &c, int r) |
| |
| complex< double > | operator- (int r, const complex< double > &c) |
| |
| complex< double > | operator- (const complex< double > &c, const float &r) |
| |
| complex< double > | operator- (const float &r, const complex< double > &c) |
| |
| complex< long double > | operator- (const complex< double > &c, const long double &r) |
| |
| complex< long double > | operator- (const long double &r, const complex< double > &c) |
| |
| complex< long double > | operator* (const complex< long double > &c, int r) |
| |
| complex< long double > | operator* (int r, const complex< long double > &c) |
| |
| complex< long double > | operator* (const complex< long double > &c, const float &r) |
| |
| complex< long double > | operator* (const float &r, const complex< long double > &c) |
| |
| complex< long double > | operator* (const complex< long double > &c, const double &r) |
| |
| complex< long double > | operator* (const double &r, const complex< long double > &c) |
| |
| complex< long double > | operator/ (const complex< long double > &c, int r) |
| |
| complex< long double > | operator/ (int r, const complex< long double > &c) |
| |
| complex< long double > | operator/ (const complex< long double > &c, const float &r) |
| |
| complex< long double > | operator/ (const float &r, const complex< long double > &c) |
| |
| complex< long double > | operator/ (const complex< long double > &c, const double &r) |
| |
| complex< long double > | operator/ (const double &r, const complex< long double > &c) |
| |
| complex< long double > | operator+ (const complex< long double > &c, int r) |
| |
| complex< long double > | operator+ (int r, const complex< long double > &c) |
| |
| complex< long double > | operator+ (const complex< long double > &c, const float &r) |
| |
| complex< long double > | operator+ (const float &r, const complex< long double > &c) |
| |
| complex< long double > | operator+ (const complex< long double > &c, const double &r) |
| |
| complex< long double > | operator+ (const double &r, const complex< long double > &c) |
| |
| complex< long double > | operator- (const complex< long double > &c, int r) |
| |
| complex< long double > | operator- (int r, const complex< long double > &c) |
| |
| complex< long double > | operator- (const complex< long double > &c, const float &r) |
| |
| complex< long double > | operator- (const float &r, const complex< long double > &c) |
| |
| complex< long double > | operator- (const complex< long double > &c, const double &r) |
| |
| complex< long double > | operator- (const double &r, const complex< long double > &c) |
| |
| const float & | real (const conjugate< float > &c) |
| |
| const negator< float > & | imag (const conjugate< float > &c) |
| |
| const complex< float > & | conj (const conjugate< float > &c) |
| |
| float | abs (const conjugate< float > &c) |
| |
| float | norm (const conjugate< float > &c) |
| |
| const double & | real (const conjugate< double > &c) |
| |
| const negator< double > & | imag (const conjugate< double > &c) |
| |
| const complex< double > & | conj (const conjugate< double > &c) |
| |
| double | abs (const conjugate< double > &c) |
| |
| double | norm (const conjugate< double > &c) |
| |
| const long double & | real (const conjugate< long double > &c) |
| |
| const negator< long double > & | imag (const conjugate< long double > &c) |
| |
| const complex< long double > & | conj (const conjugate< long double > &c) |
| |
| long double | abs (const conjugate< long double > &c) |
| |
| long double | norm (const conjugate< long double > &c) |
| |
| template<class R , class CHAR , class TRAITS > |
std::basic_istream< CHAR,
TRAITS > & | operator>> (std::basic_istream< CHAR, TRAITS > &is, conjugate< R > &c) |
| |
| template<class R , class CHAR , class TRAITS > |
std::basic_ostream< CHAR,
TRAITS > & | operator<< (std::basic_ostream< CHAR, TRAITS > &os, const conjugate< R > &c) |
| |
| template<class R > |
| conjugate< R > | operator+ (const conjugate< R > &a, const float &b) |
| |
| template<class R > |
| conjugate< long double > | operator+ (const conjugate< R > &a, const long double &b) |
| |
| template<class R > |
| Wider< R, double >::WConj | operator+ (const conjugate< R > &a, const double &b) |
| |
| template<class R > |
| conjugate< R > | operator+ (const float &a, const conjugate< R > &b) |
| |
| template<class R > |
| conjugate< long double > | operator+ (const long double &a, const conjugate< R > &b) |
| |
| template<class R > |
| Wider< R, double >::WConj | operator+ (const double &a, const conjugate< R > &b) |
| |
| template<class R > |
| conjugate< R > | operator* (const conjugate< R > &a, const float &b) |
| |
| template<class R > |
| conjugate< long double > | operator* (const conjugate< R > &a, const long double &b) |
| |
| template<class R > |
| Wider< R, double >::WConj | operator* (const conjugate< R > &a, const double &b) |
| |
| template<class R > |
| conjugate< R > | operator* (const float &a, const conjugate< R > &b) |
| |
| template<class R > |
| conjugate< long double > | operator* (const long double &a, const conjugate< R > &b) |
| |
| template<class R > |
| Wider< R, double >::WConj | operator* (const double &a, const conjugate< R > &b) |
| |
| template<class R > |
| bool | operator== (const conjugate< R > &a, const float &b) |
| |
| template<class R > |
| bool | operator== (const conjugate< R > &a, const long double &b) |
| |
| template<class R > |
| bool | operator== (const conjugate< R > &a, const double &b) |
| |
| template<class R > |
| bool | operator== (const float &a, const conjugate< R > &b) |
| |
| template<class R > |
| bool | operator== (const long double &a, const conjugate< R > &b) |
| |
| template<class R > |
| bool | operator== (const double &a, const conjugate< R > &b) |
| |
| template<class R > |
| bool | operator!= (const conjugate< R > &a, const float &b) |
| |
| template<class R > |
| bool | operator!= (const conjugate< R > &a, const long double &b) |
| |
| template<class R > |
| bool | operator!= (const conjugate< R > &a, const double &b) |
| |
| template<class R > |
| bool | operator!= (const float &a, const conjugate< R > &b) |
| |
| template<class R > |
| bool | operator!= (const long double &a, const conjugate< R > &b) |
| |
| template<class R > |
| bool | operator!= (const double &a, const conjugate< R > &b) |
| |
| template<class R > |
| conjugate< R > | operator- (const conjugate< R > &a, const float &b) |
| |
| template<class R > |
| conjugate< long double > | operator- (const conjugate< R > &a, const long double &b) |
| |
| template<class R > |
| Wider< R, double >::WConj | operator- (const conjugate< R > &a, const double &b) |
| |
| template<class R > |
| complex< R > | operator- (const float &a, const conjugate< R > &b) |
| |
| template<class R > |
| complex< long double > | operator- (const long double &a, const conjugate< R > &b) |
| |
| template<class R > |
| Wider< R, double >::WCplx | operator- (const double &a, const conjugate< R > &b) |
| |
| template<class R > |
| conjugate< R > | operator/ (const conjugate< R > &a, const float &b) |
| |
| template<class R > |
| conjugate< long double > | operator/ (const conjugate< R > &a, const long double &b) |
| |
| template<class R > |
| Wider< R, double >::WConj | operator/ (const conjugate< R > &a, const double &b) |
| |
| template<class R > |
| complex< R > | operator/ (const float &a, const conjugate< R > &b) |
| |
| template<class R > |
| complex< long double > | operator/ (const long double &a, const conjugate< R > &b) |
| |
| template<class R > |
| Wider< R, double >::WCplx | operator/ (const double &a, const conjugate< R > &b) |
| |
| template<class R , class S > |
| Wider< R, S >::WConj | operator+ (const conjugate< R > &a, const conjugate< S > &r) |
| |
| template<class R , class S > |
| Wider< R, S >::WCplx | operator+ (const conjugate< R > &a, const complex< S > &r) |
| |
| template<class R , class S > |
| Wider< R, S >::WCplx | operator+ (const complex< R > &a, const conjugate< S > &r) |
| |
| template<class R , class S > |
| Wider< R, S >::WCplx | operator- (const conjugate< R > &a, const conjugate< S > &r) |
| |
| template<class R , class S > |
negator< typename Wider< R, S >
::WCplx > | operator- (const conjugate< R > &a, const complex< S > &r) |
| |
| template<class R , class S > |
| Wider< R, S >::WCplx | operator- (const complex< R > &a, const conjugate< S > &r) |
| |
| template<class R , class S > |
negator< typename Wider< R, S >
::WCplx > | operator* (const conjugate< R > &a, const conjugate< S > &r) |
| |
| template<class R , class S > |
| Wider< R, S >::WCplx | operator* (const conjugate< R > &a, const complex< S > &r) |
| |
| template<class R , class S > |
| Wider< R, S >::WCplx | operator* (const complex< R > &a, const conjugate< S > &r) |
| |
| template<class R , class S > |
| Wider< R, S >::WCplx | operator* (const negator< complex< R > > &a, const conjugate< S > &r) |
| |
| template<class R , class S > |
| Wider< R, S >::WCplx | operator* (const conjugate< R > &a, const negator< complex< S > > &r) |
| |
| template<class R , class S > |
| Wider< R, S >::WCplx | operator/ (const conjugate< R > &a, const conjugate< S > &r) |
| |
| template<class R , class S > |
| Wider< R, S >::WCplx | operator/ (const conjugate< R > &a, const complex< S > &r) |
| |
| template<class R , class S > |
| Wider< R, S >::WCplx | operator/ (const complex< R > &a, const conjugate< S > &r) |
| |
| template<class R , class S > |
| bool | operator== (const conjugate< R > &a, const conjugate< S > &r) |
| |
| template<class R , class S > |
| bool | operator== (const conjugate< R > &a, const complex< S > &r) |
| |
| template<class R , class S > |
| bool | operator== (const complex< R > &a, const conjugate< S > &r) |
| |
| template<class R , class S > |
| bool | operator!= (const conjugate< R > &a, const conjugate< S > &r) |
| |
| template<class R , class S > |
| bool | operator!= (const conjugate< R > &a, const complex< S > &r) |
| |
| template<class R , class S > |
| bool | operator!= (const complex< R > &a, const conjugate< S > &r) |
| |
| bool | isNaN (const negator< float > &x) |
| |
| bool | isNaN (const negator< double > &x) |
| |
| bool | isNaN (const negator< long double > &x) |
| |
| template<class P > |
| bool | isNaN (const negator< std::complex< P > > &x) |
| |
| template<class P > |
| bool | isNaN (const negator< conjugate< P > > &x) |
| |
| bool | isFinite (const negator< float > &x) |
| |
| bool | isFinite (const negator< double > &x) |
| |
| bool | isFinite (const negator< long double > &x) |
| |
| template<class P > |
| bool | isFinite (const negator< std::complex< P > > &x) |
| |
| template<class P > |
| bool | isFinite (const negator< conjugate< P > > &x) |
| |
| bool | isInf (const negator< float > &x) |
| |
| bool | isInf (const negator< double > &x) |
| |
| bool | isInf (const negator< long double > &x) |
| |
| template<class P > |
| bool | isInf (const negator< std::complex< P > > &x) |
| |
| template<class P > |
| bool | isInf (const negator< conjugate< P > > &x) |
| |
| template<class DEST , class SRC > |
| static const DEST & | negRecast (const SRC &s) |
| |
| template<class A , class B > |
negator< A >::template Result
< B >::Add | operator+ (const negator< A > &l, const B &r) |
| |
| template<class A , class B > |
CNT< A >::template Result
< negator< B > >::Add | operator+ (const A &l, const negator< B > &r) |
| |
| template<class A , class B > |
negator< A >::template Result
< negator< B > >::Add | operator+ (const negator< A > &l, const negator< B > &r) |
| |
| template<class A , class B > |
negator< A >::template Result
< B >::Sub | operator- (const negator< A > &l, const B &r) |
| |
| template<class A , class B > |
CNT< A >::template Result
< negator< B > >::Sub | operator- (const A &l, const negator< B > &r) |
| |
| template<class A , class B > |
negator< A >::template Result
< negator< B > >::Sub | operator- (const negator< A > &l, const negator< B > &r) |
| |
| template<class A , class B > |
negator< A >::template Result
< B >::Mul | operator* (const negator< A > &l, const B &r) |
| |
| template<class A , class B > |
CNT< A >::template Result
< negator< B > >::Mul | operator* (const A &l, const negator< B > &r) |
| |
| template<class A , class B > |
negator< A >::template Result
< negator< B > >::Mul | operator* (const negator< A > &l, const negator< B > &r) |
| |
| template<class A , class B > |
negator< A >::template Result
< B >::Dvd | operator/ (const negator< A > &l, const B &r) |
| |
| template<class A , class B > |
CNT< A >::template Result
< negator< B > >::Dvd | operator/ (const A &l, const negator< B > &r) |
| |
| template<class A , class B > |
negator< A >::template Result
< negator< B > >::Dvd | operator/ (const negator< A > &l, const negator< B > &r) |
| |
| template<class A , class B > |
| bool | operator== (const negator< A > &l, const B &r) |
| |
| template<class A , class B > |
| bool | operator== (const A &l, const negator< B > &r) |
| |
| template<class A , class B > |
| bool | operator== (const negator< A > &l, const negator< B > &r) |
| |
| template<class A , class B > |
| bool | operator!= (const negator< A > &l, const B &r) |
| |
| template<class A , class B > |
| bool | operator!= (const A &l, const negator< B > &r) |
| |
| template<class A , class B > |
| bool | operator!= (const negator< A > &l, const negator< B > &r) |
| |
| template<class NUM , class CHAR , class TRAITS > |
std::basic_istream< CHAR,
TRAITS > & | operator>> (std::basic_istream< CHAR, TRAITS > &is, negator< NUM > &nn) |
| |
| template<class NUM , class CHAR , class TRAITS > |
std::basic_ostream< CHAR,
TRAITS > & | operator<< (std::basic_ostream< CHAR, TRAITS > &os, const negator< NUM > &nn) |
| |
| static const complex< long double > | zeroes (0) |
| |
| bool | isNaN (const float &x) |
| |
| bool | isNaN (const double &x) |
| |
| bool | isNaN (const long double &x) |
| |
| template<class P > |
| bool | isNaN (const std::complex< P > &x) |
| |
| template<class P > |
| bool | isNaN (const conjugate< P > &x) |
| |
| bool | isFinite (const float &x) |
| |
| bool | isFinite (const double &x) |
| |
| bool | isFinite (const long double &x) |
| |
| template<class P > |
| bool | isFinite (const std::complex< P > &x) |
| |
| template<class P > |
| bool | isFinite (const conjugate< P > &x) |
| |
| bool | isInf (const float &x) |
| |
| bool | isInf (const double &x) |
| |
| bool | isInf (const long double &x) |
| |
| template<class P > |
| bool | isInf (const std::complex< P > &x) |
| |
| template<class P > |
| bool | isInf (const conjugate< P > &x) |
| |
| bool | isNumericallyEqual (const float &a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
| | Compare two floats for approximate equality. More...
|
| |
| bool | isNumericallyEqual (const double &a, const double &b, double tol=RTraits< double >::getDefaultTolerance()) |
| | Compare two doubles for approximate equality. More...
|
| |
| bool | isNumericallyEqual (const long double &a, const long double &b, double tol=RTraits< long double >::getDefaultTolerance()) |
| | Compare two long doubles for approximate equality. More...
|
| |
| bool | isNumericallyEqual (const float &a, const double &b, double tol=RTraits< float >::getDefaultTolerance()) |
| | Compare a float and a double for approximate equality at float precision. More...
|
| |
| bool | isNumericallyEqual (const double &a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
| | Compare a float and a double for approximate equality at float precision. More...
|
| |
| bool | isNumericallyEqual (const float &a, const long double &b, double tol=RTraits< float >::getDefaultTolerance()) |
| | Compare a float and a long double for approximate equality at float precision. More...
|
| |
| bool | isNumericallyEqual (const long double &a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
| | Compare a float and a long double for approximate equality at float precision. More...
|
| |
| bool | isNumericallyEqual (const double &a, const long double &b, double tol=RTraits< double >::getDefaultTolerance()) |
| | Compare a double and a long double for approximate equality at double precision. More...
|
| |
| bool | isNumericallyEqual (const long double &a, const double &b, double tol=RTraits< double >::getDefaultTolerance()) |
| | Compare a double and a long double for approximate equality at double precision. More...
|
| |
| bool | isNumericallyEqual (const float &a, int b, double tol=RTraits< float >::getDefaultTolerance()) |
| | Test a float for approximate equality to an integer. More...
|
| |
| bool | isNumericallyEqual (int a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
| | Test a float for approximate equality to an integer. More...
|
| |
| bool | isNumericallyEqual (const double &a, int b, double tol=RTraits< double >::getDefaultTolerance()) |
| | Test a double for approximate equality to an integer. More...
|
| |
| bool | isNumericallyEqual (int a, const double &b, double tol=RTraits< double >::getDefaultTolerance()) |
| | Test a double for approximate equality to an integer. More...
|
| |
| bool | isNumericallyEqual (const long double &a, int b, double tol=RTraits< long double >::getDefaultTolerance()) |
| | Test a long double for approximate equality to an integer. More...
|
| |
| bool | isNumericallyEqual (int a, const long double &b, double tol=RTraits< long double >::getDefaultTolerance()) |
| | Test a long double for approximate equality to an integer. More...
|
| |
| template<class P , class Q > |
| bool | isNumericallyEqual (const std::complex< P > &a, const std::complex< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance()) |
| | Compare two complex numbers for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. More...
|
| |
| template<class P , class Q > |
| bool | isNumericallyEqual (const conjugate< P > &a, const conjugate< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance()) |
| | Compare two conjugate numbers for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. More...
|
| |
| template<class P , class Q > |
| bool | isNumericallyEqual (const std::complex< P > &a, const conjugate< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance()) |
| | Compare a complex and a conjugate number for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. More...
|
| |
| template<class P , class Q > |
| bool | isNumericallyEqual (const conjugate< P > &a, const std::complex< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance()) |
| | Compare a complex and a conjugate number for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (const std::complex< P > &a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
| | Test whether a complex number is approximately equal to a particular real float. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (const float &a, const std::complex< P > &b, double tol=RTraits< float >::getDefaultTolerance()) |
| | Test whether a complex number is approximately equal to a particular real float. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (const std::complex< P > &a, const double &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance()) |
| | Test whether a complex number is approximately equal to a particular real double. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (const double &a, const std::complex< P > &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance()) |
| | Test whether a complex number is approximately equal to a particular real double. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (const std::complex< P > &a, const long double &b, double tol=RTraits< P >::getDefaultTolerance()) |
| | Test whether a complex number is approximately equal to a particular real long double. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (const long double &a, const std::complex< P > &b, double tol=RTraits< P >::getDefaultTolerance()) |
| | Test whether a complex number is approximately equal to a particular real long double. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (const std::complex< P > &a, int b, double tol=RTraits< P >::getDefaultTolerance()) |
| | Test whether a complex number is approximately equal to a particular integer. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (int a, const std::complex< P > &b, double tol=RTraits< P >::getDefaultTolerance()) |
| | Test whether a complex number is approximately equal to a particular integer. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (const conjugate< P > &a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
| | Test whether a conjugate number is approximately equal to a particular real float. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (const float &a, const conjugate< P > &b, double tol=RTraits< float >::getDefaultTolerance()) |
| | Test whether a conjugate number is approximately equal to a particular real float. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (const conjugate< P > &a, const double &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance()) |
| | Test whether a conjugate number is approximately equal to a particular real double. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (const double &a, const conjugate< P > &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance()) |
| | Test whether a conjugate number is approximately equal to a particular real double. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (const conjugate< P > &a, const long double &b, double tol=RTraits< P >::getDefaultTolerance()) |
| | Test whether a conjugate number is approximately equal to a particular real long double. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (const long double &a, const conjugate< P > &b, double tol=RTraits< P >::getDefaultTolerance()) |
| | Test whether a conjugate number is approximately equal to a particular real long double. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (const conjugate< P > &a, int b, double tol=RTraits< P >::getDefaultTolerance()) |
| | Test whether a conjugate number is approximately equal to a particular integer. More...
|
| |
| template<class P > |
| bool | isNumericallyEqual (int a, const conjugate< P > &b, double tol=RTraits< P >::getDefaultTolerance()) |
| | Test whether a conjugate number is approximately equal to a particular integer. More...
|
| |
| | SimTK_BNTCMPLX_SPEC (float, float) |
| |
| | SimTK_BNTCMPLX_SPEC (float, double) |
| |
| | SimTK_BNTCMPLX_SPEC (float, long double) |
| |
| | SimTK_BNTCMPLX_SPEC (double, float) |
| |
| | SimTK_BNTCMPLX_SPEC (double, double) |
| |
| | SimTK_BNTCMPLX_SPEC (double, long double) |
| |
| | SimTK_BNTCMPLX_SPEC (long double, float) |
| |
| | SimTK_BNTCMPLX_SPEC (long double, double) |
| |
| | SimTK_BNTCMPLX_SPEC (long double, long double) |
| |
| | SimTK_NTRAITS_CONJ_SPEC (float, float) |
| |
| | SimTK_NTRAITS_CONJ_SPEC (float, double) |
| |
| | SimTK_NTRAITS_CONJ_SPEC (float, long double) |
| |
| | SimTK_NTRAITS_CONJ_SPEC (double, float) |
| |
| | SimTK_NTRAITS_CONJ_SPEC (double, double) |
| |
| | SimTK_NTRAITS_CONJ_SPEC (double, long double) |
| |
| | SimTK_NTRAITS_CONJ_SPEC (long double, float) |
| |
| | SimTK_NTRAITS_CONJ_SPEC (long double, double) |
| |
| | SimTK_NTRAITS_CONJ_SPEC (long double, long double) |
| |
| | SimTK_DEFINE_REAL_NTRAITS (float) |
| |
| | SimTK_DEFINE_REAL_NTRAITS (double) |
| |
| | SimTK_DEFINE_REAL_NTRAITS (long double) |
| |
| bool | atMostOneBitIsSet (unsigned char v) |
| |
| bool | atMostOneBitIsSet (unsigned short v) |
| |
| bool | atMostOneBitIsSet (unsigned int v) |
| |
| bool | atMostOneBitIsSet (unsigned long v) |
| |
| bool | atMostOneBitIsSet (unsigned long long v) |
| |
| bool | atMostOneBitIsSet (signed char v) |
| |
| bool | atMostOneBitIsSet (char v) |
| |
| bool | atMostOneBitIsSet (short v) |
| |
| bool | atMostOneBitIsSet (int v) |
| |
| bool | atMostOneBitIsSet (long v) |
| |
| bool | atMostOneBitIsSet (long long v) |
| |
| bool | exactlyOneBitIsSet (unsigned char v) |
| |
| bool | exactlyOneBitIsSet (unsigned short v) |
| |
| bool | exactlyOneBitIsSet (unsigned int v) |
| |
| bool | exactlyOneBitIsSet (unsigned long v) |
| |
| bool | exactlyOneBitIsSet (unsigned long long v) |
| |
| bool | exactlyOneBitIsSet (signed char v) |
| |
| bool | exactlyOneBitIsSet (char v) |
| |
| bool | exactlyOneBitIsSet (short v) |
| |
| bool | exactlyOneBitIsSet (int v) |
| |
| bool | exactlyOneBitIsSet (long v) |
| |
| bool | exactlyOneBitIsSet (long long v) |
| |
| bool | signBit (unsigned char u) |
| |
| bool | signBit (unsigned short u) |
| |
| bool | signBit (unsigned int u) |
| |
| bool | signBit (unsigned long u) |
| |
| bool | signBit (unsigned long long u) |
| |
| bool | signBit (signed char i) |
| |
| bool | signBit (short i) |
| |
| bool | signBit (int i) |
| |
| bool | signBit (long long i) |
| |
| bool | signBit (long i) |
| |
| bool | signBit (const float &f) |
| |
| bool | signBit (const double &d) |
| |
| bool | signBit (const negator< float > &nf) |
| |
| bool | signBit (const negator< double > &nd) |
| |
| unsigned int | sign (unsigned char u) |
| |
| unsigned int | sign (unsigned short u) |
| |
| unsigned int | sign (unsigned int u) |
| |
| unsigned int | sign (unsigned long u) |
| |
| unsigned int | sign (unsigned long long u) |
| |
| int | sign (signed char i) |
| |
| int | sign (short i) |
| |
| int | sign (int i) |
| |
| int | sign (long i) |
| |
| int | sign (long long i) |
| |
| int | sign (const float &x) |
| |
| int | sign (const double &x) |
| |
| int | sign (const long double &x) |
| |
| int | sign (const negator< float > &x) |
| |
| int | sign (const negator< double > &x) |
| |
| int | sign (const negator< long double > &x) |
| |
| unsigned char | square (unsigned char u) |
| |
| unsigned short | square (unsigned short u) |
| |
| unsigned int | square (unsigned int u) |
| |
| unsigned long | square (unsigned long u) |
| |
| unsigned long long | square (unsigned long long u) |
| |
| char | square (char c) |
| |
| signed char | square (signed char i) |
| |
| short | square (short i) |
| |
| int | square (int i) |
| |
| long | square (long i) |
| |
| long long | square (long long i) |
| |
| float | square (const float &x) |
| |
| double | square (const double &x) |
| |
| long double | square (const long double &x) |
| |
| float | square (const negator< float > &x) |
| |
| double | square (const negator< double > &x) |
| |
| long double | square (const negator< long double > &x) |
| |
| template<class P > |
| std::complex< P > | square (const std::complex< P > &x) |
| |
| template<class P > |
| std::complex< P > | square (const conjugate< P > &x) |
| |
| template<class P > |
| std::complex< P > | square (const negator< std::complex< P > > &x) |
| |
| template<class P > |
| std::complex< P > | square (const negator< conjugate< P > > &x) |
| |
| unsigned char | cube (unsigned char u) |
| |
| unsigned short | cube (unsigned short u) |
| |
| unsigned int | cube (unsigned int u) |
| |
| unsigned long | cube (unsigned long u) |
| |
| unsigned long long | cube (unsigned long long u) |
| |
| char | cube (char c) |
| |
| signed char | cube (signed char i) |
| |
| short | cube (short i) |
| |
| int | cube (int i) |
| |
| long | cube (long i) |
| |
| long long | cube (long long i) |
| |
| float | cube (const float &x) |
| |
| double | cube (const double &x) |
| |
| long double | cube (const long double &x) |
| |
| negator< float > | cube (const negator< float > &x) |
| |
| negator< double > | cube (const negator< double > &x) |
| |
| negator< long double > | cube (const negator< long double > &x) |
| |
| template<class P > |
| std::complex< P > | cube (const std::complex< P > &x) |
| |
| template<class P > |
| std::complex< P > | cube (const negator< std::complex< P > > &x) |
| |
| template<class P > |
| std::complex< P > | cube (const conjugate< P > &x) |
| |
| template<class P > |
| std::complex< P > | cube (const negator< conjugate< P > > &x) |
| |
| double & | clampInPlace (double low, double &v, double high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| float & | clampInPlace (float low, float &v, float high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| long double & | clampInPlace (long double low, long double &v, long double high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| double & | clampInPlace (int low, double &v, int high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| float & | clampInPlace (int low, float &v, int high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| long double & | clampInPlace (int low, long double &v, int high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| double & | clampInPlace (int low, double &v, double high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| float & | clampInPlace (int low, float &v, float high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| long double & | clampInPlace (int low, long double &v, long double high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| double & | clampInPlace (double low, double &v, int high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| float & | clampInPlace (float low, float &v, int high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| long double & | clampInPlace (long double low, long double &v, int high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| unsigned char & | clampInPlace (unsigned char low, unsigned char &v, unsigned char high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| unsigned short & | clampInPlace (unsigned short low, unsigned short &v, unsigned short high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| unsigned int & | clampInPlace (unsigned int low, unsigned int &v, unsigned int high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| unsigned long & | clampInPlace (unsigned long low, unsigned long &v, unsigned long high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| unsigned long long & | clampInPlace (unsigned long long low, unsigned long long &v, unsigned long long high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| char & | clampInPlace (char low, char &v, char high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| signed char & | clampInPlace (signed char low, signed char &v, signed char high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| short & | clampInPlace (short low, short &v, short high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| int & | clampInPlace (int low, int &v, int high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| long & | clampInPlace (long low, long &v, long high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| long long & | clampInPlace (long long low, long long &v, long long high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| negator< float > & | clampInPlace (float low, negator< float > &v, float high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| negator< double > & | clampInPlace (double low, negator< double > &v, double high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| negator< long double > & | clampInPlace (long double low, negator< long double > &v, long double high) |
| | Check that low <= v <= high and modify v in place if necessary to bring it into that range. More...
|
| |
| double | clamp (double low, double v, double high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| float | clamp (float low, float v, float high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| long double | clamp (long double low, long double v, long double high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| double | clamp (int low, double v, int high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| float | clamp (int low, float v, int high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| long double | clamp (int low, long double v, int high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| double | clamp (int low, double v, double high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| float | clamp (int low, float v, float high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| long double | clamp (int low, long double v, long double high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| double | clamp (double low, double v, int high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| float | clamp (float low, float v, int high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| long double | clamp (long double low, long double v, int high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| unsigned char | clamp (unsigned char low, unsigned char v, unsigned char high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| unsigned short | clamp (unsigned short low, unsigned short v, unsigned short high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| unsigned int | clamp (unsigned int low, unsigned int v, unsigned int high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| unsigned long | clamp (unsigned long low, unsigned long v, unsigned long high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| unsigned long long | clamp (unsigned long long low, unsigned long long v, unsigned long long high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| char | clamp (char low, char v, char high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| signed char | clamp (signed char low, signed char v, signed char high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| short | clamp (short low, short v, short high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| int | clamp (int low, int v, int high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| long | clamp (long low, long v, long high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| long long | clamp (long long low, long long v, long long high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| float | clamp (float low, negator< float > v, float high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| double | clamp (double low, negator< double > v, double high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| long double | clamp (long double low, negator< long double > v, long double high) |
| | If v is in range low <= v <= high then return v, otherwise return the nearest bound; this function does not modify the input variable v. More...
|
| |
| double | stepUp (double x) |
| | Interpolate smoothly from 0 up to 1 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More...
|
| |
| double | stepDown (double x) |
| | Interpolate smoothly from 1 down to 0 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More...
|
| |
| double | stepAny (double y0, double yRange, double x0, double oneOverXRange, double x) |
| | Interpolate smoothly from y0 to y1 as the input argument goes from x0 to x1, with first and second derivatives zero at either end of the interval. More...
|
| |
| double | dstepUp (double x) |
| | First derivative of stepUp(): d/dx stepUp(x). More...
|
| |
| double | dstepDown (double x) |
| | First derivative of stepDown(): d/dx stepDown(x). More...
|
| |
| double | dstepAny (double yRange, double x0, double oneOverXRange, double x) |
| | First derivative of stepAny(): d/dx stepAny(x). More...
|
| |
| double | d2stepUp (double x) |
| | Second derivative of stepUp(): d^2/dx^2 stepUp(x). More...
|
| |
| double | d2stepDown (double x) |
| | Second derivative of stepDown(): d^2/dx^2 stepDown(x). More...
|
| |
| double | d2stepAny (double yRange, double x0, double oneOverXRange, double x) |
| | Second derivative of stepAny(): d^2/dx^2 stepAny(x). More...
|
| |
| double | d3stepUp (double x) |
| | Third derivative of stepUp(): d^3/dx^3 stepUp(x). More...
|
| |
| double | d3stepDown (double x) |
| | Third derivative of stepDown(): d^3/dx^3 stepDown(x). More...
|
| |
| double | d3stepAny (double yRange, double x0, double oneOverXRange, double x) |
| | Third derivative of stepAny(): d^3/dx^3 stepAny(x). More...
|
| |
| float | stepUp (float x) |
| | Interpolate smoothly from 0 up to 1 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More...
|
| |
| float | stepDown (float x) |
| | Interpolate smoothly from 1 down to 0 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More...
|
| |
| float | stepAny (float y0, float yRange, float x0, float oneOverXRange, float x) |
| | Interpolate smoothly from y0 to y1 as the input argument goes from x0 to x1, with first and second derivatives zero at either end of the interval. More...
|
| |
| float | dstepUp (float x) |
| | First derivative of stepUp(): d/dx stepUp(x). More...
|
| |
| float | dstepDown (float x) |
| | First derivative of stepDown(): d/dx stepDown(x). More...
|
| |
| float | dstepAny (float yRange, float x0, float oneOverXRange, float x) |
| | First derivative of stepAny(): d/dx stepAny(x). More...
|
| |
| float | d2stepUp (float x) |
| | Second derivative of stepUp(): d^2/dx^2 stepUp(x). More...
|
| |
| float | d2stepDown (float x) |
| | Second derivative of stepDown(): d^2/dx^2 stepDown(x). More...
|
| |
| float | d2stepAny (float yRange, float x0, float oneOverXRange, float x) |
| | Second derivative of stepAny(): d^2/dx^2 stepAny(x). More...
|
| |
| float | d3stepUp (float x) |
| | Third derivative of stepUp(): d^3/dx^3 stepUp(x). More...
|
| |
| float | d3stepDown (float x) |
| | Third derivative of stepDown(): d^3/dx^3 stepDown(x). More...
|
| |
| float | d3stepAny (float yRange, float x0, float oneOverXRange, float x) |
| | Third derivative of stepAny(): d^3/dx^3 stepAny(x). More...
|
| |
| long double | stepUp (long double x) |
| | Interpolate smoothly from 0 up to 1 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More...
|
| |
| long double | stepDown (long double x) |
| | Interpolate smoothly from 1 down to 0 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More...
|
| |
| long double | stepAny (long double y0, long double yRange, long double x0, long double oneOverXRange, long double x) |
| | Interpolate smoothly from y0 to y1 as the input argument goes from x0 to x1, with first and second derivatives zero at either end of the interval. More...
|
| |
| long double | dstepUp (long double x) |
| | First derivative of stepUp(): d/dx stepUp(x). More...
|
| |
| long double | dstepDown (long double x) |
| | First derivative of stepDown(): d/dx stepDown(x). More...
|
| |
| long double | dstepAny (long double yRange, long double x0, long double oneOverXRange, long double x) |
| | First derivative of stepAny(): d/dx stepAny(x). More...
|
| |
| long double | d2stepUp (long double x) |
| | Second derivative of stepUp(): d^2/dx^2 stepUp(x). More...
|
| |
| long double | d2stepDown (long double x) |
| | Second derivative of stepDown(): d^2/dx^2 stepDown(x). More...
|
| |
| long double | d2stepAny (long double yRange, long double x0, long double oneOverXRange, long double x) |
| | Second derivative of stepAny(): d^2/dx^2 stepAny(x). More...
|
| |
| long double | d3stepUp (long double x) |
| | Third derivative of stepUp(): d^3/dx^3 stepUp(x). More...
|
| |
| long double | d3stepDown (long double x) |
| | Third derivative of stepDown(): d^3/dx^3 stepDown(x). More...
|
| |
| long double | d3stepAny (long double yRange, long double x0, long double oneOverXRange, long double x) |
| | Third derivative of stepAny(): d^3/dx^3 stepAny(x). More...
|
| |
| double | stepUp (int x) |
| | Interpolate smoothly from 0 up to 1 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More...
|
| |
| double | stepDown (int x) |
| | Interpolate smoothly from 1 down to 0 as the input argument goes from 0 to 1, with first and second derivatives zero at either end of the interval. More...
|
| |
| std::pair< double, double > | approxCompleteEllipticIntegralsKE (double m) |
| | Given 0<=m<=1, return complete elliptic integrals of the first and second kinds, K(m) and E(m), approximated but with a maximum error of 2e-8 so at least 7 digits are correct (same in float or double precision). See Elliptic integrals for a discussion. More...
|
| |
| std::pair< float, float > | approxCompleteEllipticIntegralsKE (float m) |
| | This is the single precision (float) version of the approximate calculation of elliptic integrals, still yielding about 7 digits of accuracy even though all calculations are done in float precision. More...
|
| |
| std::pair< double, double > | approxCompleteEllipticIntegralsKE (int m) |
| | This integer overload is present to prevent ambiguity; it converts its argument to double precision and then calls approxCompleteEllipticIntegralsKE(double). More...
|
| |
| std::pair< double, double > | completeEllipticIntegralsKE (double m) |
| | Given 0<=m<=1, return complete elliptic integrals of the first and second kinds, K(m) and E(m), calculated to (roughly) machine precision (float or double). See Elliptic integrals for a discussion. More...
|
| |
| std::pair< float, float > | completeEllipticIntegralsKE (float m) |
| | This is the single precision (float) version of the machine-precision calculation of elliptic integrals, providing accuracy to float precision (about 7 digits) which is no better than you'll get with the much faster approximate version, so use that instead! More...
|
| |
| std::pair< double, double > | completeEllipticIntegralsKE (int m) |
| | This integer overload is present to prevent ambiguity; it converts its argument to double precision and then calls completeEllipticIntegralsKE(double). More...
|
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (EventId) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemEventTriggerIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemEventTriggerByStageIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (EventTriggerByStageIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (MeasureIndex) |
| | Define a unique integral type for safe indexing of Measures. More...
|
| |
| std::ostream & | operator<< (std::ostream &o, Stage g) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (SubsystemIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemYIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemQIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (QIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemUIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (UIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemZIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ZIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (DiscreteVariableIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (CacheEntryIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemYErrIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemQErrIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (QErrIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemUErrIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (UErrIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemUDotErrIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (UDotErrIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (SystemMultiplierIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (MultiplierIndex) |
| |
| std::ostream & | operator<< (std::ostream &o, const State &s) |
| |
| template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR> |
Mat< M, N, EL, CSL, RSL >
::template Result< Mat< M, N,
ER, CSR, RSR > >::Add | operator+ (const Mat< M, N, EL, CSL, RSL > &l, const Mat< M, N, ER, CSR, RSR > &r) |
| |
| template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR> |
Mat< M, N, EL, CSL, RSL >
::template Result< Mat< M, N,
ER, CSR, RSR > >::Sub | operator- (const Mat< M, N, EL, CSL, RSL > &l, const Mat< M, N, ER, CSR, RSR > &r) |
| |
| template<int M, int N, class EL , int CSL, int RSL, int P, class ER , int CSR, int RSR> |
Mat< M, N, EL, CSL, RSL >
::template Result< Mat< N, P,
ER, CSR, RSR > >::Mul | operator* (const Mat< M, N, EL, CSL, RSL > &l, const Mat< N, P, ER, CSR, RSR > &r) |
| |
| template<int M, int N, class EL , int CSL, int RSL, int MM, int NN, class ER , int CSR, int RSR> |
Mat< M, N, EL, CSL, RSL >
::template Result< Mat< MM, NN,
ER, CSR, RSR > >::MulNon | operator* (const Mat< M, N, EL, CSL, RSL > &l, const Mat< MM, NN, ER, CSR, RSR > &r) |
| |
| template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR> |
| bool | operator== (const Mat< M, N, EL, CSL, RSL > &l, const Mat< M, N, ER, CSR, RSR > &r) |
| |
| template<int M, int N, class EL , int CSL, int RSL, class ER , int CSR, int RSR> |
| bool | operator!= (const Mat< M, N, EL, CSL, RSL > &l, const Mat< M, N, ER, CSR, RSR > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< float >
::Mul | operator* (const Mat< M, N, E, CS, RS > &l, const float &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< float >
::Mul | operator* (const float &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< double >
::Mul | operator* (const Mat< M, N, E, CS, RS > &l, const double &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< double >
::Mul | operator* (const double &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< long double >
::Mul | operator* (const Mat< M, N, E, CS, RS > &l, const long double &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< long double >
::Mul | operator* (const long double &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< typename
CNT< E >::Precision >::Mul | operator* (const Mat< M, N, E, CS, RS > &l, int r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< typename
CNT< E >::Precision >::Mul | operator* (int l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result
< std::complex< R > >::Mul | operator* (const Mat< M, N, E, CS, RS > &l, const std::complex< R > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result
< std::complex< R > >::Mul | operator* (const std::complex< R > &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result
< std::complex< R > >::Mul | operator* (const Mat< M, N, E, CS, RS > &l, const conjugate< R > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result
< std::complex< R > >::Mul | operator* (const conjugate< R > &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result< typename
negator< R >::StdNumber >::Mul | operator* (const Mat< M, N, E, CS, RS > &l, const negator< R > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result< typename
negator< R >::StdNumber >::Mul | operator* (const negator< R > &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< float >
::Dvd | operator/ (const Mat< M, N, E, CS, RS > &l, const float &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
CNT< float >::template Result
< Mat< M, N, E, CS, RS >
>::Dvd | operator/ (const float &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< double >
::Dvd | operator/ (const Mat< M, N, E, CS, RS > &l, const double &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
CNT< double >::template Result
< Mat< M, N, E, CS, RS >
>::Dvd | operator/ (const double &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< long double >
::Dvd | operator/ (const Mat< M, N, E, CS, RS > &l, const long double &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
CNT< long double >::template
Result< Mat< M, N, E, CS, RS >
>::Dvd | operator/ (const long double &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< typename
CNT< E >::Precision >::Dvd | operator/ (const Mat< M, N, E, CS, RS > &l, int r) |
| |
| template<int M, int N, class E , int CS, int RS> |
CNT< typename CNT< E >
::Precision >::template Result
< Mat< M, N, E, CS, RS >
>::Dvd | operator/ (int l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result
< std::complex< R > >::Dvd | operator/ (const Mat< M, N, E, CS, RS > &l, const std::complex< R > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
CNT< std::complex< R >
>::template Result< Mat< M, N,
E, CS, RS > >::Dvd | operator/ (const std::complex< R > &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result
< std::complex< R > >::Dvd | operator/ (const Mat< M, N, E, CS, RS > &l, const conjugate< R > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
CNT< std::complex< R >
>::template Result< Mat< M, N,
E, CS, RS > >::Dvd | operator/ (const conjugate< R > &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result< typename
negator< R >::StdNumber >::Dvd | operator/ (const Mat< M, N, E, CS, RS > &l, const negator< R > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
CNT< R >::template Result< Mat
< M, N, E, CS, RS > >::Dvd | operator/ (const negator< R > &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< float >
::Add | operator+ (const Mat< M, N, E, CS, RS > &l, const float &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< float >
::Add | operator+ (const float &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< double >
::Add | operator+ (const Mat< M, N, E, CS, RS > &l, const double &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< double >
::Add | operator+ (const double &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< long double >
::Add | operator+ (const Mat< M, N, E, CS, RS > &l, const long double &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< long double >
::Add | operator+ (const long double &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< typename
CNT< E >::Precision >::Add | operator+ (const Mat< M, N, E, CS, RS > &l, int r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< typename
CNT< E >::Precision >::Add | operator+ (int l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result
< std::complex< R > >::Add | operator+ (const Mat< M, N, E, CS, RS > &l, const std::complex< R > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result
< std::complex< R > >::Add | operator+ (const std::complex< R > &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result
< std::complex< R > >::Add | operator+ (const Mat< M, N, E, CS, RS > &l, const conjugate< R > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result
< std::complex< R > >::Add | operator+ (const conjugate< R > &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result< typename
negator< R >::StdNumber >::Add | operator+ (const Mat< M, N, E, CS, RS > &l, const negator< R > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result< typename
negator< R >::StdNumber >::Add | operator+ (const negator< R > &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< float >
::Sub | operator- (const Mat< M, N, E, CS, RS > &l, const float &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
CNT< float >::template Result
< Mat< M, N, E, CS, RS >
>::Sub | operator- (const float &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< double >
::Sub | operator- (const Mat< M, N, E, CS, RS > &l, const double &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
CNT< double >::template Result
< Mat< M, N, E, CS, RS >
>::Sub | operator- (const double &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< long double >
::Sub | operator- (const Mat< M, N, E, CS, RS > &l, const long double &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
CNT< long double >::template
Result< Mat< M, N, E, CS, RS >
>::Sub | operator- (const long double &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS> |
Mat< M, N, E, CS, RS >
::template Result< typename
CNT< E >::Precision >::Sub | operator- (const Mat< M, N, E, CS, RS > &l, int r) |
| |
| template<int M, int N, class E , int CS, int RS> |
CNT< typename CNT< E >
::Precision >::template Result
< Mat< M, N, E, CS, RS >
>::Sub | operator- (int l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result
< std::complex< R > >::Sub | operator- (const Mat< M, N, E, CS, RS > &l, const std::complex< R > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
CNT< std::complex< R >
>::template Result< Mat< M, N,
E, CS, RS > >::Sub | operator- (const std::complex< R > &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result
< std::complex< R > >::Sub | operator- (const Mat< M, N, E, CS, RS > &l, const conjugate< R > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
CNT< std::complex< R >
>::template Result< Mat< M, N,
E, CS, RS > >::Sub | operator- (const conjugate< R > &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
Mat< M, N, E, CS, RS >
::template Result< typename
negator< R >::StdNumber >::Sub | operator- (const Mat< M, N, E, CS, RS > &l, const negator< R > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class R > |
CNT< R >::template Result< Mat
< M, N, E, CS, RS > >::Sub | operator- (const negator< R > &l, const Mat< M, N, E, CS, RS > &r) |
| |
| template<int M, int N, class E , int CS, int RS, class CHAR , class TRAITS > |
std::basic_ostream< CHAR,
TRAITS > & | operator<< (std::basic_ostream< CHAR, TRAITS > &o, const Mat< M, N, E, CS, RS > &m) |
| |
| template<int M, int N, class E , int CS, int RS, class CHAR , class TRAITS > |
std::basic_istream< CHAR,
TRAITS > & | operator>> (std::basic_istream< CHAR, TRAITS > &is, Mat< M, N, E, CS, RS > &m) |
| |
| template<int N, class E1 , int S1, class E2 , int S2> |
Row< N, E1, S1 >::template
Result< Row< N, E2, S2 >
>::Add | operator+ (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
| |
| template<int N, class E1 , int S1, class E2 , int S2> |
Row< N, E1, S1 >::template
Result< Row< N, E2, S2 >
>::Sub | operator- (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
| |
| template<int N, class E1 , int S1, class E2 , int S2> |
| bool | operator== (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
| | bool = v1[i] == v2[i], for all elements i More...
|
| |
| template<int N, class E1 , int S1, class E2 , int S2> |
| bool | operator!= (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
| | bool = v1[i] != v2[i], for any element i More...
|
| |
| template<int N, class E1 , int S1, class E2 , int S2> |
| bool | operator< (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
| | bool = v1[i] < v2[i], for all elements i More...
|
| |
| template<int N, class E1 , int S1, class E2 > |
| bool | operator< (const Row< N, E1, S1 > &v, const E2 &e) |
| | bool = v[i] < e, for all elements v[i] and element e More...
|
| |
| template<int N, class E1 , int S1, class E2 , int S2> |
| bool | operator> (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
| | bool = v1[i] > v2[i], for all elements i More...
|
| |
| template<int N, class E1 , int S1, class E2 > |
| bool | operator> (const Row< N, E1, S1 > &v, const E2 &e) |
| | bool = v[i] > e, for all elements v[i] and element e More...
|
| |
| template<int N, class E1 , int S1, class E2 , int S2> |
| bool | operator<= (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
| | bool = v1[i] <= v2[i], for all elements i. More...
|
| |
| template<int N, class E1 , int S1, class E2 > |
| bool | operator<= (const Row< N, E1, S1 > &v, const E2 &e) |
| | bool = v[i] <= e, for all elements v[i] and element e. More...
|
| |
| template<int N, class E1 , int S1, class E2 , int S2> |
| bool | operator>= (const Row< N, E1, S1 > &l, const Row< N, E2, S2 > &r) |
| | bool = v1[i] >= v2[i], for all elements i This is not the same as !(v1<v2). More...
|
| |
| template<int N, class E1 , int S1, class E2 > |
| bool | operator>= (const Row< N, E1, S1 > &v, const E2 &e) |
| | bool = v[i] >= e, for all elements v[i] and element e. More...
|
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< float >::Mul | operator* (const Row< N, E, S > &l, const float &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< float >::Mul | operator* (const float &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< double >::Mul | operator* (const Row< N, E, S > &l, const double &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< double >::Mul | operator* (const double &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< long double >::Mul | operator* (const Row< N, E, S > &l, const long double &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< long double >::Mul | operator* (const long double &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< typename CNT< E >
::Precision >::Mul | operator* (const Row< N, E, S > &l, int r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< typename CNT< E >
::Precision >::Mul | operator* (int l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< std::complex< R >
>::Mul | operator* (const Row< N, E, S > &l, const std::complex< R > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< std::complex< R >
>::Mul | operator* (const std::complex< R > &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< std::complex< R >
>::Mul | operator* (const Row< N, E, S > &l, const conjugate< R > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< std::complex< R >
>::Mul | operator* (const conjugate< R > &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< typename negator< R >
::StdNumber >::Mul | operator* (const Row< N, E, S > &l, const negator< R > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< typename negator< R >
::StdNumber >::Mul | operator* (const negator< R > &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< float >::Dvd | operator/ (const Row< N, E, S > &l, const float &r) |
| |
| template<int N, class E , int S> |
CNT< float >::template Result
< Row< N, E, S > >::Dvd | operator/ (const float &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< double >::Dvd | operator/ (const Row< N, E, S > &l, const double &r) |
| |
| template<int N, class E , int S> |
CNT< double >::template Result
< Row< N, E, S > >::Dvd | operator/ (const double &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< long double >::Dvd | operator/ (const Row< N, E, S > &l, const long double &r) |
| |
| template<int N, class E , int S> |
CNT< long double >::template
Result< Row< N, E, S > >::Dvd | operator/ (const long double &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< typename CNT< E >
::Precision >::Dvd | operator/ (const Row< N, E, S > &l, int r) |
| |
| template<int N, class E , int S> |
CNT< typename CNT< E >
::Precision >::template Result
< Row< N, E, S > >::Dvd | operator/ (int l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< std::complex< R >
>::Dvd | operator/ (const Row< N, E, S > &l, const std::complex< R > &r) |
| |
| template<int N, class E , int S, class R > |
CNT< std::complex< R >
>::template Result< Row< N, E,
S > >::Dvd | operator/ (const std::complex< R > &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< std::complex< R >
>::Dvd | operator/ (const Row< N, E, S > &l, const conjugate< R > &r) |
| |
| template<int N, class E , int S, class R > |
CNT< std::complex< R >
>::template Result< Row< N, E,
S > >::Dvd | operator/ (const conjugate< R > &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< typename negator< R >
::StdNumber >::Dvd | operator/ (const Row< N, E, S > &l, const negator< R > &r) |
| |
| template<int N, class E , int S, class R > |
CNT< R >::template Result< Row
< N, E, S > >::Dvd | operator/ (const negator< R > &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< float >::Add | operator+ (const Row< N, E, S > &l, const float &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< float >::Add | operator+ (const float &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< double >::Add | operator+ (const Row< N, E, S > &l, const double &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< double >::Add | operator+ (const double &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< long double >::Add | operator+ (const Row< N, E, S > &l, const long double &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< long double >::Add | operator+ (const long double &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< typename CNT< E >
::Precision >::Add | operator+ (const Row< N, E, S > &l, int r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< typename CNT< E >
::Precision >::Add | operator+ (int l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< std::complex< R >
>::Add | operator+ (const Row< N, E, S > &l, const std::complex< R > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< std::complex< R >
>::Add | operator+ (const std::complex< R > &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< std::complex< R >
>::Add | operator+ (const Row< N, E, S > &l, const conjugate< R > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< std::complex< R >
>::Add | operator+ (const conjugate< R > &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< typename negator< R >
::StdNumber >::Add | operator+ (const Row< N, E, S > &l, const negator< R > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< typename negator< R >
::StdNumber >::Add | operator+ (const negator< R > &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< float >::Sub | operator- (const Row< N, E, S > &l, const float &r) |
| |
| template<int N, class E , int S> |
CNT< float >::template Result
< Row< N, E, S > >::Sub | operator- (const float &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< double >::Sub | operator- (const Row< N, E, S > &l, const double &r) |
| |
| template<int N, class E , int S> |
CNT< double >::template Result
< Row< N, E, S > >::Sub | operator- (const double &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< long double >::Sub | operator- (const Row< N, E, S > &l, const long double &r) |
| |
| template<int N, class E , int S> |
CNT< long double >::template
Result< Row< N, E, S > >::Sub | operator- (const long double &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S> |
Row< N, E, S >::template
Result< typename CNT< E >
::Precision >::Sub | operator- (const Row< N, E, S > &l, int r) |
| |
| template<int N, class E , int S> |
CNT< typename CNT< E >
::Precision >::template Result
< Row< N, E, S > >::Sub | operator- (int l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< std::complex< R >
>::Sub | operator- (const Row< N, E, S > &l, const std::complex< R > &r) |
| |
| template<int N, class E , int S, class R > |
CNT< std::complex< R >
>::template Result< Row< N, E,
S > >::Sub | operator- (const std::complex< R > &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< std::complex< R >
>::Sub | operator- (const Row< N, E, S > &l, const conjugate< R > &r) |
| |
| template<int N, class E , int S, class R > |
CNT< std::complex< R >
>::template Result< Row< N, E,
S > >::Sub | operator- (const conjugate< R > &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S, class R > |
Row< N, E, S >::template
Result< typename negator< R >
::StdNumber >::Sub | operator- (const Row< N, E, S > &l, const negator< R > &r) |
| |
| template<int N, class E , int S, class R > |
CNT< R >::template Result< Row
< N, E, S > >::Sub | operator- (const negator< R > &l, const Row< N, E, S > &r) |
| |
| template<int N, class E , int S, class CHAR , class TRAITS > |
std::basic_ostream< CHAR,
TRAITS > & | operator<< (std::basic_ostream< CHAR, TRAITS > &o, const Row< N, E, S > &v) |
| |
| template<int N, class E , int S, class CHAR , class TRAITS > |
std::basic_istream< CHAR,
TRAITS > & | operator>> (std::basic_istream< CHAR, TRAITS > &is, Row< N, E, S > &v) |
| | Read a Row from a stream as M elements separated by white space or by commas, optionally enclosed in () or [] (but no leading "~"). More...
|
| |
| template<int M, class EL , int CSL, int RSL, class ER , int RSR> |
| bool | operator== (const Mat< M, M, EL, CSL, RSL > &l, const SymMat< M, ER, RSR > &r) |
| |
| template<int M, class EL , int CSL, int RSL, class ER , int RSR> |
| bool | operator!= (const Mat< M, M, EL, CSL, RSL > &l, const SymMat< M, ER, RSR > &r) |
| |
| template<int M, class EL , int RSL, class ER , int CSR, int RSR> |
| bool | operator== (const SymMat< M, EL, RSL > &l, const Mat< M, M, ER, CSR, RSR > &r) |
| |
| template<int M, class EL , int RSL, class ER , int CSR, int RSR> |
| bool | operator!= (const SymMat< M, EL, RSL > &l, const Mat< M, M, ER, CSR, RSR > &r) |
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
CNT< typename CNT< E1 >::THerm >
::template Result< E2 >::Mul | dot (const Vec< M, E1, S1 > &r, const Vec< M, E2, S2 > &v) |
| |
| template<class E1 , int S1, class E2 , int S2> |
CNT< typename CNT< E1 >::THerm >
::template Result< E2 >::Mul | dot (const Vec< 1, E1, S1 > &r, const Vec< 1, E2, S2 > &v) |
| |
| template<int N, class E1 , int S1, class E2 , int S2> |
CNT< E1 >::template Result< E2 >
::Mul | operator* (const Row< N, E1, S1 > &r, const Vec< N, E2, S2 > &v) |
| |
| template<class E1 , int S1, class E2 , int S2> |
CNT< E1 >::template Result< E2 >
::Mul | operator* (const Row< 1, E1, S1 > &r, const Vec< 1, E2, S2 > &v) |
| |
| template<int N, class E1 , int S1, class E2 , int S2> |
CNT< E1 >::template Result< E2 >
::Mul | dot (const Row< N, E1, S1 > &r, const Vec< N, E2, S2 > &v) |
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
CNT< E1 >::template Result< E2 >
::Mul | dot (const Vec< M, E1, S1 > &v, const Row< M, E2, S2 > &r) |
| |
| template<int N, class E1 , int S1, class E2 , int S2> |
CNT< E1 >::template Result< E2 >
::Mul | dot (const Row< N, E1, S1 > &r, const Row< N, E2, S2 > &s) |
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
Mat< M, M, typename CNT< E1 >
::template Result< typename
CNT< E2 >::THerm >::Mul > | outer (const Vec< M, E1, S1 > &v, const Vec< M, E2, S2 > &w) |
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
Vec< M, E1, S1 >::template
Result< Row< M, E2, S2 >
>::Mul | operator* (const Vec< M, E1, S1 > &v, const Row< M, E2, S2 > &r) |
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
Mat< M, M, typename CNT< E1 >
::template Result< E2 >::Mul > | outer (const Vec< M, E1, S1 > &v, const Row< M, E2, S2 > &r) |
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
Mat< M, M, typename CNT< E1 >
::template Result< E2 >::Mul > | outer (const Row< M, E1, S1 > &r, const Vec< M, E2, S2 > &v) |
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
Mat< M, M, typename CNT< E1 >
::template Result< E2 >::Mul > | outer (const Row< M, E1, S1 > &r, const Row< M, E2, S2 > &s) |
| |
| template<int M, int N, class ME , int CS, int RS, class E , int S> |
Mat< M, N, ME, CS, RS >
::template Result< Vec< N, E,
S > >::Mul | operator* (const Mat< M, N, ME, CS, RS > &m, const Vec< N, E, S > &v) |
| |
| template<int M, class E , int S, int N, class ME , int CS, int RS> |
Row< M, E, S >::template
Result< Mat< M, N, ME, CS, RS >
>::Mul | operator* (const Row< M, E, S > &r, const Mat< M, N, ME, CS, RS > &m) |
| |
| template<int N, class ME , int RS, class E , int S> |
SymMat< N, ME, RS >::template
Result< Vec< N, E, S > >::Mul | operator* (const SymMat< N, ME, RS > &m, const Vec< N, E, S > &v) |
| |
| template<class ME , int RS, class E , int S> |
SymMat< 1, ME, RS >::template
Result< Vec< 1, E, S > >::Mul | operator* (const SymMat< 1, ME, RS > &m, const Vec< 1, E, S > &v) |
| |
| template<class ME , int RS, class E , int S> |
SymMat< 2, ME, RS >::template
Result< Vec< 2, E, S > >::Mul | operator* (const SymMat< 2, ME, RS > &m, const Vec< 2, E, S > &v) |
| |
| template<class ME , int RS, class E , int S> |
SymMat< 3, ME, RS >::template
Result< Vec< 3, E, S > >::Mul | operator* (const SymMat< 3, ME, RS > &m, const Vec< 3, E, S > &v) |
| |
| template<int M, class E , int S, class ME , int RS> |
Row< M, E, S >::template
Result< SymMat< M, ME, RS >
>::Mul | operator* (const Row< M, E, S > &r, const SymMat< M, ME, RS > &m) |
| |
| template<class E , int S, class ME , int RS> |
Row< 1, E, S >::template
Result< SymMat< 1, ME, RS >
>::Mul | operator* (const Row< 1, E, S > &r, const SymMat< 1, ME, RS > &m) |
| |
| template<class E , int S, class ME , int RS> |
Row< 2, E, S >::template
Result< SymMat< 2, ME, RS >
>::Mul | operator* (const Row< 2, E, S > &r, const SymMat< 2, ME, RS > &m) |
| |
| template<class E , int S, class ME , int RS> |
Row< 3, E, S >::template
Result< SymMat< 3, ME, RS >
>::Mul | operator* (const Row< 3, E, S > &r, const SymMat< 3, ME, RS > &m) |
| |
| template<int M, class E1 , int S1, int N, class E2 , int S2> |
Vec< M, E1, S1 >::template
Result< Row< N, E2, S2 >
>::MulNon | operator* (const Vec< M, E1, S1 > &v, const Row< N, E2, S2 > &r) |
| |
| template<int M, class E1 , int S1, int MM, int NN, class E2 , int CS2, int RS2> |
Vec< M, E1, S1 >::template
Result< Mat< MM, NN, E2, CS2,
RS2 > >::MulNon | operator* (const Vec< M, E1, S1 > &v, const Mat< MM, NN, E2, CS2, RS2 > &m) |
| |
| template<int M, class E1 , int S1, int MM, class E2 , int RS2> |
Vec< M, E1, S1 >::template
Result< SymMat< MM, E2, RS2 >
>::MulNon | operator* (const Vec< M, E1, S1 > &v, const SymMat< MM, E2, RS2 > &m) |
| |
| template<int M, class E1 , int S1, int MM, class E2 , int S2> |
Vec< M, E1, S1 >::template
Result< Vec< MM, E2, S2 >
>::MulNon | operator* (const Vec< M, E1, S1 > &v1, const Vec< MM, E2, S2 > &v2) |
| |
| template<int M, class E , int S, int MM, int NN, class ME , int CS, int RS> |
Row< M, E, S >::template
Result< Mat< MM, NN, ME, CS,
RS > >::MulNon | operator* (const Row< M, E, S > &r, const Mat< MM, NN, ME, CS, RS > &m) |
| |
| template<int N, class E1 , int S1, int M, class E2 , int S2> |
Row< N, E1, S1 >::template
Result< Vec< M, E2, S2 >
>::MulNon | operator* (const Row< N, E1, S1 > &r, const Vec< M, E2, S2 > &v) |
| |
| template<int N1, class E1 , int S1, int N2, class E2 , int S2> |
Row< N1, E1, S1 >::template
Result< Row< N2, E2, S2 >
>::MulNon | operator* (const Row< N1, E1, S1 > &r1, const Row< N2, E2, S2 > &r2) |
| |
| template<int M, int N, class ME , int CS, int RS, int MM, class E , int S> |
Mat< M, N, ME, CS, RS >
::template Result< Vec< MM, E,
S > >::MulNon | operator* (const Mat< M, N, ME, CS, RS > &m, const Vec< MM, E, S > &v) |
| |
| template<int M, int N, class ME , int CS, int RS, int NN, class E , int S> |
Mat< M, N, ME, CS, RS >
::template Result< Row< NN, E,
S > >::MulNon | operator* (const Mat< M, N, ME, CS, RS > &m, const Row< NN, E, S > &r) |
| |
| template<int M, int N, class ME , int CS, int RS, int Dim, class E , int S> |
Mat< M, N, ME, CS, RS >
::template Result< SymMat< Dim,
E, S > >::MulNon | operator* (const Mat< M, N, ME, CS, RS > &m, const SymMat< Dim, E, S > &sy) |
| |
| template<class E1 , int S1, class E2 , int S2> |
Vec< 3, typename CNT< E1 >
::template Result< E2 >::Mul > | cross (const Vec< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b) |
| |
| template<class E1 , int S1, class E2 , int S2> |
Vec< 3, typename CNT< E1 >
::template Result< E2 >::Mul > | operator% (const Vec< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b) |
| |
| template<class E1 , int S1, class E2 , int S2> |
Row< 3, typename CNT< E1 >
::template Result< E2 >::Mul > | cross (const Vec< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b) |
| |
| template<class E1 , int S1, class E2 , int S2> |
Row< 3, typename CNT< E1 >
::template Result< E2 >::Mul > | operator% (const Vec< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b) |
| |
| template<class E1 , int S1, class E2 , int S2> |
Row< 3, typename CNT< E1 >
::template Result< E2 >::Mul > | cross (const Row< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b) |
| |
| template<class E1 , int S1, class E2 , int S2> |
Row< 3, typename CNT< E1 >
::template Result< E2 >::Mul > | operator% (const Row< 3, E1, S1 > &a, const Vec< 3, E2, S2 > &b) |
| |
| template<class E1 , int S1, class E2 , int S2> |
Row< 3, typename CNT< E1 >
::template Result< E2 >::Mul > | cross (const Row< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b) |
| |
| template<class E1 , int S1, class E2 , int S2> |
Row< 3, typename CNT< E1 >
::template Result< E2 >::Mul > | operator% (const Row< 3, E1, S1 > &a, const Row< 3, E2, S2 > &b) |
| |
| template<class E1 , int S1, int N, class E2 , int CS, int RS> |
Mat< 3, N, typename CNT< E1 >
::template Result< E2 >::Mul > | cross (const Vec< 3, E1, S1 > &v, const Mat< 3, N, E2, CS, RS > &m) |
| |
| template<class E1 , int S1, int N, class E2 , int CS, int RS> |
Mat< 3, N, typename CNT< E1 >
::template Result< E2 >::Mul > | operator% (const Vec< 3, E1, S1 > &v, const Mat< 3, N, E2, CS, RS > &m) |
| |
| template<class E1 , int S1, int N, class E2 , int S2, int S3> |
Row< N, Vec< 3, typename CNT
< E1 >::template Result< E2 >
::Mul > > | cross (const Vec< 3, E1, S1 > &v, const Row< N, Vec< 3, E2, S2 >, S3 > &m) |
| |
| template<class E1 , int S1, class E2 , int S2, int S3> |
Row< 3, Vec< 3, typename CNT
< E1 >::template Result< E2 >
::Mul > > | cross (const Vec< 3, E1, S1 > &v, const Row< 3, Vec< 3, E2, S2 >, S3 > &m) |
| |
| template<class E1 , int S1, int N, class E2 , int S2, int S3> |
Row< N, Vec< 3, typename CNT
< E1 >::template Result< E2 >
::Mul > > | operator% (const Vec< 3, E1, S1 > &v, const Row< N, Vec< 3, E2, S2 >, S3 > &m) |
| |
| template<class E1 , int S1, class E2 , int S2, int S3> |
Row< 3, Vec< 3, typename CNT
< E1 >::template Result< E2 >
::Mul > > | operator% (const Vec< 3, E1, S1 > &v, const Row< 3, Vec< 3, E2, S2 >, S3 > &m) |
| |
| template<class EV , int SV, class EM , int RS> |
Mat< 3, 3, typename CNT< EV >
::template Result< EM >::Mul > | cross (const Vec< 3, EV, SV > &v, const SymMat< 3, EM, RS > &s) |
| |
| template<class EV , int SV, class EM , int RS> |
Mat< 3, 3, typename CNT< EV >
::template Result< EM >::Mul > | operator% (const Vec< 3, EV, SV > &v, const SymMat< 3, EM, RS > &s) |
| |
| template<class E1 , int S1, int N, class E2 , int CS, int RS> |
Mat< 3, N, typename CNT< E1 >
::template Result< E2 >::Mul > | cross (const Row< 3, E1, S1 > &r, const Mat< 3, N, E2, CS, RS > &m) |
| |
| template<class E1 , int S1, int N, class E2 , int CS, int RS> |
Mat< 3, N, typename CNT< E1 >
::template Result< E2 >::Mul > | operator% (const Row< 3, E1, S1 > &r, const Mat< 3, N, E2, CS, RS > &m) |
| |
| template<class EV , int SV, class EM , int RS> |
Mat< 3, 3, typename CNT< EV >
::template Result< EM >::Mul > | cross (const Row< 3, EV, SV > &r, const SymMat< 3, EM, RS > &s) |
| |
| template<class EV , int SV, class EM , int RS> |
Mat< 3, 3, typename CNT< EV >
::template Result< EM >::Mul > | operator% (const Row< 3, EV, SV > &r, const SymMat< 3, EM, RS > &s) |
| |
| template<int M, class EM , int CS, int RS, class EV , int S> |
Mat< M, 3, typename CNT< EM >
::template Result< EV >::Mul > | cross (const Mat< M, 3, EM, CS, RS > &m, const Vec< 3, EV, S > &v) |
| |
| template<int M, class EM , int CS, int RS, class EV , int S> |
Mat< M, 3, typename CNT< EM >
::template Result< EV >::Mul > | operator% (const Mat< M, 3, EM, CS, RS > &m, const Vec< 3, EV, S > &v) |
| |
| template<class EM , int RS, class EV , int SV> |
Mat< 3, 3, typename CNT< EM >
::template Result< EV >::Mul > | cross (const SymMat< 3, EM, RS > &s, const Vec< 3, EV, SV > &v) |
| |
| template<class EM , int RS, class EV , int SV> |
Mat< 3, 3, typename CNT< EM >
::template Result< EV >::Mul > | operator% (const SymMat< 3, EM, RS > &s, const Vec< 3, EV, SV > &v) |
| |
| template<int M, class EM , int CS, int RS, class ER , int S> |
Mat< M, 3, typename CNT< EM >
::template Result< ER >::Mul > | cross (const Mat< M, 3, EM, CS, RS > &m, const Row< 3, ER, S > &r) |
| |
| template<int M, class EM , int CS, int RS, class ER , int S> |
Mat< M, 3, typename CNT< EM >
::template Result< ER >::Mul > | operator% (const Mat< M, 3, EM, CS, RS > &m, const Row< 3, ER, S > &r) |
| |
| template<class EM , int RS, class EV , int SV> |
Mat< 3, 3, typename CNT< EM >
::template Result< EV >::Mul > | cross (const SymMat< 3, EM, RS > &s, const Row< 3, EV, SV > &r) |
| |
| template<class EM , int RS, class EV , int SV> |
Mat< 3, 3, typename CNT< EM >
::template Result< EV >::Mul > | operator% (const SymMat< 3, EM, RS > &s, const Row< 3, EV, SV > &r) |
| |
| template<class E1 , int S1, class E2 , int S2> |
CNT< E1 >::template Result< E2 >
::Mul | cross (const Vec< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b) |
| |
| template<class E1 , int S1, class E2 , int S2> |
CNT< E1 >::template Result< E2 >
::Mul | operator% (const Vec< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b) |
| |
| template<class E1 , int S1, class E2 , int S2> |
CNT< E1 >::template Result< E2 >
::Mul | cross (const Row< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b) |
| |
| template<class E1 , int S1, class E2 , int S2> |
CNT< E1 >::template Result< E2 >
::Mul | operator% (const Row< 2, E1, S1 > &a, const Vec< 2, E2, S2 > &b) |
| |
| template<class E1 , int S1, class E2 , int S2> |
CNT< E1 >::template Result< E2 >
::Mul | cross (const Vec< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b) |
| |
| template<class E1 , int S1, class E2 , int S2> |
CNT< E1 >::template Result< E2 >
::Mul | operator% (const Vec< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b) |
| |
| template<class E1 , int S1, class E2 , int S2> |
CNT< E1 >::template Result< E2 >
::Mul | cross (const Row< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b) |
| |
| template<class E1 , int S1, class E2 , int S2> |
CNT< E1 >::template Result< E2 >
::Mul | operator% (const Row< 2, E1, S1 > &a, const Row< 2, E2, S2 > &b) |
| |
| template<class E , int S> |
| Mat< 3, 3, E > | crossMat (const Vec< 3, E, S > &v) |
| | Calculate matrix M(v) such that M(v)*w = v % w. More...
|
| |
| template<class E , int S> |
| Mat< 3, 3, E > | crossMat (const Vec< 3, negator< E >, S > &v) |
| | Specialize crossMat() for negated scalar types. More...
|
| |
| template<class E , int S> |
| Mat< 3, 3, E > | crossMat (const Row< 3, E, S > &r) |
| | Form cross product matrix from a Row vector; 3 flops. More...
|
| |
| template<class E , int S> |
| Mat< 3, 3, E > | crossMat (const Row< 3, negator< E >, S > &r) |
| | Form cross product matrix from a Row vector whose elements are negated scalars; 3 flops. More...
|
| |
| template<class E , int S> |
| Row< 2, E > | crossMat (const Vec< 2, E, S > &v) |
| | Calculate 2D cross product matrix M(v) such that M(v)*w = v0*w1-v1*w0 = v % w (a scalar). More...
|
| |
| template<class E , int S> |
| Row< 2, E > | crossMat (const Vec< 2, negator< E >, S > &v) |
| | Specialize 2D cross product matrix for negated scalar types; 1 flop. More...
|
| |
| template<class E , int S> |
| Row< 2, E > | crossMat (const Row< 2, E, S > &r) |
| | Form 2D cross product matrix from a Row<2>; 1 flop. More...
|
| |
| template<class E , int S> |
| Row< 2, E > | crossMat (const Row< 2, negator< E >, S > &r) |
| | Form 2D cross product matrix from a Row<2> with negated scalar elements; 1 flop. More...
|
| |
| template<class E , int S> |
| SymMat< 3, E > | crossMatSq (const Vec< 3, E, S > &v) |
| | Calculate matrix S(v) such that S(v)*w = -v % (v % w) = (v % w) % v. More...
|
| |
| template<class E , int S> |
| SymMat< 3, E > | crossMatSq (const Vec< 3, negator< E >, S > &v) |
| |
| template<class E , int S> |
| SymMat< 3, E > | crossMatSq (const Row< 3, E, S > &r) |
| |
| template<class E , int S> |
| SymMat< 3, E > | crossMatSq (const Row< 3, negator< E >, S > &r) |
| |
| template<class E , int CS, int RS> |
| E | det (const Mat< 1, 1, E, CS, RS > &m) |
| | Special case Mat 1x1 determinant. No computation. More...
|
| |
| template<class E , int RS> |
| E | det (const SymMat< 1, E, RS > &s) |
| | Special case SymMat 1x1 determinant. No computation. More...
|
| |
| template<class E , int CS, int RS> |
| E | det (const Mat< 2, 2, E, CS, RS > &m) |
| | Special case Mat 2x2 determinant. 3 flops (if elements are Real). More...
|
| |
| template<class E , int RS> |
| E | det (const SymMat< 2, E, RS > &s) |
| | Special case 2x2 SymMat determinant. 3 flops (if elements are Real). More...
|
| |
| template<class E , int CS, int RS> |
| E | det (const Mat< 3, 3, E, CS, RS > &m) |
| | Special case Mat 3x3 determinant. 14 flops (if elements are Real). More...
|
| |
| template<class E , int RS> |
| E | det (const SymMat< 3, E, RS > &s) |
| | Special case SymMat 3x3 determinant. 14 flops (if elements are Real). More...
|
| |
| template<int M, class E , int CS, int RS> |
| E | det (const Mat< M, M, E, CS, RS > &m) |
| | Calculate the determinant of a square matrix larger than 3x3 by recursive template expansion. More...
|
| |
| template<int M, class E , int RS> |
| E | det (const SymMat< M, E, RS > &s) |
| | Determinant of SymMat larger than 3x3. More...
|
| |
| template<class E , int CS, int RS> |
| Mat< 1, 1, E, CS, RS >::TInvert | lapackInverse (const Mat< 1, 1, E, CS, RS > &m) |
| | Specialized 1x1 lapackInverse(): costs one divide. More...
|
| |
| template<int M, class E , int CS, int RS> |
| Mat< M, M, E, CS, RS >::TInvert | lapackInverse (const Mat< M, M, E, CS, RS > &m) |
| | General inverse of small, fixed-size, square (mXm), non-singular matrix with scalar elements: use Lapack's LU routine with pivoting. More...
|
| |
| template<class E , int CS, int RS> |
| Mat< 1, 1, E, CS, RS >::TInvert | inverse (const Mat< 1, 1, E, CS, RS > &m) |
| | Specialized 1x1 Mat inverse: costs one divide. More...
|
| |
| template<class E , int RS> |
| SymMat< 1, E, RS >::TInvert | inverse (const SymMat< 1, E, RS > &s) |
| | Specialized 1x1 SymMat inverse: costs one divide. More...
|
| |
| template<class E , int CS, int RS> |
| Mat< 2, 2, E, CS, RS >::TInvert | inverse (const Mat< 2, 2, E, CS, RS > &m) |
| | Specialized 2x2 Mat inverse: costs one divide plus 9 flops. More...
|
| |
| template<class E , int RS> |
| SymMat< 2, E, RS >::TInvert | inverse (const SymMat< 2, E, RS > &s) |
| | Specialized 2x2 SymMat inverse: costs one divide plus 7 flops. More...
|
| |
| template<class E , int CS, int RS> |
| Mat< 3, 3, E, CS, RS >::TInvert | inverse (const Mat< 3, 3, E, CS, RS > &m) |
| | Specialized 3x3 inverse: costs one divide plus 41 flops (for real-valued matrices). More...
|
| |
| template<class E , int RS> |
| SymMat< 3, E, RS >::TInvert | inverse (const SymMat< 3, E, RS > &s) |
| | Specialized 3x3 inverse for symmetric or Hermitian: costs one divide plus 29 flops (for real-valued matrices). More...
|
| |
| template<int M, class E , int CS, int RS> |
| Mat< M, M, E, CS, RS >::TInvert | inverse (const Mat< M, M, E, CS, RS > &m) |
| | For any matrix larger than 3x3, we just punt to the Lapack implementation. More...
|
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
SymMat< M, E1, S1 >::template
Result< SymMat< M, E2, S2 >
>::Add | operator+ (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r) |
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
SymMat< M, E1, S1 >::template
Result< SymMat< M, E2, S2 >
>::Sub | operator- (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r) |
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
SymMat< M, E1, S1 >::template
Result< SymMat< M, E2, S2 >
>::Mul | operator* (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r) |
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
| bool | operator== (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r) |
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
| bool | operator!= (const SymMat< M, E1, S1 > &l, const SymMat< M, E2, S2 > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< float >::Mul | operator* (const SymMat< M, E, S > &l, const float &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< float >::Mul | operator* (const float &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< double >::Mul | operator* (const SymMat< M, E, S > &l, const double &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< double >::Mul | operator* (const double &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< long double >::Mul | operator* (const SymMat< M, E, S > &l, const long double &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< long double >::Mul | operator* (const long double &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< typename CNT< E >
::Precision >::Mul | operator* (const SymMat< M, E, S > &l, int r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< typename CNT< E >
::Precision >::Mul | operator* (int l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< std::complex< R >
>::Mul | operator* (const SymMat< M, E, S > &l, const std::complex< R > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< std::complex< R >
>::Mul | operator* (const std::complex< R > &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< std::complex< R >
>::Mul | operator* (const SymMat< M, E, S > &l, const conjugate< R > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< std::complex< R >
>::Mul | operator* (const conjugate< R > &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< typename negator< R >
::StdNumber >::Mul | operator* (const SymMat< M, E, S > &l, const negator< R > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< typename negator< R >
::StdNumber >::Mul | operator* (const negator< R > &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< float >::Dvd | operator/ (const SymMat< M, E, S > &l, const float &r) |
| |
| template<int M, class E , int S> |
CNT< float >::template Result
< SymMat< M, E, S > >::Dvd | operator/ (const float &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< double >::Dvd | operator/ (const SymMat< M, E, S > &l, const double &r) |
| |
| template<int M, class E , int S> |
CNT< double >::template Result
< SymMat< M, E, S > >::Dvd | operator/ (const double &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< long double >::Dvd | operator/ (const SymMat< M, E, S > &l, const long double &r) |
| |
| template<int M, class E , int S> |
CNT< long double >::template
Result< SymMat< M, E, S >
>::Dvd | operator/ (const long double &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< typename CNT< E >
::Precision >::Dvd | operator/ (const SymMat< M, E, S > &l, int r) |
| |
| template<int M, class E , int S> |
CNT< typename CNT< E >
::Precision >::template Result
< SymMat< M, E, S > >::Dvd | operator/ (int l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< std::complex< R >
>::Dvd | operator/ (const SymMat< M, E, S > &l, const std::complex< R > &r) |
| |
| template<int M, class E , int S, class R > |
CNT< std::complex< R >
>::template Result< SymMat< M,
E, S > >::Dvd | operator/ (const std::complex< R > &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< std::complex< R >
>::Dvd | operator/ (const SymMat< M, E, S > &l, const conjugate< R > &r) |
| |
| template<int M, class E , int S, class R > |
CNT< std::complex< R >
>::template Result< SymMat< M,
E, S > >::Dvd | operator/ (const conjugate< R > &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< typename negator< R >
::StdNumber >::Dvd | operator/ (const SymMat< M, E, S > &l, const negator< R > &r) |
| |
| template<int M, class E , int S, class R > |
CNT< R >::template Result
< SymMat< M, E, S > >::Dvd | operator/ (const negator< R > &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< float >::Add | operator+ (const SymMat< M, E, S > &l, const float &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< float >::Add | operator+ (const float &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< double >::Add | operator+ (const SymMat< M, E, S > &l, const double &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< double >::Add | operator+ (const double &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< long double >::Add | operator+ (const SymMat< M, E, S > &l, const long double &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< long double >::Add | operator+ (const long double &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< typename CNT< E >
::Precision >::Add | operator+ (const SymMat< M, E, S > &l, int r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< typename CNT< E >
::Precision >::Add | operator+ (int l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< std::complex< R >
>::Add | operator+ (const SymMat< M, E, S > &l, const std::complex< R > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< std::complex< R >
>::Add | operator+ (const std::complex< R > &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< std::complex< R >
>::Add | operator+ (const SymMat< M, E, S > &l, const conjugate< R > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< std::complex< R >
>::Add | operator+ (const conjugate< R > &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< typename negator< R >
::StdNumber >::Add | operator+ (const SymMat< M, E, S > &l, const negator< R > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< typename negator< R >
::StdNumber >::Add | operator+ (const negator< R > &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< float >::Sub | operator- (const SymMat< M, E, S > &l, const float &r) |
| |
| template<int M, class E , int S> |
CNT< float >::template Result
< SymMat< M, E, S > >::Sub | operator- (const float &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< double >::Sub | operator- (const SymMat< M, E, S > &l, const double &r) |
| |
| template<int M, class E , int S> |
CNT< double >::template Result
< SymMat< M, E, S > >::Sub | operator- (const double &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< long double >::Sub | operator- (const SymMat< M, E, S > &l, const long double &r) |
| |
| template<int M, class E , int S> |
CNT< long double >::template
Result< SymMat< M, E, S >
>::Sub | operator- (const long double &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S> |
SymMat< M, E, S >::template
Result< typename CNT< E >
::Precision >::Sub | operator- (const SymMat< M, E, S > &l, int r) |
| |
| template<int M, class E , int S> |
CNT< typename CNT< E >
::Precision >::template Result
< SymMat< M, E, S > >::Sub | operator- (int l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< std::complex< R >
>::Sub | operator- (const SymMat< M, E, S > &l, const std::complex< R > &r) |
| |
| template<int M, class E , int S, class R > |
CNT< std::complex< R >
>::template Result< SymMat< M,
E, S > >::Sub | operator- (const std::complex< R > &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< std::complex< R >
>::Sub | operator- (const SymMat< M, E, S > &l, const conjugate< R > &r) |
| |
| template<int M, class E , int S, class R > |
CNT< std::complex< R >
>::template Result< SymMat< M,
E, S > >::Sub | operator- (const conjugate< R > &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
SymMat< M, E, S >::template
Result< typename negator< R >
::StdNumber >::Sub | operator- (const SymMat< M, E, S > &l, const negator< R > &r) |
| |
| template<int M, class E , int S, class R > |
CNT< R >::template Result
< SymMat< M, E, S > >::Sub | operator- (const negator< R > &l, const SymMat< M, E, S > &r) |
| |
| template<int M, class E , int RS, class CHAR , class TRAITS > |
std::basic_ostream< CHAR,
TRAITS > & | operator<< (std::basic_ostream< CHAR, TRAITS > &o, const SymMat< M, E, RS > &m) |
| |
| template<int M, class E , int RS, class CHAR , class TRAITS > |
std::basic_istream< CHAR,
TRAITS > & | operator>> (std::basic_istream< CHAR, TRAITS > &is, SymMat< M, E, RS > &m) |
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
Vec< M, E1, S1 >::template
Result< Vec< M, E2, S2 >
>::Add | operator+ (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
Vec< M, E1, S1 >::template
Result< Vec< M, E2, S2 >
>::Sub | operator- (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
| bool | operator== (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
| | bool = v1[i] == v2[i], for all elements i More...
|
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
| bool | operator!= (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
| | bool = v1[i] != v2[i], for any element i More...
|
| |
| template<int M, class E1 , int S1, class E2 > |
| bool | operator== (const Vec< M, E1, S1 > &v, const E2 &e) |
| | bool = v[i] == e, for all elements v[i] and element e More...
|
| |
| template<int M, class E1 , int S1, class E2 > |
| bool | operator!= (const Vec< M, E1, S1 > &v, const E2 &e) |
| | bool = v[i] != e, for any element v[i] and element e More...
|
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
| bool | operator< (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
| | bool = v1[i] < v2[i], for all elements i More...
|
| |
| template<int M, class E1 , int S1, class E2 > |
| bool | operator< (const Vec< M, E1, S1 > &v, const E2 &e) |
| | bool = v[i] < e, for all elements v[i] and element e More...
|
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
| bool | operator> (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
| | bool = v1[i] > v2[i], for all elements i More...
|
| |
| template<int M, class E1 , int S1, class E2 > |
| bool | operator> (const Vec< M, E1, S1 > &v, const E2 &e) |
| | bool = v[i] > e, for all elements v[i] and element e More...
|
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
| bool | operator<= (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
| | bool = v1[i] <= v2[i], for all elements i. More...
|
| |
| template<int M, class E1 , int S1, class E2 > |
| bool | operator<= (const Vec< M, E1, S1 > &v, const E2 &e) |
| | bool = v[i] <= e, for all elements v[i] and element e. More...
|
| |
| template<int M, class E1 , int S1, class E2 , int S2> |
| bool | operator>= (const Vec< M, E1, S1 > &l, const Vec< M, E2, S2 > &r) |
| | bool = v1[i] >= v2[i], for all elements i This is not the same as !(v1<v2). More...
|
| |
| template<int M, class E1 , int S1, class E2 > |
| bool | operator>= (const Vec< M, E1, S1 > &v, const E2 &e) |
| | bool = v[i] >= e, for all elements v[i] and element e. More...
|
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< float >::Mul | operator* (const Vec< M, E, S > &l, const float &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< float >::Mul | operator* (const float &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< double >::Mul | operator* (const Vec< M, E, S > &l, const double &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< double >::Mul | operator* (const double &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< long double >::Mul | operator* (const Vec< M, E, S > &l, const long double &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< long double >::Mul | operator* (const long double &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< typename CNT< E >
::Precision >::Mul | operator* (const Vec< M, E, S > &l, int r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< typename CNT< E >
::Precision >::Mul | operator* (int l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< std::complex< R >
>::Mul | operator* (const Vec< M, E, S > &l, const std::complex< R > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< std::complex< R >
>::Mul | operator* (const std::complex< R > &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< std::complex< R >
>::Mul | operator* (const Vec< M, E, S > &l, const conjugate< R > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< std::complex< R >
>::Mul | operator* (const conjugate< R > &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< typename negator< R >
::StdNumber >::Mul | operator* (const Vec< M, E, S > &l, const negator< R > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< typename negator< R >
::StdNumber >::Mul | operator* (const negator< R > &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< float >::Dvd | operator/ (const Vec< M, E, S > &l, const float &r) |
| |
| template<int M, class E , int S> |
CNT< float >::template Result
< Vec< M, E, S > >::Dvd | operator/ (const float &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< double >::Dvd | operator/ (const Vec< M, E, S > &l, const double &r) |
| |
| template<int M, class E , int S> |
CNT< double >::template Result
< Vec< M, E, S > >::Dvd | operator/ (const double &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< long double >::Dvd | operator/ (const Vec< M, E, S > &l, const long double &r) |
| |
| template<int M, class E , int S> |
CNT< long double >::template
Result< Vec< M, E, S > >::Dvd | operator/ (const long double &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< typename CNT< E >
::Precision >::Dvd | operator/ (const Vec< M, E, S > &l, int r) |
| |
| template<int M, class E , int S> |
CNT< typename CNT< E >
::Precision >::template Result
< Vec< M, E, S > >::Dvd | operator/ (int l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< std::complex< R >
>::Dvd | operator/ (const Vec< M, E, S > &l, const std::complex< R > &r) |
| |
| template<int M, class E , int S, class R > |
CNT< std::complex< R >
>::template Result< Vec< M, E,
S > >::Dvd | operator/ (const std::complex< R > &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< std::complex< R >
>::Dvd | operator/ (const Vec< M, E, S > &l, const conjugate< R > &r) |
| |
| template<int M, class E , int S, class R > |
CNT< std::complex< R >
>::template Result< Vec< M, E,
S > >::Dvd | operator/ (const conjugate< R > &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< typename negator< R >
::StdNumber >::Dvd | operator/ (const Vec< M, E, S > &l, const negator< R > &r) |
| |
| template<int M, class E , int S, class R > |
CNT< R >::template Result< Vec
< M, E, S > >::Dvd | operator/ (const negator< R > &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< float >::Add | operator+ (const Vec< M, E, S > &l, const float &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< float >::Add | operator+ (const float &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< double >::Add | operator+ (const Vec< M, E, S > &l, const double &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< double >::Add | operator+ (const double &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< long double >::Add | operator+ (const Vec< M, E, S > &l, const long double &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< long double >::Add | operator+ (const long double &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< typename CNT< E >
::Precision >::Add | operator+ (const Vec< M, E, S > &l, int r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< typename CNT< E >
::Precision >::Add | operator+ (int l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< std::complex< R >
>::Add | operator+ (const Vec< M, E, S > &l, const std::complex< R > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< std::complex< R >
>::Add | operator+ (const std::complex< R > &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< std::complex< R >
>::Add | operator+ (const Vec< M, E, S > &l, const conjugate< R > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< std::complex< R >
>::Add | operator+ (const conjugate< R > &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< typename negator< R >
::StdNumber >::Add | operator+ (const Vec< M, E, S > &l, const negator< R > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< typename negator< R >
::StdNumber >::Add | operator+ (const negator< R > &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< float >::Sub | operator- (const Vec< M, E, S > &l, const float &r) |
| |
| template<int M, class E , int S> |
CNT< float >::template Result
< Vec< M, E, S > >::Sub | operator- (const float &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< double >::Sub | operator- (const Vec< M, E, S > &l, const double &r) |
| |
| template<int M, class E , int S> |
CNT< double >::template Result
< Vec< M, E, S > >::Sub | operator- (const double &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< long double >::Sub | operator- (const Vec< M, E, S > &l, const long double &r) |
| |
| template<int M, class E , int S> |
CNT< long double >::template
Result< Vec< M, E, S > >::Sub | operator- (const long double &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S> |
Vec< M, E, S >::template
Result< typename CNT< E >
::Precision >::Sub | operator- (const Vec< M, E, S > &l, int r) |
| |
| template<int M, class E , int S> |
CNT< typename CNT< E >
::Precision >::template Result
< Vec< M, E, S > >::Sub | operator- (int l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< std::complex< R >
>::Sub | operator- (const Vec< M, E, S > &l, const std::complex< R > &r) |
| |
| template<int M, class E , int S, class R > |
CNT< std::complex< R >
>::template Result< Vec< M, E,
S > >::Sub | operator- (const std::complex< R > &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< std::complex< R >
>::Sub | operator- (const Vec< M, E, S > &l, const conjugate< R > &r) |
| |
| template<int M, class E , int S, class R > |
CNT< std::complex< R >
>::template Result< Vec< M, E,
S > >::Sub | operator- (const conjugate< R > &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S, class R > |
Vec< M, E, S >::template
Result< typename negator< R >
::StdNumber >::Sub | operator- (const Vec< M, E, S > &l, const negator< R > &r) |
| |
| template<int M, class E , int S, class R > |
CNT< R >::template Result< Vec
< M, E, S > >::Sub | operator- (const negator< R > &l, const Vec< M, E, S > &r) |
| |
| template<int M, class E , int S, class CHAR , class TRAITS > |
std::basic_ostream< CHAR,
TRAITS > & | operator<< (std::basic_ostream< CHAR, TRAITS > &o, const Vec< M, E, S > &v) |
| |
| template<int M, class E , int S, class CHAR , class TRAITS > |
std::basic_istream< CHAR,
TRAITS > & | operator>> (std::basic_istream< CHAR, TRAITS > &is, Vec< M, E, S > &v) |
| | Read a Vec from a stream as M elements separated by white space or by commas, optionally enclosed in () [] ~() or ~[]. More...
|
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactSurfaceIndex) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactId) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactTypeId) |
| |
| std::ostream & | operator<< (std::ostream &o, const Contact &c) |
| |
| | SimTK_DEFINE_UNIQUE_INDEX_TYPE (ContactGeometryTypeId) |
| |
| OrientedBoundingBox | operator* (const Transform &t, const OrientedBoundingBox &box) |
| |
| static int | explicitODE_static (const CPodesSystem &sys, Real t, const Vector &y, Vector &fout) |
| |
| static int | implicitODE_static (const CPodesSystem &sys, Real t, const Vector &y, const Vector &yp, Vector &fout) |
| |
| static int | constraint_static (const CPodesSystem &sys, Real t, const Vector &y, Vector &cout) |
| |
| static int | project_static (const CPodesSystem &sys, Real t, const Vector &ycur, Vector &corr, Real epsProj, Vector &err) |
| |
| static int | quadrature_static (const CPodesSystem &sys, Real t, const Vector &y, Vector &qout) |
| |
| static int | root_static (const CPodesSystem &sys, Real t, const Vector &y, const Vector &yp, Vector &gout) |
| |
| static int | weight_static (const CPodesSystem &sys, const Vector &y, Vector &weights) |
| |
| static void | errorHandler_static (const CPodesSystem &sys, int error_code, const char *module, const char *function, char *msg) |
| |
|
These operators take MatrixBase arguments and produce Matrix_ results.
|
| template<class E1 , class E2 > |
Matrix_< typename CNT< E1 >
::template Result< E2 >::Add > | operator+ (const MatrixBase< E1 > &l, const MatrixBase< E2 > &r) |
| |
| template<class E > |
| Matrix_< E > | operator+ (const MatrixBase< E > &l, const typename CNT< E >::T &r) |
| |
| template<class E > |
| Matrix_< E > | operator+ (const typename CNT< E >::T &l, const MatrixBase< E > &r) |
| |
| template<class E1 , class E2 > |
Matrix_< typename CNT< E1 >
::template Result< E2 >::Sub > | operator- (const MatrixBase< E1 > &l, const MatrixBase< E2 > &r) |
| |
| template<class E > |
| Matrix_< E > | operator- (const MatrixBase< E > &l, const typename CNT< E >::T &r) |
| |
| template<class E > |
| Matrix_< E > | operator- (const typename CNT< E >::T &l, const MatrixBase< E > &r) |
| |
| template<class E > |
| Matrix_< E > | operator* (const MatrixBase< E > &l, const typename CNT< E >::StdNumber &r) |
| |
| template<class E > |
| Matrix_< E > | operator* (const typename CNT< E >::StdNumber &l, const MatrixBase< E > &r) |
| |
| template<class E > |
| Matrix_< E > | operator/ (const MatrixBase< E > &l, const typename CNT< E >::StdNumber &r) |
| |
| template<class E > |
| Matrix_< E > | operator* (const MatrixBase< E > &l, int r) |
| |
| template<class E > |
| Matrix_< E > | operator* (int l, const MatrixBase< E > &r) |
| |
| template<class E > |
| Matrix_< E > | operator/ (const MatrixBase< E > &l, int r) |
| |
|
These operators take VectorBase arguments and produce Vector_ results.
|
| template<class E1 , class E2 > |
Vector_< typename CNT< E1 >
::template Result< E2 >::Add > | operator+ (const VectorBase< E1 > &l, const VectorBase< E2 > &r) |
| |
| template<class E > |
| Vector_< E > | operator+ (const VectorBase< E > &l, const typename CNT< E >::T &r) |
| |
| template<class E > |
| Vector_< E > | operator+ (const typename CNT< E >::T &l, const VectorBase< E > &r) |
| |
| template<class E1 , class E2 > |
Vector_< typename CNT< E1 >
::template Result< E2 >::Sub > | operator- (const VectorBase< E1 > &l, const VectorBase< E2 > &r) |
| |
| template<class E > |
| Vector_< E > | operator- (const VectorBase< E > &l, const typename CNT< E >::T &r) |
| |
| template<class E > |
| Vector_< E > | operator- (const typename CNT< E >::T &l, const VectorBase< E > &r) |
| |
| template<class E > |
| Vector_< E > | operator* (const VectorBase< E > &l, const typename CNT< E >::StdNumber &r) |
| |
| template<class E > |
| Vector_< E > | operator* (const typename CNT< E >::StdNumber &l, const VectorBase< E > &r) |
| |
| template<class E > |
| Vector_< E > | operator/ (const VectorBase< E > &l, const typename CNT< E >::StdNumber &r) |
| |
| template<class E > |
| Vector_< E > | operator* (const VectorBase< E > &l, int r) |
| |
| template<class E > |
| Vector_< E > | operator* (int l, const VectorBase< E > &r) |
| |
| template<class E > |
| Vector_< E > | operator/ (const VectorBase< E > &l, int r) |
| |
| template<class E1 , int M, class E2 , int S> |
Vector_< typename CNT< E1 >
::template Result< Vec< M, E2,
S > >::Mul > | operator* (const VectorBase< E1 > &v, const Vec< M, E2, S > &s) |
| |
| template<class E1 , int M, class E2 , int S> |
Vector_< typename Vec< M, E2,
S >::template Result< E1 >
::Mul > | operator* (const Vec< M, E2, S > &s, const VectorBase< E1 > &v) |
| |
| template<class E1 , int N, class E2 , int S> |
Vector_< typename CNT< E1 >
::template Result< Row< N, E2,
S > >::Mul > | operator* (const VectorBase< E1 > &v, const Row< N, E2, S > &s) |
| |
| template<class E1 , int N, class E2 , int S> |
Vector_< typename Row< N, E2,
S >::template Result< E1 >
::Mul > | operator* (const Row< N, E2, S > &s, const VectorBase< E1 > &v) |
| |
| template<class E1 , int M, int N, class E2 , int S1, int S2> |
Vector_< typename CNT< E1 >
::template Result< Mat< M, N,
E2, S1, S2 > >::Mul > | operator* (const VectorBase< E1 > &v, const Mat< M, N, E2, S1, S2 > &s) |
| |
| template<class E1 , int M, int N, class E2 , int S1, int S2> |
Vector_< typename Mat< M, N,
E2, S1, S2 >::template Result
< E1 >::Mul > | operator* (const Mat< M, N, E2, S1, S2 > &s, const VectorBase< E1 > &v) |
| |
| template<class E1 , int M, class E2 , int S> |
Vector_< typename CNT< E1 >
::template Result< SymMat< M,
E2, S > >::Mul > | operator* (const VectorBase< E1 > &v, const SymMat< M, E2, S > &s) |
| |
| template<class E1 , int M, class E2 , int S> |
Vector_< typename SymMat< M,
E2, S >::template Result< E1 >
::Mul > | operator* (const SymMat< M, E2, S > &s, const VectorBase< E1 > &v) |
| |
|
These operators take RowVectorBase arguments and produce RowVector_ results.
|
| template<class E1 , class E2 > |
RowVector_< typename CNT< E1 >
::template Result< E2 >::Add > | operator+ (const RowVectorBase< E1 > &l, const RowVectorBase< E2 > &r) |
| |
| template<class E > |
| RowVector_< E > | operator+ (const RowVectorBase< E > &l, const typename CNT< E >::T &r) |
| |
| template<class E > |
| RowVector_< E > | operator+ (const typename CNT< E >::T &l, const RowVectorBase< E > &r) |
| |
| template<class E1 , class E2 > |
RowVector_< typename CNT< E1 >
::template Result< E2 >::Sub > | operator- (const RowVectorBase< E1 > &l, const RowVectorBase< E2 > &r) |
| |
| template<class E > |
| RowVector_< E > | operator- (const RowVectorBase< E > &l, const typename CNT< E >::T &r) |
| |
| template<class E > |
| RowVector_< E > | operator- (const typename CNT< E >::T &l, const RowVectorBase< E > &r) |
| |
| template<class E > |
| RowVector_< E > | operator* (const RowVectorBase< E > &l, const typename CNT< E >::StdNumber &r) |
| |
| template<class E > |
| RowVector_< E > | operator* (const typename CNT< E >::StdNumber &l, const RowVectorBase< E > &r) |
| |
| template<class E > |
| RowVector_< E > | operator/ (const RowVectorBase< E > &l, const typename CNT< E >::StdNumber &r) |
| |
| template<class E > |
| RowVector_< E > | operator* (const RowVectorBase< E > &l, int r) |
| |
| template<class E > |
| RowVector_< E > | operator* (int l, const RowVectorBase< E > &r) |
| |
| template<class E > |
| RowVector_< E > | operator/ (const RowVectorBase< E > &l, int r) |
| |
| template<class E1 , int M, class E2 , int S> |
RowVector_< typename CNT< E1 >
::template Result< Vec< M, E2,
S > >::Mul > | operator* (const RowVectorBase< E1 > &v, const Vec< M, E2, S > &s) |
| |
| template<class E1 , int M, class E2 , int S> |
RowVector_< typename Vec< M,
E2, S >::template Result< E1 >
::Mul > | operator* (const Vec< M, E2, S > &s, const RowVectorBase< E1 > &v) |
| |
| template<class E1 , int N, class E2 , int S> |
RowVector_< typename CNT< E1 >
::template Result< Row< N, E2,
S > >::Mul > | operator* (const RowVectorBase< E1 > &v, const Row< N, E2, S > &s) |
| |
| template<class E1 , int N, class E2 , int S> |
RowVector_< typename Row< N,
E2, S >::template Result< E1 >
::Mul > | operator* (const Row< N, E2, S > &s, const RowVectorBase< E1 > &v) |
| |
| template<class E1 , int M, int N, class E2 , int S1, int S2> |
RowVector_< typename CNT< E1 >
::template Result< Mat< M, N,
E2, S1, S2 > >::Mul > | operator* (const RowVectorBase< E1 > &v, const Mat< M, N, E2, S1, S2 > &s) |
| |
| template<class E1 , int M, int N, class E2 , int S1, int S2> |
RowVector_< typename Mat< M, N,
E2, S1, S2 >::template Result
< E1 >::Mul > | operator* (const Mat< M, N, E2, S1, S2 > &s, const RowVectorBase< E1 > &v) |
| |
| template<class E1 , int M, class E2 , int S> |
RowVector_< typename CNT< E1 >
::template Result< SymMat< M,
E2, S > >::Mul > | operator* (const RowVectorBase< E1 > &v, const SymMat< M, E2, S > &s) |
| |
| template<class E1 , int M, class E2 , int S> |
RowVector_< typename SymMat< M,
E2, S >::template Result< E1 >
::Mul > | operator* (const SymMat< M, E2, S > &s, const RowVectorBase< E1 > &v) |
| |
|
These operators take MatrixBase, VectorBase, and RowVectorBase arguments and produce Matrix_, Vector_, and RowVector_ results.
|
| template<class E1 , class E2 > |
CNT< E1 >::template Result< E2 >
::Mul | operator* (const RowVectorBase< E1 > &r, const VectorBase< E2 > &v) |
| |
| template<class E1 , class E2 > |
Vector_< typename CNT< E1 >
::template Result< E2 >::Mul > | operator* (const MatrixBase< E1 > &m, const VectorBase< E2 > &v) |
| |
| template<class E1 , class E2 > |
Matrix_< typename CNT< E1 >
::template Result< E2 >::Mul > | operator* (const MatrixBase< E1 > &m1, const MatrixBase< E2 > &m2) |
| |
|
| template<class P , int S> |
| UnitVec< P, 1 > | operator* (const Rotation_< P > &R, const UnitVec< P, S > &v) |
| | Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization. More...
|
| |
| template<class P , int S> |
| UnitRow< P, 1 > | operator* (const UnitRow< P, S > &r, const Rotation_< P > &R) |
| | Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization. More...
|
| |
| template<class P , int S> |
| UnitVec< P, 1 > | operator* (const InverseRotation_< P > &R, const UnitVec< P, S > &v) |
| | Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization. More...
|
| |
| template<class P , int S> |
| UnitRow< P, 1 > | operator* (const UnitRow< P, S > &r, const InverseRotation_< P > &R) |
| | Rotating a unit vector leaves it unit length, saving us from having to perform an expensive normalization. More...
|
| |
|
| template<class P > |
| Rotation_< P > | operator* (const Rotation_< P > &R1, const Rotation_< P > &R2) |
| | Composition of Rotation matrices via operator*. More...
|
| |
| template<class P > |
| Rotation_< P > | operator* (const Rotation_< P > &R1, const InverseRotation_< P > &R2) |
| | Composition of Rotation matrices via operator*. More...
|
| |
| template<class P > |
| Rotation_< P > | operator* (const InverseRotation_< P > &R1, const Rotation_< P > &R2) |
| | Composition of Rotation matrices via operator*. More...
|
| |
| template<class P > |
| Rotation_< P > | operator* (const InverseRotation_< P > &R1, const InverseRotation_< P > &R2) |
| | Composition of Rotation matrices via operator*. More...
|
| |
|
| template<class P > |
| Rotation_< P > | operator/ (const Rotation_< P > &R1, const Rotation_< P > &R2) |
| | Composition of a Rotation matrix and the inverse of another Rotation via operator/, that is R1/R2 == R1*(~R2). More...
|
| |
| template<class P > |
| Rotation_< P > | operator/ (const Rotation_< P > &R1, const InverseRotation &R2) |
| | Composition of a Rotation matrix and the inverse of another Rotation via operator/, that is R1/R2 == R1*(~R2). More...
|
| |
| template<class P > |
| Rotation_< P > | operator/ (const InverseRotation_< P > &R1, const Rotation_< P > &R2) |
| | Composition of a Rotation matrix and the inverse of another Rotation via operator/, that is R1/R2 == R1*(~R2). More...
|
| |
| template<class P > |
| Rotation_< P > | operator/ (const InverseRotation_< P > &R1, const InverseRotation_< P > &R2) |
| | Composition of a Rotation matrix and the inverse of another Rotation via operator/, that is R1/R2 == R1*(~R2). More...
|
| |
1.8.6