Clase Java Math y sus métodos.

En este artículo, daremos una breve descripción general de la clase Math en Java. Hablemos de los métodos de esta clase y cómo usarlos. La clase Math reside en el paquete java.lang y proporciona un conjunto de métodos estáticos para realizar varios cálculos matemáticos diferentes. Los siguientes son ejemplos de cálculos para los cuales la clase de Matemáticas puede resultar útil:

• Cálculo de valores absolutos (valores de módulo)
• Cálculo de valores de funciones trigonométricas (senos, cosenos, etc.)
• Elevación en varios grados.
• Extracción de raíces de varios grados.
• Generación de números aleatorios
• redondeo
• Etc.

A continuación intentaremos ver cómo la clase Java Math ayuda a resolver los problemas enumerados anteriormente. Comencemos a analizar la clase con métodos que le permitan calcular un valor módulo. El método abs es responsable de esto. Este método está sobrecargado y la clase Math tiene las siguientes diferencias:

• abdominales dobles estáticos (doble a)
• abs de flotación estática (flotación a)
• estático int abs(int a)
• abdominales largos estáticos (a larga)

Ejemplo de uso:

public static void main(String[] args) {
        System.out.println(Math.abs(-1));      // 1
        System.out.println(Math.abs(-21.8d));  // 21.8
        System.out.println(Math.abs(4532L));   // 4532
        System.out.println(Math.abs(5.341f));  // 5.341
    }

Calcular los valores de funciones trigonométricas.

La clase de Matemáticas le permite calcular varias funciones trigonométricas: senos, cosenos, tangentes, etc. Puede encontrar una lista completa de métodos en el sitio web de documentación oficial . A continuación se muestra una lista de estos métodos:

• doble pecado estático (doble a)
• cos doble estático (doble a)
• doble bronceado estático (doble a)
• doble asin estático (doble a)
• acos dobles estáticos (doble a)
• doble atan estático (doble a)

Los métodos calculan: seno, coseno, tangente, arcoseno, arcocoseno, arcotangente. Cada método calcula un valor para el ángulo "a". Este parámetro se pasa a cada método y en cada caso se mide en radianes (y no en grados, como estamos acostumbrados). Aquí hay dos noticias, buenas y malas. Empecemos por el bueno. La clase Math tiene métodos para convertir radianes a grados y grados a radianes:

• doble estático a grados (doble angrad)
• doble estático a radianes (doble angdeg)

Aquí el método toDegrees convertirá el ángulo angrad, medido en radianes, a grados. El método toRadians, por el contrario, convierte el ángulo angdeg, medido en grados, en radianes. La mala noticia es que esto sucede con algún error. A continuación se muestra un ejemplo de cálculo de senos y cosenos:

public static void main(String[] args) {
        System.out.println(Math.sin(Math.toRadians(0)));
        System.out.println(Math.sin(Math.toRadians(30)));
        System.out.println(Math.sin(Math.toRadians(90)));

        System.out.println(Math.cos(Math.toRadians(0)));
        System.out.println(Math.cos(Math.toRadians(30)));
        System.out.println(Math.cos(Math.toRadians(90)));
    }

El programa generará:

0.0
0.49999999999999994
1.0

1.0
0.8660254037844387
6.123233995736766E-17

Lo cual no se corresponde del todo con las tablas de senos y cosenos, en parte debido a errores en la conversión de grados a radianes.

exponenciación

Para elevar un número a una potencia, la clase Math proporciona un método pow, que tiene la siguiente firma:

static double pow(double a, double b)

Este método eleva el parámetro "a" a la potencia "b". Ejemplos:

public static void main(String[] args) {
        System.out.println(Math.pow(1,2)); // 1.0
        System.out.println(Math.pow(2,2)); // 4.0
        System.out.println(Math.pow(3,2)); // 9.0
        System.out.println(Math.pow(4,2)); // 16.0
        System.out.println(Math.pow(5,2)); // 25.0

        System.out.println(Math.pow(1,3)); // 1.0
        System.out.println(Math.pow(2,3)); // 8.0
        System.out.println(Math.pow(3,3)); // 27.0
        System.out.println(Math.pow(4,3)); // 64.0
        System.out.println(Math.pow(5,3)); // 125.0
    }

Extracción de raíces

La clase de Matemáticas proporciona métodos para extraer raíces cuadradas y cúbicas. Los siguientes métodos son responsables de este procedimiento:

• raíz doble estática (doble a)
• cbrt doble estático (doble a)

El método sqrt toma la raíz cuadrada y el método cbrt toma la raíz cúbica. Ejemplos:

public static void main(String[] args) {
        System.out.println(Math.sqrt(4));   // 2.0
        System.out.println(Math.sqrt(9));   // 3.0
        System.out.println(Math.sqrt(16));  // 4.0

        System.out.println(Math.cbrt(8));   // 2.0
        System.out.println(Math.cbrt(27));  // 3.0
        System.out.println(Math.cbrt(125)); // 5.0
    }

