Funciones matemáticas

SQL estándar de Google para BigQuery es compatible con las funciones matemáticas. Todas las funciones matemáticas tienen los siguientes comportamientos:

Muestran NULL si alguno de los parámetros de entrada es NULL.
Muestran NaN si alguno de los argumentos es NaN.

`ABS`

ABS(X)

Descripción

Calcula el valor absoluto. Muestra un error si el argumento es un número entero y el valor de resultado no se puede representar como el mismo tipo; esto sucede solo para el valor de entrada negativo más grande, que no tiene una representación positiva.

X	ABS(X)
25	25
-25	25
`+inf`	`+inf`
`-inf`	`+inf`

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
OUTPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`

`SIGN`

SIGN(X)

Descripción

Muestra -1 0 o +1 para los argumentos negativos, de cero y positivos, respectivamente. Para argumentos de punto flotante, esta función no distingue entre cero positivo y negativo.

X	SIGN(X)
25	+1
0	0
-25	-1
NaN	NaN

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
OUTPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`

`IS_INF`

IS_INF(X)

Descripción

Muestra TRUE si el valor es infinito positivo o negativo.

X	IS_INF(X)
`+inf`	`TRUE`
`-inf`	`TRUE`
25	`FALSE`

`IS_NAN`

IS_NAN(X)

Descripción

Muestra TRUE si el valor es NaN.

X	IS_NAN(X)
`NaN`	`TRUE`
25	`FALSE`

`IEEE_DIVIDE`

IEEE_DIVIDE(X, Y)

Descripción

Divide X por Y; esta función nunca presenta errores. Muestra FLOAT64. A diferencia del operador de división (/), esta función no genera errores de divisiones por cero ni se desborda.

X	S	IEEE_DIVIDE(X, Y)
20.0	4.0	5.0
0.0	25.0	0.0
25.0	0.0	`+inf`
-25.0	0.0	`-inf`
0.0	0.0	`NaN`
0.0	`NaN`	`NaN`
`NaN`	0.0	`NaN`
`+inf`	`+inf`	`NaN`
`-inf`	`-inf`	`NaN`

`RAND`

RAND()

Descripción

Genera un valor seudoaleatorio de tipo FLOAT64 en el rango de [0, 1), el cual incluye 0 pero no 1.

`SQRT`

SQRT(X)

Descripción

Calcula la raíz cuadrada de X. Genera un error si X es menor que 0.

X	SQRT(X)
`25.0`	`5.0`
`+inf`	`+inf`
`X < 0`	Error

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
OUTPUT	`FLOAT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`

`POW`

POW(X, Y)

Descripción

Muestra el valor de X elevado a la potencia de Y. Si el resultado se subdesborda y no es representable, entonces la función muestra un valor de cero.

X	S	POW(X, Y)
2.0	3.0	8.0
1.0	Cualquier valor, incluido `NaN`	1.0
Cualquier valor, incluido `NaN`	0	1.0
-1.0	`+inf`	1.0
-1.0	`-inf`	1.0
ABS(X) < 1	`-inf`	`+inf`
ABS(X) > 1	`-inf`	0.0
ABS(X) < 1	`+inf`	0.0
ABS(X) > 1	`+inf`	`+inf`
`-inf`	Y < 0	0.0
`-inf`	Y > 0	`-inf` si Y es un número entero impar, `+inf` si es lo contrario
`+inf`	Y < 0	0
`+inf`	Y > 0	`+inf`
Valor finito < 0	Sin número entero	Error
0	Valor finito < 0	Error

Tipo de datos mostrados

El tipo de datos que se muestra se determina según los tipos de argumentos de la siguiente tabla.

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`INT64`	`FLOAT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`NUMERIC`	`NUMERIC`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`	`FLOAT64`
`FLOAT64`	`FLOAT64`	`FLOAT64`	`FLOAT64`	`FLOAT64`

`POWER`

POWER(X, Y)

Descripción

Sinónimo de POW(X, Y).

`EXP`

EXP(X)

Descripción

Calcula e elevado a X, también llamada función exponencial natural. Si el resultado se subdesborda, esta función muestra un cero. Genera un error si el resultado se desborda.

X	EXP(X)
0.0	1.0
`+inf`	`+inf`
`-inf`	0.0

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
OUTPUT	`FLOAT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`

`LN`

LN(X)

Descripción

Calcula el logaritmo natural de X. Genera un error si X es menor o igual que cero.

