Simbody
3.7
|
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 in-range 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.