// limits standard header
#ifndef _LIMITS_
#define _LIMITS_

#pragma info(none)
#ifndef __CHKHDR__
#  pragma report(level, E)
#endif
#pragma info(restore)

#if __IBMCPP__ < 400
#error This file to be used only with IBM VisualAge C++ v4 and later compilers.
#endif /* __IBMCPP__ */

#pragma namemangling(ansi)

   /********************************************************************/
   /*  <limits> header file                                            */
   /*                                                                  */
   /*  VisualAge C++, Version 4.0                                      */
   /*    Licensed Material - Property of IBM                           */
   /*                                                                  */
   /*  5801-AAR and Other Materials                                    */
   /*                                                                  */
   /*  (c) Copyright IBM Corp 1991, 1998. All rights reserved.         */
   /*                                                                  */
   /*                                                                  */
   /*  Licensed Materials.                                             */
   /*                                                                  */
   /*  Dinkum C++ Library                                              */
   /*  Copyright (c) 1998.  Licensed to IBM Corp. and its suppliers.   */
   /*                                                                  */
   /********************************************************************/

#include <ymath.h>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cwchar>
#include <xstddef>

#ifdef __TOS_AIX__
#include <limits>
#ifdef _AIX43
#include <wchar.h>
#else
#include <ansic_aix.h>
#endif /* _AIX43 */
#endif /* __TOS_AIX__ */

//	ASSUMES:
//	wraparound 2's complement integer arithmetic w/o traps
//	all CHAR_BITs of each byte used by integers
//	IEC559 (IEEE 754) floating-point arithmetic
//	floating-point errors can trap
//	tinyness detected before floating-point rounding
_STD_BEGIN
		// ENUM float_denorm_style
typedef enum {
	denorm_indeterminate = -1, denorm_absent = 0,
	denorm_present = 1} float_denorm_style;
		// ENUM float_round_style
typedef enum {
	round_indeterminate = -1, round_toward_zero = 0,
	round_to_nearest = 1, round_toward_infinity = 2,
	round_toward_neg_infinity = 3} float_round_style;
		// STRUCT _Num_base
struct _CXX_IMPORT _Num_base {
	_STCONS(float_denorm_style, has_denorm, denorm_absent);
	_STCONS(bool, has_denorm_loss, false);
	_STCONS(bool, has_infinity, false);
	_STCONS(bool, has_quiet_NaN, false);
	_STCONS(bool, has_signaling_NaN, false);
	_STCONS(bool, is_bounded, false);
	_STCONS(bool, is_exact, false);
	_STCONS(bool, is_iec559, false);
	_STCONS(bool, is_integer, false);
	_STCONS(bool, is_modulo, false);
	_STCONS(bool, is_signed, false);
	_STCONS(bool, is_specialized, false);
	_STCONS(bool, tinyness_before, false);
	_STCONS(bool, traps, false);
	_STCONS(float_round_style, round_style, round_toward_zero);
	_STCONS(int, digits, 0);
	_STCONS(int, digits10, 0);
	_STCONS(int, max_exponent, 0);
	_STCONS(int, max_exponent10, 0);
	_STCONS(int, min_exponent, 0);
	_STCONS(int, min_exponent10, 0);
	_STCONS(int, radix, 0);
	};
		// TEMPLATE CLASS numeric_limits
template<class _Ty>
class _CXX_IMPORT numeric_limits : public _Num_base {
public:
	static _Ty (min)() _THROW0()
		{return (_Ty(0)); }
	static _Ty (max)() _THROW0()
		{return (_Ty(0)); }
	static _Ty epsilon() _THROW0()
		{return (_Ty(0)); }
	static _Ty round_error() _THROW0()
		{return (_Ty(0)); }
	static _Ty denorm_min() _THROW0()
		{return (_Ty(0)); }
	static _Ty infinity() _THROW0()
		{return (_Ty(0)); }
	static _Ty quiet_NaN() _THROW0()
		{return (_Ty(0)); }
	static _Ty signaling_NaN() _THROW0()
		{return (_Ty(0)); }
	};
		// STRUCT _Num_int_base
