///////////////////////////////////////////////////////////////////////////

//

// Copyright (c) 2002-2012, Industrial Light & Magic, a division of Lucas

// Digital Ltd. LLC

// 

// All rights reserved.

// 

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

// *       Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

// *       Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

// *       Neither the name of Industrial Light & Magic nor the names of

// its contributors may be used to endorse or promote products derived

// from this software without specific prior written permission. 

// 

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

///////////////////////////////////////////////////////////////////////////

#ifndef INCLUDED_IMATHLIMITS_H

#define INCLUDED_IMATHLIMITS_H

//----------------------------------------------------------------

//

//	Limitations of the basic C++ numerical data types

//

//----------------------------------------------------------------

#include "ImathNamespace.h"

#include <float.h>

#include <limits.h>

//------------------------------------------

// In Windows, min and max are macros.  Yay.

//------------------------------------------

#if defined _WIN32 || defined _WIN64

    #ifdef min

        #undef min

    #endif

    #ifdef max

        #undef max

    #endif

#endif

IMATH_INTERNAL_NAMESPACE_HEADER_ENTER

//-----------------------------------------------------------------

//

// Template class limits<T> returns information about the limits

// of numerical data type T:

//

//	min()		largest possible negative value of type T

//

//	max()		largest possible positive value of type T

//

//	smallest()	smallest possible positive value of type T

//			(for float and double: smallest normalized

//			positive value)

//

//	epsilon()	smallest possible e of type T, for which

//			1 + e != 1

//

//	isIntegral()	returns true if T is an integral type

//

//	isSigned()	returns true if T is signed

//

// Class limits<T> is useful to implement template classes or

// functions which depend on the limits of a numerical type

// which is not known in advance; for example:

//

//	template <class T> max (T x[], int n)

//	{

//	    T m = limits<T>::min();

//

//	    for (int i = 0; i < n; i++)

//		if (m < x[i])

//		    m = x[i];

//

//	    return m;

//	}

//

// Class limits<T> has been implemented for the following types:

//

//	char, signed char, unsigned char

//	short, unsigned short

//	int, unsigned int

//	long, unsigned long

//	float

//	double

//	long double

//

// Class limits<T> has only static member functions, all of which

// are implemented as inlines.  No objects of type limits<T> are

// ever created.

//

//-----------------------------------------------------------------

template <class T> struct limits

{

    static T	min();

    static T	max();

    static T	smallest();

    static T	epsilon();

    static bool	isIntegral();

    static bool	isSigned();

};

//---------------

// Implementation

//---------------

template <>

struct limits <char>

{

    static char			min()		{return CHAR_MIN;}

    static char			max()		{return CHAR_MAX;}

    static char			smallest()	{return 1;}

    static char			epsilon()	{return 1;}

    static bool			isIntegral()	{return true;}

    static bool			isSigned()	{return (char) ~0 < 0;}

};

template <>

struct limits <signed char>

{

    static signed char		min()		{return SCHAR_MIN;}

    static signed char		max()		{return SCHAR_MAX;}

    static signed char		smallest()	{return 1;}

    static signed char		epsilon()	{return 1;}

    static bool			isIntegral()	{return true;}

    static bool			isSigned()	{return true;}

};

template <>

struct limits <unsigned char>

{

    static unsigned char	min()		{return 0;}

    static unsigned char	max()		{return UCHAR_MAX;}

    static unsigned char	smallest()	{return 1;}

    static unsigned char	epsilon()	{return 1;}

    static bool			isIntegral()	{return true;}

    static bool			isSigned()	{return false;}

};

template <>

struct limits <short>

{

    static short		min()		{return SHRT_MIN;}

    static short		max()		{return SHRT_MAX;}

    static short		smallest()	{return 1;}

    static short		epsilon()	{return 1;}

    static bool			isIntegral()	{return true;}

    static bool			isSigned()	{return true;}

};

template <>

struct limits <unsigned short>

{

    static unsigned short	min()		{return 0;}

    static unsigned short	max()		{return USHRT_MAX;}

    static unsigned short	smallest()	{return 1;}

    static unsigned short	epsilon()	{return 1;}

    static bool			isIntegral()	{return true;}

    static bool			isSigned()	{return false;}

};

template <>

struct limits <int>

{

    static int			min()		{return INT_MIN;}

    static int			max()		{return INT_MAX;}

    static int			smallest()	{return 1;}

    static int			epsilon()	{return 1;}

    static bool			isIntegral()	{return true;}

    static bool			isSigned()	{return true;}

};

template <>

struct limits <unsigned int>

{

    static unsigned int		min()		{return 0;}

    static unsigned int		max()		{return UINT_MAX;}

    static unsigned int		smallest()	{return 1;}

    static unsigned int		epsilon()	{return 1;}

    static bool			isIntegral()	{return true;}

    static bool			isSigned()	{return false;}

};

template <>

struct limits <long>

{

    static long			min()		{return LONG_MIN;}

    static long			max()		{return LONG_MAX;}

    static long			smallest()	{return 1;}

    static long			epsilon()	{return 1;}

    static bool			isIntegral()	{return true;}

    static bool			isSigned()	{return true;}

};

template <>

struct limits <unsigned long>

{

    static unsigned long	min()		{return 0;}

    static unsigned long	max()		{return ULONG_MAX;}

    static unsigned long	smallest()	{return 1;}

    static unsigned long	epsilon()	{return 1;}

    static bool			isIntegral()	{return true;}

    static bool			isSigned()	{return false;}

};

template <>

struct limits <float>

{

    static float		min()		{return -FLT_MAX;}

    static float		max()		{return FLT_MAX;}

    static float		smallest()	{return FLT_MIN;}

    static float		epsilon()	{return FLT_EPSILON;}

    static bool			isIntegral()	{return false;}

    static bool			isSigned()	{return true;}

};

template <>

struct limits <double>

{

    static double		min()		{return -DBL_MAX;}

    static double		max()		{return DBL_MAX;}

    static double		smallest()	{return DBL_MIN;}

    static double		epsilon()	{return DBL_EPSILON;}

    static bool			isIntegral()	{return false;}

    static bool			isSigned()	{return true;}

};

template <>

struct limits <long double>

{

    static long double		min()		{return -LDBL_MAX;}

    static long double		max()		{return LDBL_MAX;}

    static long double		smallest()	{return LDBL_MIN;}

    static long double		epsilon()	{return LDBL_EPSILON;}

    static bool			isIntegral()	{return false;}

    static bool			isSigned()	{return true;}

};

IMATH_INTERNAL_NAMESPACE_HEADER_EXIT

#endif // INCLUDED_IMATHLIMITS_H