Open In App

Java Math Class

Improve
Improve
Like Article
Like
Save
Share
Report

Java.lang.Math Class methods help to perform numeric operations like square, square root, cube, cube root, exponential and trigonometric operations.

Declaration

public final class Math
extends Object

Methods of Math Class in Java

Math class consists of methods that can perform mathematical operations and can make long calculations a bit easier. Let us check the method provided in the Math class.

Method Description
sin Returns the trigonometric value of the sine of an angle.
cos Returns the trigonometric value of the cosine of an angle.
tan Returns the trigonometric value of the tangent of an angle.
asin Returns the trigonometric value of the arc sine of an angle.
acos Returns the trigonometric value of the arc cosine of an angle.
atan Returns the trigonometric value of the arc tangent of an angle.
toRadians Convert value in degrees to value in radians
toDegrees Convert value in radians to value in degrees
exp Returns Euler’s number e raised to the power of a double value
log Returns the natural logarithm (base e) of a double value
log10 Returns the base 10 logarithms of a double value
sqrt Returns the correct rounded positive square root of a double value
cbrt Returns the cube root of a double value
IEEEremainder Computes the remainder operation on two arguments as instructed by the IEEE 754 standard.
ceil Returns the smallest double value that is greater than or equal to the argument. It is a fixed mathematical integer
floor Returns the smallest double value that is less than or equal to the argument. It is a fixed mathematical integer.
rint Returns the double value that is closest in value to the argument and is equal to a mathematical integer
atan2 Returns the angle theta from the conversion of rectangular coordinates (x, y) to polar coordinates (r, theta)
pow Returns(pow(a,b)) the value of ab.
round Returns the closest int to the argument, with ties rounding to positive infinity
random Returns a double value with a positive sign, in the range [0.0, 1.0].
addExact Returns the sum of its arguments, throwing an exception if the result overflows a value.
subtractExact Returns the difference of its arguments, throwing an exception if the result overflows a value.
multiplyExact Returns the product of the arguments, throwing an exception if the result overflows a value.
incrementExact Returns the argument value incremented by 1 and throws an exception if the value overflows.
decrementExact Returns the argument value decremented by 1 and throws an exception if the value overflows.
negateExact Returns the negation of the argument and throws an exception if the value overflows.
toIntExact Returns the value of the long argument and throws an exception if the int overflows.
floorDiv Returns the largest (closest to positive infinity) long value that is less than or equal to the algebraic quotient
floorMod Returns the floor modulus of the arguments
abs Return the absolute value
max Returns the maximum out of the two arguments
min Returns the minimum out of the two arguments
ulp Returns the size of an ulp of the argument.
signum Returns value 0,1 and -1 depending upon if the argument is equal, greater, or less than zero respectively.
sinh Returns the hyperbolic sine of the value.
cosh Returns the hyperbolic cosine of the value.
tanh Returns the hyperbolic sine of the value.
hypot Returns the hyperbolic tangent of the value.
expm1 Returns ex-1
log1p Returns the natural logarithm of the sum of the argument and 1
copySign Returns the first value argument with the sign of the second value argument
getExponent Returns the unbiased exponent used in the representation of a value
nextAfter Returns the floating-point number adjacent to the first argument in the direction of the second argument.
nextUp Returns the floating-point value adjacent to d in the direction of positive infinity.
nextDown Returns the floating-point value adjacent to d in the direction of negative infinity.
scalb Returns f × 2scaleFactor rounded as if performed by a single correctly rounded floating-point multiplied to a member of the value set.

Example of the Java Math Class

Java




// Java Program to demonstrate the
// Use of Math Class
public class MathLibraryExample {
    public static void main(String[] args)
    {
        int i = 7;
        int j = -9;
        double x = 72.3;
        double y = 0.34;
  
        System.out.println("i is " + i);
        System.out.println("j is " + j);
  
        // The absolute value of a number is equal to the
        // number if the number is positive or zero and
        // equal to the negative of the number if the number
        // is negative.
  
        System.out.println("|" + i + "| is " + Math.abs(i));
        System.out.println("|" + y + "| is " + Math.abs(y));
  
        // Truncating and Rounding functions
        // You can round off a floating point number  to the
        // nearest integer with round()
        System.out.println(x + " is approximately "
                           + Math.round(x));
        System.out.println(y + " is approximately "
                           + Math.round(y));
  
        // The "ceiling" of a number is the smallest integer
        // greater than or equal to the number. Every
        // integer is its own //ceiling.
        System.out.println("The ceiling of " + x + " is "
                           + Math.ceil(x));
        System.out.println("The ceiling of " + y + " is "
                           + Math.ceil(y));
  
        // The "floor" of a number is the largest integer
        // less than or equal to the number. Every integer
        // is its own floor.
        System.out.println("The floor of " + x + " is "
                           + Math.floor(x));
        System.out.println("The floor of " + y + " is "
                           + Math.floor(y));
  
        // Comparison operators
  
        // min() returns the smaller of the two arguments
        // you pass it
        System.out.println("min(" + i + "," + j + ") is "
                           + Math.min(i, j));
        System.out.println("min(" + x + "," + y + ") is "
                           + Math.min(x, y));
  
        // There's a corresponding max() method
        // that returns the larger of two numbers
        System.out.println("max(" + i + "," + j + ") is "
                           + Math.max(i, j));
        System.out.println("max(" + x + "," + y + ") is "
                           + Math.max(x, y));
  
        // The Math library defines a couple of useful
        // constants:
        System.out.println("Pi is " + Math.PI);
        System.out.println("e is " + Math.E);
  
        // Trigonometric methods. All arguments are given in
        // radians
        // Convert a 45 degree angle to radians
        double angle = 45.0 * 2.0 * Math.PI / 360.0;
        System.out.println("cos(" + angle + ") is "
                           + Math.cos(angle));
        System.out.println("sin(" + angle + ") is "
                           + Math.sin(angle));
  
        // Inverse Trigonometric methods. All values are
        // returned as radians
  
        double value = 0.707;
  
        System.out.println("acos(" + value + ") is "
                           + Math.acos(value));
        System.out.println("asin(" + value + ") is "
                           + Math.asin(value));
        System.out.println("atan(" + value + ") is "
                           + Math.atan(value));
  
        // Exponential and Logarithmic Methods
  
        // exp(a) returns e (2.71828...) raised
        // to the power of a.
        System.out.println("exp(1.0) is " + Math.exp(1.0));
        System.out.println("exp(10.0) is "
                           + Math.exp(10.0));
        System.out.println("exp(0.0) is " + Math.exp(0.0));
  
        // log(a) returns  the natural
        // logarithm (base e) of a.
        System.out.println("log(1.0) is " + Math.log(1.0));
        System.out.println("log(10.0) is "
                           + Math.log(10.0));
        System.out.println("log(Math.E) is "
                           + Math.log(Math.E));
  
        // pow(x, y) returns the x raised
        // to the yth power.
        System.out.println("pow(2.0, 2.0) is "
                           + Math.pow(2.0, 2.0));
        System.out.println("pow(10.0, 3.5) is "
                           + Math.pow(10.0, 3.5));
        System.out.println("pow(8, -1) is "
                           + Math.pow(8, -1));
  
        // sqrt(x) returns the square root of x.
        for (i = 0; i < 10; i++) {
            System.out.println("The square root of " + i
                               + " is " + Math.sqrt(i));
        }
  
        // Finally there's one Random method
        // that returns a pseudo-random number
        // between 0.0 and 1.0;
  
        System.out.println("Here's one random number: "
                           + Math.random());
    }
}


Output

i is 7j is -9
|7| is 7
|0.34| is 0.34
72.3 is approximately 72
0.34 is approximately 0
The ceiling of 72.3 is 73.0
The ceiling of 0.34 is 1.0
The floor of 72.3 is 72.0
The floor of 0.34 is 0.0min(7,-9) is -9
min(72.3,0.34) is 0.34
max(7,-9) is 7
max(72.3,0.34) is 72.3
Pi is 3.141592653589793
e is 2.718281828459045
cos(0.7853981633974483) is 0.7071067811865476
sin(0.7853981633974483) is 0.7071067811865475
acos(0.707) is 0.7855491633997437
asin(0.707) is 0.785247163395153
atan(0.707) is 0.6154085176292563
exp(1.0) is 2.718281828459045
exp(10.0) is 22026.465794806718
exp(0.0) is 1.0
log(1.0) is 0.0
log(10.0) is 2.302585092994046
log(Math.E) is 1.0
pow(2.0, 2.0) is 4.0

NaN’s argument: A constant holding a Not-a-Number (NaN) value of type double. It is equivalent to the value returned by Double.longBitsToDouble(0x7ff8000000000000L).



Last Updated : 11 Mar, 2024
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads