# Java.lang.Math Class in Java | Set 1

• Difficulty Level : Easy
• Last Updated : 04 Sep, 2022

Math Class methods helps to perform the numeric operations like square, square root, cube, cube root, exponential and trigonometric operations

Declaration :

```public final class Math
extends Object```

## Java

 `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);``    ``System.out.println(``"x is "` `+ x);    ``    ``System.out.println(``"y is "` `+ y);``     ` `    ``// 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(``"|"` `+ j + ``"| is "` `+ Math.abs(j));``    ``System.out.println(``"|"` `+ x + ``"| is "` `+ Math.abs(x));    ``    ``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 "` `+ i + ``" is "` `+ Math.ceil(i));    ``     ``System.out.println(``"The ceiling of "` `+ j + ``" is "` `+ Math.ceil(j));``     ``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 "` `+ i + ``" is "` `+ Math.floor(i));    ``     ``System.out.println(``"The floor of "` `+ j + ``" is "` `+ Math.floor(j));``     ``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));    ``     ``System.out.println(``"min("` `+ i + ``","` `+ x + ``") is "` `+ Math.min(i,x));    ``     ``System.out.println(``"min("` `+ y + ``","` `+ j + ``") is "` `+ Math.min(y,j));    ` `     ``// 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));    ``     ``System.out.println(``"max("` `+ i + ``","` `+ x + ``") is "` `+ Math.max(i,x));    ``     ``System.out.println(``"max("` `+ y + ``","` `+ j + ``") is "` `+ Math.max(y,j));    ``      ` `     ``// 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());    ``    ``System.out.println(``"Here's another random number: "` `+ Math.random());` `  ``}``}`

Output

```...(7,-9) is 7
max(72.3,0.34) is 72.3
max(7,72.3) is 72.3
max(0.34,-9) is 0.34
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
pow(10.0, 3.5) is 3162.2776601683795
pow(8, -1) is 0.125
The square root of 0 is 0.0
The square root of 1 is 1.0
The square root of 2 is 1.4142135623730951
The square root of 3 is 1.7320508075688772
The square root of 4 is 2.0
The square root of 5 is 2.23606797749979
The square root of 6 is 2.449489742783178
The square root of 7 is 2.6457513110645907
The square root of 8 is 2.8284271247461903
The square root of 9 is 3.0
Here's one random number: 0.20980590409217137
Here's another random number: 0.8736627851185991```

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

Methods of lang.math class :

1. abs() : java.lang.Math.abs() method returns the absolute value of any type of argument passed. This method can handle all the data types.

• Result is positive zero, if the argument is positive zero or negative zero.
• Result is positive infinity if the argument is infinite.
• Result is NaN, if passed argument is NaN.

Syntax:

```public static datatype abs(datatype arg)
Parameters:
arg - the argument whose absolute value we need
Returns:
absolute value of the passed argument.```

2. acos() : java.lang.Math.acos() method returns the arc cosine value of the passed argument.
arc cosine is inverse cosine of the argument passed.
acos(arg) = cos-1 of arg

Special Case: Result is NaN, if the argument is NaN or its absolute value is greater than 1.
Syntax:

```public static double acos(double a)
Parameters:
a - the argument whose arc cosine value we need.
Returns:
arc cosine value of the argument.```

Note: Math class usually takes radians as an input which is very much different in real life applications since angles is usually represented in degrees.

Syntax:

```public static double toRadians(double deg)
Parameters:
deg - degree angle needs to be in radian.
Returns:
radians equivalent of the degree-argument passed.```

Java code explaining abs(), acos(), toRadians() method in lang.Math class.

## Java

 `// Java program explaining lang.Math class methods``// abs(), acos(), toRadians()` `import` `java.lang.*;``public` `class` `NewClass``{``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Declaring the variables``        ``int` `Vali = -``1``;``        ``float` `Valf = .5f;` `        ``// Printing the values``        ``System.out.println(``"Initial value of int  : "``+Vali);``        ``System.out.println(``"Initial value of int  : "``+Valf);`  `        ``// Use of .abs() method to get the absoluteValue``        ``int` `Absi = Math.abs(Vali);``        ``float` `Absf = Math.abs(Valf);` `        ``System.out.println(``"Absolute value of int : "``+Absi);``        ``System.out.println(``"Absolute value of int : "``+Absf);``        ``System.out.println(``""``);` `        ``// Use of acos() method``        ``// Value greater than 1, so passing NaN``        ``double` `Acosi = Math.acos(``60``);``        ``System.out.println(``"acos value of Acosi : "``+Acosi);``        ``double` `x = Math.PI;` `        ``// Use of toRadian() method``        ``x = Math.toRadians(x);``        ``double` `Acosj = Math.acos(x);``        ``System.out.println(``"acos value of Acosj : "``+Acosj);``        ` `    ``}``}`