X	LN(X)
1.0	0.0
`+inf`	`+inf`
`X < 0`	Error

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
OUTPUT	`FLOAT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`

`LOG`

LOG(X [, Y])

Descripción

Si solo X está presente, LOG es un sinónimo de LN. Si Y también está presente, LOG calcula el logaritmo de X en base Y.

X	Y	LOG(X, Y)
100.0	10.0	2.0
`-inf`	Cualquier valor	`NaN`
Cualquier valor	`+inf`	`NaN`
`+inf`	0.0 Y < 1.0	`-inf`
`+inf`	Y > 1.0	`+inf`
X <= 0	Cualquier valor	Error
Cualquier valor	Y <= 0	Error
Cualquier valor	1.0	Error

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`INT64`	`FLOAT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`NUMERIC`	`NUMERIC`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`	`FLOAT64`
`FLOAT64`	`FLOAT64`	`FLOAT64`	`FLOAT64`	`FLOAT64`

`LOG10`

LOG10(X)

Descripción

Similar a LOG, pero calcula el logaritmo en base 10.

X	LOG10(X)
100.0	2.0
`-inf`	`NaN`
`+inf`	`+inf`
X <= 0	Error

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
OUTPUT	`FLOAT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`

`GREATEST`

GREATEST(X1,...,XN)

Descripción

Muestra el valor más alto entre X1,...,XN. Si algún argumento es NULL, muestra NULL. De lo contrario, en el caso de argumentos de punto flotante, si algún argumento es NaN, muestra NaN. En todos los demás casos, muestra el valor entre X1,...,XN que tiene el valor más alto de acuerdo con el orden que usa la cláusula ORDER BY. Los argumentos X1, ..., XN deben ser coercibles a un supertipo común y el supertipo debe admitir el orden.

X1,...,XN	GREATEST(X1,...,XN)
3,5,1	5

Esta función admite la especificación de la intercalación.

Tipos de datos mostrados

Tipo de datos de los valores de entrada.

`LEAST`

LEAST(X1,...,XN)

Descripción

Muestra el valor mínimo entre X1,...,XN. Si algún argumento es NULL, muestra NULL. De lo contrario, en el caso de argumentos de punto flotante, si algún argumento es NaN, muestra NaN. En todos los demás casos, muestra el valor entre X1,...,XN que tiene el menor valor según el orden que usa la cláusula ORDER BY. Los argumentos X1, ..., XN deben ser coercibles a un supertipo común y el supertipo debe admitir el orden.

X1,...,XN	LEAST(X1,...,XN)
3,5,1	1

Esta función admite la especificación de la intercalación.

Tipos de datos mostrados

Tipo de datos de los valores de entrada.

`DIV`

DIV(X, Y)

Descripción

Muestra el resultado de la división del número entero de X por Y. La división por cero muestra un error. La división por -1 se puede desbordar.

X	S	DIV(X, Y)
20	4	5
12	-7	-1
20	3	6
0	20	0
20	0	Error

Tipo de datos mostrados

El tipo de datos que se muestra se determina según los tipos de argumentos de la siguiente tabla.

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`
`INT64`	`INT64`	`NUMERIC`	`BIGNUMERIC`
`NUMERIC`	`NUMERIC`	`NUMERIC`	`BIGNUMERIC`
`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`

`SAFE_DIVIDE`

SAFE_DIVIDE(X, Y)

Descripción

Equivale al operador de división (X / Y), pero muestra NULL si se produce un error, como un error de división por cero.

X	S	SAFE_DIVIDE(X, Y)
20	4	5
0	20	`0`
20	0	`NULL`

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`INT64`	`FLOAT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`NUMERIC`	`NUMERIC`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`	`FLOAT64`
`FLOAT64`	`FLOAT64`	`FLOAT64`	`FLOAT64`	`FLOAT64`

`SAFE_MULTIPLY`

SAFE_MULTIPLY(X, Y)

Descripción

Equivalente al operador de multiplicación (*), pero muestra NULL si se produce un desbordamiento.

X	S	SAFE_MULTIPLY(X, Y)
20	4	80

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`INT64`	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`NUMERIC`	`NUMERIC`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`	`FLOAT64`
`FLOAT64`	`FLOAT64`	`FLOAT64`	`FLOAT64`	`FLOAT64`

`SAFE_NEGATE`

SAFE_NEGATE(X)

Descripción

Equivalente al operador unario menos (-), pero muestra NULL si se produce un desbordamiento.

