La clase java.lang.Math contiene métodos para realizar operaciones matemáticas básicas, como exponenciales elementales, logaritmos, raíces cuadradas y funciones trigonométricas.
Nota: todos los campos y métodos de la clase Math son estáticos, por lo que puede usar directamente el nombre de la clase al llamar.
1. Constantes de campo:
1.1 La base del
doble E final estático público del logaritmo natural
está más cerca del valor doble de e (la base del logaritmo natural) que cualquier otro valor. Valor: 2.718281828459045
1.2 PI
doble final estático público PI
está más cerca del valor doble de pi (la relación entre la circunferencia de un círculo y su diámetro) que cualquier otro valor. Valor: 3.141592653589793
2. Método:
2.1 Valor absoluto
public static int abs(int a)
public static long abs(long a)
public static float abs(float a)
public static double abs(double a)
devuelve el valor absoluto del valor del parámetro. Si el argumento no es negativo, se devuelve. Si el argumento es negativo, devuelve el inverso del argumento.
Ejemplo:
Math.abs(-3); // devuelve 3
Math.abs(0); // devuelve 0
Math.abs(3); // devuelve 3
Math.abs(-0.7F); // devuelve 0.7F
2.2 Devuelve un valor más pequeño
public static int min(int a, int b)
public static long min(long a, long b)
public static float min(float a, float b)
public static double min(doble a, doble b)
return El menor de los dos valores de parámetro. Es decir, el resultado es un argumento más cercano al infinito negativo. Si los valores de los parámetros son los mismos, el resultado también es el mismo valor.
Ejemplo:
Math.min(0, 3); // devuelve 0
Math.min(3, 0); // devuelve 0
Math.min(-1, 3); // devuelve -1
Math.min(3, 3) ); // devuelve 3
2.3 Devolver un valor mayor
public static int max(int a, int b)
public static long max(long a, long b)
public static float max(float a, float b)
public static double max(doble a, doble b )
devuelve el mayor de los dos valores de parámetro. Es decir, el resultado es un argumento más cercano al infinito positivo. Si los valores de los parámetros son los mismos, el resultado también es el mismo valor.
Ejemplo:
Math.max(0, 3); // devuelve 3
Math.max(3, 0); // devuelve 3
Math.max(-1, 3); // devuelve 3
Math.max(3, 3) ; // devuelve 3
2.4 Devuelve el entero adyacente en la dirección del infinito positivo
public static double floor (doble d)
devuelve el número de punto flotante más grande (el más cercano al infinito positivo), que es menor o igual que el parámetro e igual a un cierto número entero.
Ejemplo:
Math.floor(0); // devuelve 0.0
Math.floor(10); // devuelve 10.0
Math.floor(10.2); // devuelve 10.0
Math.floor(-10.2); // devuelve -11.0
Math. floor(10.9); // devuelve 10.0
Math. floor(-10.9); // devuelve -11.0
2.5 Devuelve el entero adyacente en la dirección del infinito negativo
public static double ceil (doble d)
devuelve el número de coma flotante más pequeño (más cercano al infinito negativo), que es mayor o igual que el parámetro e igual a un cierto número entero.
Ejemplo:
Math.ceil(0); // devuelve 0,0
Math.ceil(10); // devuelve 10,0
Math.ceil(10,2); // devuelve 11,0
Math.ceil(-10,2); // devuelve -10,0
Math. ceil(10.9); // devuelve 11.0
Math. ceil(-10.9); // devuelve -10.0
2.6 devuelve el entero más cercano al parámetro
public static int round(float f)
public static long round(doble d)
devuelve el entero más cercano al parámetro. El resultado se redondea a un número entero: agregue 1/2, llame al piso en el resultado y convierta el resultado resultante en tipo int. En otras palabras, el resultado es igual al valor de la siguiente expresión: (int)Math.floor(a + 0.5f).
Ejemplo:
Math.round(10); // devuelve 10
Math.round(10.2); // devuelve 10
Math.round(-10.2); // devuelve -10
Math.round(10.9); // devuelve 11
Math. ronda(-10.9); // devuelve -11
2.7 Devuelve el entero más cercano al parámetro mediante el redondeo
public static double rint(doble d)
devuelve el valor doble más cercano al parámetro e igual a un cierto número entero. Si dos valores dobles que son ambos enteros son igualmente cercanos, el resultado es par.
Ejemplo:
Math.rint(1); // devuelve 1,0
Math.rint(1,2); // devuelve 1,0
Math.rint(1,9); // devuelve 2,0
Math.rint(1,5); // devuelve 2,0 (cuando el decimal es 5, los enteros 1 y 2 son igualmente cercanos, pero 2 es par, por lo que el resultado es 2)
Math.rint(2.5); // devuelve 2.0 (cuando el decimal es 5, los enteros 1 y 2 son igualmente cercanos, pero 2 es par, entonces el resultado es 2)
2.8 Devolver e a la potencia de d
public static double exp(doble d)
devuelve el valor de e (es decir, la base del logaritmo natural) a la potencia de d.
Ejemplo:
Math.exp(0); // devuelve 1.0
Math.exp(2); // devuelve 7.38905609893065
Math.exp(3.3); // devuelve 27.112638920657883
Math.exp(-3.3); // devuelve 0.036883167401240015
2.9 Devolver e elevado a d menos 1
public static double expm1(doble d)
devuelve el valor de e (es decir, la base del logaritmo natural) elevado a d menos 1.
Ejemplo:
Math.expm1(0); // devuelve 1.0
Math.expm1(2); // devuelve 6.38905609893065
Math.expm1(3.3); // devuelve 26.112638920657883
Math.expm1(-3.3); // devuelve -0.96311683259876
2.10 Devolver a elevado a b
public static double pow(doble a, doble b)
devuelve el valor del primer parámetro elevado a la potencia del segundo parámetro.
Ejemplo:
Math.pow(2, 5); // devuelve 32,0
Math.pow(2, -5); // devuelve 0,03125
Math.pow(2,1, 5); // devuelve 40,84101000000001
Math.pow(-2, 5) ); // devuelve -32.0
Math.pow(10, 0); // devuelve 1.0
Math.pow(0, 10); // devuelve 0.0
2.11 Devuelve un número de punto flotante pseudoaleatorio
public static double random()
devuelve un valor doble con un signo positivo, que es mayor o igual a 0,0 y menor que 1,0. El valor devuelto es un número elegido pseudoaleatoriamente, distribuido (aproximadamente) uniformemente en el rango.
Ejemplo:
Math.random(); // retorno: 0.739333266112564 (cada llamada obtendrá un valor de retorno diferente)
2.12 Devuelve la raíz cuadrada positiva
public static double sqrt(doble d)
devuelve la raíz cuadrada positiva del valor double redondeado correctamente.
Ejemplo:
Math.sqrt(0); // devuelve 0.0
Math.sqrt(4); // devuelve 2.0
Math.sqrt(-4); // devuelve NaN
Math.sqrt(10.8); // devuelve 3.286335345030997
2.13 Devolver la raíz cúbica
public static double cbrt(doble d)
devuelve la raíz cúbica del valor doble.
Ejemplo:
Math.cbrt(0); // devuelve 0.0
Math.cbrt(8); // devuelve 2.0
Math.cbrt(-8); // devuelve -2.0
Math.cbrt(10.8); // devuelve 2.2104188991842317
2.14 Conversión de ángulos y radianes
doble estático público a radianes (doble ángulo)
convierte el ángulo expresado en ángulos en un ángulo aproximadamente igual expresado en radianes. Esta conversión suele ser inexacta.
public static double toDegrees(double angrad)
Convierte un ángulo expresado en radianes en un ángulo aproximadamente equivalente expresado en grados. Esta conversión suele ser inexacta.
Ejemplo:
Math.toRadians(30); // devuelve 0,5235987755982988
Math.toRadians(90); // devuelve 1,5707963267948966
Math.toDegrees(0,5235987755982988); // devuelve 29,9999999999999996 Math.toDegrees
(1,57) 07963267948966); // devuelve 90.0
2.15 La función trigonométrica
public static double sin(doble radianes)
devuelve el seno trigonométrico de un ángulo. El argumento es el ángulo expresado en radianes.
public static double sinh(doble radianes)
Devuelve el seno hiperbólico de un valor doble. El argumento es el ángulo expresado en radianes.
public static double cos(doble radianes)
devuelve el coseno trigonométrico del ángulo. El argumento es el ángulo expresado en radianes.
public static double cosh(doble radianes)
devuelve el coseno hiperbólico del valor doble. El argumento es el ángulo expresado en radianes.
public static double tan(doble radianes)
Devuelve la tangente trigonométrica de un ángulo. El argumento es el ángulo expresado en radianes.
public static double tanh(doble radianes)
Devuelve la tangente hiperbólica de un valor doble. El argumento es el ángulo expresado en radianes.
public static double asin(doble d)
Devuelve el arcoseno de un valor; el ángulo devuelto oscila entre -pi/2 y pi/2. El argumento es el ángulo expresado en radianes.
public static double acos(doble d)
Devuelve el arcocoseno de un valor; el ángulo devuelto oscila entre 0,0 y pi. El argumento es el ángulo expresado en radianes.
público estático doble atan (doble d)
Devuelve el arcotangente de un valor; los ángulos devueltos van desde -pi/2 a pi/2. El argumento es el ángulo expresado en radianes.
public static double atan2(double y, double x)
convierte las coordenadas rectangulares (x, y) en coordenadas polares (r, theta) y devuelve el ángulo theta resultante. Este método calcula el ángulo de fase theta de -pi a pi calculando la arcotangente de y/x.
Ejemplo:
Math.sin(Math.toRadians(30)); // devuelve 0,499999999999999994
Math.sinh(Math.toRadians(30)); // devuelve 0,5478534738880397
Math.cos(Math.toRadians(30)); // devuelve 0,8660254037844 387
Math.cosh (math.toradians (30)); // Devuelve 1.1402383210764286
math.tan (math.toradians (30)); // Devuelve 0.5773502691896257
math.tanh (30)); // Devuelve 0.480472781564516
Math. asin(Math .toRadians(30)); // devuelve 0.5510695830994463
Math.acos(Math.toRadians(30)); // devuelve 1.0197267436954502
Math.atan(Math.toRadians(30)); // devuelve 0.48234790710102493
Math. atan2( 2, 3 ); // devuelve 0.5880026035475675
2.16 Devuelve el signo del parámetro
public static float signum(float f)
public static double signum(doble d)
devuelve la función de signo del parámetro; si el parámetro es 0, devuelve 0; si el parámetro es mayor que 0, devuelve 1.0 ; si el parámetro es menor que 0, devuelve -1.0.
Ejemplo:
Math.signum(0); // devuelve 0.0
Math.signum(1); // devuelve 1.0
Math.signum(-1); // devuelve -1.0
Math.signum(10); // devuelve 1.0
Math. signum(10.1); // devuelve 1.0
2.17 Copy Sign
public static float copySign(magnitud flotante, signo flotante)
public static double copySign(magnitud doble, signo doble)
Devuelve el primer argumento de punto flotante con el signo del segundo argumento de punto flotante.
Ejemplo:
Math.copySign(-3, 0); // devuelve 3.0
Math.copySign(2, -3); // devuelve -2.0
Math.copySign(3.3, -3); // devuelve -3.3
Math.copySign( -3.3, 2.1); // devuelve 3.3
2.18 Devuelve el logaritmo del parámetro
public static double log(doble d)
devuelve el logaritmo natural del parámetro (la base es e).
public static double log10(doble d)
devuelve el logaritmo en base 10 del argumento.
public static double log1p(doble d)
devuelve el logaritmo natural (base e) de la suma del argumento y 1. Tenga en cuenta que para parámetros pequeños, el resultado de log1p(d) está más cerca del resultado real de ln(1 + d) que el resultado de punto flotante de log(1.0+d).
Ejemplo:
Math.log(10); // devuelve 2,302585092994046
Math.log10(10); // devuelve 1,0
Math.log1p(10); // devuelve 2,3978952727983707