Documentation PostgreSQL 14.22 » Langage SQL » Fonctions et opérateurs » Fonctions et opérateurs mathématiques

Précédent | Niveau supérieur | Suivant
9.2. Fonctions et opérateurs de comparaison | Sommaire | 9.4. Fonctions et opérateurs sur des chaînes de caractères

## 9.3. Fonctions et opérateurs mathématiques

Les opérateurs mathématiques sont fournies pour de nombreux types de données pour PostgreSQL. Pour les types sans conventions mathématiques standards (par exemple les types dates/heures), nous décrivons le comportement réel dans les sections suivantes.

Tableau 9.4 affiche les opérateurs mathématiques disponibles pour les types numériques standards. Sauf note explicite, les opérateurs affichés comme acceptant `numeric_type` sont disponibles pour tous les types `smallint`, `integer`, `bigint`, `numeric`, `real` et `double precision`. Les opérateurs affichés comme acceptant `integral_type` sont disponibles pour les types `smallint`, `integer` et `bigint`. Sauf note explicite, chaque forme d'un opérateur renvoie le même type de données que ses arguments, Les appels impliquant plusieurs types de données en argument, tel que `integer` `+` `numeric`, sont résolus en utilisant le type apparaissant en dernier dans ces listes.

Tableau 9.4. Opérateurs mathématiques

