Tutorialspoint.dev

Java.lang.StrictMath class in Java | Set 2

Java.lang.StrictMath Class in Java | Set 1

More methods of java.lang.StrictMath class

  1. exp() : java.lang.StrictMath.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
    
  2. cosh() : java.lang.StrictMath.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.
    
  3. decrementExact() : java.lang.StrictMath.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.
    
  4. Java code explaining exp(), decrementExact(), cosh() method in lang.StrictMath class.

    // Java program explaining lang.StrictMath 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 = StrictMath.cosh(value);
            System.out.println("Hyperbolic Cosine of "  + coshValue);
            System.out.println("");
      
            // Use of decrementExact() method
            int result = StrictMath.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 = StrictMath.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. log10() : java.lang.StrictMath.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.StrictMath.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
    
  7. incrementExact() : java.lang.StrictMath.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
  8. JAVA code explaining incrementExact(), log10(), pow() method in lang.StrictMath 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 = StrictMath.incrementExact(f1);
            System.out.println("Incremented value of f1 : " + f1);
      
            f2 = StrictMath.incrementExact(f2);
            System.out.println("Incremented value of f2 : " + f2);
            System.out.println("");
             
      
            // Use of log10() method
            double value = 10;
            double logValue = StrictMath.log10(value);
            System.out.println("Log10 value of 10 : " + logValue);
            System.out.println("");
      
            // Use of pow() method
            double b = 10, e = 2;
            double power = StrictMath.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.StrictMath.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. max() : java.lang.StrictMath.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. 
    
  11. round() : java.lang.StrictMath.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
    
  12. Java code explaining signum(), round(), max() method in lang.StrictMath class.



    // Java code explaining the lang.StrictMath 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 = StrictMath.signum(x);
            System.out.println("Signum of 10.45 = " + signm);
      
            signm = StrictMath.signum(y);
            System.out.println("Signum of -23.34 = " + signm);
            System.out.println("");
      
            // Use of round() method
            double r1 = StrictMath.round(x);
            System.out.println("Round off 10.4556 = " + r1);
      
            double r2 = StrictMath.round(y);
            System.out.println("Round off 23.34789 = " + r2);
            System.out.println("");
      
            // Use of max() method on r1 and r2
            double m = StrictMath.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. ulp() : java.lang.StrictMath.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.
    
  14. log1p() : java.lang.StrictMath.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.
    
  15. Java code explaining ulp(), log1p() method in lang.StrictMath class.

    // Java code explaining the lang.StrictMath 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 = StrictMath.ulp(x);
            System.out.println("ulp of 34.652    : " + u);
      
            u = StrictMath.ulp(y);
            System.out.println("ulp of -23.34789 : " + u);
            System.out.println("");
      
            // Use of log() method
            double l = 99;
            double l1 = StrictMath.log1p(l);
            System.out.println("Log of (1 + 99)  : " + l1);
      
            l1 = StrictMath.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