La clase Math en Java: pow, sqrt, abs, round, random y más

Una caja de herramientas de métodos estáticos

java.lang.Math es una clase llena de funciones matemáticas ya hechas: potencias, raíces, valores absolutos, redondeo, trigonometría, logaritmos y números aleatorios. Dos cosas la hacen fácil de usar:

• Está en java.lang, que todo archivo Java importa automáticamente. No hay que escribir ninguna línea import.
• Todos los métodos son static. Los llamas sobre el nombre de la clase, Math.sqrt(25), y nunca creas un objeto Math. La página de miembros estáticos explica qué significa static.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.pow(2, 3));    // 8.0
        System.out.println(Math.sqrt(25));     // 5.0
        System.out.println(Math.abs(-7));      // 7
        System.out.println(Math.max(4, 9));    // 9
        System.out.println(Math.round(2.6));   // 3
    }
}

Fíjate en que algunos resultados se imprimen con .0 y otros no. Cada método de Math tiene un tipo de retorno fijo, y conocerlo es casi todo lo que hay que aprender sobre esta clase.

Math.pow: potencias

Math.pow(base, exponent) eleva un número a una potencia. Recibe dos parámetros double y devuelve un double, aunque le pases números enteros:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.pow(2, 3));     // 8.0
        System.out.println(Math.pow(5, 2));     // 25.0
        System.out.println(Math.pow(2, -1));    // 0.5
        System.out.println(Math.pow(9, 0.5));   // 3.0 (una raíz cuadrada)

        int kilobyte = (int) Math.pow(2, 10);
        System.out.println(kilobyte);           // 1024
    }
}

Para guardar el resultado en un int, haz un cast con (int). Para potencias enteras pequeñas el resultado double es exacto, así que el cast da la respuesta correcta. El problema aparece con resultados grandes: un double por encima de Integer.MAX_VALUE (2147483647) se convierte exactamente en Integer.MAX_VALUE, así que (int) Math.pow(2, 40) da 2147483647. Para potencias mayores haz el cast a long, y recuerda que por encima de 2⁵³ un double no puede representar exactamente todos los números enteros. La página de conversión de tipos explica qué le hace un cast al valor.

Java no tiene operador de potencia. 2 ^ 3 compila, pero ^ es el XOR bit a bit, y el resultado es 1, no 8. Es uno de los errores de principiante más comunes en el código matemático de Java.

Un double de diez millones o más se imprime en notación científica, lo que sorprende la primera vez que imprimes una potencia de diez:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.pow(10, 6));          // 1000000.0
        System.out.println(Math.pow(10, 7));          // 1.0E7
        System.out.println((long) Math.pow(10, 7));   // 10000000
    }
}

1.0E7 significa 1.0 × 10⁷. El valor es el mismo; solo cambia la forma de imprimirlo. Haz un cast a long, o formatea con String.format("%.0f", value), para imprimirlo como dígitos normales.

Math.sqrt y Math.cbrt: raíces

Math.sqrt(x) devuelve la raíz cuadrada de x como un double. Math.cbrt(x) devuelve la raíz cúbica.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.sqrt(16));    // 4.0
        System.out.println(Math.sqrt(2));     // 1.4142135623730951
        System.out.println(Math.cbrt(27));    // 3.0
        System.out.println(Math.sqrt(-4));    // NaN

        double a = 3;
        double b = 4;
        System.out.println(Math.sqrt(a * a + b * b));   // 5.0
        System.out.println(Math.hypot(a, b));           // 5.0
    }
}

La raíz cuadrada de un número negativo no es un número real, así que Math.sqrt(-4) devuelve NaN ("not a number", no es un número) en lugar de lanzar una excepción. NaN se propaga por cualquier operación en la que participe, así que comprueba las entradas antes de calcular una raíz si pueden llegar valores negativos. Math.hypot(a, b) calcula sqrt(a*a + b*b) directamente, una forma habitual de obtener la distancia entre dos puntos.

Math.abs: valor absoluto

Math.abs(x) quita el signo. A diferencia de pow y sqrt, devuelve el mismo tipo que le das: un int para un int, un double para un double.

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.abs(-7));      // 7
        System.out.println(Math.abs(7));       // 7
        System.out.println(Math.abs(-2.5));    // 2.5

        int start = 12;
        int end = 5;
        System.out.println("Distance: " + Math.abs(end - start));   // Distance: 7
    }
}