Opérateur Description Exemple(s)
`numeric_type` `+` `numeric_type` → ``numeric_type`` Addition `2 + 3` → `5`
`+` `numeric_type` → ``numeric_type`` Plus unitaire (pas d'opération) `+ 3.5` → `3.5`
`numeric_type` `-` `numeric_type` → ``numeric_type`` Soustraction `2 - 3` → `-1`
`-` `numeric_type` → ``numeric_type`` Négation `- (-4)` → `4`
`numeric_type` `*` `numeric_type` → ``numeric_type`` Multiplication `2 * 3` → `6`
`numeric_type` `/` `numeric_type` → ``numeric_type`` Division (pour les types entiers, la division tronque le résultat vers zéro) `5.0 / 2` → `2.5000000000000000` `5 / 2` → `2` `(-5) / 2` → `-2`
`numeric_type` `%` `numeric_type` → ``numeric_type`` Modulo (reste) ; disponible pour `smallint`, `integer`, `bigint` et `numeric` `5 % 4` → `1`
`numeric` `^` `numeric` → `numeric` `double precision` `^` `double precision` → `double precision` Exponentiel `2 ^ 3` → `8` Contrairement aux pratiques mathématiques typiques, plusieurs utilisations de `^` feront une association de gauche à droite par défaut : `2 ^ 3 ^ 3` → `512` `2 ^ (3 ^ 3)` → `134217728`
`|/` `double precision` → `double precision` Racine carrée `|/ 25.0` → `5`
`||/` `double precision` → `double precision` Racine cubique `||/ 64.0` → `4`
`@` `numeric_type` → ``numeric_type`` Valeur absolue `@ -5.0` → `5.0`
`integral_type` `&` `integral_type` → ``integral_type`` AND bit à bit `91 & 15` → `11`
`integral_type` `|` `integral_type` → ``integral_type`` OR bit à bit `32 | 3` → `35`
`integral_type` `#` `integral_type` → ``integral_type`` OR exclusif bit à bit `17 # 5` → `20`
`~` `integral_type` → ``integral_type`` NOT bit à bit `~1` → `-2`
`integral_type` `<<` `integer` → ``integral_type`` Décalage à gauche bit à bit `1 << 4` → `16`
`integral_type` `>>` `integer` → ``integral_type`` Décalage à droite bit à bit `8 >> 2` → `2`

Tableau 9.5 affiche les fonctions mathématiques disponibles. Beaucoup de ces fonctions sont fournies dans des formes différentes avec des types d'argument différents. Sauf note explicite, toute forme donnée d'une fonction renvoie le même type de donnée que ses arguments ; les cas inter-type sont résolus de la même façon qu'expliqué ci-dessus pour les opérateurs. Les fonctions travaillant avec des données de type `double precision` sont implémentées majoritairement grâce à la bibliothèque C du système hôte ; la précision et le comportement dans les cas limites peuvent donc varier suivant le système hôte.

Tableau 9.5. Fonctions mathématiques

Fonction Description Exemple(s)
`abs` ( `numeric_type` ) → ``numeric_type`` Valeur absolue `abs(-17.4)` → `17.4`
`cbrt` ( `double precision` ) → `double precision` Racine cubique `cbrt(64.0)` → `4`
`ceil` ( `numeric` ) → `numeric` `ceil` ( `double precision` ) → `double precision` Entier le plus proche plus grand ou égal à l'argument `ceil(42.2)` → `43` `ceil(-42.8)` → `-42`
`ceiling` ( `numeric` ) → `numeric` `ceiling` ( `double precision` ) → `double precision` Entier le plus proche plus grand ou égal à l'argument (identique à `ceil`) `ceiling(95.3)` → `96`
`degrees` ( `double precision` ) → `double precision` Convertit des radians en degrés `degrees(0.5)` → `28.64788975654116`
`div` ( `y` `numeric`, `x` `numeric` ) → `numeric` Quotient entier de `y`/`x` (tronque vers zéro) `div(9, 4)` → `2`
`exp` ( `numeric` ) → `numeric` `exp` ( `double precision` ) → `double precision` Exponentiel (`e` élevé à la puissance donnée) `exp(1.0)` → `2.7182818284590452`
`factorial` ( `bigint` ) → `numeric` Factorielle `factorial(5)` → `120`
`floor` ( `numeric` ) → `numeric` `floor` ( `double precision` ) → `double precision` Entier le plus proche plus petit ou égal à l'argument `floor(42.8)` → `42` `floor(-42.8)` → `-43`
`gcd` ( `numeric_type`, `numeric_type` ) → ``numeric_type`` Plus grand commun diviseur (plus grand nombre positif qui divise les arguments en entrée sans reste) ; renvoie `0` si les deux arguments valent zéro ; disponible pour `integer`, `bigint`et `numeric` `gcd(1071, 462)` → `21`
`lcm` ( `numeric_type`, `numeric_type` ) → ``numeric_type`` Plus petit commun multiple (plus petit nombre strictement positif qui est un multiple entier des deux arguments en entrée) ; renvoie `0` si les deux arguments valent zéro ; disponible pour `integer`, `bigint`et `numeric` `lcm(1071, 462)` → `23562`
`ln` ( `numeric` ) → `numeric` `ln` ( `double precision` ) → `double precision` Logarithme `ln(2.0)` → `0.6931471805599453`
`log` ( `numeric` ) → `numeric` `log` ( `double precision` ) → `double precision` Logarithme base 10 `log(100)` → `2`
`log10` ( `numeric` ) → `numeric` `log10` ( `double precision` ) → `double precision` Logarithme base 10 (identique à `log`) `log10(1000)` → `3`
`log` ( `b` `numeric`, `x` `numeric` ) → `numeric` Logarithme de `x` en base `b` `log(2.0, 64.0)` → `6.0000000000000000`
`min_scale` ( `numeric` ) → `integer` Échelle minimale (nombre de chiffres décimaux en fraction) nécessaire pour représenter la valeur fournie précisément `min_scale(8.4100)` → `2`
`mod` ( `y` `numeric_type`, `x` `numeric_type` ) → ``numeric_type`` Reste de `y`/`x` ; disponible pour `smallint`, `integer`, `bigint` et `numeric` `mod(9, 4)` → `1`
`pi` ( ) → `double precision` Valeur approximative de pi `pi()` → `3.141592653589793`
`power` ( `a` `numeric`, `b` `numeric` ) → `numeric` `power` ( `a` `double precision`, `b` `double precision` ) → `double precision` `a` élevé à la puissance de `b` `power(9, 3)` → `729`
`radians` ( `double precision` ) → `double precision` Convertit des degrés en radians `radians(45.0)` → `0.7853981633974483`
`round` ( `numeric` ) → `numeric` `round` ( `double precision` ) → `double precision` Arrondit à l'entier le plus proche. Pour le type `numeric`, les nombres à mi-chemin sont arrondis en s'éloignant de zéro. Pour le type `double precision`, le comportement de l'arrondi est dépendant de la plateforme, mais « l'arrondi vers le plus proche » est la règle la plus commune. `round(42.4)` → `42`
`round` ( `v` `numeric`, `s` `integer` ) → `numeric` Arrondit `v` à `s` positions décimales. Les nombres à mi-chemin sont arrondis en s'éloignant de zéro. `round(42.4382, 2)` → `42.44` `round(1234.56, -1)` → `1230`
`scale` ( `numeric` ) → `integer` Échelle de l'argument (le nombre de chiffres décimaux dans la partie fractionnelle) `scale(8.4100)` → `4`
`sign` ( `numeric` ) → `numeric` `sign` ( `double precision` ) → `double precision` Signe de l'argument (-1, 0 ou +1) `sign(-8.4)` → `-1`
`sqrt` ( `numeric` ) → `numeric` `sqrt` ( `double precision` ) → `double precision` Racine carrée `sqrt(2)` → `1.4142135623730951`
`trim_scale` ( `numeric` ) → `numeric` Réduit l'échelle de la valeur (nombre de chiffres décimaux fractionnels) en supprimant les zéro à la fin `trim_scale(8.4100)` → `8.41`
`trunc` ( `numeric` ) → `numeric` `trunc` ( `double precision` ) → `double precision` Tronque à l'entier (vers zéro) `trunc(42.8)` → `42` `trunc(-42.8)` → `-42`
`trunc` ( `v` `numeric`, `s` `integer` ) → `numeric` Tronque `v` à `s` places décimales `trunc(42.4382, 2)` → `42.43`
`width_bucket` ( `operand` `numeric`, `low` `numeric`, `high` `numeric`, `count` `integer` ) → `integer` `width_bucket` ( `operand` `double precision`, `low` `double precision`, `high` `double precision`, `count` `integer` ) → `integer` Renvoie le numéro du compartiment dans lequel `operand` serait affecté dans un histogramme ayant `count` compartiments d'égale longueur répartis entre `low` et `high`. Les compartiments ont des limits basses inclusives et des limites hautes exclusives. Renvoie `0` pour un argument inférieur à `low`, ou ``count`+1` pour un argument supérieur ou égal à `high`. Si `low` > `high`, le comportement est inversé avec le compartiment `1` juste en dessous de `low`, et les limites inclusives étant maintenant du côté haut. `width_bucket(5.35, 0.024, 10.06, 5)` → `3` `width_bucket(9, 10, 0, 10)` → `2`
`width_bucket` ( `operand` `anycompatible`, `thresholds` `anycompatiblearray` ) → `integer` Renvoie le numéro du compartiment dans lequel `operand` serait affecté pour un tableau listant les limites basses inclusives des compartiments. Renvoie `0` pour un argument inférieur à la première limite basse. `operand` et les éléments du tableau peuvent être de tout type ayant des opérateurs de comparaison standards. Le tableau `thresholds` doit être triés, les plus petits en premier. Sinon, des résultats inattendus pourraient être obtenus. `width_bucket(now(), array['yesterday', 'today', 'tomorrow']::timestamptz[])` → `2`

Tableau 9.6 affiche les fonctions pour générer des nombres aléatoires.

Tableau 9.6. Fonctions aléatoires

Fonction Description Exemple(s)
`random` ( ) → `double precision` Renvoie une valeur aléatoire comprise dans l'intervalle 0.0 <= x < 1.0 `random()` → `0.897124072839091`
`setseed` ( `double precision` ) → `void` Configure le sel pour les appels suivants à `random()` ; l'argument doit être compris entre -1.0 et 1.0, valeurs comprises. `setseed(0.12345)`

La fonction `random()` utilise un algorithme congruentiel linéaire simple. Il est rapide mais non convenable pour des applications cryptographiques. Voir le module pgcrypto pour une alternative plus sécurisée. Si `setseed()` est appelé, la série de résultats d'appels en bouicle à `random()` dans la même session peut être répétée 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.

Tableau 9.7 montre les fonctions trigonométriques disponibles. Chacune de ces fonctions vient en deux variantes, une pour mesurer les angles en radians et une pour les mesurer en degrés.

Tableau 9.7. Fonctions trigonométriques

Fonction Description Exemple(s)
`acos` ( `double precision` ) → `double precision` Cosinus inverse, résultat en radians `acos(1)` → `0`
`acosd` ( `double precision` ) → `double precision` Cosinus inverse, résultat en degrés `acosd(0.5)` → `60`
`asin` ( `double precision` ) → `double precision` Sinus inverse, résultat en radians `asin(1)` → `1.5707963267948966`
`asind` ( `double precision` ) → `double precision` Sinus inverse, résultat en degrés `asind(0.5)` → `30`
`atan` ( `double precision` ) → `double precision` Tangente inverse, résultat en radians `atan(1)` → `0.7853981633974483`
`atand` ( `double precision` ) → `double precision` Tangente inverse, résultat en degrés `atand(1)` → `45`
`atan2` ( `y` `double precision`, `x` `double precision` ) → `double precision` Tangente inverse de `y`/`x`, résultat en radians `atan2(1, 0)` → `1.5707963267948966`
`atan2d` ( `y` `double precision`, `x` `double precision` ) → `double precision` Tangente inverse de `y`/`x`, résultat en degrés `atan2d(1, 0)` → `90`
`cos` ( `double precision` ) → `double precision` Cosinus, argument en radians `cos(0)` → `1`
`cosd` ( `double precision` ) → `double precision` Cosinus, argument en degrés `cosd(60)` → `0.5`
`cot` ( `double precision` ) → `double precision` Cotangente, argument en radians `cot(0.5)` → `1.830487721712452`
`cotd` ( `double precision` ) → `double precision` Cotangente, argument en degrés `cotd(45)` → `1`
`sin` ( `double precision` ) → `double precision` Sinus, argument en radians `sin(1)` → `0.8414709848078965`
`sind` ( `double precision` ) → `double precision` Sinus, argument en degrés `sind(30)` → `0.5`
`tan` ( `double precision` ) → `double precision` Tangente, argument en radians `tan(1)` → `1.5574077246549023`
`tand` ( `double precision` ) → `double precision` Tangente, argument en degrés `tand(45)` → `1`

### Note

Une autre façon de travailler avec des angles mesurés en degrés est d'utiliser les fonctions de transformation d'unité ``radians()`` et ``degrees()`` montrées plus tôt. Néanmoins, utiliser les fonctions trigonométriques basées sur les degrés est préféré, car cette façon évite les erreurs d'arrondi pour les cas spéciaux comme `sind(30)`.

Tableau 9.8 affiche les fonctions hyperboliques.

Tableau 9.8. Fonctions hyperboliques

Fonction Description Exemple(s)
`sinh` ( `double precision` ) → `double precision` Sinus hyperbolique `sinh(1)` → `1.1752011936438014`
`cosh` ( `double precision` ) → `double precision` Cosinus hyperbolique `cosh(0)` → `1`
`tanh` ( `double precision` ) → `double precision` Tangente hyperbolique `tanh(1)` → `0.7615941559557649`
`asinh` ( `double precision` ) → `double precision` Sinus inverse hyperbolique `asinh(1)` → `0.881373587019543`
`acosh` ( `double precision` ) → `double precision` Cosinus inverse hyperbolique `acosh(1)` → `0`
`atanh` ( `double precision` ) → `double precision` Tangente inverse hyperbolique `atanh(0.5)` → `0.5493061443340548`