I'm restricting this answer, perhaps unnecessarily, to IEEE754 floating point.

DBL_MIN is not allowed to be a subnormal number.

But std::nextafter is allowed to return a subnormal number.

Hence the return value of the latter could be less than DBL_MIN.

For more details see https://en.wikipedia.org/wiki/Denormal_number

-DBL_MAX in ANSI C, which is defined in float.h.

Double.NEGATIVE_INFINITY is not a finite value, so it can't be the smallest finite value of type double.

Double.MIN_VALUE is also not the smallest finite value of type double, since that's the

smallest positive nonzero value of type double

The smallest finite value of type double is -Double.MAX_VALUE, whose value is -1.79769313348623157E308, or -(2-2^-52)*2¹⁰²³ or Double.longBitsToDouble(0xffefffffffffffffL).

This can be calculated based on JLS 4.2.3. Floating-Point Types, Formats, and Values:

The finite nonzero values of any floating-point value set can all be expressed in the form s ⋅ m ⋅ 2^{(e - N + 1)}, where s is +1 or -1, m is a positive integer less than 2^N, and e is an integer between Emin = -(2^K-1-2) and Emax = 2^K-1-1, inclusive.

For double, Emax==1023 and N==53.

When you assign in s ⋅ m ⋅ 2^{(e - N + 1)} the values s=-1, m=2^N-1 and e = Emax, you get the minimum finite value: -1 * (2⁵³-1)*2^{(1023 - 53 + 1)} = - (2 - 2^-52) * 2¹⁰²³.

The IEEE 754 format has one bit reserved for the sign and the remaining bits representing the magnitude. This means that it is "symmetrical" around origo (as opposed to the Integer values, which have one more negative value). Thus the minimum value is simply the same as the maximum value, with the sign-bit flipped, so yes, -Double.MAX_VALUE is the lowest actual number you can represent with a double.

I suppose the Double.MAX_VALUE should be seen as maximum magnitude, in which case it actually makes sense to simply write -Double.MAX_VALUE. It also explains why Double.MIN_VALUE is the least positive value (since that represents the least possible magnitude).

But sure, I agree that the naming is a bit misleading. Being used to the meaning Integer.MIN_VALUE, I too was a bit surprised when I read that Double.MIN_VALUE was the smallest absolute value that could be represented. Perhaps they thought it was superfluous to have a constant representing the least possible value as it is simply a - away from MAX_VALUE :-)

