🔢

Funciones Matemáticas y Trigonométricas

DIVIDE, ROUND, ABS, MOD, SQRT, LOG, trigonometría completa y mucho más — las 47 funciones matemáticas de DAX

Principiante Intermedio Avanzado

🔍

Bienvenida desde Excel 🌸
Las funciones matemáticas en DAX son casi idénticas a las de Excel — si vienes de ahí, te sentirás como en casa. Pero hay algunas que son exclusivas de DAX y muy importantes para análisis de datos, como DIVIDE (que maneja la división por cero de forma elegante) o CONVERT (para cambiar tipos de datos). Vamos por categorías.

🎯

Las más usadas en proyectos reales

DIVIDE(<numerador>, <denominador>, [<alternativa>])

Principiante

Divide dos números de forma SEGURA. Si el denominador es 0 o BLANK, devuelve el valor alternativo (por defecto BLANK) en lugar de dar error. La forma correcta de dividir en DAX — nunca uses el operador / directamente sin protección.

Ejemplo básico — la diferencia crítica:

// ❌ Nunca hagas esto en una medida:
Ratio PELIGROSO = [Ventas] / [Pedidos]
// Si Pedidos = 0 → ERROR en el visual

// ✅ Siempre usa DIVIDE:
Ticket Medio = DIVIDE([Total Ventas], [Nº Pedidos])
// Si Nº Pedidos = 0 → BLANK (la celda aparece vacía, sin error)

// Con valor alternativo explícito:
Ticket Medio = DIVIDE([Total Ventas], [Nº Pedidos], 0)
// Si Nº Pedidos = 0 → 0

// Margen %:
Margen % = DIVIDE([Total Margen], [Total Ventas], BLANK())

// Variación %:
Variación % = DIVIDE([Ventas Actual] - [Ventas Anterior], [Ventas Anterior], BLANK())

🏆 Best Practice
DIVIDE es más eficiente que IFERROR([Ventas]/[Pedidos], 0) porque está optimizada internamente. Úsala siempre que dividas — es una de esas buenas prácticas que deberían ser automáticas.

ABS(<número>)

Principiante

Devuelve el valor absoluto (sin signo) de un número. Útil para calcular diferencias sin importar el orden, desviaciones y análisis de errores.

Ejemplos:

// Diferencia absoluta entre presupuesto y real (sin importar el signo)
Desviación = ABS([Real] - [Presupuesto])

// Error medio absoluto (MAE — Mean Absolute Error):
MAE = AVERAGEX('Predicciones', ABS('Predicciones'[Predicho] - 'Predicciones'[Real]))

SIGN(<número>)

Intermedio

Devuelve 1 si el número es positivo, -1 si es negativo, 0 si es cero. Útil para clasificar tendencias y crear indicadores visuales de dirección.

Ejemplo:

// Indicador de tendencia como emoji:
Tendencia =
SWITCH(
    SIGN([Variación]),
    1,  "📈 Subida",
    -1, "📉 Bajada",
    "➡️ Sin cambio"
)

MOD(<número>, <divisor>)

Principiante — Intermedio

Devuelve el RESTO de la división entera. Esencial para detectar si un número es par/impar, para ciclos, patrones y lógica de rotación.

Ejemplos:

// ¿El año es bisiesto? (divisible por 4 pero no por 100, excepto por 400)
Es Bisiesto =
IF(
    OR(
        AND(MOD(YEAR('Calendario'[Fecha]), 4) = 0, MOD(YEAR('Calendario'[Fecha]), 100) <> 0),
        MOD(YEAR('Calendario'[Fecha]), 400) = 0
    ),
    TRUE, FALSE
)

// Filas en grupos de 3 (para layout alternado):
Grupo = MOD(ROWNUMBER(ALL('Tabla'), ORDERBY('Tabla'[ID])), 3)

// Color alternado en tabla (usando columna calculada):
'Tabla'[FilaAlterna] = IF(MOD('Tabla'[IndiceOrden], 2) = 0, "Par", "Impar")

QUOTIENT(<numerador>, <denominador>)

Principiante

Devuelve la parte ENTERA de una división (sin el resto). Complementario de MOD — juntos dan el cociente y el resto completos.

Ejemplos:

// Convertir minutos totales a horas y minutos:
VAR TotalMinutos = 150
VAR Horas = QUOTIENT(TotalMinutos, 60)     -- 2 horas
VAR Minutos = MOD(TotalMinutos, 60)         -- 30 minutos
RETURN Horas & "h " & Minutos & "min"       -- "2h 30min"

