Simbody
3.6

Limit a numerical value so that it does not go outside a given range. More...
Functions  
double &  SimTK::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 &  SimTK::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...  
double &  SimTK::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 &  SimTK::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...  
double &  SimTK::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 &  SimTK::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...  
double &  SimTK::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 &  SimTK::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...  
unsigned char &  SimTK::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 &  SimTK::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 &  SimTK::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 &  SimTK::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 &  SimTK::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 &  SimTK::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 &  SimTK::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 &  SimTK::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 &  SimTK::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 &  SimTK::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 &  SimTK::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 > &  SimTK::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 > &  SimTK::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...  
double  SimTK::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  SimTK::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...  
double  SimTK::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  SimTK::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...  
double  SimTK::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  SimTK::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...  
double  SimTK::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  SimTK::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...  
unsigned char  SimTK::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  SimTK::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  SimTK::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  SimTK::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  SimTK::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  SimTK::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  SimTK::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  SimTK::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  SimTK::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  SimTK::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  SimTK::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  SimTK::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  SimTK::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...  
Limit a numerical value so that it does not go outside a given range.
There are two functions (plus overloads) defined here: clamp() and clampInPlace(). The first one is the most commonly used and simply calculates an inrange value from an input value and a given range [low,high]. clampInPlace() is given a reference to a variable and if necessary modifies that variable so that its value is in the given range [low,high]. Both functions are overloaded for all the integral and real types but are not defined for complex or conjugate types.
The following examples shows how clamp() and clampInPlace() can be defined in terms of std::min() and std::max().

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops. Takes integer bounds to avoid need for explicit casts.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops. Takes integer bounds to avoid need for explicit casts.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops. Takes an integer bound to avoid need for explicit casts.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops. Takes an integer bound to avoid need for explicit casts.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops. Takes an integer bound to avoid need for explicit casts.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops. Takes an integer bound to avoid need for explicit casts.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops.

inline 
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops.
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops.
Check that low <= v <= high and modify v in place if necessary to bring it into that range.
[in]  low  The lower bound; must be <= high. 
[in,out]  v  The variable whose value is changed if necessary. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.

inline 
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.
[in]  low  The lower bound; must be <= high. 
[in]  v  The value to be put into range [low,high]. 
[in]  high  The upper bound; must be >= low. 
This method is overloaded for all standard integral and floating point types. All the arguments and the return type will be the same type; there are no explicit overloads for mixed types so you may find you need to cast the bounds in some cases to ensure you are calling the correct overload.
Cost: These are very fast, inline methods; the floating point ones use just two flops.