Negative infinity

[better_cs_now]

Hello all,

I'd like to get the negative value of largest possible magnitude for a
float. I've considered:

-numeric_limits< float>::max()

and

-numeric_limits< float>::infinit y()

Are either of these correct? If not, how may I accomplish my goal?

Thanks,
Dave

[Noah Roberts]

be***********@y ahoo.com wrote:

Hello all,

I'd like to get the negative value of largest possible magnitude for a
float. I've considered:

-numeric_limits< float>::max()

and

-numeric_limits< float>::infinit y()

Are either of these correct? If not, how may I accomplish my goal?

Seems like min() would do it and be more meaningful.

[better_cs_now]

Unfortunately, min() returns the positive value of smallest magnitude,
not the negative value of largest magnitude (which is what I want).

[Noah Roberts]

be***********@y ahoo.com wrote:

Unfortunately, min() returns the positive value of smallest magnitude,
not the negative value of largest magnitude (which is what I want).

Eek, so it does.

max() is probably better then because it will work so long as
is_bounded != false and I think this more likely than has_infinity !=
false. Can't think of a case when either is false but there appears to
be less restrictions on max() so use it.

[better_cs_now]

Noah Roberts wrote:

be***********@y ahoo.com wrote:

Unfortunately, min() returns the positive value of smallest magnitude,
not the negative value of largest magnitude (which is what I want).

Eek, so it does.

max() is probably better then because it will work so long as
is_bounded != false and I think this more likely than has_infinity !=
false. Can't think of a case when either is false but there appears to
be less restrictions on max() so use it.

Hmmm, this takes us back to the original question of whether the
following is well-formed code according to the C++ Standard:

float num := -numeric_limits< float>::max(); // Note the minus sign

Is the value I'm trying to assign to num above always representable and
legal on a standards-conforming compiler?

[Robert Mabee]

be***********@y ahoo.com wrote:

float num := -numeric_limits< float>::max(); // Note the minus sign

Is the value I'm trying to assign to num above always representable and
legal on a standards-conforming compiler?

Since C and C++ try to use the native floating-point format, this is
a question about how silly a hardware implementation might be. max
would be valid but not the right answer on Multics, which used a
twos-complement representation of the mantissa, so there is "one more"
negative value than positive. This gives other silly effects such as
an exponent overflow on negate or abs.

[better_cs_now]

Robert Mabee wrote:

be***********@y ahoo.com wrote:

float num := -numeric_limits< float>::max(); // Note the minus sign

Is the value I'm trying to assign to num above always representable and
legal on a standards-conforming compiler?

Since C and C++ try to use the native floating-point format, this is
a question about how silly a hardware implementation might be. max
would be valid but not the right answer on Multics, which used a
twos-complement representation of the mantissa, so there is "one more"
negative value than positive. This gives other silly effects such as
an exponent overflow on negate or abs.

OK, so it sounds like it's platform-dependent and not mandated by the
standard.

[noone]

On Thu, 04 May 2006 16:17:45 -0700, be***********@y ahoo.com wrote:

Robert Mabee wrote:

be***********@y ahoo.com wrote:

> float num := -numeric_limits< float>::max(); // Note the minus sign
>
> Is the value I'm trying to assign to num above always representable
> and legal on a standards-conforming compiler?
>

Since C and C++ try to use the native floating-point format, this is a
question about how silly a hardware implementation might be. max would
be valid but not the right answer on Multics, which used a
twos-complement representation of the mantissa, so there is "one more"
negative value than positive. This gives other silly effects such as an
exponent overflow on negate or abs.

OK, so it sounds like it's platform-dependent and not mandated by the
standard.

Is what platform dependent, the value of num or the method of calculating
it? Certainly num is platform dependent, but whether or not the method of
calculating it is...I'm not sure.

If you understand the ieee floating point formats better than I you might
be able to bit pack contiguous bytes of memory to the size of a float and
then cast that memory space as a float to see what dribbles out.

[Robert Mabee]

noone wrote:

If you understand the ieee floating point formats better than I you might
be able to bit pack contiguous bytes of memory to the size of a float and
then cast that memory space as a float to see what dribbles out.

If you've got hardware modern enough to have IEEE floating point then
-max IS the minimum (negative infinity). The problem is to write code
that is portable to an unspecified set of architectures, maybe including
some with surprising "features". Perhaps OP would be better served by
specifying his program is only portable to "reasonable " machines, such
as only those on which -max is a valid extremely-negative number.