// Dividir stock en lotes de 12 (cajas completas):
Cajas Completas = QUOTIENT('Productos'[Stock], 12)
Unidades Sueltas = MOD('Productos'[Stock], 12)

🎯

Redondeo — más opciones de las que crees

Tabla comparativa de todas las funciones de redondeo:

FUNCIÓN	QUÉ HACE	EJEMPLO (con 2.567)	RESULTADO
ROUND(n, 2)	Redondea al decimal más cercano	ROUND(2.567, 2)	2.57
ROUNDUP(n, 2)	Siempre redondea HACIA ARRIBA	ROUNDUP(2.561, 2)	2.57
ROUNDDOWN(n, 2)	Siempre redondea HACIA ABAJO	ROUNDDOWN(2.569, 2)	2.56
INT(n)	Redondea al entero inferior (hacia -∞)	INT(2.9) / INT(-2.1)	2 / -3
TRUNC(n, 2)	Trunca (elimina decimales) hacia 0	TRUNC(2.9) / TRUNC(-2.9)	2 / -2
CEILING(n, 1)	Redondea al múltiplo superior	CEILING(2.1, 0.5)	2.5
FLOOR(n, 1)	Redondea al múltiplo inferior	FLOOR(2.9, 0.5)	2.5
MROUND(n, 0.5)	Redondea al múltiplo más cercano	MROUND(2.3, 0.5)	2.5
ISO.CEILING(n, 1)	Como CEILING pero siempre hacia +∞	ISO.CEILING(-2.1, 1)	-2
EVEN(n)	Redondea al entero par superior	EVEN(3) / EVEN(2.1)	4 / 4
ODD(n)	Redondea al entero impar superior	ODD(2) / ODD(3.1)	3 / 5

Diferencia clave INT vs TRUNC:

// Con números negativos:
INT(-2.3)   -- resultado: -3 (redondea hacia -infinito)
TRUNC(-2.3) -- resultado: -2 (trunca hacia 0)

// Con números positivos, ambas dan el mismo resultado:
INT(2.9)   -- 2
TRUNC(2.9) -- 2

Ejemplos prácticos:

// Precio redondeado al múltiplo de 0.05 más cercano:
Precio Redondeado = MROUND('Productos'[Precio], 0.05)
// 1.23 → 1.25, 1.22 → 1.20

// Número de camiones necesarios (siempre redondear arriba):
Camiones Necesarios = CEILING(DIVIDE([TotalUnidades], [CapacidadCamion]), 1)

// Redondear a miles (sin decimales negativos):
En Miles = ROUND([Ventas] / 1000, 1)

// O directamente con decimales negativos:
En Miles v2 = ROUND([Ventas], -3)
// ROUND con decimales negativos redondea a la izquierda del punto decimal:
// ROUND(12345, -3) → 12000

📐

Potencias, raíces y logaritmos

SQRT(<número>) | SQRTPI(<número>)

Principiante

SQRT: Raíz cuadrada. SQRTPI(n) = SQRT(n × π). Útil en estadística y física.

Ejemplo:

// Distancia euclidiana entre dos puntos (Pitágoras):
Distancia = SQRT(POWER([X2] - [X1], 2) + POWER([Y2] - [Y1], 2))

POWER(<base>, <exponente>)

Principiante

Eleva la base al exponente. Equivalente al operador ^ en DAX.

Ejemplos:

// Interés compuesto: Capital × (1 + tasa)^años
Capital Final = 'Inversión'[Capital] * POWER(1 + 'Inversión'[Tasa], 'Inversión'[Años])

// 2^10:
POWER(2, 10) -- 1024

EXP(<número>)

Intermedio

Calcula e^número (número de Euler ≈ 2.71828 elevado a la potencia dada). Fundamental para cálculos de crecimiento exponencial y modelos logísticos.

Ejemplo:

// Modelo de crecimiento exponencial: P(t) = P0 × e^(r×t)
Población Estimada = 'Ciudades'[PoblacionInicial] * EXP('Ciudades'[TasaCrecimiento] * [AñosTranscurridos])

LN(<número>) | LOG(<número>, [<base>]) | LOG10(<número>)

Intermedio

LN: Logaritmo natural (base e). LOG: Logaritmo en la base especificada (por defecto base 10). LOG10: Logaritmo base 10.