struct _CXX_IMPORT _Num_int_base : public _Num_base {
	_STCONS(bool, is_bounded, true);
	_STCONS(bool, is_exact, true);
	_STCONS(bool, is_integer, true);
	_STCONS(bool, is_modulo, true);
	_STCONS(bool, is_specialized, true);
	_STCONS(int, radix, 2);
	};
		// STRUCT _Num_float_base
struct _CXX_IMPORT _Num_float_base : public _Num_base {
	_STCONS(float_denorm_style, has_denorm, denorm_present);
	_STCONS(bool, has_denorm_loss, true);
	_STCONS(bool, has_infinity, true);
	_STCONS(bool, has_quiet_NaN, true);
	_STCONS(bool, has_signaling_NaN, true);
	_STCONS(bool, is_bounded, true);
	_STCONS(bool, is_exact, false);
	_STCONS(bool, is_iec559, true);
	_STCONS(bool, is_integer, false);
	_STCONS(bool, is_modulo, false);
	_STCONS(bool, is_signed, true);
	_STCONS(bool, is_specialized, true);
	_STCONS(bool, tinyness_before, true);
	_STCONS(bool, traps, true);
	_STCONS(float_round_style, round_style, round_to_nearest);
	_STCONS(int, radix, FLT_RADIX);
	};
		// CLASS numeric_limits<char>
template<>
class _CXX_IMPORT numeric_limits<char>
	: public _Num_int_base {
public:
	typedef char _Ty;
	static _Ty (min)() _THROW0()
		{return (CHAR_MIN); }
	static _Ty (max)() _THROW0()
		{return (CHAR_MAX); }
	static _Ty epsilon() _THROW0()
		{return (0); }
	static _Ty round_error() _THROW0()
		{return (0); }
	static _Ty denorm_min() _THROW0()
		{return (0); }
	static _Ty infinity() _THROW0()
		{return (0); }
	static _Ty quiet_NaN() _THROW0()
		{return (0); }
	static _Ty signaling_NaN() _THROW0()
		{return (0); }
	_STCONS(bool, is_signed, CHAR_MIN < 0);
	_STCONS(int, digits, CHAR_BIT - (CHAR_MIN < 0 ? 1 : 0));
	_STCONS(int, digits10, (CHAR_BIT - (CHAR_MIN < 0 ? 1 : 0))
		* 301L / 1000);
	};
		// CLASS numeric_limits<wchar_t>
template<>
class _CXX_IMPORT numeric_limits<wchar_t>
	: public _Num_int_base {
public:
	typedef wchar_t _Ty;
	static _Ty (min)() _THROW0()
		{return (WCHAR_MIN); }
	static _Ty (max)() _THROW0()
		{return (WCHAR_MAX); }
	static _Ty epsilon() _THROW0()
		{return (0); }
	static _Ty round_error() _THROW0()
		{return (0); }
	static _Ty denorm_min() _THROW0()
		{return (0); }
	static _Ty infinity() _THROW0()
		{return (0); }
	static _Ty quiet_NaN() _THROW0()
		{return (0); }
	static _Ty signaling_NaN() _THROW0()
		{return (0); }
	_STCONS(bool, is_signed, WCHAR_MIN < 0);
	_STCONS(int, digits, CHAR_BIT * sizeof (wchar_t)
		- (WCHAR_MIN < 0 ? 1 : 0));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (wchar_t)
		- (WCHAR_MIN < 0 ? 1 : 0)) * 301L / 1000);
	};
		// CLASS numeric_limits<_Bool>
template<>
class _CXX_IMPORT numeric_limits<_Bool>
	: public _Num_int_base {
public:
	typedef bool _Ty;
	static _Ty (min)() _THROW0()
		{return (false); }
	static _Ty (max)() _THROW0()
		{return (true); }
	static _Ty epsilon() _THROW0()
		{return (0); }
	static _Ty round_error() _THROW0()
		{return (0); }
	static _Ty denorm_min() _THROW0()
		{return (0); }
	static _Ty infinity() _THROW0()
		{return (0); }
	static _Ty quiet_NaN() _THROW0()
		{return (0); }
	static _Ty signaling_NaN() _THROW0()
		{return (0); }
	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, 1);
	_STCONS(int, digits10, 0);
	};
		// CLASS numeric_limits<signed char>
template<>
class _CXX_IMPORT numeric_limits<signed char>
	: public _Num_int_base {
public:
	typedef signed char _Ty;
	static _Ty (min)() _THROW0()
		{return (SCHAR_MIN); }
	static _Ty (max)() _THROW0()
		{return (SCHAR_MAX); }
	static _Ty epsilon() _THROW0()
		{return (0); }
	static _Ty round_error() _THROW0()
		{return (0); }
	static _Ty denorm_min() _THROW0()
		{return (0); }
	static _Ty infinity() _THROW0()
		{return (0); }
	static _Ty quiet_NaN() _THROW0()
		{return (0); }
	static _Ty signaling_NaN() _THROW0()
		{return (0); }
	_STCONS(bool, is_signed, true);
	_STCONS(int, digits, CHAR_BIT - 1);
	_STCONS(int, digits10, (CHAR_BIT - 1) * 301L / 1000);
	};
		// CLASS numeric_limits<unsigned char>
template<>
class _CXX_IMPORT numeric_limits<unsigned char>
	: public _Num_int_base {
public:
	typedef unsigned char _Ty;
	static _Ty (min)() _THROW0()
		{return (0); }
	static _Ty (max)() _THROW0()
		{return (UCHAR_MAX); }
	static _Ty epsilon() _THROW0()
		{return (0); }
	static _Ty round_error() _THROW0()
		{return (0); }
	static _Ty denorm_min() _THROW0()
		{return (0); }
	static _Ty infinity() _THROW0()
		{return (0); }
	static _Ty quiet_NaN() _THROW0()
		{return (0); }
	static _Ty signaling_NaN() _THROW0()
		{return (0); }
	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT);
	_STCONS(int, digits10, (CHAR_BIT) * 301L / 1000);
	};
		// CLASS numeric_limits<short>
template<>
class _CXX_IMPORT numeric_limits<short>
	: public _Num_int_base {
public:
	typedef short _Ty;
	static _Ty (min)() _THROW0()
		{return (SHRT_MIN); }
	static _Ty (max)() _THROW0()
		{return (SHRT_MAX); }
	static _Ty epsilon() _THROW0()
		{return (0); }
	static _Ty round_error() _THROW0()
		{return (0); }
	static _Ty denorm_min() _THROW0()
		{return (0); }
	static _Ty infinity() _THROW0()
		{return (0); }
	static _Ty quiet_NaN() _THROW0()
		{return (0); }
	static _Ty signaling_NaN() _THROW0()
		{return (0); }
	_STCONS(bool, is_signed, true);
	_STCONS(int, digits, CHAR_BIT * sizeof (short) - 1);
	_STCONS(int, digits10, (CHAR_BIT * sizeof (short) - 1)
		* 301L / 1000);
	};
		// CLASS numeric_limits<unsigned short>
template<>
class _CXX_IMPORT numeric_limits<unsigned short>
	: public _Num_int_base {
public:
	typedef unsigned short _Ty;
	static _Ty (min)() _THROW0()
		{return (0); }
	static _Ty (max)() _THROW0()
		{return (USHRT_MAX); }
	static _Ty epsilon() _THROW0()
		{return (0); }
	static _Ty round_error() _THROW0()
		{return (0); }
	static _Ty denorm_min() _THROW0()
		{return (0); }
	static _Ty infinity() _THROW0()
		{return (0); }
	static _Ty quiet_NaN() _THROW0()
		{return (0); }
	static _Ty signaling_NaN() _THROW0()
		{return (0); }
	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT * sizeof (unsigned short));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned short))
		* 301L / 1000);
	};
		// CLASS numeric_limits<int>
