Operaciones matemáticas básicas

PHP proporciona soporte completo para realizar operaciones matemáticas básicas utilizando operadores aritméticos y funciones integradas. Estas operaciones son esenciales para el desarrollo de aplicaciones que requieren cálculos numéricos.

Los operadores aritméticos en PHP incluyen suma (+), resta (-), multiplicación (*), división (/), módulo (%) y exponenciación (**). A continuación, se muestran ejemplos prácticos de cómo utilizar estos operadores:

<?php
$a = 10;
$b = 3;

$suma = $a + $b;          // 13
$resta = $a - $b;         // 7
$multiplicacion = $a * $b; // 30
$division = $a / $b;       // 3.3333333333333
$modulo = $a % $b;         // 1
$exponenciacion = $a ** $b; // 1000

Es importante tener en cuenta el tipo de datos involucrados en estas operaciones. Al realizar cálculos con enteros y flotantes, PHP maneja automáticamente la conversión de tipos según sea necesario. Por ejemplo:

<?php
$entero = 5;
$flotante = 2.5;

$resultado = $entero * $flotante; // 12.5

En este caso, el resultado es un número flotante debido a la presencia de un valor flotante en la operación.

Cuando se realiza una división entre dos enteros, el resultado puede ser un flotante si la división no es exacta:

<?php
$numerador = 9;
$denominador = 2;

$cociente = $numerador / $denominador; // 4.5

Si se desea obtener un resultado entero, se puede utilizar la función intdiv():

<?php
$cociente_entero = intdiv($numerador, $denominador); // 4

Intentar dividir un número por cero genera un error en tiempo de ejecución. Es recomendable verificar el valor del denominador antes de realizar la operación:

<?php
$denominador = 0;

if ($denominador != 0) {
    $resultado = $numerador / $denominador;
} else {
    echo "Error: División por cero no permitida.";
}

PHP ofrece los operadores de incremento (++) y decremento (--) para aumentar o disminuir el valor de una variable en una unidad:

<?php
$contador = 10;

$contador++; // 11
$contador--; // 10

Estos operadores pueden usarse en forma prefija o postfija, lo que afecta el momento en que se incrementa o decrementa el valor:

<?php
$a = 5;

$b = $a++; // $b es 5, luego $a es 6
$c = ++$a; // $a es 7, luego $c es 7

Para simplificar operaciones, PHP permite usar operadores de asignación compuesta:

<?php
$a = 10;

$a += 5;  // $a es 15
$a -= 3;  // $a es 12
$a *= 2;  // $a es 24
$a /= 4;  // $a es 6
$a %= 4;  // $a es 2
$a **= 3; // $a es 8

Estos operadores hacen el código más conciso y legible.

Como ejemplo práctico, se puede calcular el área de un círculo dado su radio:

<?php
$radio = 5;
$pi = 3.1416;

$area = $pi * ($radio ** 2);

echo "El área del círculo es " . $area; // El área del círculo es 78.54

En este ejemplo, se utiliza la exponenciación para elevar el radio al cuadrado y se multiplican los valores para obtener el área.

Funciones matemáticas (round, ceil, floor, etc.)

PHP ofrece una amplia gama de funciones matemáticas que facilitan la realización de operaciones numéricas más complejas. Entre las funciones más utilizadas se encuentran aquellas destinadas al redondeo de números y otras operaciones matemáticas comunes.

La función round() permite redondear un número flotante al entero más cercano. Esta función es útil cuando se necesita aproximar un resultado numérico. Por ejemplo:

<?php
$numero = 3.6;
$redondeado = round($numero); // 4

$numero_negativo = -2.3;
$redondeado_negativo = round($numero_negativo); // -2

La función round() también acepta un segundo argumento opcional que especifica la cantidad de decimales a considerar:

<?php
$numero = 5.5678;
$redondeado = round($numero, 2); // 5.57

Para redondear siempre hacia arriba, se utiliza la función ceil(). Esta función devuelve el entero inmediato superior al número proporcionado:

<?php
$numero = 4.2;
$redondeado_arriba = ceil($numero); // 5

$numero_negativo = -3.7;
$redondeado_arriba_negativo = ceil($numero_negativo); // -3

De manera similar, la función floor() redondea siempre hacia abajo, devolviendo el entero inmediato inferior:

<?php
$numero = 6.8;
$redondeado_abajo = floor($numero); // 6

