Clase Java.lang.StrictMath en Java | Conjunto 1
Más métodos de la clase java.lang.StrictMath
13. exp() : el método java.lang.StrictMath.exp(double arg) devuelve el número de Euler elevado a la potencia del doble argumento.
Casos importantes:
- El resultado es NaN, si el argumento es NaN.
- El resultado es +ve infinito, si el argumento es +ve infinito.
- El resultado es +ve cero, si el argumento es -ve infinito.
Sintaxis:
public static double exp(double arg) Parameters: arg - argument passed. Returns: Euler’s number raised to the power of passed argument
14. cosh() : el método java.lang.StrictMath.cosh() devuelve el coseno hiperbólico del argumento pasado.
Casos especiales :
- El resultado es NaN, si el argumento es NaN.
- El resultado es 1.0, si el argumento es cero.
- El resultado es +ve infinito, si el argumento es infinito.
Sintaxis:
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.
15. decrementExact() : el método java.lang.StrictMath.decrementExact() disminuye el valor del argumento pasado en uno.
Sintaxis:
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.
Código Java que explica el método exp(), decrementExact(), cosh() en la clase lang.StrictMath.
Java
// 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); } }
Producción:
Using addExact() : 9 acos value of Asini : NaN acos value of Asinj : 0.054858647341251204 cube root : 6.0
16. log10() : el método java.lang.StrictMath.log10() devuelve el valor logarítmico base10 del argumento pasado.
Syntax: public static double log(double arg) Parameters: arg - argument passed. Returns: base10 logarithmic value of the argument passed.
17. pow() : el método java.lang.StrictMath.pow(doble b, doble e) devuelve el valor como b e
Syntax: public static double pow(double b, double e) Parameters: b : base e : exponent Returns: value as baseexponent
18. incrementExact() : el método java.lang.StrictMath.incrementExact() devuelve el argumento incrementando su valor.
Syntax: public static int incrementExact(int arg) or public static long incrementExact(long arg) Parameters: arg - the argument Returns: incremented value of the argument
Código JAVA que explica el método incrementExact(), log10(), pow() en la clase lang.StrictMath.
Java
// 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); } }
Producción :
Incremented value of f1 : 31 Incremented value of f2 : -55 Log10 value of 10 : 1.0 Use of pow() : 100.0
19. signum() : el método java.lang.StrictMath.signum() devuelve el valor signum del argumento pasado.
-1 if x < 0 signum fun(x) = 0 if x = 0 1 if x > 0
Nota:
El resultado es NaN, si se pasa, el argumento es Nan.
Sintaxis:
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
20. max() : el método java.lang.StrictMath.max(double v1, double v2) devuelve el mayor valor de los dos valores de argumento pasados.
Este método solo compara usando la magnitud sin considerar ningún signo.
Sintaxis:
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.
21. round() : el método java.lang.StrictMath.round() redondea el argumento pasado hasta los lugares decimales más cercanos.
Nota: El resultado es 0, si el argumento es NaN.
Sintaxis:
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
Código Java que explica el método signum(), round(), max() en la clase lang.StrictMath.
Java
// 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); } }
Producción:
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
22. ulp(): el método java.lang.StrictMath.ulp() devuelve la unidad de menor precisión (ulp), es decir. la menor distancia entre dos números de coma flotante.
Aquí, es la menor distancia entre el argumento y el siguiente valor más grande.
Sintaxis:
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.
23. log1p() : el método java.lang.StrictMath.log1p() devuelve el registro natural de (argumento pasado + 1).
Sintaxis:
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.
Código Java que explica el método ulp(), log1p() en la clase lang.StrictMath.
Java
// 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); } }
Producción:
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
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA