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

//

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