9.3. Fonctions et opérateurs mathématiques
Des opérateurs mathématiques sont fournis pour un grand nombre de types
PostgreSQL. Pour les types sans conventions
mathématiques standard (les types dates/time, par exemple), le
comportement réel est décrit dans les sections appropriées.
Le Tableau 9.4 affiche les opérateurs
mathématiques disponibles.
Tableau 9.4. Opérateurs mathématiques
| Opérateur | Description | Exemple | Résultat |
|---|
+ | addition | 2 + 3 | 5 |
- | soustraction | 2 - 3 | -1 |
* | multiplication | 2 * 3 | 6 |
/ | division (la division entière tronque les résultats) | 4 / 2 | 2 |
% | modulo (reste) | 5 % 4 | 1 |
^ | exposant (association de gauche à droite) | 2.0 ^ 3.0 | 8 |
|/ | racine carrée | |/ 25.0 | 5 |
||/ | racine cubique | ||/ 27.0 | 3 |
! | factoriel
(obsolète, utilisez factorial() à la place) | 5 ! | 120 |
!! | factoriel (opérateur préfixe) | !! 5 | 120 |
@ | valeur absolue | @ -5.0 | 5 |
& | AND bit à bit | 91 & 15 | 11 |
| | OR bit à bit | 32 | 3 | 35 |
# | XOR bit à bit | 17 # 5 | 20 |
~ | NOT bit à bit | ~1 | -2 |
<< | décalage gauche | 1 << 4 | 16 |
>> | décalage droit | 8 >> 2 | 2 |
Les opérateurs bit à bit ne fonctionnent que sur les types de données
entiers et sont aussi disponibles pour
les types de chaînes de bits bit et bit varying
comme le montre le Tableau 9.14.
Le Tableau 9.5 affiche les fonctions
mathématiques disponibles. Dans ce tableau, dp
signifie double precision. Beaucoup de ces fonctions sont
fournies dans de nombreuses formes avec différents types d'argument.
Sauf précision contraire, toute forme donnée d'une fonction renvoie le
même type de données que son argument.
Les fonctions utilisant des données de type double
precision sont pour la plupart implantées avec la bibliothèque C du
système hôte ; la précision et le comportement dans les cas
particuliers peuvent varier en fonction du système hôte.
Tableau 9.5. Fonctions mathématiques
| Fonction | Type renvoyé | Description | Exemple | Résultat |
|---|
abs(x) | (identique à l'entrée) | valeur absolue | abs(-17.4) | 17.4 |
cbrt(dp) | dp | racine cubique | cbrt(27.0) | 3 |
ceil(dp ou numeric) | (identique à l'argument) | plus proche entier plus grand ou égal à l'argument | ceil(-42.8) | -42 |
ceiling(dp ou numeric) | (identique à l'argument) | plus proche entier plus grand ou égal à l'argumen (identique à ceil) | ceiling(-95.3) | -95 |
degrees(dp) | dp | radians vers degrés | degrees(0.5) | 28.6478897565412 |
div(y numeric,
x numeric) | numeric | quotient entier de y/x | div(9,4) | 2 |
exp(dp ou numeric) | (identique à l'argument) | exponentiel | exp(1.0) | 2.71828182845905 |
factorial(bigint) | numeric | factoriel | factorial(5) | 120 |
floor(dp ou numeric) | (identique à l'argument) | plus proche entier plus petit ou égal à l'argument | floor(-42.8) | -43 |
ln(dp ou numeric) | (identique à l'argument) | logarithme | ln(2.0) | 0.693147180559945 |
log(dp ou numeric) | (identique à l'argument) | logarithme base 10 | log(100.0) | 2 |
log10(dp or numeric) | (identique à l'argument) | base 10 logarithm | log10(100.0) | 2 |
log(b
numeric,
x numeric) | numeric | logarithme en base b | log(2.0, 64.0) | 6.0000000000 |
mod(y,
x) | (identique au type des arguments) | reste de
y/x | mod(9,4) | 1 |
pi() | dp | constante « pi » | pi() | 3.14159265358979 |
power(a dp,
b dp) | dp | a élevé à la puissance
b | power(9.0, 3.0) | 729 |
power(a
numeric,
b numeric) | numeric | a élevé à la puissance
b | power(9.0, 3.0) | 729 |
radians(dp) | dp | degrés vers radians | radians(45.0) | 0.785398163397448 |
round(dp ou numeric) | (identique à l'argument) | arrondi à l'entier le plus proche | round(42.4) | 42 |
round(v
numeric, s
int) | numeric | arrondi pour s décimales | round(42.4382, 2) | 42.44 |
scale(numeric) | integer | échelle de l'argument (le nombre de chiffres décimaux dans la partie de fraction) | scale(8.41) | 2 |
sign(dp ou numeric) | (identique à l'argument) | signe de l'argument (-1, 0, +1) | sign(-8.4) | -1 |
sqrt(dp ou numeric) | (identique à l'argument) | racine carrée | sqrt(2.0) | 1.4142135623731 |
trunc(dp ou numeric) | (identique à l'argument) | tronque vers zéro | trunc(42.8) | 42 |
trunc(v
numeric, s
int) | numeric | tronque sur s décimales | trunc(42.4382, 2) | 42.43 |
width_bucket(opérande dp, b1 dp, b2 dp, nombre int) | int | renvoie le numéro du compartiment dans lequel
l'opérande serait affecté dans un
histogramme ayant nombre compartiments
d'égale longueur répartis entre b1
et b2 ; renvoie 0 ou
nombre+1 | width_bucket(5.35, 0.024, 10.06, 5) | 3 |
width_bucket(opérande numeric, b1 numeric, b2 numeric, nombre int) | int | renvoie le numéro du compartiment dans lequel
l'opérande serait affecté dans un
histogramme ayant nombre compartiments
d'égale longueur répartis entre b1
et b2 ; renvoie 0 ou
nombre+1 | width_bucket(5.35, 0.024, 10.06, 5) | 3 |
width_bucket(opérande anyelement, seuils anyarray) | int | renvoie le numéro du compartiment dans lequel
opérande serait affecté compte
tenu d'un tableau qui comporterait les limites inférieures
de chaque compartiment ; renvoie 0 pour une
valeur d'entrée inférieure à la première valeur du tableau ;
le tableau seuils doit
être trié, par ordre croissant, sinon des résultats inattendus
seront obtenus | width_bucket(now(), array['yesterday', 'today', 'tomorrow']::timestamptz[]) | 2 |
Tableau 9.6 montre les fonctions de
génération de nombres aléatoires.
Tableau 9.6. Fonctions de génération de nombres aléatoires
| Fonction | Type renvoyé | Description |
|---|
random() | dp | valeur aléatoire comprise entre 0,0 et 1,0 |
setseed(dp) | void | configuration de la graine pour les appels suivants à
random() (valeur comprise entre -1,0 et
1.0, valeurs incluses) |
La fonction random() utilise un algorithme congruentiel
linéaire simple. Elle est rapide, mais elle ne convient pas pour des
applications de chiffrement ; voir le module pgcrypto
pour une alternative plus sécurisée. Si la fonction
setseed() est appelée, les résultats des appels suivant
à random() dans la même session sont répétables en
réexécutant setseed() avec le même argument.
Sans un appel précédent à setseed() dans la même session,
le premier appel à random() obtient une graine d'une
source dépendante de la plateforme de bits aléatoires.
Le Tableau 9.7 affiche les fonctions
disponibles. Toutes les fonctions trigonométriques prennent
des arguments et renvoient des valeurs de type double precision.
Chaque fonction trigonométrique est disponible en deux variantes, une qui
mesure l'angle en radians et l'autre qui mesure l'angle en degrés.
Tableau 9.7. Fonctions trigonométriques
| Fonction (radians) | Fonction (degrés) | Description |
|---|
acos(x) |
acosd(x) | arccosinus |
asin(x) |
asind(x) | arcsinus |
atan(x) |
atand(x) | arctangente |
atan2(y,
x) |
atan2d(y,
x) |
arctangente de y/x |
cos(x) |
cosd(x) | cosinus |
cot(x) |
cotd(x) | cotangente |
sin(x) |
sind(x) | sinus |
tan(x) |
tand(x) | tangente |
Note
Un autre moyen de travailler avec des angles mesurés en degrés est
d'utiliser les fonctions de transformation d'unités
radians()degrees()sind(30).
Tableau 9.8 montre les fonctions
hyperboliques disponibles. Toutes ces fonctions prennent des arguments et
renvoient des valeurs de type double precision.
Tableau 9.8. Fonctions hyperboliques
| Fonction | Description | Exemple | Résultat |
|---|
sinh(x) | sinus hyperbolique | sinh(0) | 0 |
cosh(x) | cosinus hyperbolique | cosh(0) | 1 |
tanh(x) | tangente hyperbolique | tanh(0) | 0 |
asinh(x) | sinus hyperbolique inverse | asinh(0) | 0 |
acosh(x) | cosinus hyperbolique inverse | acosh(1) | 0 |
atanh(x) | tangente hyperbolique hyperbolique | atanh(0) | 0 |