$numero_negativo = -1.2;
$redondeado_abajo_negativo = floor($numero_negativo); // -2

Es importante notar el comportamiento de estas funciones con números negativos, ya que pueden resultar contraintuitivas.

Para obtener el valor absoluto de un número, se utiliza la función abs(). Esta función es especialmente útil cuando se necesita trabajar con la magnitud de un número sin considerar su signo:

<?php
$numero = -15;
$valor_absoluto = abs($numero); // 15

La función sqrt() calcula la raíz cuadrada de un número. Si se proporciona un número negativo, la función devolverá NAN (Not A Number):

<?php
$numero = 25;
$raiz_cuadrada = sqrt($numero); // 5

$numero_negativo = -9;
$raiz_cuadrada_negativa = sqrt($numero_negativo); // NAN

Para elevar un número a una potencia específica, se utiliza el operador de exponenciación **. Aunque también está disponible la función pow(), el operador ** es la forma moderna y recomendada:

<?php
$base = 2;
$exponente = 3;

$resultado = $base ** $exponente; // 8

// Usando la función pow()
$resultado_funcion = pow($base, $exponente); // 8

Las funciones max() y min() permiten encontrar el valor máximo y mínimo dentro de un conjunto de números. Pueden aceptar múltiples argumentos o un array:

<?php
$a = 5;
$b = 10;
$c = 3;

$maximo = max($a, $b, $c); // 10
$minimo = min($a, $b, $c); // 3

// Con un array
$numeros = [2, 8, 4, 1];
$valor_maximo = max($numeros); // 8
$valor_minimo = min($numeros); // 1

Para trabajar con logaritmos, PHP ofrece las funciones log() y log10(). La función log() calcula el logaritmo natural (base e) de un número, mientras que log10() calcula el logaritmo en base 10:

<?php
$numero = 100;

$logaritmo_natural = log($numero);   // 4.6051701859881
$logaritmo_base10 = log10($numero);  // 2

La función pi() devuelve el valor de π con la máxima precisión disponible:

<?php
$valor_pi = pi(); // 3.1415926535898

Si se requiere calcular funciones trigonométricas, PHP cuenta con funciones como sin(), cos() y tan(), que operan con radianes:

<?php
$angulo = pi() / 4; // 45 grados en radianes

$seno = sin($angulo);     // 0.70710678118655
$coseno = cos($angulo);   // 0.70710678118655
$tangente = tan($angulo); // 1

Para convertir entre grados y radianes, se pueden utilizar las funciones deg2rad() y rad2deg():

<?php
$grados = 180;
$radianes = deg2rad($grados); // 3.1415926535898

$radianes = pi();
$grados = rad2deg($radianes); // 180

Números aleatorios

En PHP, la generación de números aleatorios es esencial en aplicaciones que requieren valores impredecibles, como tokens de seguridad, claves únicas o datos de prueba. PHP proporciona funciones nativas que facilitan esta tarea de manera eficaz y segura.

La función random_int() es la forma recomendada para obtener números enteros aleatorios dentro de un rango específico. Esta función garantiza resultados criptográficamente seguros, lo que la hace ideal para aplicaciones donde la seguridad es crucial:

<?php
$numeroAleatorio = random_int(1, 100);
echo "El número aleatorio es " . $numeroAleatorio;

En este ejemplo, random_int(1, 100) genera un número entero aleatorio entre 1 y 100. La seguridad criptográfica de esta función evita patrones predecibles, reduciendo el riesgo en aplicaciones sensibles.

Para generar bytes aleatorios, PHP ofrece la función random_bytes(), que devuelve una cadena de bytes aleatorios de la longitud especificada:

<?php
$bytesAleatorios = random_bytes(16);
$tokenSeguro = bin2hex($bytesAleatorios);
echo "El token generado es " . $tokenSeguro;

Aquí, random_bytes(16) genera 16 bytes aleatorios. La función bin2hex() convierte esos bytes en una representación hexadecimal, creando así un token único de 32 caracteres, ideal para identificadores y claves.

Es importante destacar que, aunque existen funciones como mt_rand() y rand(), estas no son adecuadas para fines criptográficos debido a su menor nivel de aleatoriedad y mayor predictibilidad. Por lo tanto, para aplicaciones donde la seguridad es esencial, se debe preferir random_int() y random_bytes().

