Tutorialspoint.dev

Java.lang.Math Class in Java | Set 2

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 infifnity.
    • 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
    
  4. Java code explaining exp(), decrementExact(), cosh() method in lang.Math class.

    // Java program explaining lang.Math class methods
    // exp(), decrementExact(), cosh()
      
    import java.math.*;
    public class NewClass
    {
        public static void main(String[] args)
        {
            // Use of cosh() method
            double value = 2;
            double coshValue = Math.cosh(value);
            System.out.println("Hyperbolic Cosine of "  + coshValue);
            System.out.println("");
      
            // Use of decrementExact() method
            int result = Math.decrementExact(3051);
            System.out.println("Use of decrementExact() : " + result);
            System.out.println("");
      
      
            // Use of exp() method
            // declare the exponent to be used
            double exponent = 34;
            // raise e to exponent declared
            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
    
  5. 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
  6. 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.
    
  7. 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
    
  8. JAVA code explaining incrementExact(), log10(), pow() method in lang.Math class.

    // Java program explaining lang.MATH class methods
    // incrementExact(), log10(), pow()
      
    import java.lang.*;
    public class NewClass
    {
        public static void main(String[] args)
        {
            // Use of incrementExact() method
            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("");
             
      
            // Use of log10() method
            double value = 10;
            double logValue = Math.log10(value);
            System.out.println("Log10 value of 10 : "+logValue);
            System.out.println("");
      
            // Use of pow() method
            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
    
  9. 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
    
  10. 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
    
  11. 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. 
    
  12. Java code explaining signum(), round(), max() method in lang.Math class.



    // Java code explaining the lang.Math Class methods
    // signum(), round(), max()
      
    import java.lang.*;
    public class NewClass
    {
        public static void main(String args[])
        {
            // Use of signum() method
            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("");
      
            // Use of round() method
            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("");
      
            // Use of max() method on r1 and r2
            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
    
  13. 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.
    
  14. 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.
    
  15. Java code explaining ulp(), log1p() method in lang.Math class.

    // Java code explaining the lang.Math Class methods
    // ulp(), log1p()
      
    import java.lang.*;
    public class NewClass
    {
        public static void main(String args[])
        {
            // Use of ulp() method
            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("");
      
            // Use of log() method
            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
    

    Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above..



This article is attributed to GeeksforGeeks.org

leave a comment

code

0 Comments

load comments

Subscribe to Our Newsletter