Ejemplos:

// Tiempo de duplicación (Rule of 72 precisa):
Tiempo Duplicación = LN(2) / LN(1 + 'Inversión'[TasaAnual])

// Escala logarítmica para valores muy dispares:
Escala Log Ventas = LOG10([Total Ventas])
// Útil cuando tienes desde ventas de 100€ hasta 10.000.000€ en el mismo visual

🔄

Conversión y funciones de utilidad

DEGREES(<radianes>) | RADIANS(<grados>)

Intermedio

Convierten entre grados y radianes. Las funciones trigonométricas de DAX trabajan en radianes, así que necesitas RADIANS() si tu ángulo está en grados.

Ejemplos:

// Convertir 45 grados a radianes:
RADIANS(45)  -- 0.7854 (π/4)

// Convertir π/2 radianes a grados:
DEGREES(PI() / 2)  -- 90

PI()

Principiante

Devuelve el valor de π (3.14159265358979...). Sin argumentos.

Ejemplos:

// Área de un círculo:
Área = PI() * POWER('Formas'[Radio], 2)

// Longitud de circunferencia:
Circunferencia = PI() * 'Formas'[Diámetro]

CONVERT(<valor>, <tipo_dato>)

Intermedio

Convierte un valor a un tipo de dato específico: INTEGER, DOUBLE, DECIMAL, DATETIME, BOOLEAN, STRING, CURRENCY. Más explícito que las conversiones implícitas de DAX.

Ejemplos:

// Convertir texto a entero:
CONVERT("123", INTEGER)  -- 123 (número)

// Convertir número a fecha (los números son fechas seriales en DAX):
CONVERT(45291, DATETIME)  -- la fecha correspondiente al día 45291

CURRENCY(<valor>)

Intermedio

Convierte un valor al tipo de dato Currency (4 decimales fijos, alta precisión). Útil cuando necesitas garantizar precisión en cálculos financieros.

Ejemplo:

Importe Preciso = CURRENCY([Total Ventas])

GCD(<número1>, <número2>, ...) | LCM(<número1>, <número2>, ...)

Avanzado

GCD: Máximo común divisor. LCM: Mínimo común múltiplo. Raramente usados en BI pero útiles en análisis de ritmos, ciclos y normalización.

Ejemplo:

// Ciclo en el que coinciden dos frecuencias (ej: reuniones cada 4 y 6 semanas):
Ciclo Reuniones = LCM(4, 6)  -- 12 semanas

FACT(<número>)

Avanzado

Factorial de un número no negativo. Usado principalmente en combinatoria y probabilidad.

Ejemplo:

// Probabilidades combinatorias:
FACT(5)  -- 120  (5! = 5×4×3×2×1)

🎲

Combinatoria y permutaciones

COMBIN(<n>, <k>) | COMBINA(<n>, <k>)

Avanzado

COMBIN: Combinaciones sin repetición (C(n,k) = n! / k!(n-k)!). COMBINA: Combinaciones CON repetición.

Ejemplos:

// ¿Cuántas formas de elegir 3 productos de un catálogo de 10?
COMBIN(10, 3)   -- 120 combinaciones sin repetición
COMBINA(10, 3)  -- 220 combinaciones con repetición

// Útil en A/B testing: cuántas combinaciones de variantes:
Combinaciones Test = COMBIN([Nº Variantes], 2)

PERMUT(<n>, <k>)

Avanzado

Permutaciones sin repetición — como COMBIN pero el orden importa.

Ejemplo:

// ¿De cuántas formas puedes ordenar 3 ganadores de un grupo de 10?
PERMUT(10, 3)  -- 720

🎲

RAND y RANDBETWEEN — números aleatorios

RAND() | RANDBETWEEN(<inferior>, <superior>)

Intermedio

RAND: Devuelve un número decimal aleatorio entre 0 y 1 (exclusivo). RANDBETWEEN: Devuelve un entero aleatorio entre dos valores (inclusivo). Ambas son VOLÁTILES — se recalculan en cada refresco.

Ejemplo de uso en datos de prueba:

// Crear datos de prueba (en tabla calculada):
Datos Prueba =
ADDCOLUMNS(
    GENERATESERIES(1, 100, 1),  -- 100 filas
    "Ventas", RANDBETWEEN(100, 10000),
    "Mes", RANDBETWEEN(1, 12),
    "Activo", IF(RAND() > 0.3, TRUE, FALSE)  -- 70% activos
)