Si se requiere seleccionar uno o más elementos aleatorios de un array, la función array_rand() es útil. Devuelve una o varias claves aleatorias del array proporcionado:

<?php
$frutas = ['manzana', 'banana', 'cereza', 'naranja'];
$claveAleatoria = array_rand($frutas);
echo "Fruta seleccionada: " . $frutas[$claveAleatoria];

En este caso, se obtiene una fruta aleatoria del array $frutas. Si se necesita obtener múltiples claves, se puede especificar el número de elementos:

<?php
$clavesAleatorias = array_rand($frutas, 2);
echo "Frutas seleccionadas: " . $frutas[$clavesAleatorias[0]] . " y " . $frutas[$clavesAleatorias[1]];

Para barajar el orden de los elementos en un array, la función shuffle() reorganiza el array de forma aleatoria:

<?php
$numeros = [1, 2, 3, 4, 5];
shuffle($numeros);
print_r($numeros);

Después de aplicar shuffle(), los elementos de $numeros estarán en un orden aleatorio, lo cual es útil en juegos o aplicaciones que requieren un ordenamiento impredecible.

En situaciones donde se necesita un número flotante aleatorio entre 0 y 1, se puede utilizar la siguiente expresión combinando random_int() y constantes:

<?php
$numeroFlotante = random_int(0, PHP_INT_MAX - 1) / PHP_INT_MAX;
echo "Número flotante aleatorio: " . $numeroFlotante;

Este método genera un número flotante aleatorio con alta precisión y seguridad, aprovechando el rango máximo de enteros en PHP.

Para generar contraseñas o cadenas aleatorias con caracteres específicos, se puede crear una función personalizada que utilice random_int() para seleccionar caracteres de un conjunto definido:

<?php
function generarCadenaAleatoria($longitud) {
    $caracteres = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
    $cadenaAleatoria = '';
    $max = strlen($caracteres) - 1;
    for ($i = 0; $i < $longitud; $i++) {
        $indiceAleatorio = random_int(0, $max);
        $cadenaAleatoria .= $caracteres[$indiceAleatorio];
    }
    return $cadenaAleatoria;
}

echo "Cadena aleatoria: " . generarCadenaAleatoria(10);

Esta función genera una cadena aleatoria de la longitud especificada, seleccionando caracteres al azar del conjunto definido, lo que es útil para generar contraseñas temporales o identificadores únicos.

En resumen, las funciones random_int() y random_bytes() proporcionan métodos seguros y eficientes para la generación de números y datos aleatorios en PHP. Es esencial utilizar estas funciones en lugar de las obsoletas mt_rand() y rand() para asegurar un nivel adecuado de seguridad y aleatoriedad en las aplicaciones modernas.

Formateo de números

El formateo de números en PHP es esencial para presentar valores numéricos de manera legible y ajustada a las necesidades específicas de una aplicación. PHP proporciona funciones integradas que permiten dar formato a números, ya sea para mostrar cantidades monetarias, porcentajes o para ajustarse a convenciones locales.

Una de las funciones más utilizadas para formatear números es number_format(). Esta función permite dar formato a un número con miles y decimales, facilitando la lectura de cifras largas. Su sintaxis básica es:

<?php
$numero = 1234567.8910;
$formateado = number_format($numero);
echo $formateado; // 1,234,568

En este ejemplo, number_format() redondea el número a su valor entero más cercano y agrega separadores de miles. Para mayor control sobre el número de decimales, los separadores de decimales y miles, number_format() acepta parámetros adicionales:

<?php
$numero = 1234567.8910;
$formateado = number_format($numero, 2, ',', '.');
echo $formateado; // 1.234.567,89

Aquí, el número se formatea con dos decimales, utilizando la coma , como separador decimal y el punto . como separador de miles, que es la convención en muchos países de habla hispana.

Para aplicaciones que requieren mostrar valores monetarios, es recomendable utilizar funciones que respeten la configuración regional. La clase NumberFormatter de la extensión Intl es ideal para este propósito:

<?php
$formatter = new NumberFormatter('es_ES', NumberFormatter::CURRENCY);
$moneda = $formatter->formatCurrency(1234.56, 'EUR');
echo $moneda; // 1.234,56 €

En este caso, se crea un NumberFormatter para la localidad es_ES (España) con el estilo CURRENCY, y se utiliza formatCurrency() para formatear un número como una cantidad en euros. La extensión Intl permite adaptarse a diferentes locales y monedas de manera dinámica.

