# Java.lang.StrictMath class in Java | Set 1

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

Declaration :

```public final class StrictMath
extends Object```

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. acos() : java.lang.StrictMath.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.
argument is taken as radian
Returns:
arc cosine value of the argument.```

2. abs() : java.lang.StrictMath.abs() method returns the absolute value of any type of the 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.```

3. toRadians() : java.lang.StrictMath.toRadians(double deg) method converts argument (degree) to radians.
Note: StrictMath 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.StrictMath class.

## Java

 `// Java program explaining lang.StrictMath 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 = StrictMath.abs(Vali); ``        ``float` `Absf = StrictMath.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 = StrictMath.acos(``60``); ``        ``System.out.println(``"acos value of Acosi : "` `+ Acosi); ``        ``double` `x = StrictMath.PI; `` ` `        ``// Use of toRadian() method ``        ``x = StrictMath.toRadians(x); ``        ``double` `Acosj = StrictMath.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. cbrt() : java.lang.StrictMath.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```

5. asin() : java.lang.StrictMath.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.```

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

## Java

 `// Java program explaining lang.StrictMath 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 = StrictMath.asin(radd); ``        ``System.out.println(``"asin value of Asini : "` `+ Asini); ``        ``double` `x = StrictMath.PI; `` ` `        ``// Use of toRadian() method ``        ``x = StrictMath.toRadians(x); ``        ``double` `Asinj = StrictMath.asin(x); ``        ``System.out.println(``"asin value of Asinj : "` `+ Asinj); ``        ``System.out.println(``""``); `` ` `        ``// Use of cbrt() method ``        ``double` `cbrtval = StrictMath.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. log() : java.lang.StrictMath.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.```

7. hypot() : java.lang.StrictMath.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. floor() : java.lang.StrictMath.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  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```

9. IEEEremainder() : java.lang.StrictMath.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)```

Java code explaining floor(), hypot(), IEEEremainder(), log() method in lang.StrictMath 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 = StrictMath.floor(f1); ``        ``System.out.println(``"Floor value of f1 : "` `+ f1); `` ` `        ``f2 = StrictMath.floor(f2); ``        ``System.out.println(``"Floor value of f2 : "`  `+ f2); ``        ``System.out.println(``""``); `` ` `        ``// Use of hypot() method ``        ``double` `p = ``12``, b = -``5``; ``        ``double` `h = StrictMath.hypot(p, b); ``        ``System.out.println(``"Hypotenuse : "``+h); ``        ``System.out.println(``""``); `` ` `        ``// Use of IEEEremainder() method ``        ``double` `d1 = ``105``, d2 = ``2``; ``        ``double` `r = StrictMath.IEEEremainder(d1, d2); ``        ``System.out.println(``"Remainder : "` `+ r); ``        ``System.out.println(``""``); ``         ` `        ``// Use of log() method ``        ``double` `l = ``10``; ``        ``l = StrictMath.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.StrictMath.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. copySign() : java.lang.StrictMath.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 second argument with sign of first floating-point argument.```

12. atan() : java.lang.StrictMath.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.
argument is taken as radian
Returns:
arc tan value of the argument.```

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

## Java

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

Refer more methods of lang.StrictMath class at : JAva.lang.StrictMath class in Java | Set 2

Previous
Next
Share your thoughts in the comments
Similar Reads