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.
float &	SimTK::clampInPlace (float low, float &v, float high)
long double &	SimTK::clampInPlace (long double low, long double &v, long double high)
double &	SimTK::clampInPlace (int low, double &v, int high)
float &	SimTK::clampInPlace (int low, float &v, int high)
long double &	SimTK::clampInPlace (int low, long double &v, int high)
double &	SimTK::clampInPlace (int low, double &v, double high)
float &	SimTK::clampInPlace (int low, float &v, float high)
long double &	SimTK::clampInPlace (int low, long double &v, long double high)
double &	SimTK::clampInPlace (double low, double &v, int high)
float &	SimTK::clampInPlace (float low, float &v, int high)
long double &	SimTK::clampInPlace (long double low, long double &v, int high)
unsigned char &	SimTK::clampInPlace (unsigned char low, unsigned char &v, unsigned char high)
unsigned short &	SimTK::clampInPlace (unsigned short low, unsigned short &v, unsigned short high)
unsigned int &	SimTK::clampInPlace (unsigned int low, unsigned int &v, unsigned int high)
unsigned long &	SimTK::clampInPlace (unsigned long low, unsigned long &v, unsigned long high)
unsigned long long &	SimTK::clampInPlace (unsigned long long low, unsigned long long &v, unsigned long long high)
char &	SimTK::clampInPlace (char low, char &v, char high)
signed char &	SimTK::clampInPlace (signed char low, signed char &v, signed char high)
short &	SimTK::clampInPlace (short low, short &v, short high)
int &	SimTK::clampInPlace (int low, int &v, int high)
long &	SimTK::clampInPlace (long low, long &v, long high)
long long &	SimTK::clampInPlace (long long low, long long &v, long long high)
negator< float > &	SimTK::clampInPlace (float low, negator< float > &v, float high)
negator< double > &	SimTK::clampInPlace (double low, negator< double > &v, double high)
negator< long double > &	SimTK::clampInPlace (long double low, negator< long double > &v, long double high)
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.
float	SimTK::clamp (float low, float v, float high)
long double	SimTK::clamp (long double low, long double v, long double high)
double	SimTK::clamp (int low, double v, int high)
float	SimTK::clamp (int low, float v, int high)
long double	SimTK::clamp (int low, long double v, int high)
double	SimTK::clamp (int low, double v, double high)
float	SimTK::clamp (int low, float v, float high)
long double	SimTK::clamp (int low, long double v, long double high)
double	SimTK::clamp (double low, double v, int high)
float	SimTK::clamp (float low, float v, int high)
long double	SimTK::clamp (long double low, long double v, int high)
unsigned char	SimTK::clamp (unsigned char low, unsigned char v, unsigned char high)
unsigned short	SimTK::clamp (unsigned short low, unsigned short v, unsigned short high)
unsigned int	SimTK::clamp (unsigned int low, unsigned int v, unsigned int high)
unsigned long	SimTK::clamp (unsigned long low, unsigned long v, unsigned long high)
unsigned long long	SimTK::clamp (unsigned long long low, unsigned long long v, unsigned long long high)
char	SimTK::clamp (char low, char v, char high)
signed char	SimTK::clamp (signed char low, signed char v, signed char high)
short	SimTK::clamp (short low, short v, short high)
int	SimTK::clamp (int low, int v, int high)
long	SimTK::clamp (long low, long v, long high)
long long	SimTK::clamp (long long low, long long v, long long high)
float	SimTK::clamp (float low, negator< float > v, float high)
double	SimTK::clamp (double low, negator< double > v, double high)
long double	SimTK::clamp (long double low, negator< long double > v, long double high)

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

clamp(), clampInPlace()

Functions

Detailed Description

Function Documentation