Es importante verificar que la extensión Intl esté habilitada en el entorno de PHP, ya que es necesaria para utilizar NumberFormatter. Se puede comprobar con la función extension_loaded():

<?php
if (!extension_loaded('intl')) {
    echo "La extensión Intl no está habilitada.";
}

Si se requiere formatear números según diferentes localidades, es posible cambiar el indicador de región en NumberFormatter:

<?php
$formatter = new NumberFormatter('en_US', NumberFormatter::CURRENCY);
$moneda = $formatter->formatCurrency(1234.56, 'USD');
echo $moneda; // $1,234.56

De esta manera, el mismo número se presenta acorde a las convenciones de Estados Unidos, utilizando el símbolo $, el punto como separador decimal y la coma como separador de miles.

Para formatear números con porcentajes, NumberFormatter también ofrece el estilo PERCENT:

<?php
$formatter = new NumberFormatter('es_ES', NumberFormatter::PERCENT);
$porcentaje = $formatter->format(0.75);
echo $porcentaje; // 75 %

En este ejemplo, se formatea el valor 0.75 como un porcentaje, mostrando 75 % según las convenciones españolas.

En ausencia de NumberFormatter, se pueden utilizar funciones como sprintf() (en caso de strings) o printf() (para números) para lograr cierto nivel de formateo:

<?php
$numero = 1234.5678;
printf("El número es %.2f", $numero); // El número es 1234.57

La función printf() permite formatear una cadena con un especificador de formato. En este caso, %.2f indica que el número debe mostrarse con dos decimales.

Para obtener una cadena formateada sin imprimirla directamente, se utiliza sprintf():

<?php
$numero = 3.141592;
$texto = sprintf("El valor de pi es %.3f", $numero);
echo $texto; // El valor de pi es 3.142

Los especificadores de formato en sprintf() son muy flexibles y permiten ajustar el ancho, relleno y alineación del campo, así como el tipo de dato:

<?php
$numero = 42;
$texto = sprintf("El número es %05d", $numero);
echo $texto; // El número es 00042

En este ejemplo, %05d indica que el número entero debe estar formado por al menos cinco dígitos, rellenando con ceros a la izquierda.

Para formatear números en notación científica, también se pueden utilizar los especificadores de formato:

<?php
$numero = 0.0001234;
$texto = sprintf("Notación científica: %e", $numero);
echo $texto; // Notación científica: 1.234000e-4

El especificador %e muestra el número en notación exponencial.

En contextos donde se manejan números muy grandes o se requiere un formateo más sofisticado, es posible combinar funciones. Por ejemplo, para formatear un número grande con separadores de miles y notación abreviada:

<?php
function formatearNumeroAbreviado($numero) {
    if ($numero >= 1000000) {
        return number_format($numero / 1000000, 1) . 'M';
    } elseif ($numero >= 1000) {
        return number_format($numero / 1000, 1) . 'K';
    }
    return number_format($numero);
}

echo formatearNumeroAbreviado(2500);      // 2,5K
echo formatearNumeroAbreviado(5300000);   // 5,3M

Esta función personalizada abrevia números grandes, mostrándolos en millones o miles, lo cual es útil en interfaces de usuario o reportes.

Cuando se trabaja con números negativos y formateo, es importante considerar cómo se presentan los signos:

<?php
$numero = -1234.56;
$formateado = number_format($numero, 2, ',', '.');
echo $formateado; // -1.234,56

Si se desea mostrar los números negativos entre paréntesis, se puede aplicar lógica adicional:

<?php
$numero = -1234.56;
$formateado = number_format(abs($numero), 2, ',', '.');
if ($numero < 0) {
    $formateado = '(' . $formateado . ')';
}
echo $formateado; // (1.234,56)

En este ejemplo, se utiliza abs() para obtener el valor absoluto del número y luego se encapsula entre paréntesis si es negativo.

Para concluir, el formateo de números en PHP es una tarea crucial para la presentación adecuada de datos numéricos. Mediante el uso de funciones como number_format(), NumberFormatter, y las funciones de formato de cadena como sprintf(), es posible adaptar la visualización de los números a los requisitos específicos de cada aplicación, respetando convenciones locales y mejorando la legibilidad y profesionalismo del software desarrollado.