template<>
class _CXX_IMPORT numeric_limits<int>
	: public _Num_int_base {
public:
	typedef int _Ty;
	static _Ty (min)() _THROW0()
		{return (INT_MIN); }
	static _Ty (max)() _THROW0()
		{return (INT_MAX); }
	static _Ty epsilon() _THROW0()
		{return (0); }
	static _Ty round_error() _THROW0()
		{return (0); }
	static _Ty denorm_min() _THROW0()
		{return (0); }
	static _Ty infinity() _THROW0()
		{return (0); }
	static _Ty quiet_NaN() _THROW0()
		{return (0); }
	static _Ty signaling_NaN() _THROW0()
		{return (0); }
	_STCONS(bool, is_signed, true);
	_STCONS(int, digits, CHAR_BIT * sizeof (int) - 1);
	_STCONS(int, digits10, (CHAR_BIT * sizeof (int) - 1)
		* 301L / 1000);
	};
		// CLASS numeric_limits<unsigned int>
template<>
class _CXX_IMPORT numeric_limits<unsigned int>
	: public _Num_int_base {
public:
	typedef unsigned int _Ty;
	static _Ty (min)() _THROW0()
		{return (0); }
	static _Ty (max)() _THROW0()
		{return (UINT_MAX); }
	static _Ty epsilon() _THROW0()
		{return (0); }
	static _Ty round_error() _THROW0()
		{return (0); }
	static _Ty denorm_min() _THROW0()
		{return (0); }
	static _Ty infinity() _THROW0()
		{return (0); }
	static _Ty quiet_NaN() _THROW0()
		{return (0); }
	static _Ty signaling_NaN() _THROW0()
		{return (0); }
	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT * sizeof (unsigned int));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned int))
		* 301L / 1000);
	};
		// CLASS numeric_limits<long>
template<>
class _CXX_IMPORT numeric_limits<long>
	: public _Num_int_base {
public:
	typedef long _Ty;
	static _Ty (min)() _THROW0()
		{return (LONG_MIN); }
	static _Ty (max)() _THROW0()
		{return (LONG_MAX); }
	static _Ty epsilon() _THROW0()
		{return (0); }
	static _Ty round_error() _THROW0()
		{return (0); }
	static _Ty denorm_min() _THROW0()
		{return (0); }
	static _Ty infinity() _THROW0()
		{return (0); }
	static _Ty quiet_NaN() _THROW0()
		{return (0); }
	static _Ty signaling_NaN() _THROW0()
		{return (0); }
	_STCONS(bool, is_signed, true);
	_STCONS(int, digits, CHAR_BIT * sizeof (long) - 1);
	_STCONS(int, digits10, (CHAR_BIT * sizeof (long) - 1)
		* 301L / 1000);
	};
		// CLASS numeric_limits<unsigned long>
template<>
class _CXX_IMPORT numeric_limits<unsigned long>
	: public _Num_int_base {
public:
	typedef unsigned long _Ty;
	static _Ty (min)() _THROW0()
		{return (0); }
	static _Ty (max)() _THROW0()
		{return (ULONG_MAX); }
	static _Ty epsilon() _THROW0()
		{return (0); }
	static _Ty round_error() _THROW0()
		{return (0); }
	static _Ty denorm_min() _THROW0()
		{return (0); }
	static _Ty infinity() _THROW0()
		{return (0); }
	static _Ty quiet_NaN() _THROW0()
		{return (0); }
	static _Ty signaling_NaN() _THROW0()
		{return (0); }
	_STCONS(bool, is_signed, false);
	_STCONS(int, digits, CHAR_BIT * sizeof (unsigned long));
	_STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned long))
		* 301L / 1000);
	};
		// CLASS numeric_limits<float>