(Note, there is also Double.NEGATIVE_INFINITY but I'm disregarding from this, as it is to be seen as a "special case" and does not in fact represent any actual number.)

Here is a good text on the subject.

Okay, let's imagine it this way, sticking with decimal numbers. Suppose you have a floating decimal point type which allows you to represent 5 decimal digits, and a number between 0 and 3 for the exponent, to multiple the result by 1, 10, 100 or 1000.

So the smallest non-zero value is just 1 (i.e. mantissa=00001, exponent=0). The largest value is 99999000 (mantissa=99999, exponent=3).

Now, what happens when you add 1 to 50000000? You can't represent 50000001...the next representable number after 500000000 is 50001000. So if you try to add them together, the result is just going to be the closest value to the "true" result - which is still 500000000. That's like adding Double.MIN_VALUE to a large double.

My version (converting to bits, incrementing and then converting back) is like taking that 50000000, splitting into mantissa and exponent (m=50000, e=3) then incrementing it the smallest amount, to (m=50001, e=3) and then reassembling to 50001000.

Do you see how they're different?

Now here's a concrete example:

public class Test{
    public static void main(String[] args) {
        double before = 100000000000000d;
        double after = before + Double.MIN_VALUE;
        System.out.println(before == after);

        long bits = Double.doubleToLongBits(before);
        bits++;
        double afterBits = Double.longBitsToDouble(bits);
        System.out.println(before == afterBits);
        System.out.println(afterBits - before);
    }
}

This tries both approaches with a large number. The output is:

true
false
0.015625

Going through the output, that means:

• Adding Double.MIN_VALUE didn't have any effect
• Incrementing the bit did have an effect
• The difference between afterBits and before is 0.015625, which is much bigger than Double.MIN_VALUE. No wonder the simple addition had no effect!

The documentation for sys.float_info says that this is the way to get the smallest possible float:

>>> math.ulp(0.0)
5e-324

The value of sys.float_info.min (part of a previous answer that I deleted) gives the smallest normalized float, a much bigger value.

If your numbers are finite, you can use a couple of convenient methods in the BitConverter class:

long bits = BitConverter.DoubleToInt64Bits(value);
if (value > 0)
    return BitConverter.Int64BitsToDouble(bits - 1);
else if (value < 0)
    return BitConverter.Int64BitsToDouble(bits + 1);
else
    return -double.Epsilon;

IEEE-754 formats were designed so that the bits that make up the exponent and mantissa together form an integer that has the same ordering as the floating-point numbers. So, to get the largest smaller number, you can subtract one from this number if the value is positive, and you can add one if the value is negative.

The key reason why this works is that the leading bit of the mantissa is not stored. If your mantissa is all zeros, then your number is a power of two. If you subtract 1 from the exponent/mantissa combination, you get all ones and you'll have to borrow from the exponent bits. In other words: you have to decrement the exponent, which is exactly what we want.

.Machine$double.xmin gives the value of the smallest positive number whose representation meets the requirements of IEEE 754 technical standard for floating point computation. As is mentioned in the Wikipedia article on double-precision floating point numbers, that standard requires that:

If a decimal string with at most 15 significant digits is converted to IEEE 754 double precision representation and then converted back to a string with the same number of significant digits, then the final string should match the original. If an IEEE 754 double precision is converted to a decimal string with at least 17 significant digits and then converted back to double, then the final number must match the original.

The same article goes on to note that, by compromising precision, even smaller positive numbers (which do not meet the standards' precision requirements) can be represented:

The 11 bit width of the exponent allows the representation of numbers between 10^-308 and 10³⁰⁸, with full 15–17 decimal digits precision. By compromising precision, the subnormal representation allows even smaller values up to about 5 × 10^-324.

R's doubles behave in exactly this way, as is noted in the Details section of ?.Machine:

Note that on most platforms smaller positive values than ‘.Machine$double.xmin’ can occur. On a typical R platform the smallest positive double is about ‘5e-324’.

To confirm that that is the smallest positive value that can be represented using R's doubles and to see the cost in loss of precision, try out a few operations like this:

5e-324
# [1] 4.940656e-324
2e-324
# [1] 0
1.4 * 5e-324
# [1] 4.940656e-324
1.6 * 5e-324
# [1] 9.881313e-324

I doubt there is a standard library function for finding the number you need, however, it is not too hard to find the needed value using a simple binary search:

#include <iostream>
#include <cmath>
#include <typeinfo>

template<typename T> T find_magic_epsilon(T from, T to) {
    if (to == std::nextafter(from, to)) return to;
    T mid = (from + to)/2;
    if (std::isinf((T)1.0/mid)) return find_magic_epsilon<T>(mid, to);
    else return find_magic_epsilon<T>(from, mid);
}

template<typename T> T meps() {
    return find_magic_epsilon<T>(0.0, 0.1);
}

template<typename T> T test_meps() {
    T value = meps<T>();
    std::cout << typeid(T).name() << ": MEPS=" << value
              << " 1/MEPS=" << (T)1.0/value << " 1/(MEPS--)="
              << (T)1.0/std::nextafter(value,(T)0.0) << std::endl;
}

int main() {
    test_meps<float>();
    test_meps<double>();
    test_meps<long double>();
    return 0;
}

The output of the script above:

f: MEPS=2.93874e-39 1/MEPS=3.40282e+38 1/(MEPS--)=inf
d: MEPS=5.56268e-309 1/MEPS=1.79769e+308 1/(MEPS--)=inf
e: MEPS=8.40526e-4933 1/MEPS=1.18973e+4932 1/(MEPS--)=inf

By definition, for floating types, min returns the smallest positive value the type can encode, not the lowest.

If you want the lowest value, use numeric_limits::lowest instead.

Documentation: http://en.cppreference.com/w/cpp/types/numeric_limits/min

As for why it is this way, I can only speculate that the Standard committee needed to have a way to represent all forms of extreme values for all different native types. In the case of integral types, there's only two types of extreme: max positive and max negative. For floats there is another: smallest possible.

If you think the semantics are a bit muddled, I agree. The semantics of the related #defines in the C standard are muddled in much the same way.

I'm guessing at what you want from your code: You want to start with largest possible negative value and increment it toward positive infinity in the smallest possible steps until the value is no longer negative.

I think the function you want is nextafter().

int main() {
    double value(-std::numeric_limits<double>::max());
    while(value < 0) {
        std::cout << value << '\n';
        value = std::nextafter(value,std::numeric_limits<double>::infinity());
    }
}

Have you looked at double.PositiveInfinity? (aka System.Double.PositiveInfinity). The are similar values for negative infinity, NaN, epsilon (the smallest positive double) and min/max values.

It's a constant in the double struct. If that doesn't do what you want it to, please clarify.

Note that to test for infinity, you can use double.IsPositiveInfinity (and IsNegativeInfinity, and just IsInfinity).

Think about it in these terms. Take a 2-bit number with a preceding sign:

000 = 0
001 = 1
010 = 2
011 = 3

Now let's have some negatives:

111 = -1
110 = -2
101 = -3

Wait, we also have

100 ... 

It has to be negative, because the sign-bit is 1. So, logically, it must be -4.

(Edit: As WorldEngineer rightly points out, not all numbering systems work this way -- but the ones you're asking about do.)

Take a look at http://www.cplusplus.com/reference/clibrary/cfloat/ the FLT_EPSILON can be used to compare a float variable to 0 (zero), or nearly zero in that case.

There's an other article here: http://www.cygnus-software.com/papers/comparingfloats/Comparing%20floating%20point%20numbers.htm

EDIT: what you need is this q&a: https://stackoverflow.com/questions/9380108/get-machine-epsilon-in-microsoft-excel it describes the epsilon value in excel.

Actual zero is zero. The result can become zero in different ways. A double has an value range of +/-10^^+/-308 (roughly). A number smaller than the smallest number will be considered zero. Using #include <limits>, you can get numeric_limits<double>::denorm_min(), which is the smallest value that can be represented in a double.

But you can get "the effect of zero" in other ways. Say you have a fairly large number, 10 million, and you add (or subtract - read add as add or subtract in the rest of this paragraph) a very small number, say 1/10 million, then the addition will have no effect, because it is outside the actual value bits of the mantissa of the floating point number - that is, 53 bits in the case of double - then the effect will be the same as adding zero. In other words, even if you have a number that is not zero, using it to add to another number is not always going to change the other number.

See IEEE-754 on Wikipedia (other floating point formats do exist, but they are unusual).

According to the javadoc for Double.MIN_VALUE, MIN_VALUE is:

A constant holding the smallest positive nonzero value of type double

So Double.MIN_VALUE is not negative, it's the positive value that's as close as a Double can get to zero (without being zero).