Java.lang.Math Class in Java | Set 2 (original) (raw)

Last Updated : 13 Sep, 2023

Java.lang.Math Class in Java | Set 1

More Methods:

1. cosh() : java.lang.Math.cosh() method returns the hyperbolic cosine of the argument passed.
   Special cases :
   • Result is NaN, if argument is NaN.
   • Result is 1.0, if the argument is zero.
   • Result is +ve infinity, if argument is infinite.
     Syntax:
     public static double cosh(double arg)
     Parameters:
     arg - The number whose hyperbolic cosine is to be returned.
     Returns:
     the hyperbolic cosine of the argument arg.
2. decrementExact() : java.lang.Math.decrementExact() method decrements the value of passed argument by one.
   Syntax:
   public static int decrementExact(int arg)
   or

public static long decrementExact(long arg)
Parameters:
arg - argument passed.
Returns:
return argument decremented by one.
Throws:
Exception if the result overflows long or int datatype, according to the
argumented data type. 3. exp() : java.lang.Math.exp(double arg) method returns the Euler’s number raised to the power of double argument.
Important cases:

• Result is NaN, if argument is NaN.
• Result is +ve infinity, if the argument is +ve infinity.
• Result is +ve zero, if argument is -ve infinity.
  Syntax:
  public static double exp(double arg)
  Parameters:
  arg - argument passed.
  Returns:
  Euler’s number raised to the power of passed argument

Java code explaining exp(), decrementExact(), cosh() method in lang.Math class.

import java.math.*;

public class NewClass

{

`` public static void main(String[] args)

`` {

`` double value = 2 ;

`` double coshValue = Math.cosh(value);

`` System.out.println( "Hyperbolic Cosine of " + coshValue);

`` System.out.println( "" );

`` int result = Math.decrementExact( 3051 );

`` System.out.println( "Use of decrementExact() : " + result);

`` System.out.println( "" );

`` double exponent = 34 ;

`` double expVal = Math.exp(exponent);

`` System.out.println( "Value of exp : " + expVal);

`` }

}

Output:

Using addExact() : 9

acos value of Asini : NaN acos value of Asinj : 0.054858647341251204

cube root : 6.0

1. incrementExact() : java.lang.Math.incrementExact() method returns the argument by incrementing it’s value.
   Syntax:
   public static int incrementExact(int arg)
   or

public static long incrementExact(long arg)
Parameters:
arg - the argument
Returns:
incremented value of the argument 5. log10() : java.lang.Math.log10() method returns the base10 logarithmic value of the passed argument.
Syntax:
public static double log(double arg)
Parameters:
arg - argument passed.
Returns:
base10 logarithmic value of the argument passed. 6. pow() : java.lang.Math.pow(double b, double e) method returns the value as be
Syntax:
public static double pow(double b,double e)
Parameters:
b : base
e : exponent
Returns:
value as baseexponent

JAVA code explaining incrementExact(), log10(), pow() method in lang.Math class.

import java.lang.*;

public class NewClass

{

`` public static void main(String[] args)

`` {

`` int f1 = 30 , f2 = - 56 ;

`` f1 =Math.incrementExact(f1);

`` System.out.println( "Incremented value of f1 : " +f1);

`` f2 =Math.incrementExact(f2);

`` System.out.println( "Incremented value of f2 : " +f2);

`` System.out.println( "" );

`` double value = 10 ;

`` double logValue = Math.log10(value);

`` System.out.println( "Log10 value of 10 : " +logValue);

`` System.out.println( "" );

`` double b = 10 , e = 2 ;

`` double power = Math.pow(b,e);

`` System.out.println( "Use of pow() : " +power);

`` }

}

Output :

Incremented value of f1 : 31 Incremented value of f2 : -55

Log10 value of 10 : 1.0

Use of pow() : 100.0

1. signum() : java.lang.Math.signum() method returns the signum value of the argument passed.
   -1 if x < 0
   signum fun(x) = 0 if x = 0
   1 if x > 0

Note: Result is NaN, if passed the argument is NaN.;
Syntax:
public static double signum(double x)
or
public static float signum(float x)
Parameters:
x - the argument whose signum value we need
Returns:
signum value of x 8. round() : java.lang.Math.round() method round off the passed argument upto closest decimal places.
Note: Result is 0, if the argument is NaN.
Syntax:
public static long round(long arg)
or
public static double round(double arg)
Parameters:
arg - argument needs to round off
Returns:
round off value of the argument 9. max() : java.lang.Math.max(double v1, double v2) method returns the greater value out of the two passed argument values.
This method just compares using magnitude without considering any sign.
Syntax:
public static double max(double v1, double v2)
Parameters:
v1 - first value
v2 - second value
Returns:
v1 or v2 based on which number is greater.
It can return either of the two if v1 = v2.

Java code explaining signum(), round(), max() method in lang.Math class.

import java.lang.*;

public class NewClass

{

`` public static void main(String args[])

`` {

`` double x = 10.4556 , y = - 23.34789 ;

`` double signm = Math.signum(x);

`` System.out.println( "Signum of 10.45 = " +signm);

`` signm = Math.signum(y);

`` System.out.println( "Signum of -23.34 = " +signm);

`` System.out.println( "" );

`` double r1 = Math.round(x);

`` System.out.println( "Round off 10.4556 = " +r1);

`` double r2 = Math.round(y);

`` System.out.println( "Round off 23.34789 = " +r2);

`` System.out.println( "" );

`` double m = Math.max(r1, r2);

`` System.out.println( "Max b/w r1 and r2 = " +r2);

`` }

}

Output:

Signum of 10.45 = 1.0 Signum of -23.34 = -1.0

Round off 10.4556 = 10.0 Round off 23.34789 = -23.0

Max b/w r1 and r2 = -23.0

1. log1p() : java.lang.Math.log1p() method returns natural log of (passed argument + 1).
   Syntax:
   public static double log1p(double arg)
   Parameters:
   arg - the argument
   Returns:
   log of (argument + 1).
   This result is within 1 unit in the last place of exact result.
2. ulp() : java.lang.Math.ulp() method returns Unit of least precision(ulp) ie. the least distance between two floating point numbers.
   Here, it is the least distance b/w the argument and next larger value.
   Syntax:
   public static double ulp(double arg)
   or

public static float ulp(float arg)
Parameters:
arg - argument passed.
Returns:
least distance b/w the argument and next larger value.

Java code explaining ulp(), log1p() method in lang.Math class.

import java.lang.*;

public class NewClass

{

`` public static void main(String args[])

`` {

`` double x = 34.652 , y = - 23.34789 ;

`` double u = Math.ulp(x);

`` System.out.println( "ulp of 34.652 : " +u);

`` u = Math.ulp(y);

`` System.out.println( "ulp of -23.34789 : " +u);

`` System.out.println( "" );

`` double l = 99 ;

`` double l1 = Math.log1p(l);

`` System.out.println( "Log of (1 + 99) : " +l1);

`` l1 = Math.log( 100 );

`` System.out.println( "Log of 100 : " +l1);

`` }

}

Output:

ulp of 34.652 : 7.105427357601002E-15 ulp of -23.34789 : 3.552713678800501E-15

Log of (1 + 99) : 4.605170185988092 Log of 100 : 4.605170185988092

.