The Java nextUp Function is one of the Java Math Library function which is used to return the floating point value adjacent to the user specified argument in the direction of positive infinity. This method is semantically equal to nextAfter(number, Double.POSITIVE_INFINITY). Please refer Java nextAfter Function to under the nextAfter function. In this article we will show you, How to use Math.nextUp Function in Java Programming language with example.
Java nextUp Function syntax
The basic syntax of the Math.nextUp Function in Java Programming language is as shown below:
|
1 |
Math.nextUp(data_type number); |
- number: Please specify the floating point value here.
The nextUp function will not return the expected output for the below specified cases:
- If the number argument is not a number, java Math.nextUp function will return NaN.
- If the number argument is positive infinity, java Math.nextUp function will return Positive Infinity.
- If the number argument is zero, java Math.nextUp function will return Double.MIN_VALUE
Java Programming provides two different Math.nextUp Java functions to find the adjacent floating point value in the direction of positive infinity. Following function will accept positive or negative double value as an argument and returns the result
|
1 2 3 4 |
static double nextUp(double number); // In order to use in program: Math.nextUp(double number); |
Following function will accept positive or negative float value as an argument and returns the adjacent floating value of the argument in the direction of positive infinity
|
1 2 3 4 |
static float nextUp(float number); //Return Type is float // In order to use in program: Math.nextUp(float number); |
Java nextUp Function Example
The Java Math.nextUp function is used to return the floating point value adjacent to the first argument in the direction of positive infinity. In this example, We are going to find the same of different data types and display the output
JAVA CODE
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
// Java Math.nextUp Function package MathFunctions; public class NextUpMethod { public static void main(String[] args) { double a = 14.9666, b = -95.474; float c = 65.23f, d = -3.54f; System.out.println("NextUp result of Positive Values: " + Math.nextUp(10)); System.out.println("NextUp result of Negative Values: " + Math.nextUp(-10)); System.out.println("\nNextUp result of Positive Doubles: " + Math.nextUp(a)); System.out.println("NextUp result of Negative Double Values: " + Math.nextUp(b)); System.out.println("\nNextUp result of Positive Float Values: " + Math.nextUp(c)); System.out.println("NextUp result of Negative Float Values: " + Math.nextUp(d)); } } |
OUTPUT
ANALYSIS
First, We declared variables of type Double and Float to display the functionality of java Math.nextUp function on different data types.
|
1 2 |
double a = 14.9666, b = -95.474; float c = 65.23f, d = -3.54f; |
Next, We used the Math.nextUp Function directly on both the Positive and negative values.
|
1 2 |
System.out.println("NextUp result of Positive Values: " + Math.nextUp(10)); System.out.println("NextUp result of Negative Values: " + Math.nextUp(-10)); |
Next, We used the Java Math.nextUp Function on variable a and b (they belongs to double type). Following statements will call the nextUp method of double type ( static double nextUp(double number) ) to return the adjacent floating value in the direction of positive infinity.
|
1 2 |
System.out.println("\nNextUp result of Positive Doubles: " + Math.nextUp(a)); System.out.println("NextUp result of Negative Double Values: " + Math.nextUp(b)); |
Next, We used the Math.nextAfter Function on variable c and d (they belongs to float type). Following statements will call the nextUp method of float type ( static float nextUp(float number) ) to return the adjacent floating value.
|
1 2 |
System.out.println("\nNextUp result of Positive Float Values: " + Math.nextUp(c)); System.out.println("NextUp result of Negative Float Values: " + Math.nextUp(d)); |
Java nextUp Function on Array example
In this Java program we will show you, How to find the adjacent floating point values of bulk data. Here, we are going to declare an Array of double type and find the adjacent floating point value of each and every element in an array in the direction of positive infinity.
JAVA CODE
|
1 2 3 4 5 6 7 8 9 10 11 12 |
package MathFunctions; public class NextUpOnArrays { public static void main(String[] args) { double [] myArray = {-5.02, 120.08, 124.21, -3.00, 6.10, 4.01}; for (int i = 0; i < myArray.length; i++) { System.out.println("NextUp Result of Array Element = " + Math.nextUp(myArray[i])); } } } |
OUTPUT
ANALYSIS
First, We declared an Array of double type and assigned some random values.
|
1 |
double [] myArray = {-5.02, 120.08, 124.21, -3.00, 6.10, 4.01}; |
Next, We used the Java For Loop to iterate the Array. Within the For Loop, we initialized the i value as 0. Next, compiler will check the condition (i < myArray.length). As along the condition is True, statement inside the for loop will be executed.
TIP: myArray.length is used to find the length of an array.
|
1 |
for (int i = 0; i < myArray.length; i++) { |
Following statements will print the output. If you observe the code snippet, we used the Math.nextUp Function directly inside the System.out.format statement. Here, compiler will call the Java Math.nextUp method ( static double nextUp(double number) ) to find the adjacent floating point value of corresponding values in the direction of positive infinity.
|
1 |
System.out.println("NextUp Result of Array Element = " + Math.nextUp(myArray[i])); |
NOTE: If you want to find the adjacent floating point value of a single item then use: Math.nextUp(myArray[index_position])
Thank You for Visiting Our Blog
Leave a Reply