Java Math nextUp() Method

The Math.nextUp() method in Java comes under java.lang.Math package. This method returns the floating-point value that is next greater than the given input and moving in the direction of positive infinity. This method is very useful when we need to find the smallest representable number that is greater than the given floating point number.

The nextUp() method is overloaded which means that we have more than one method with the same name under the Math class. Two overloaded method of the nextUp() are:

• double type: Math.nextUp(double d)
• float type: Math.nextUp(float f)

Working of nextUp() Method

The nextUp() method is used to find the smallest possible value which is greater than the provided input and the input is based on IEEE 754 floating-point precision. This method is helpful in mathematical calculations where small increments are important.

Syntax of Math nextUp() Method

public static double Math.nextUp(double d)

public static float Math.nextUp(float f)

Parameters: d or f: The input value for which we want the next greater floating-point number.

Return Value:

• It returns the next floating-point value which is greater than the argument.
• If the argument is NaN, the result is NaN.
• If the argument is zero, the result is Double.MIN_VALUE if we are dealing with double and if it’s float then the result is Float.MIN_VALUE.
• If the argument is positive infinity, the result is positive infinity.

Examples of Java Math nextUp() Method

Example 1: In this example, we are passing a double value to the nextUp() method.

// Java program to demonstrate
// Math.nextUp() with a double value
import java.lang.Math;

public class Geeks {
    
    public static void main(String[] args) {
        double num = 28.19;

        System.out.println("Next up of 28.19: " + Math.nextUp(num));
    }
}

Next up of 28.19: 28.190000000000005

Explanation: This example returns the next representable floating-point number greater than the num 28.19.

Example 2: In this example, we are passing a float value to the nextUp() method.

// Java program to demonstrate
// Math.nextUp() with a float value
import java.lang.Math;

public class Geeks {
    
    public static void main(String[] args) {
        float num = 28.1f;

        System.out.println("Next up of 78.1f: " + Math.nextUp(num));
    }
}

Next up of 78.1f: 28.100002

Explanation: This example returns the next representable float greater than num.

Example 3: In this example, we are checking how nextUp() handles special cases like NaN, zero, and positive infinity.

// Java program to demonstrate
// Math.nextUp() with special values
import java.lang.Math;

public class Geeks {
    
    public static void main(String[] args) {
        
        double nan = 0.0 / 0.0;
        float zero = 0.0f;
        double infinity = 1.0 / 0.0;

        // NaN input
        System.out.println("Next up of NaN: " + Math.nextUp(nan));

        // Zero input 
        System.out.println("Next up of 0.0f: " + Math.nextUp(zero));

        // Positive infinity 
        System.out.println("Next up of +Infinity: " + Math.nextUp(infinity));
    }
}

Next up of NaN: NaN
Next up of 0.0f: 1.4E-45
Next up of +Infinity: Infinity