Output :

```Initial value of int  : -1
Initial value of int  : 0.5
Absolute value of int : 1
Absolute value of int : 0.5

acos value of Acosi : NaN
acos value of Acosj : 1.5159376794536454```

4. asin() : java.lang.Math.asin() method returns the arc sine value of the method argument passed. Returned angle is in the range -pi/2 to pi/2.
arc sine is inverse sine of the argument passed.
asin(arg) = sine-1 of arg

Special Case :

• Result is NaN,if the argument is NaN or its absolute value is greater than 1.
• Result is a zero, if the argument is zero.

Syntax:

```public static double asin(double arg)
Parameters:
arg - argument passed.
Returns:
arc sine of the argument passed.```

5. cbrt() : java.lang.Math.cbrt() method returns the cube root of the passed argument.
Special Point :

• Result is NaN, if the argument is NaN.
• Result is an infinity with the same sign as the argument, if the argument is infinite.
• Result is a zero, if the argument is zero.

Syntax:

```public static double cbrt(double arg)
Parameters:
arg - argument passed.
Returns:
cube root of the argument passed```

Java code explaining asin(), cbrt() method in lang.Math class.

## Java

 `// Java program explaining lang.Math class methods``// asin(), cbrt()` `import` `java.lang.*;``public` `class` `NewClass``{` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `a = ``1``, b = ``8``;``        ``int` `radd = a+b;` `        ``// Use of asin() method``        ``// Value greater than 1, so passing NaN``        ``double` `Asini = Math.asin(radd);``        ``System.out.println(``"asin value of Asini : "` `+ Asini);``        ``double` `x = Math.PI;` `        ``// Use of toRadian() method``        ``x = Math.toRadians(x);``        ``double` `Asinj = Math.asin(x);``        ``System.out.println(``"asin value of Asinj : "` `+ Asinj);``        ``System.out.println(``""``);` `        ``// Use of cbrt() method``        ``double` `cbrtval = Math.cbrt(``216``);``        ``System.out.println(``"cube root : "` `+ cbrtval);` `    ``}``}`

Output :

```asin value of Asini : NaN
asin value of Asinj : 0.054858647341251204

cube root : 6.0```

6. floor() : java.lang.Math.floor() method returns the floor value of an argument i.e. the closest integer value which is either less or equal to the passed argument.
eg : 101.23 has floor value = 101

Important point : Same argument is resulted if if passed an NaN or infinite argument.

```Syntax:
public static double floor(double arg)
Parameters:
arg - the argument whose floor value we need
Returns:closest possible value that is either less than
or equal to the argument passed```

7. hypot() : java.lang.Math.hypot(double p, double b) method returns hypotenuse of a right triangle on passing the triangle’s base and perpendicular as arguments.
hypotenuse = [perpendicular2 + base2]1/2

Important Point :

• If either argument is infinite, then the result is positive infinity.
• If either argument is NaN and neither argument is infinite, then the result is NaN.
```Syntax:
public static double hypot(double p, double b)
Parameters:
p - perpendicular of the right triangle
b - base of the right triangle
Returns:
hypotenuse of the right triangle```

8. IEEEremainder() : java.lang.Math.IEEERemainder(double d1, double d2) method returns the remainder value by applying remainder operation on two arguments w.r.t IEEE 754 standard.
Remainder value = d1 – d2 * n
where,
n = closest exact value of d1/d2

```Syntax:
public static double IEEEremainder(double d1,double d2)
Parameters:
d1 - dividend
d2 - divisor
Returns:
remainder when f1(dividend) is divided by(divisor)```

9. log() : java.lang.Math.log() method returns the logarithmic value of the passed argument.

```Syntax:
public static double log(double arg)
Parameters:
arg - argument passed.
Returns:
logarithmic value of the argument passed.```

Java code explaining floor(), hypot(), IEEEremainder(), log() method in lang.Math class.