Generación de números aleatorios

Para generar números aleatorios, la clase Math proporciona el método aleatorio. Este método genera un número real (doble) positivo aleatorio en el rango de 0,0 a 1,0. La firma del método se ve así:

public static double random()

Veamos ejemplos:

public static void main(String[] args) {
    for (int i = 0; i < 5; i++) {
        System.out.println(Math.random());
    }
}

Después de ejecutar el método principal, se mostró lo siguiente en la consola:

0.37057465028778513
0.2516253742011597
0.9315649439611121
0.6346725713527239
0.7442959932755443

Con un poco de manipulación, puede utilizar el método aleatorio de la clase Math para obtener números aleatorios enteros que se encuentran en un rango determinado. A continuación se muestra un ejemplo de una función que toma dos argumentos min y max y devuelve un número entero aleatorio que se encuentra en el rango de min (inclusive) a max (inclusive):

static int randomInARange(int min, int max) {
    return  (int) (Math.random() * ((max - min) + 1)) + min;
}

Escribamos un método principal en el que probaremos el método randomInARange:

public class MathExample {


    public static void main(String[] args) {
        // Карта, в которой мы будем хранить количество выпадений Cómoого-то числа
        Map<Integer, Integer> map = new TreeMap<>();

        // За 10000 операций
        for (int i = 0; i < 10000; i++) {

            // Сгенерируем рандомное число от -10 включительно до 10 включительно
            final Integer randomNumber = randomInARange(-10, 10);


            if (!map.containsKey(randomNumber)) {
                // Если карта еще не содержит "выпавшего случайного числа"
                // Положим его в карту с кол-вом выпадений = 1
                map.put(randomNumber, 1);
            } else {
                // Иначе, увеличим количество выпадений данного числа на 1
                map.put(randomNumber, map.get(randomNumber) + 1);
            }
        }

        // Выведем на экран содержимое карты в формате ключ=[significado]
        for (Map.Entry<Integer, Integer> entry : map.entrySet()){
            System.out.println(String.format("%d=[%d]", entry.getKey(), entry.getValue()));
        }
    }

    static int randomInARange(int min, int max) {
        return  (int) (Math.random() * ((max - min) + 1)) + min;
    }
}

Después de ejecutar el método principal, el resultado podría verse así:

-10=[482]
-9=[495]
-8=[472]
-7=[514]
-6=[457]
-5=[465]
-4=[486]
-3=[500]
-2=[490]
-1=[466]
0=[458]
1=[488]
2=[461]
3=[470]
4=[464]
5=[463]
6=[484]
7=[479]
8=[459]
9=[503]
10=[444]

Process finished with exit code 0

redondeo

Para redondear números en Java, una de las herramientas son los métodos de la clase Math. Más precisamente, los métodos redondo, de techo y de suelo:

• ronda larga estática (doble a)
• ronda int estática (flotante a)
• piso doble estático (doble a)
• techo doble estático (doble a)

El método de la ronda: rondas como de costumbre para la persona promedio. Si la parte fraccionaria del número es mayor o igual a 0,5, el número se redondeará hacia arriba; en caso contrario, se redondeará hacia abajo. El método del suelo siempre, independientemente de los valores de la parte fraccionaria, redondea el número hacia abajo (hacia el infinito negativo). El método ceil, por el contrario, independientemente de los valores de la parte fraccionaria, redondea los números hacia arriba (hacia el infinito positivo). Veamos ejemplos:

public static void main(String[] args) {
    System.out.println(Math.round(1.3)); // 1
    System.out.println(Math.round(1.4)); // 1
    System.out.println(Math.round(1.5)); // 2
    System.out.println(Math.round(1.6)); // 2

    System.out.println(Math.floor(1.3)); // 1.0
    System.out.println(Math.floor(1.4)); // 1.0
    System.out.println(Math.floor(1.5)); // 1.0
    System.out.println(Math.floor(1.6)); // 1.0

    System.out.println(Math.ceil(1.3)); // 2.0
    System.out.println(Math.ceil(1.4)); // 2.0
    System.out.println(Math.ceil(1.5)); // 2.0
    System.out.println(Math.ceil(1.6)); // 2.0
}

Conclusión

En este artículo, echamos un vistazo superficial a la clase de Matemáticas. Vimos cómo usando esta clase puedes:

• Calcular valores del módulo;
• Calcular valores de funciones trigonométricas;
• Elevar números a potencias;
• Extraer raíces cuadradas y cúbicas;
• Generar números aleatorios;
• Números redondos.

Hay muchos otros métodos interesantes en esta clase. Que se puede encontrar en el sitio web de documentación oficial . Bueno, para un primer contacto, los métodos enumerados anteriormente son suficientes.