El uso habitual es una diferencia en la que te importa el tamaño y no la dirección, como la distancia entre dos posiciones.

Math.max y Math.min

Math.max(a, b) devuelve el mayor de dos valores y Math.min(a, b) el menor. Reciben exactamente dos argumentos. Para tres o más, anida las llamadas:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.max(4, 9));      // 9
        System.out.println(Math.min(4, 9));      // 4
        System.out.println(Math.max(3, 7.5));    // 7.5

        int a = 12, b = 45, c = 30;
        System.out.println(Math.max(a, Math.max(b, c)));   // 45

        int score = 130;
        int clamped = Math.max(0, Math.min(score, 100));
        System.out.println(clamped);             // 100
    }
}

Cuando los dos argumentos tienen tipos distintos, el más estrecho se amplía primero. Math.max(3, 7.5) compara dos valores double y devuelve un double. El último ejemplo limita un valor al rango de 0 a 100: Math.min lo deja como máximo en 100 y Math.max evita que baje de 0.

Redondeo: round, floor, ceil

Java tiene tres métodos de redondeo, y se diferencian tanto en la dirección como en el tipo de retorno:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.round(2.4));    // 2
        System.out.println(Math.round(2.5));    // 3
        System.out.println(Math.round(-2.5));   // -2

        System.out.println(Math.floor(2.7));    // 2.0
        System.out.println(Math.floor(-2.3));   // -3.0

        System.out.println(Math.ceil(2.1));     // 3.0
        System.out.println(Math.ceil(-2.7));    // -2.0

        System.out.println((int) 2.7);          // 2
        System.out.println((int) -2.7);         // -2
    }
}

• Math.round va al número entero más cercano. Un valor justo en la mitad se redondea hacia arriba, hacia el infinito positivo, así que 2.5 pasa a 3 y -2.5 pasa a -2. Devuelve un long para un argumento double (y un int para un float).
• Math.floor siempre redondea hacia abajo, hacia el infinito negativo, y devuelve un double.
• Math.ceil siempre redondea hacia arriba, hacia el infinito positivo, y devuelve un double.
• Un cast (int) no redondea en absoluto: descarta la parte decimal, lo que baja los números positivos y sube los negativos.

Como Math.round(double) devuelve un long, asignarlo a un int no compila sin un cast:

int n = Math.round(2.6);          // error: incompatible types: possible lossy conversion from long to int
int m = (int) Math.round(2.6);    // OK, m vale 3
long k = Math.round(2.6);         // OK

Para redondear a un número de decimales, multiplica, redondea y vuelve a dividir. Dividir entre 100.0 (un double) en lugar de 100 conserva los decimales:

public class Main {
    public static void main(String[] args) {
        double price = 19.4567;

        System.out.println(Math.round(price * 100) / 100.0);   // 19.46
        System.out.println(Math.round(price * 100) / 100);     // 19

        System.out.println(String.format("%.2f", price));      // 19.46
    }
}

La segunda línea divide un long entre un int, lo que es división entera, así que se pierden los decimales. Cuando solo necesitas mostrar un número redondeado, String.format("%.2f", value) es más sencillo y no cambia el valor guardado.

Math.random: números aleatorios

Math.random() devuelve un double mayor o igual que 0.0 y menor que 1.0. El valor es distinto en cada llamada, así que la salida de los programas de esta sección cambia cada vez que pulsas Run.

public class Main {
    public static void main(String[] args) {
        double r = Math.random();
        System.out.println(r);
        System.out.println(r >= 0.0 && r < 1.0);   // true
    }
}

Para obtener un número entero en un rango, estira ese valor, haz el cast y desplázalo. Para un número entero de min a max, ambos incluidos:

int value = (int) (Math.random() * (max - min + 1)) + min;

Así funciona para un dado, donde min es 1 y max es 6:

1. Math.random() * 6 da un double desde 0.0 hasta 6.0, sin incluir 6.0.
2. (int) descarta la parte decimal y da uno de 0, 1, 2, 3, 4, 5.
3. + 1 lo desplaza a 1, 2, 3, 4, 5, 6.

public class Main {
    public static void main(String[] args) {
        int min = 1;
        int max = 6;

        for (int i = 0; i < 5; i++) {
            int roll = (int) (Math.random() * (max - min + 1)) + min;
            System.out.print(roll + " ");
        }
        System.out.println();

        int lowest = max;
        int highest = min;
        for (int i = 0; i < 10000; i++) {
            int roll = (int) (Math.random() * (max - min + 1)) + min;
            lowest = Math.min(lowest, roll);
            highest = Math.max(highest, roll);
        }
        System.out.println("lowest: " + lowest + ", highest: " + highest);
    }
}