## Java

 `// Java program explaining lang.MATH class methods``// floor(), hypot(), IEEEremainder(), log()` `import` `java.lang.*;``public` `class` `NewClass``{` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Use of floor method``        ``double` `f1 = ``30.56``, f2 = -``56.34``;``        ``f1 =Math.floor(f1);``        ``System.out.println(``"Floor value of f1 : "``+f1);` `        ``f2 =Math.floor(f2);``        ``System.out.println(``"Floor value of f2 : "``+f2);``        ``System.out.println(``""``);` `        ``// Use of hypot() method``        ``double` `p = ``12``, b = -``5``;``        ``double` `h = Math.hypot(p, b);``        ``System.out.println(``"Hypotenuse : "``+h);``        ``System.out.println(``""``);` `        ``// Use of IEEEremainder() method``        ``double` `d1 = ``105``, d2 = ``2``;``        ``double` `r = Math.IEEEremainder(d1,d2);``        ``System.out.println(``"Remainder : "``+r);``        ``System.out.println(``""``);``        ` `        ``// Use of log() method``        ``double` `l = ``10``;``        ``l = Math.log(l);``        ``System.out.println(``"Log value of 10 : "``+l);``        ` `    ``}``}`

Output :

```Floor value of f1 : 30.0
Floor value of f2 : -57.0

Hypotenuse : 13.0

Remainder : 1.0

Log value of 10 : 2.302585092994046```

10. ceil() : java.lang.Math.ceil(double a) method returns the smallest possible value which is either greater or equal to the argument passed. The returned value is a mathematical integer.

• Result is same, if the returned value is already a mathematical integer.
• Result is same, if the passed argument is NaN or infinite or zero.
• Result is negative zero, if the passed argument is less than zero but greater than -1.0

Syntax:

```public static double ceil(double arg)
Parameters:
arg - the argument value
Returns:
smallest possible value(mathematical integer)
which is either greater or equal to the argument passed```

11. atan() : java.lang.Math.atan() method returns returns the arc tangent of the method argument value. The returned angle is in the range -pi/2 through pi/2.
arc tan is inverse tan of the argument passed.
atan(arg) = tan inverse of arg

Special Case :

• Result is NaN, if the passed argument is NaN or its absolute value is > 1.
• Result is zero, if argument is zero.

Syntax:

```public static double atan(double a)
Parameters:
a - the argument whose arc tangent value we need.
Returns:
arc tan value of the argument.```

12. copySign() : java.lang.Math.copySign() method returns first floating-point argument but having the sign of second argument.

Syntax:

```public static double copySign(double m, double s)
or
public static float copySign(float m, float s)
Parameters:
m - magnitude
s - sign
Returns:
returns first argument with sign of second floating-point argument.```

Java code explaining atan(), ceil(), copySign() method in lang.Math class.

## Java

 `// Java program explaining lang.Math class methods``// atan(), ceil(), copySign()` `import` `java.math.*;``public` `class` `NewClass``{``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Use of atan() method``        ``double` `Atani = Math.atan(``0``);``        ``System.out.println(``"atan value of Atani : "``+Atani);``        ``double` `x = Math.PI/``2``;` `        ``// Use of toRadian() method``        ``x = Math.toRadians(x);``        ``double` `Atanj = Math.atan(x);``        ``System.out.println(``"atan value of Atanj : "``+Atanj);``        ``System.out.println(``""``);`  `        ``// Use of ceil() method``        ``double` `val = ``15.34` `,ceilval;``        ``ceilval = Math.ceil(val);``        ``System.out.println(``"ceil value of val : "``+ceilval);``        ``System.out.println(``""``);` `        ``double` `dblMag = val;``        ``double` `dblSign1 = ``3``;``        ``double` `dblSign2 = -``3``;`  `        ``// Use of copySign() method``        ``double` `result1 = Math.copySign(dblMag,dblSign1);``        ``System.out.println(``"copySign1 : "``+result1);` `        ``double` `result2 = Math.copySign(dblMag,dblSign2);``        ``System.out.println(``"copySign2 : "``+result2);``        ` `    ``}``}`

Output :

```atan value of Atani : 0.0
atan value of Atanj : 0.0274087022410345

ceil value of val : 16.0

copySign1 : 15.34
copySign2 : -15.34```

Next Article: Java.lang.math | Set 2

This article is contributed by Mohit Gupta_OMG ðŸ˜€. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.