X	SAFE_NEGATE(X)
+1	-1
-1	+1
0	0

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
OUTPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`

`SAFE_ADD`

SAFE_ADD(X, Y)

Descripción

Equivale al operador de suma (+), pero muestra NULL si se produce un desbordamiento.

X	S	SAFE_ADD(X, Y)
5	4	9

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`INT64`	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`NUMERIC`	`NUMERIC`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`	`FLOAT64`
`FLOAT64`	`FLOAT64`	`FLOAT64`	`FLOAT64`	`FLOAT64`

`SAFE_SUBTRACT`

SAFE_SUBTRACT(X, Y)

Descripción

Muestra el resultado de Y que se restó de X. Equivalente al operador de resta (-), pero muestra NULL si se produce un desbordamiento.

X	S	SAFE_SUBTRACT(X, Y)
5	4	1

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`INT64`	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`NUMERIC`	`NUMERIC`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`	`FLOAT64`
`FLOAT64`	`FLOAT64`	`FLOAT64`	`FLOAT64`	`FLOAT64`

`MOD`

MOD(X, Y)

Descripción

Función de módulo: muestra el resto de la división de X por Y. El valor que se muestra tiene el mismo signo que X. Se generará un error si Y es 0.

X	S	MOD(X, Y)
25	12	1
25	0	Error

Tipo de datos mostrados

El tipo de datos que se muestra se determina según los tipos de argumentos de la siguiente tabla.

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`
`INT64`	`INT64`	`NUMERIC`	`BIGNUMERIC`
`NUMERIC`	`NUMERIC`	`NUMERIC`	`BIGNUMERIC`
`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`	`BIGNUMERIC`

`ROUND`

ROUND(X [, N] [, rounding_mode])

Descripción

Si solo está presente X, redondea X al número entero más cercano. Si N está presente, redondea X a N decimales después del punto decimal. Si N es negativo, redondea los dígitos a la izquierda del punto decimal. Se redondean casos de punto medio en dirección opuesta al cero. Genera un error si se produce un desbordamiento.

Si X es un tipo NUMERIC o BIGNUMERIC, puedes configurar rounding_mode ([Preview][preview]) de forma explícita como una de las siguientes opciones:

["ROUND_HALF_AWAY_FROM_ZERO"][round-half-away-from-zero]: (Predeterminado) redondea los casos de punto medio en dirección opuesta al cero.
["ROUND_HALF_EVEN"][round-half-even]: redondea casos del punto medio hacia el dígito par más cercano.

Si estableces rounding_mode y X no es un tipo NUMERIC o BIGNUMERIC, la función genera un error.

Expresión	Valor de retorno
`ROUND(2.0)`	2.0
`ROUND(2.3)`	2.0
`ROUND(2.8)`	3.0
`ROUND(2.5)`	3.0
`ROUND(-2.3)`	-2.0
`ROUND(-2.8)`	-3.0
`ROUND(-2.5)`	-3.0
`ROUND(0)`	0
`ROUND(+inf)`	`+inf`
`ROUND(-inf)`	`-inf`
`ROUND(NaN)`	`NaN`
`ROUND(123.7, -1)`	120.0
`ROUND(1.235, 2)`	1.24
`ROUND(NUMERIC "2.25", 1, "ROUND_HALF_EVEN")`	2.2
`ROUND(NUMERIC "2.35", 1, "ROUND_HALF_EVEN")`	2.4
`ROUND(NUMERIC "2.251", 1, "ROUND_HALF_EVEN")`	2.3
`ROUND(NUMERIC "-2.5", 0, "ROUND_HALF_EVEN")`	-2
`ROUND(NUMERIC "2.5", 0, "ROUND_HALF_AWAY_FROM_ZERO")`	3
`ROUND(NUMERIC "-2.5", 0, "ROUND_HALF_AWAY_FROM_ZERO")`	-3

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
OUTPUT	`FLOAT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`

`TRUNC`

TRUNC(X [, N])

Descripción

Si solo está presente X, TRUNC redondea X al número entero más cercano cuyo valor absoluto no es mayor que el valor absoluto de X. Si N también está presente, TRUNC se comporta como ROUND(X, N), pero siempre se redondea hacia cero y nunca se desborda.

X	TRUNC(X)
2.0	2.0
2.3	2.0
2.8	2.0
2.5	2.0
-2.3	-2.0
-2.8	-2.0
-2.5	-2.0
0	0
`+inf`	`+inf`
`-inf`	`-inf`
`NaN`	`NaN`

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
OUTPUT	`FLOAT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`

`CEIL`

CEIL(X)

Descripción

Muestra el valor integral más pequeño que no sea menor que X.

X	CEIL(X)
2.0	2.0
2.3	3.0
2.8	3.0
2.5	3.0
-2.3	-2.0
-2.8	-2.0
-2.5	-2.0
0	0
`+inf`	`+inf`
`-inf`	`-inf`
`NaN`	`NaN`

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
OUTPUT	`FLOAT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`

`CEILING`

CEILING(X)

Descripción

Sinónimo de CEIL(X)

`FLOOR`

FLOOR(X)

Descripción

Muestra el valor integral más grande que no sea mayor que X.

X	FLOOR(X)
2.0	2.0
2.3	2.0
2.8	2.0
2.5	2.0
-2.3	-3.0
-2.8	-3.0
-2.5	-3.0
0	0
`+inf`	`+inf`
`-inf`	`-inf`
`NaN`	`NaN`

Tipo de datos mostrados

INPUT	`INT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`
OUTPUT	`FLOAT64`	`NUMERIC`	`BIGNUMERIC`	`FLOAT64`

`COS`

COS(X)

Descripción

Calcula el coseno de X, en el que X se especifica en radianes. Nunca falla.

X	COS(X)
`+inf`	`NaN`
`-inf`	`NaN`
`NaN`	`NaN`

`COSH`

COSH(X)

Descripción

Calcula el coseno hiperbólico de X, en el que X se especifica en radianes. Genera un error si se produce un desbordamiento.

X	COSH(X)
`+inf`	`+inf`
`-inf`	`+inf`
`NaN`	`NaN`

`ACOS`

ACOS(X)

Descripción

Calcula el valor principal del coseno inverso de X. El valor de muestra está en el rango [0,π]. Genera un error si X es un valor fuera del rango [-1, 1].

X	ACOS(X)
`+inf`	`NaN`
`-inf`	`NaN`
`NaN`	`NaN`
X < -1	Error
X > 1	Error

`ACOSH`

ACOSH(X)

Descripción

Calcula el coseno hiperbólico inverso de X. Genera un error si X es un valor inferior a 1.

X	ACOSH(X)
`+inf`	`+inf`
`-inf`	`NaN`
`NaN`	`NaN`
X < 1	Error

`COT`

COT(X)

Descripción

Calcula la cotangente para el ángulo de X, en el que X se especifica en radianes. X puede ser cualquier tipo de datos que se convierta a FLOAT64. Admite el prefijo SAFE..

X	COT(X)
`+inf`	`NaN`
`-inf`	`NaN`
`NaN`	`NaN`
`0`	`Error`
`NULL`	`NULL`

Tipo de datos mostrados

FLOAT64

Ejemplo

SELECT COT(1) AS a, SAFE.COT(0) AS b;

+---------------------+------+
| a                   | b    |
+---------------------+------+
| 0.64209261593433065 | NULL |
+---------------------+------+

`COTH`

COTH(X)

Descripción

Calcula la cotangente hiperbólica para el ángulo de X, en la que X se especifica en radianes. X puede ser cualquier tipo de datos que se convierta a FLOAT64. Admite el prefijo SAFE..

X	COTH(X)
`+inf`	`1`
`-inf`	`-1`
`NaN`	`NaN`
`0`	`Error`
`NULL`	`NULL`

Tipo de datos mostrados

FLOAT64

Ejemplo

SELECT COTH(1) AS a, SAFE.COTH(0) AS b;

+----------------+------+
| a              | b    |
+----------------+------+
| 1.313035285499 | NULL |
+----------------+------+

`CSC`

CSC(X)

Descripción

Calcula la cosecante del ángulo de entrada, que está en radianes. X puede ser cualquier tipo de datos que se convierta a FLOAT64. Admite el prefijo SAFE..

X	CSC(X)
`+inf`	`NaN`
`-inf`	`NaN`
`NaN`	`NaN`
`0`	`Error`
`NULL`	`NULL`

Tipo de datos mostrados

FLOAT64

Ejemplo

SELECT CSC(100) AS a, CSC(-1) AS b, SAFE.CSC(0) AS c;

+----------------+-----------------+------+
| a              | b               | c    |
+----------------+-----------------+------+
| -1.97485753142 | -1.188395105778 | NULL |
+----------------+-----------------+------+

`CSCH`