La primera línea muestra cinco tiradas aleatorias. La segunda comprueba diez mil tiradas y, en la práctica, siempre imprime lowest: 1, highest: 6: la fórmula alcanza los dos extremos del rango y nunca los supera.

Los paréntesis alrededor de Math.random() * (max - min + 1) importan. Un cast se aplica al valor que tiene justo después, así que (int) Math.random() * 6 convierte primero Math.random(). Eso siempre es 0, y 0 * 6 es 0, así que todas las "tiradas" salen iguales.

Math.random() está bien para juegos y ejercicios. Para algo más, la clase java.util.Random y ThreadLocalRandom.current().nextInt(min, max + 1) (en java.util.concurrent) devuelven enteros directamente, y Random admite una semilla para repetir la misma secuencia en las pruebas. Ninguno de ellos sirve para contraseñas ni tokens de seguridad; para eso usa java.security.SecureRandom.

Math.PI y Math.E

Math.PI (π) y Math.E (el número de Euler, e) son constantes static final double:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.PI);   // 3.141592653589793
        System.out.println(Math.E);    // 2.718281828459045

        double radius = 3;
        double area = Math.PI * radius * radius;
        double circumference = 2 * Math.PI * radius;

        System.out.printf("area: %.2f%n", area);                     // area: 28.27
        System.out.printf("circumference: %.2f%n", circumference);   // circumference: 18.85
    }
}

Úsalas en lugar de escribir 3.14. Son tan precisas como permite un double, y el nombre le dice al lector qué número es.

Resultados enteros frente a resultados double

La mayoría de los métodos de Math reciben y devuelven double. Cuando les pasas valores int, Java amplía automáticamente los argumentos a double, pero la aritmética que escribes antes de la llamada sigue haciéndose en int. De ahí sale la mayoría de las respuestas incorrectas:

public class Main {
    public static void main(String[] args) {
        int items = 7;
        int perBox = 2;

        System.out.println(Math.ceil(items / perBox));            // 3.0 (incorrecto)
        System.out.println(Math.ceil((double) items / perBox));   // 4.0

        System.out.println(Math.sqrt(10 / 4));     // 1.4142135623730951
        System.out.println(Math.sqrt(10 / 4.0));   // 1.5811388300841898

        int boxes = (int) Math.ceil((double) items / perBox);
        System.out.println(boxes + " boxes");      // 4 boxes
    }
}

items / perBox es 7 / 2, y dividir dos valores int descarta el resto, así que vale 3 antes de que Math.ceil llegue a verlo. Math.ceil(3.0) es 3.0. Haz que uno de los operandos sea un double, con un cast o con un literal como 4.0, para que la división conserve su parte decimal. La página de operadores explica la división entera con más detalle.

La regla general: decide qué tipo quieres al final, haz que la división o la multiplicación se calculen en double cuando importen los decimales, y vuelve a int o long con un solo cast, al final.

Otros métodos útiles

Algunos métodos más de la misma clase, todos llamados de la misma forma:

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.log10(1000));      // 3.0
        System.out.println(Math.log(Math.E));      // 1.0 (logaritmo natural)
        System.out.println(Math.signum(-4.2));     // -1.0

        System.out.println(-7 % 3);                // -1
        System.out.println(Math.floorMod(-7, 3));  // 2

        double angle = Math.toRadians(90);
        System.out.println(Math.sin(angle));       // 1.0

        try {
            Math.addExact(Integer.MAX_VALUE, 1);
        } catch (ArithmeticException e) {
            System.out.println("overflow: " + e.getMessage());   // overflow: integer overflow
        }
    }
}

• Math.log es el logaritmo natural; Math.log10 es en base 10.
• Math.floorMod(a, b) da un resto con el signo de b, que es lo que quieres para dar la vuelta dentro de un rango, como los días de la semana. El operador % conserva el signo de a.
• Los métodos trigonométricos (sin, cos, tan) reciben radianes. Convierte antes los grados con Math.toRadians.
• Math.addExact, Math.multiplyExact y sus métodos hermanos lanzan una ArithmeticException cuando hay desbordamiento, en lugar de dar la vuelta en silencio hasta un número negativo.