⚠️ Funciones volátiles
RAND() y RANDBETWEEN() son VOLÁTILES — se recalculan cada vez que el informe se actualiza. Esto significa que los valores cambian en cada refresco. Si necesitas datos aleatorios fijos (para pruebas reproducibles), genera la tabla una vez con DATATABLE o importa los datos.

📐

Trigonometría completa

Trigonometría en Power BI 🌸
La trigonometría en DAX es casi idéntica a la de Excel. La mayoría de proyectos de BI nunca la necesitarán, pero si trabajas con datos geoespaciales, física, ingeniería o análisis de señales, estas funciones serán tus mejores amigas. ¡Y tampoco está de más conocerlas! 😊

Tabla completa de funciones trigonométricas:

FUNCIÓN	DESCRIPCIÓN	DEVUELVE
SIN(x)	Seno de x (en radianes)	-1 a 1
COS(x)	Coseno de x (en radianes)	-1 a 1
TAN(x)	Tangente de x (en radianes)	-∞ a +∞
ASIN(x)	Arcoseno de x	-π/2 a π/2 radianes
ACOS(x)	Arcocoseno de x	0 a π radianes
ATAN(x)	Arcotangente de x	-π/2 a π/2 radianes
COT(x)	Cotangente de x	-∞ a +∞
SINH(x)	Seno hiperbólico	-∞ a +∞
COSH(x)	Coseno hiperbólico	1 a +∞
TANH(x)	Tangente hiperbólica	-1 a 1
ACOT(x)	Arcocotangente	0 a π radianes
ACOSH(x)	Arcoseno hiperbólico inverso	0 a +∞
ASINH(x)	Arcseno hiperbólico	-∞ a +∞
ATANH(x)	Arctangente hiperbólica	-∞ a +∞
COTH(x)	Cotangente hiperbólica	-∞ a +∞

Ejemplo práctico — distancia entre dos coordenadas geográficas (fórmula Haversine):

// Distancia en km entre dos puntos (lat/lon en grados)
Distancia KM =
VAR R = 6371    -- radio de la Tierra en km
VAR Lat1 = RADIANS('Tiendas'[Latitud])
VAR Lat2 = RADIANS('Almacenes'[Latitud])
VAR DLat = RADIANS('Almacenes'[Latitud] - 'Tiendas'[Latitud])
VAR DLon = RADIANS('Almacenes'[Longitud] - 'Tiendas'[Longitud])
VAR A = POWER(SIN(DLat/2), 2) + COS(Lat1) * COS(Lat2) * POWER(SIN(DLon/2), 2)
VAR C = 2 * ATAN(SQRT(A) / SQRT(1-A))
RETURN R * C

Caso de uso real 💡
La fórmula Haversine es el caso de uso real más común para trigonometría en Power BI. Si tienes coordenadas GPS de puntos de entrega, tiendas o clientes, puedes calcular distancias reales en DAX con esta fórmula.

🛠️

Patrones prácticos

Patrón 1 — Formateo de número en escala automática:

Ventas Formateadas =
VAR V = [Total Ventas]
RETURN
SWITCH(
    TRUE(),
    V >= 1000000000, FORMAT(DIVIDE(V, 1000000000), "#,##0.0") & " B",
    V >= 1000000,    FORMAT(DIVIDE(V, 1000000), "#,##0.0") & " M",
    V >= 1000,       FORMAT(DIVIDE(V, 1000), "#,##0.0") & " K",
    FORMAT(V, "#,##0")
)

Patrón 2 — Redondeo a cifras significativas:

// Redondear a N cifras significativas:
VAR Valor = 12345.678
VAR Cifras = 3
VAR Magnitud = POWER(10, INT(LOG10(ABS(Valor))) - Cifras + 1)
RETURN ROUND(Valor / Magnitud, 0) * Magnitud
// Resultado: 12300

Patrón 3 — Porcentaje siempre entre 0 y 100:

% Seguro =
VAR Ratio = DIVIDE([Parte], [Total])
RETURN MAX(0, MIN(1, IFERROR(Ratio, 0))) * 100

🚀 Siguiente paso
¡Ahora tienes todo el arsenal matemático de DAX! Si tu trabajo incluye análisis estadístico — distribuciones, percentiles, regresión — la siguiente página de Estadísticas te va a encantar.