CSCH(X)

Descripción

Calcula la cosecante hiperbólica del ángulo de entrada, que está en radianes. X puede ser cualquier tipo de datos que se convierta a FLOAT64. Admite el prefijo SAFE..

X	CSCH(X)
`+inf`	`0`
`-inf`	`0`
`NaN`	`NaN`
`0`	`Error`
`NULL`	`NULL`

Tipo de datos mostrados

FLOAT64

Ejemplo

SELECT CSCH(0.5) AS a, CSCH(-2) AS b, SAFE.CSCH(0) AS c;

+----------------+----------------+------+
| a              | b              | c    |
+----------------+----------------+------+
| 1.919034751334 | -0.27572056477 | NULL |
+----------------+----------------+------+

`SEC`

SEC(X)

Descripción

Calcula la secante para el ángulo de X, en el que X se especifica en radianes. X puede ser cualquier tipo de datos que se convierta a FLOAT64.

X	SEC(X)
`+inf`	`NaN`
`-inf`	`NaN`
`NaN`	`NaN`
`NULL`	`NULL`

Tipo de datos mostrados

FLOAT64

Ejemplo

SELECT SEC(100) AS a, SEC(-1) AS b;

+----------------+---------------+
| a              | b             |
+----------------+---------------+
| 1.159663822905 | 1.85081571768 |
+----------------+---------------+

`SECH`

SECH(X)

Descripción

Calcula la secante hiperbólica para el ángulo de X, en la que X se especifica en radianes. X puede ser cualquier tipo de datos que se convierta a FLOAT64. Nunca produce un error.

X	SECH(X)
`+inf`	`0`
`-inf`	`0`
`NaN`	`NaN`
`NULL`	`NULL`

Tipo de datos mostrados

FLOAT64

Ejemplo

SELECT SECH(0.5) AS a, SECH(-2) AS b, SECH(100) AS c;

+----------------+----------------+---------------------+
| a              | b              | c                   |
+----------------+----------------+---------------------+
| 0.88681888397  | 0.265802228834 | 7.4401519520417E-44 |
+----------------+----------------+---------------------+

`SIN`

SIN(X)

Descripción

Calcula el seno de X, en el que X se especifica en radianes. Nunca falla.

X	SIN(X)
`+inf`	`NaN`
`-inf`	`NaN`
`NaN`	`NaN`

`SINH`

SINH(X)

Descripción

Calcula el seno hiperbólico de X, en el que X se especifica en radianes. Genera un error si se produce un desbordamiento.

X	SINH(X)
`+inf`	`+inf`
`-inf`	`-inf`
`NaN`	`NaN`

`ASIN`

ASIN(X)

Descripción

Calcula el valor principal del seno inverso de X. El valor que se muestra está en el rango [-π/2,π/2]. Genera un error si X está fuera del rango [-1, 1].

X	ASIN(X)
`+inf`	`NaN`
`-inf`	`NaN`
`NaN`	`NaN`
X < -1	Error
X > 1	Error

`ASINH`

ASINH(X)

Descripción

Calcula el seno hiperbólico inverso de X. No falla.

X	ASINH(X)
`+inf`	`+inf`
`-inf`	`-inf`
`NaN`	`NaN`

`TAN`

TAN(X)

Descripción

Calcula la tangente de X, en la que X se especifica en radianes. Genera un error si se produce un desbordamiento.

X	TAN(X)
`+inf`	`NaN`
`-inf`	`NaN`
`NaN`	`NaN`

`TANH`

TANH(X)

Descripción

Calcula la tangente hiperbólica de X, en la que X se especifica en radianes. No falla.

X	TANH(X)
`+inf`	1.0
`-inf`	-1.0
`NaN`	`NaN`

`ATAN`

ATAN(X)

Descripción

Calcula el valor principal de la tangente inversa de X. El valor que se muestra está en el rango [-π/2,π/2]. No falla.

X	ATAN(X)
`+inf`	π/2
`-inf`	-π/2
`NaN`	`NaN`

`ATANH`

ATANH(X)

Descripción

Calcula la tangente hiperbólica inversa de X. Genera un error si X está fuera del rango (-1, 1).

X	ATANH(X)
`+inf`	`NaN`
`-inf`	`NaN`
`NaN`	`NaN`
X < -1	Error
X > 1	Error

`ATAN2`

ATAN2(X, Y)

Descripción

