Por fin luego de mucho trabajar ya encontramos el resultado de esta escollo que muchos los usuarios de este espacio tienen. Si tienes alguna información que aportar no dejes de compartir tu información.
Se proporcionan operadores matemáticos para muchos tipos de PostgreSQL. Para los tipos sin convenciones matemáticas estándar (por ejemplo, tipos de fecha / hora), describimos el comportamiento real en las secciones siguientes.
La Tabla 9.4 muestra los operadores matemáticos que están disponibles para los tipos numéricos estándar. A menos que se indique lo contrario, los operadores que se muestran aceptando numeric_type están disponibles para todos los tipos smallint, integer, bigint, numeric, real, y double precision. Operadores mostrados como aceptando integral_type están disponibles para los tipos smallint, integer, y bigint. Excepto donde se indique, cada forma de un operador devuelve el mismo tipo de datos que sus argumentos. Llamadas que involucran múltiples tipos de datos de argumentos, como integer+numeric, se resuelven utilizando el tipo que aparece más adelante en estas listas.
Cuadro 9.4. Operadores matemáticos
Operador
Descripción
Ejemplo (s)
numeric_type+numeric_type → numeric_type
Adición
2 + 3 → 5
+numeric_type → numeric_type
Unario plus (sin operación)
+ 3.5 → 3.5
numeric_type-numeric_type → numeric_type
Sustracción
2 - 3 → -1
-numeric_type → numeric_type
Negación
- (-4) → 4
numeric_type*numeric_type → numeric_type
Multiplicación
2 * 3 → 6
numeric_type/numeric_type → numeric_type
División (para tipos integrales, la división trunca el resultado hacia cero)
5.0 / 2 → 2.5000000000000000
5 / 2 → 2
(-5) / 2 → -2
numeric_type%numeric_type → numeric_type
Módulo (resto); disponible para smallint, integer, bigint, y numeric
Exponenciación (a diferencia de la práctica matemática típica, los usos múltiples de ^ asociará de izquierda a derecha)
2 ^ 3 → 8
2 ^ 3 ^ 3 → 512
|/double precision → double precision
Raíz cuadrada
|/ 25.0 → 5
||/double precision → double precision
raíz cúbica
||/ 64.0 → 4
bigint! → numeric
Factorial (obsoleto, use factorial() en lugar de)
5 ! → 120
!!bigint → numeric
Factorial como operador de prefijo (obsoleto, use factorial() en lugar de)
!! 5 → 120
@numeric_type → numeric_type
Valor absoluto
@ -5.0 → 5
integral_type&integral_type → integral_type
Y bit a bit
91 & 15 → 11
integral_type|integral_type → integral_type
O bit a bit
32 | 3 → 35
integral_type#integral_type → integral_type
OR exclusivo bit a bit
17 # 5 → 20
~integral_type → integral_type
Bit a bit NO
~1 → -2
integral_type<<integer → integral_type
Desplazamiento bit a bit a la izquierda
1 << 4 → 16
integral_type>>integer → integral_type
Desplazamiento bit a bit a la derecha
8 >> 2 → 2
La Tabla 9.5 muestra las funciones matemáticas disponibles. Muchas de estas funciones se proporcionan en múltiples formas con diferentes tipos de argumentos. Excepto donde se indique, cualquier forma dada de una función devuelve el mismo tipo de datos que sus argumentos; Los casos de tipo cruzado se resuelven de la misma manera que se explicó anteriormente para los operadores. Las funciones que trabajan con double precision los datos se implementan principalmente en la parte superior de la biblioteca C del sistema host; Por lo tanto, la precisión y el comportamiento en los casos límite pueden variar según el sistema anfitrión.
Cuadro 9.5. Funciones Matemáticas
Función
Descripción
Ejemplo (s)
abs ( numeric_type ) → numeric_type
Valor absoluto
abs(-17.4) → 17.4
cbrt ( double precision ) → double precision
raíz cúbica
cbrt(64.0) → 4
ceil ( numeric ) → numeric
ceil ( double precision ) → double precision
Entero más cercano mayor o igual que el argumento
ceil(42.2) → 43
ceil(-42.8) → -42
ceiling ( numeric ) → numeric
ceiling ( double precision ) → double precision
Entero más cercano mayor o igual al argumento (igual que ceil)
ceiling(95.3) → 96
degrees ( double precision ) → double precision
Convierte radianes a grados
degrees(0.5) → 28.64788975654116
div ( ynumeric, xnumeric ) → numeric
Cociente entero de y/x (trunca hacia cero)
div(9,4) → 2
exp ( numeric ) → numeric
exp ( double precision ) → double precision
Exponencial (e elevado al poder dado)
exp(1.0) → 2.7182818284590452
factorial ( bigint ) → numeric
Factorial
factorial(5) → 120
floor ( numeric ) → numeric
floor ( double precision ) → double precision
Entero más cercano menor o igual al argumento
floor(42.8) → 42
floor(-42.8) → -43
gcd ( numeric_type, numeric_type ) → numeric_type
Máximo común divisor (el mayor número positivo que divide ambas entradas sin resto); devoluciones 0 si ambas entradas son cero; disponible para integer, bigint, y numeric
gcd(1071, 462) → 21
lcm ( numeric_type, numeric_type ) → numeric_type
Mínimo común múltiplo (el menor número estrictamente positivo que es un múltiplo integral de ambas entradas); devoluciones 0 si alguna de las entradas es cero; disponible para integer, bigint, y numeric
lcm(1071, 462) → 23562
ln ( numeric ) → numeric
ln ( double precision ) → double precision
Logaritmo natural
ln(2.0) → 0.6931471805599453
log ( numeric ) → numeric
log ( double precision ) → double precision
Logaritmo en base 10
log(100) → 2
log10 ( numeric ) → numeric
log10 ( double precision ) → double precision
Logaritmo en base 10 (igual que log)
log10(1000) → 3
log ( bnumeric, xnumeric ) → numeric
Logaritmo de x a la base b
log(2.0, 64.0) → 6.0000000000
min_scale ( numeric ) → integer
Escala mínima (número de dígitos decimales fraccionarios) necesaria para representar el valor proporcionado con precisión
min_scale(8.4100) → 2
mod ( ynumeric_type, xnumeric_type ) → numeric_type
Resto de y/x; disponible para smallint, integer, bigint, y numeric
mod(9,4) → 1
pi () → double precision
Valor aproximado de π
pi() → 3.141592653589793
power ( anumeric, bnumeric ) → numeric
power ( adouble precision, bdouble precision ) → double precision
a elevado al poder de b
power(9, 3) → 729
radians ( double precision ) → double precision
Convierte grados a radianes
radians(45.0) → 0.7853981633974483
round ( numeric ) → numeric
round ( double precision ) → double precision
Redondea al entero más cercano
round(42.4) → 42
round ( vnumeric, sinteger ) → numeric
Rondas v para s lugares decimales
round(42.4382, 2) → 42.44
scale ( numeric ) → integer
Escala del argumento (el número de dígitos decimales en la parte fraccionaria)
scale(8.4100) → 4
sign ( numeric ) → numeric
sign ( double precision ) → double precision
Signo del argumento (-1, 0 o +1)
sign(-8.4) → -1
sqrt ( numeric ) → numeric
sqrt ( double precision ) → double precision
Raíz cuadrada
sqrt(2) → 1.4142135623730951
trim_scale ( numeric ) → numeric
Reduce la escala del valor (número de dígitos decimales fraccionarios) eliminando ceros finales
Devuelve el número del depósito en el que operand cae en un histograma que tiene count cubos de igual ancho que abarcan el rango low para high. Devoluciones 0 o count+1 para una entrada fuera de ese rango.
Devuelve el número del depósito en el que operand cae dada una matriz que enumera los límites inferiores de los depósitos. Devoluciones 0 para una entrada menor que el primer límite inferior. operand y los elementos de la matriz pueden ser de cualquier tipo que tengan operadores de comparación estándar. los thresholds formación debe ser ordenado, los más pequeños primero o se obtendrán resultados inesperados.
La tabla 9.6 muestra funciones para generar números aleatorios.
Cuadro 9.6. Funciones aleatorias
Función
Descripción
Ejemplo (s)
random () → double precision
Devuelve un valor aleatorio en el rango 0.0 <= x <1.0
random() → 0.897124072839091
setseed ( double precision ) → void
Establece la semilla para posteriores random() llamadas; el argumento debe estar entre -1.0 y 1.0, inclusive
setseed(0.12345)
los random() La función utiliza un algoritmo congruencial lineal simple. Es rápido pero no apto para aplicaciones criptográficas; consulte el módulo pgcrypto para una alternativa más segura. Si setseed() se llama, la serie de resultados de posteriores random() las llamadas en la sesión actual se pueden repetir volviendo a emitir setseed() con el mismo argumento.
La tabla 9.7 muestra las funciones trigonométricas disponibles. Cada una de estas funciones viene en dos variantes, una que mide ángulos en radianes y otra que mide ángulos en grados.
Otra forma de trabajar con ángulos medidos en grados es usar las funciones de transformación unitaria radians() y degrees() mostrado anteriormente. Sin embargo, se prefiere el uso de funciones trigonométricas basadas en grados, ya que de esa manera se evita el error de redondeo para casos especiales como sind(30).
La tabla 9.8 muestra las funciones hiperbólicas disponibles.
