Functions
template<class T >
const T &	csMax (const T &a, const T &b)

template<class T >
const T &	csMin (const T &a, const T &b)

template<class T >
void	csSort (T &a, T &b)

template<class T , class U >
void	csSort (T &a, T &b, U &x, U &y)

template<class T >
T	csClamp (const T &a, T max, T min)

template<class T >
T	csSmoothStep (const T &a, T max, T min)

template<class T , class Tfactor >
T	csLerp (const T &a, const T &b, const Tfactor &f)

template<class T >
T	csSquare (const T &x)

CS_FORCEINLINE bool	csFinite (float f)
	Checks if a floating point value is finite. More...

CS_FORCEINLINE bool	csFinite (double d)
	Checks if a double-precision floating point value is finite. More...

CS_FORCEINLINE bool	csNaN (float f)
	Checks if a floating point value is not-a-number. More...

CS_FORCEINLINE bool	csNaN (double d)
	Checks if a double-precision floating point value is not-a-number. More...

CS_FORCEINLINE bool	csNormal (float f)
	Checks if a floating point value is normal (not infinite or nan). More...

CS_FORCEINLINE bool	csNormal (double d)
	Checks if a double-precision floating point value is normal. More...

Detailed Description

Function Documentation

template<class T >

T csClamp	(	const T &	a,
		T	max,
		T	min
	)

Clamp a between max and min.

Definition at line 92 of file opmath.h.

References csMax(), and csMin().

 {
   return csMin (csMax (a, min), max);
 }

CS_FORCEINLINE bool csFinite ( float f)

Checks if a floating point value is finite.

Definition at line 139 of file opmath.h.

Referenced by csNormal().

 {
 #if defined (HAVE_FINITEF)
   return finitef (f);
 #elif defined (HAVE_STD__ISFINITE)
   return std::isfinite (f);
 #elif defined(HAVE_ISFINITE)
   return (isfinite (f));
 #elif defined (HAVE_FINITE)
   return finite (f);
 #elif defined (HAVE__FINITE)
   return _finite (f) != 0;
 #else
 #error Your platform has no isfinite()-alike function!
 #endif
 }

CS_FORCEINLINE bool csFinite ( double d)

Checks if a double-precision floating point value is finite.

Definition at line 156 of file opmath.h.

 {
 #if defined (HAVE_STD__ISFINITE)
   return std::isfinite (d);
 #elif defined(HAVE_ISFINITE)
   return isfinite (d);
 #elif defined (HAVE_FINITE)
   return finite (d);
 #elif defined (HAVE__FINITE)
   return _finite (d) != 0;
 #else
 #error Your platform has no isfinite()-alike function!
 #endif
 }

template<class T , class Tfactor >

T csLerp	(	const T &	a,
		const T &	b,
		const Tfactor &	f
	)

Performs a linear interpolation between a and b with the factor f.

Definition at line 123 of file opmath.h.

 {
   return (a + (b - a) * f);
 }

template<class T >

const T& csMax	(	const T &	a,
		const T &	b
	)

Returns bigger of a and b. If they are equal, a or b can be returned.

Definition at line 47 of file opmath.h.

References a, and b.

Referenced by csClamp(), and csTerrainSegmentCellCollider::csTerrainSegmentCellCollider().

 {
   if (b < a) return a;
   return b;
 }

template<class T >

const T& csMin	(	const T &	a,
		const T &	b
	)

Returns smaller of a and b. If they are equal, a or b can be returned.

Definition at line 57 of file opmath.h.

References a, and b.

Referenced by csClamp(), and csTerrainSegmentCellCollider::csTerrainSegmentCellCollider().

 {
   if (a < b) return a;
   return b;
 }

CS_FORCEINLINE bool csNaN ( float f)

Checks if a floating point value is not-a-number.

Definition at line 172 of file opmath.h.

Referenced by csNormal().

 {
 #if defined (HAVE_NANF)
   return isnanf (f);
 #elif defined (HAVE_STD__ISNAN)
   return std::isnan (f);
 #elif defined(HAVE_ISNAN)
   return isnan (f);
 #elif defined (HAVE__ISNAN)
   return _isnan (f) != 0;
 #else
 #error Your platform has no isnan()-alike function!
 #endif
 }

CS_FORCEINLINE bool csNaN ( double d)

Checks if a double-precision floating point value is not-a-number.

Definition at line 187 of file opmath.h.

 {
 #if defined (HAVE_STD__ISNAN)
   return std::isnan (d);
 #elif defined(HAVE_ISNAN)
   return isnan (d);
 #elif defined (HAVE__ISNAN)
   return _isnan (d) != 0;
 #else
 #error Your platform has no isnan()-alike function!
 #endif
 }

CS_FORCEINLINE bool csNormal ( float f)

Checks if a floating point value is normal (not infinite or nan).

Definition at line 201 of file opmath.h.

References csFinite(), and csNaN().

 {
 #if defined (HAVE_NORMALF)
   return normalf (f);
 #elif defined (HAVE_STD__ISNORMAL)
   return std::isnormal (f);
 #elif defined(HAVE_ISNORMAL)
   return isnormal (f);
 #else
   return csFinite(f) && !csNaN(f);
 #endif
 }

CS_FORCEINLINE bool csNormal ( double d)

Checks if a double-precision floating point value is normal.

Definition at line 214 of file opmath.h.

References csFinite(), and csNaN().

 {
 #if defined (HAVE_STD__ISNORMAL)
   return std::isnormal (d);
 #elif defined(HAVE_ISNORMAL)
   return isnormal (d);
 #else
   return csFinite(d) && !csNaN(d);
 #endif
 }

template<class T >

T csSmoothStep	(	const T &	a,
		T	max,
		T	min
	)

Performs a smooth interpolation of a on range min to max.

Returns: Smooth interporlated value if min < a < max, and 0 resp. 1 if a is smaller than min resp. larger than max.

Definition at line 103 of file opmath.h.

References min().

 {
   T tmp, tmp2;
   if (a <= min)
     tmp = 0.0f;
   else if (a >= max)
     tmp = 1.0f;
   else
   {
     tmp2 = (a - min) / (max-min);
     tmp = tmp2*tmp2 * (3.0 - 2.0*tmp2);
   }
   return tmp;
 }

template<class T >

void csSort	(	T &	a,
		T &	b
	)

Sort a and b in order of size.

Definition at line 67 of file opmath.h.

References CS::Swap().

 {
   if (b < a)
     CS::Swap (a, b);
 }

template<class T , class U >

void csSort	(	T &	a,
		T &	b,
		U &	x,
		U &	y
	)

Sort a and b in order of size. If swapping them, also swap x and y

Definition at line 78 of file opmath.h.

References CS::Swap().

 {
   if (b < a)
   {
     CS::Swap (a, b);
     CS::Swap (x, y);
   }
 }

template<class T >

T csSquare ( const T & x)

Returns the square of the argument

Definition at line 132 of file opmath.h.

References x.

 {
   return x * x;
 }

Functions

Detailed Description

Function Documentation