template<>
class _CXX_IMPORT numeric_limits<float>
	: public _Num_float_base {
public:
	typedef float _Ty;
	static _Ty (min)() _THROW0()
		{return (FLT_MIN); }
	static _Ty (max)() _THROW0()
		{return (FLT_MAX); }
	static _Ty epsilon() _THROW0()
		{return (FLT_EPSILON); }
	static _Ty round_error() _THROW0()
		{return (0.5); }
	static _Ty denorm_min() _THROW0()
		{return (_FDenorm._F); }
	static _Ty infinity() _THROW0()
		{return (_FInf._F); }
	static _Ty quiet_NaN() _THROW0()
		{return (_FNan._F); }
	static _Ty signaling_NaN() _THROW0()
		{return (_FSnan._F); }
	_STCONS(int, digits, FLT_MANT_DIG);
	_STCONS(int, digits10, FLT_DIG);
	_STCONS(int, max_exponent, FLT_MAX_EXP);
	_STCONS(int, max_exponent10, FLT_MAX_10_EXP);
	_STCONS(int, min_exponent, FLT_MIN_EXP);
	_STCONS(int, min_exponent10, FLT_MIN_10_EXP);
	};
		// CLASS numeric_limits<double>
template<>
class _CXX_IMPORT numeric_limits<double>
	: public _Num_float_base {
public:
	typedef double _Ty;
	static _Ty (min)() _THROW0()
		{return (DBL_MIN); }
	static _Ty (max)() _THROW0()
		{return (DBL_MAX); }
	static _Ty epsilon() _THROW0()
		{return (DBL_EPSILON); }
	static _Ty round_error() _THROW0()
		{return (0.5); }
	static _Ty denorm_min() _THROW0()
		{return (_Denorm._D); }
	static _Ty infinity() _THROW0()
		{return (_Inf._D); }
	static _Ty quiet_NaN() _THROW0()
		{return (_Nan._D); }
	static _Ty signaling_NaN() _THROW0()
		{return (_Snan._D); }
	_STCONS(int, digits, DBL_MANT_DIG);
	_STCONS(int, digits10, DBL_DIG);
	_STCONS(int, max_exponent, DBL_MAX_EXP);
	_STCONS(int, max_exponent10, DBL_MAX_10_EXP);
	_STCONS(int, min_exponent, DBL_MIN_EXP);
	_STCONS(int, min_exponent10, DBL_MIN_10_EXP);
	};
		// CLASS numeric_limits<long double>
template<>
class _CXX_IMPORT numeric_limits<long double>
	: public _Num_float_base {
public:
	typedef long double _Ty;
	static _Ty (min)() _THROW0()
		{return (LDBL_MIN); }
	static _Ty (max)() _THROW0()
		{return (LDBL_MAX); }
	static _Ty epsilon() _THROW0()
		{return (LDBL_EPSILON); }
	static _Ty round_error() _THROW0()
		{return (0.5); }
	static _Ty denorm_min() _THROW0()
		{return (_LDenorm._L); }
	static _Ty infinity() _THROW0()
		{return (_LInf._L); }
	static _Ty quiet_NaN() _THROW0()
		{return (_LNan._L); }
	static _Ty signaling_NaN() _THROW0()
		{return (_LSnan._L); }
	_STCONS(int, digits, LDBL_MANT_DIG);
	_STCONS(int, digits10, LDBL_DIG);

#ifdef __TOS_AIX__
      #undef     LDBL_MAX_EXP
      #define    LDBL_MAX_EXP    DBL_MAX_EXP
      #undef     LDBL_MAX_10_EXP
      #define    LDBL_MAX_10_EXP DBL_MAX_10_EXP
      #undef     LDBL_MIN_EXP
      #define    LDBL_MIN_EXP    DBL_MIN_EXP
      #undef     LDBL_MIN_10_EXP
      #define    LDBL_MIN_10_EXP DBL_MIN_10_EXP
#endif

	_STCONS(int, max_exponent, LDBL_MAX_EXP);
	_STCONS(int, max_exponent10, LDBL_MAX_10_EXP);
	_STCONS(int, min_exponent, LDBL_MIN_EXP);
	_STCONS(int, min_exponent10, LDBL_MIN_10_EXP);
	};
_STD_END

#pragma namemangling()

#pragma info(none)
#ifndef __CHKHDR__
#  pragma report(pop)
#endif
#pragma info(restore)

#endif /* _LIMITS_ */

/*
 * Copyright (c) 1995 by P.J. Plauger.  ALL RIGHTS RESERVED. 
 * Consult your license regarding permissions and restrictions.
V2.2:0081 */
