Java Math ceilDivExact() Method

The Math.ceilDivExact() method in Java is used to perform division and return the smallest (closest to negative infinity) value that is greater than or equal to the algebraic quotient. If the result overflows the range of the type, an ArithmeticException is thrown. 

Table of Contents

1. Introduction
2. ceilDivExact() Method Syntax
3. Overloaded ceilDivExact() Methods
4. Examples
   • ceilDivExact(int x, int y)
   • ceilDivExact(long x, long y)
5. Real-World Use Case
6. Conclusion

Introduction

The Math.ceilDivExact() method provides a way to perform division and ensure that the result is rounded up to the nearest integer value, with an overflow check. This is useful in scenarios where you need to divide two numbers and ensure that the result is always rounded up, and any overflow is detected and handled.

ceilDivExact() Method Syntax

The syntax for the ceilDivExact() method varies depending on the types of the arguments:

ceilDivExact(int x, int y)

public static int ceilDivExact(int x, int y)

ceilDivExact(long x, long y)

public static long ceilDivExact(long x, long y)

Parameters:

• x: The dividend.
• y: The divisor.

Returns:

• The smallest value that is greater than or equal to the algebraic quotient.

Throws:

• ArithmeticException if the divisor y is zero or if the result overflows the positive range of the type.

Overloaded ceilDivExact() Methods

The Math.ceilDivExact() method is overloaded to handle different primitive data types: int and long. Each version returns the quotient of the division, rounded up to the nearest integer value, and throws an ArithmeticException if the result overflows.

Examples

ceilDivExact(int x, int y)

The ceilDivExact(int x, int y) method returns the quotient of two int values, rounded up to the nearest integer value, and throws an ArithmeticException if the result overflows.

Example

public class CeilDivExactIntExample {
    public static void main(String[] args) {
        int x1 = 7, y1 = 3;
        int x2 = Integer.MAX_VALUE, y2 = 1;
        int x3 = Integer.MIN_VALUE, y3 = -1;

        try {
            int result1 = Math.ceilDivExact(x1, y1);
            System.out.println("Ceiling division of " + x1 + " / " + y1 + " is " + result1);
        } catch (ArithmeticException e) {
            System.out.println("Overflow occurred for division: " + x1 + " / " + y1);
        }

        try {
            int result2 = Math.ceilDivExact(x2, y2);
            System.out.println("Ceiling division of " + x2 + " / " + y2 + " is " + result2);
        } catch (ArithmeticException e) {
            System.out.println("Overflow occurred for division: " + x2 + " / " + y2);
        }

        try {
            int result3 = Math.ceilDivExact(x3, y3);
            System.out.println("Ceiling division of " + x3 + " / " + y3 + " is " + result3);
        } catch (ArithmeticException e) {
            System.out.println("Overflow occurred for division: " + x3 + " / " + y3);
        }
    }
}

Output:

Ceiling division of 7 / 3 is 3
Ceiling division of 2147483647 / 1 is 2147483647
Overflow occurred for division: -2147483648 / -1

ceilDivExact(long x, long y)

The ceilDivExact(long x, long y) method returns the quotient of two long values, rounded up to the nearest integer value, and throws an ArithmeticException if the result overflows.

Example

public class CeilDivExactLongExample {
    public static void main(String[] args) {
        long x1 = 10L, y1 = 3L;
        long x2 = Long.MAX_VALUE, y2 = 1L;
        long x3 = Long.MIN_VALUE, y3 = -1L;

        try {
            long result1 = Math.ceilDivExact(x1, y1);
            System.out.println("Ceiling division of " + x1 + " / " + y1 + " is " + result1);
        } catch (ArithmeticException e) {
            System.out.println("Overflow occurred for division: " + x1 + " / " + y1);
        }

        try {
            long result2 = Math.ceilDivExact(x2, y2);
            System.out.println("Ceiling division of " + x2 + " / " + y2 + " is " + result2);
        } catch (ArithmeticException e) {
            System.out.println("Overflow occurred for division: " + x2 + " / " + y2);
        }

        try {
            long result3 = Math.ceilDivExact(x3, y3);
            System.out.println("Ceiling division of " + x3 + " / " + y3 + " is " + result3);
        } catch (ArithmeticException e) {
            System.out.println("Overflow occurred for division: " + x3 + " / " + y3);
        }
    }
}

Output:

Ceiling division of 10 / 3 is 4
Ceiling division of 9223372036854775807 / 1 is 9223372036854775807
Overflow occurred for division: -9223372036854775808 / -1

Real-World Use Case

Safe Arithmetic Calculations

In real-world scenarios, the Math.ceilDivExact() method can be used to perform safe arithmetic calculations where it is crucial to handle potential overflow situations. This can be particularly useful in financial applications, data processing, and any other scenarios where accurate arithmetic operations are necessary.

Example

public class SafeArithmeticExample {
    public static void main(String[] args) {
        long dividend = Long.MAX_VALUE;
        long divisor = 1L;

        try {
            long quotient = Math.ceilDivExact(dividend, divisor);
            System.out.println("The quotient of " + dividend + " divided by " + divisor + " is " + quotient);
        } catch (ArithmeticException e) {
            System.out.println("Overflow occurred for division: " + dividend + " / " + divisor);
        }
    }
}

Output:

The quotient of 9223372036854775807 divided by 1 is 9223372036854775807

Conclusion

The Math.ceilDivExact() method in Java provides a way to perform division with rounding up, ensuring that the result is the smallest integer greater than or equal to the algebraic quotient, with overflow detection. By understanding how to use this method and its overloaded versions, you can perform various division operations and handle potential overflow issues in your Java applications. 

Whether you are working with integers or long integers, the ceilDivExact() method offers a reliable tool for ensuring correct division results and safe arithmetic calculations.