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...

long double &	SimTK::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 &	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...

long double &	SimTK::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 &	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...

long double &	SimTK::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 &	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...

long double &	SimTK::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 &	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...

negator< long double > &	SimTK::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	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...

long double	SimTK::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	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...

long double	SimTK::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	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...

long double	SimTK::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	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...

long double	SimTK::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	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...

long double	SimTK::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...

Detailed Description

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().

clamp():

const double low, high; // from somewhere
const double v;
double clampedValue;
clampedValue = clamp(low,v,high); // clampedValue is in [low,high]
clampedValue = std::min(std::max(low,v), high); // equivalent

clampInPlace():

const double low, high; // from somewhere
double v;
clampInPlace(low,v,high); // now v is in [low,high]
v = std::min(std::max(low,v), high); // equivalent

Function Documentation

double& SimTK::clampInPlace	(	double	low,
		double &	v,
		double	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

float& SimTK::clampInPlace	(	float	low,
		float &	v,
		float	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

long double& SimTK::clampInPlace	(	long double	low,
		long double &	v,
		long double	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

double& SimTK::clampInPlace	(	int	low,
		double &	v,
		int	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

float& SimTK::clampInPlace	(	int	low,
		float &	v,
		int	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

long double& SimTK::clampInPlace	(	int	low,
		long double &	v,
		int	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

double& SimTK::clampInPlace	(	int	low,
		double &	v,
		double	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

float& SimTK::clampInPlace	(	int	low,
		float &	v,
		float	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

long double& SimTK::clampInPlace	(	int	low,
		long double &	v,
		long double	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

double& SimTK::clampInPlace	(	double	low,
		double &	v,
		int	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

float& SimTK::clampInPlace	(	float	low,
		float &	v,
		int	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

long double& SimTK::clampInPlace	(	long double	low,
		long double &	v,
		int	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

unsigned char& SimTK::clampInPlace	(	unsigned char	low,
		unsigned char &	v,
		unsigned char	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

unsigned short& SimTK::clampInPlace	(	unsigned short	low,
		unsigned short &	v,
		unsigned short	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

unsigned int& SimTK::clampInPlace	(	unsigned int	low,
		unsigned int &	v,
		unsigned int	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

unsigned long& SimTK::clampInPlace	(	unsigned long	low,
		unsigned long &	v,
		unsigned long	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

unsigned long long& SimTK::clampInPlace	(	unsigned long long	low,
		unsigned long long &	v,
		unsigned long long	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

char& SimTK::clampInPlace	(	char	low,
		char &	v,
		char	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

signed char& SimTK::clampInPlace	(	signed char	low,
		signed char &	v,
		signed char	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

short& SimTK::clampInPlace	(	short	low,
		short &	v,
		short	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

int& SimTK::clampInPlace	(	int	low,
		int &	v,
		int	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

long& SimTK::clampInPlace	(	long	low,
		long &	v,
		long	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

long long& SimTK::clampInPlace	(	long long	low,
		long long &	v,
		long long	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

negator<float>& SimTK::clampInPlace	(	float	low,
		negator< float > &	v,
		float	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

negator<double>& SimTK::clampInPlace	(	double	low,
		negator< double > &	v,
		double	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

negator<long double>& SimTK::clampInPlace	(	long double	low,
		negator< long double > &	v,
		long double	high
	)

inline

Check that low <= v <= high and modify v in place if necessary to bring it into that range.

Parameters

[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.

Returns: A writable reference to the now-possibly-modified input variable v.

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.

double SimTK::clamp	(	double	low,
		double	v,
		double	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace()

float SimTK::clamp	(	float	low,
		float	v,
		float	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace()

long double SimTK::clamp	(	long double	low,
		long double	v,
		long double	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace()

double SimTK::clamp	(	int	low,
		double	v,
		int	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace() Takes integer bounds to avoid need for explicit casts.

float SimTK::clamp	(	int	low,
		float	v,
		int	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace() Takes integer bounds to avoid need for explicit casts.

long double SimTK::clamp	(	int	low,
		long double	v,
		int	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace() Takes integer bounds to avoid need for explicit casts.

double SimTK::clamp	(	int	low,
		double	v,
		double	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace() Takes an integer bound to avoid need for explicit casts.

float SimTK::clamp	(	int	low,
		float	v,
		float	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace() Takes an integer bound to avoid need for explicit casts.

long double SimTK::clamp	(	int	low,
		long double	v,
		long double	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace() Takes an integer bound to avoid need for explicit casts.

double SimTK::clamp	(	double	low,
		double	v,
		int	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace() Takes an integer bound to avoid need for explicit casts.

float SimTK::clamp	(	float	low,
		float	v,
		int	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace() Takes an integer bound to avoid need for explicit casts.

long double SimTK::clamp	(	long double	low,
		long double	v,
		int	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace() Takes an integer bound to avoid need for explicit casts.

unsigned char SimTK::clamp	(	unsigned char	low,
		unsigned char	v,
		unsigned char	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace()

unsigned short SimTK::clamp	(	unsigned short	low,
		unsigned short	v,
		unsigned short	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace()

unsigned int SimTK::clamp	(	unsigned int	low,
		unsigned int	v,
		unsigned int	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace()

unsigned long SimTK::clamp	(	unsigned long	low,
		unsigned long	v,
		unsigned long	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace()

unsigned long long SimTK::clamp	(	unsigned long long	low,
		unsigned long long	v,
		unsigned long long	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace()

char SimTK::clamp	(	char	low,
		char	v,
		char	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace()

signed char SimTK::clamp	(	signed char	low,
		signed char	v,
		signed char	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace()

short SimTK::clamp	(	short	low,
		short	v,
		short	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace()

int SimTK::clamp	(	int	low,
		int	v,
		int	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace()

long SimTK::clamp	(	long	low,
		long	v,
		long	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace()

long long SimTK::clamp	(	long long	low,
		long long	v,
		long long	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace()

float SimTK::clamp	(	float	low,
		negator< float >	v,
		float	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace() Explicitly takes a negator<float> argument to help the compiler find the right overload, but the negation is performed (1 extra flop) and the result type is an ordinary float.

double SimTK::clamp	(	double	low,
		negator< double >	v,
		double	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace() Explicitly takes a negator<double> argument to help the compiler find the right overload, but the negation is performed (1 extra flop) and the result type is an ordinary double.

long double SimTK::clamp	(	long double	low,
		negator< long double >	v,
		long double	high
	)

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.

Parameters

[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.

Returns: Either the value v or one of the bounds.

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.

Warning: Viewed as a function of the input value v, clamp(v) is not very smooth – it is continuous (C0) but even its first derivative is infinite at the bounds.

Cost: These are very fast, inline methods; the floating point ones use just two flops.

See also: clampInPlace() Explicitly takes a negator<long double> argument to help the compiler find the right overload, but the negation is performed (1 extra flop) and the result type is an ordinary long double.

Functions

Detailed Description

Function Documentation