# Maximum/minimum values of int, double, long, etc....

I am often writing optimization routines that either start or are toggled off of extremum values of various datatypes. Are there any globally-defined max/min values for the various types (int, long...). For example, coming from Java, there exist things like Double.MAX_VALUE that start you off at the upper limit of double.

I realize of course I could look through a book, remember how many bits are in a long, and do the binary arithmetic, but the Java approach or something like it seems preferable.
###### Who is Participating?

x
I wear a lot of hats...

"The solutions and answers provided on Experts Exchange have been extremely helpful to me over the last few years. I wear a lot of hats - Developer, Database Administrator, Help Desk, etc., so I know a lot of things but not a lot about one thing. Experts Exchange gives me answers from people who do know a lot about one thing, in a easy to use platform." -Todd S.

Commented:
yes... it's in <limits.h>

{CHAR_BIT}
Number of bits in a type char.
[CX]  Value: 8
{CHAR_MAX}
Maximum value of type char.
Value: {UCHAR_MAX} or {SCHAR_MAX}
{CHAR_MIN}
Minimum value of type char.
Value: {SCHAR_MIN} or 0
{INT_MAX}
Maximum value of an int.
Minimum Acceptable Value: 2 147 483 647
{LONG_BIT}
[XSI]
Number of bits in a long.
Minimum Acceptable Value: 32
{LONG_MAX}
Maximum value of a long.
Minimum Acceptable Value: +2 147 483 647
{MB_LEN_MAX}
Maximum number of bytes in a character, for any supported locale.
Minimum Acceptable Value: 1
{SCHAR_MAX}
Maximum value of type signed char.
[CX]  Value: +127
{SHRT_MAX}
Maximum value of type short.
Minimum Acceptable Value: +32 767
{SSIZE_MAX}
Maximum value of an object of type ssize_t.
Minimum Acceptable Value: {_POSIX_SSIZE_MAX}
{UCHAR_MAX}
Maximum value of type unsigned char.
[CX]  Value: 255
{UINT_MAX}
Maximum value of type unsigned.
Minimum Acceptable Value: 4 294 967 295
{ULONG_MAX}
Maximum value of type unsigned long.
Minimum Acceptable Value: 4 294 967 295
{USHRT_MAX}
Maximum value for a type unsigned short.
Minimum Acceptable Value: 65 535
{WORD_BIT}
[XSI]
Number of bits in a word or type int.
Minimum Acceptable Value: 16
{INT_MIN}
Minimum value of type int.
Maximum Acceptable Value: -2 147 483 647
{LONG_MIN}
Minimum value of type long.
Maximum Acceptable Value: -2 147 483 647
{SCHAR_MIN}
Minimum value of type signed char.
[CX]  Value: -128
{SHRT_MIN}
Minimum value of type short.
Maximum Acceptable Value: -32 767
{LLONG_MIN}
Minimum value of type long long.
Maximum Acceptable Value: -9223372036854775807
{LLONG_MAX}
Maximum value of type long long.
Minimum Acceptable Value: +9223372036854775807
{ULLONG_MAX}
Maximum value of type unsigned long long.
Minimum Acceptable Value: 18446744073709551615

for more: http://www.opengroup.org/onlinepubs/007904975/basedefs/limits.h.html
0

Experts Exchange Solution brought to you by

Facing a tech roadblock? Get the help and guidance you need from experienced professionals who care. Ask your question anytime, anywhere, with no hassle.

Author Commented:
Thanks for the response.

However...
There seems to be no limit on doubles however. Wha'ts up with that?
0
Author Commented:
Thanks for the response.

However...
There seems to be no limit on doubles however. Wha'ts up with that?
0
Commented:
> There seems to be no limit on doubles however. Wha'ts up with that?

There is no limit on floats and doubles.  The IEEE 754 float and double encodings
can represent numbers in the range +/- Infinity (with limited precision).

http://www.psc.edu/general/software/packages/ieee/ieee.html

0
Author Commented:
So that raises the corollary question: how do you express infinity?

Or is there no way to do so? Do doubles just wrap around when incremented beyond their max?
0
Commented:
If you had followed the hyperlink I gave, it shows exactly how
infinity is expressed.  You will also notice that it doesn't "wrap" as
you expect.

0
Author Commented:
Idid follow the link, and it gives precisely the information that my question stated I did not want to deal with. Knowing how infinity is represented bitwise in some IEEE document does precious little good when coding in C++. In any case, I'll take the answer as 'no', there is no way to compactly represent the maximal value of a double in C.
0
Commented:
limits.h is inherited from C.  The corresponding header file for floating-point numbers is float.h.  C++ adds a different header file <limits>.  The numeric_limits template class in that header file gives you a lot of information about various types.  For example, the smallest float value would be numeric_limits<float>::min().

For details, see:

The IEEE standard for floating point numbers does have special values for positive infinity, negative infinity, and "not a number," but the number of different values it can represent is certainly finite.

--efn
0
Commented:
> Knowing how infinity is represented bitwise in some IEEE document
> does precious little good when coding in C++. In any case, I'll take
> the answer as 'no', there is no way to compactly represent the
> maximal value of a double in C.

Actually, it has everything to do with coding in C++, since that is
how C/C++ represents floating point numbers.  I'm still not sure
what you are looking for.  I think what you want is in math.h.

To set a float to infinity:
float f = INFINITY;

To test if float is infinity:
if (isinf(f)) ...

To test if float is finite:
if (isfinite(f)) ...

To test if float is NaN (Not a Number)
if (isnan(f)) ...

To set a float to NaN:
float f = NAN;
0
Commented:
To answer the original question more specifically than I did before, yes, there are functions similar to the Java functions.  There is a function is_bounded in the numeric_limits template class that returns a bool that tells you whether the type has a bounded set of representable values.  It returns true for all predefined types.  If numeric_limits<x>::is_bounded() is true for a type x, then numeric_limits<x>::max() returns the largest finite value the type can store, and numeric_limits<x>::min() returns the lowest finite value for the type.  There is also another function is_signed(), and min() also works if both is_bounded() and is_signed() are false.

--efn
0
Commented:
No comment has been added lately, so it's time to clean up this question.
I will leave the following recommendation for this question in the Cleanup topic area:

Split: bobbit31 {http:#9659283} & efn {http:#9661227} & brettmjohnson {http:#9662220}