Calcula el valor principal de la tangente inversa de X/Y con los signos de los dos argumentos para determinar el cuadrante. El valor que se muestra está en el rango [-π,π].

X	S	ATAN2(X, Y)
`NaN`	Cualquier valor	`NaN`
Cualquier valor	`NaN`	`NaN`
0.0	0.0	0.0
Valor finito positivo	`-inf`	π
Valor finito negativo	`-inf`	-π
Valor finito	`+inf`	0.0
`+inf`	Valor finito	π/2
`-inf`	Valor finito	-π/2
`+inf`	`-inf`	¾π
`-inf`	`-inf`	-¾π
`+inf`	`+inf`	π/4
`-inf`	`+inf`	-π/4

`CBRT`

CBRT(X)

Descripción

Calcula la raíz cúbica de X. X puede ser cualquier tipo de datos que se convierta a FLOAT64. Admite el prefijo SAFE..

X	CBRT(X)
`+inf`	`inf`
`-inf`	`-inf`
`NaN`	`NaN`
`0`	`0`
`NULL`	`NULL`

Tipo de datos mostrados

FLOAT64

Ejemplo

SELECT CBRT(27) AS cube_root;

+--------------------+
| cube_root          |
+--------------------+
| 3.0000000000000004 |
+--------------------+

`RANGE_BUCKET`

RANGE_BUCKET(point, boundaries_array)

Descripción

RANGE_BUCKET examina un arreglo ordenado y muestra la posición basada en 0 del límite superior del punto. Esto puede ser útil si necesitas agrupar tus datos para compilar particiones, histogramas, reglas definidas por el negocio y mucho más.

RANGE_BUCKET sigue estas reglas:

Si el punto existe en el arreglo, muestra el índice del siguiente valor más grande.

RANGE_BUCKET(20, [0, 10, 20, 30, 40]) -- 3 is return value
RANGE_BUCKET(20, [0, 10, 20, 20, 40, 40]) -- 4 is return value

Si el punto no existe en el arreglo, pero oscila entre dos valores, muestra el índice del valor más grande.
```
RANGE_BUCKET(25, [0, 10, 20, 30, 40]) -- 3 is return value
```
Si el punto es más pequeño que el primer valor del arreglo, muestra 0.
```
RANGE_BUCKET(-10, [5, 10, 20, 30, 40]) -- 0 is return value
```
Si el punto es mayor o igual que el último valor del arreglo, muestra la longitud de este.
```
RANGE_BUCKET(80, [0, 10, 20, 30, 40]) -- 5 is return value
```

Si el arreglo está vacío, muestra 0.

RANGE_BUCKET(80, []) -- 0 is return value

Si el punto es NULL o NaN, muestra NULL.

RANGE_BUCKET(NULL, [0, 10, 20, 30, 40]) -- NULL is return value

El tipo de datos del punto y el arreglo debe ser compatible.

RANGE_BUCKET('a', ['a', 'b', 'c', 'd']) -- 1 is return value
RANGE_BUCKET(1.2, [1, 1.2, 1.4, 1.6]) -- 2 is return value
RANGE_BUCKET(1.2, [1, 2, 4, 6]) -- execution failure

La falla de ejecución se produce en los siguientes casos:

El arreglo tiene un valor NaN o NULL.

RANGE_BUCKET(80, [NULL, 10, 20, 30, 40]) -- execution failure

El arreglo no se ordenó de forma ascendente.

RANGE_BUCKET(30, [10, 30, 20, 40, 50]) -- execution failure

Parámetros

point: Un valor genérico.
boundaries_array: Un arreglo genérico de valores.

Valor que se muestra

INT64

Ejemplos

En una tabla denominada students, verifica cuántos registros existirían en cada depósito de age_group, según la edad del alumno:

age_group 0 (age < 10)
age_group 1 (age >= 10, age < 20)
age_group 2 (age >= 20, age < 30)
age_group 3 (age >= 30)

WITH students AS
(
  SELECT 9 AS age UNION ALL
  SELECT 20 AS age UNION ALL
  SELECT 25 AS age UNION ALL
  SELECT 31 AS age UNION ALL
  SELECT 32 AS age UNION ALL
  SELECT 33 AS age
)
SELECT RANGE_BUCKET(age, [10, 20, 30]) AS age_group, COUNT(*) AS count
FROM students
GROUP BY 1

+--------------+-------+
| age_group    | count |
+--------------+-------+
| 0            | 1     |
| 2            | 2     |
| 3            | 3     |
+--------------+-------+