9.3. 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`

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`
`erf` ( `double precision` ) → `double precision` Fonction erreur `erf(1.0)` → `0.8427007929497149`
`erfc` ( `double precision` ) → `double precision` Fonction erreur supplémentaire (`1 - erf(x)`, sans perte de précision pour les gros arguments) `erfc(1.0)` → `0.15729920705028513`
`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`

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

erf ( double precision ) → double precision

Fonction erreur

erf(1.0) → 0.8427007929497149

erfc ( double precision ) → double precision

Fonction erreur supplémentaire (1 - erf(x), sans perte de précision pour les gros arguments)

erfc(1.0) → 0.15729920705028513

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, bigintet 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, bigintet 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`
`random` ( `min` `integer`, `max` `integer` ) → `integer` `random` ( `min` `bigint`, `max` `bigint` ) → `bigint` `random` ( `min` `numeric`, `max` `numeric` ) → `numeric` Renvoie une valeur aléatoire dans la plage `min` <= x <= `max`. Pour le type `numeric`, le résultat aura le même nombre de chiffres décimaux fractionnaires que `min` ou `max`, selon celui qui en a le plus. `random(1, 10)` → `7` `random(-0.499, 0.499)` → `0.347`
`random_normal` ( [ `mean` `double precision` [, `stddev` `double precision` ]] ) → `double precision` Renvoie une valeur aléatoire à partir d'une distribution normale avec les paramètres donnés ; `mean` vaut 0.0 par défaut et `stddev` vaut 1.0 par défaut. `random_normal(0.0, 1.0)` → `0.051285419`
`setseed` ( `double precision` ) → `void` Configure le sel pour les appels suivants à `random()` et `random_normal()` ; l'argument doit être compris entre -1.0 et 1.0, valeurs comprises. `setseed(0.12345)`

Fonction

Description

Exemple(s)

random ( ) → double precision

Renvoie une valeur aléatoire comprise dans l'intervalle 0.0 <= x < 1.0

random() → 0.897124072839091

random ( min integer, max integer ) → integer

random ( min bigint, max bigint ) → bigint

random ( min numeric, max numeric ) → numeric

Renvoie une valeur aléatoire dans la plage min <= x <= max. Pour le type numeric, le résultat aura le même nombre de chiffres décimaux fractionnaires que min ou max, selon celui qui en a le plus.

random(1, 10) → 7

random(-0.499, 0.499) → 0.347

random_normal ( [ mean double precision [, stddev double precision ]] ) → double precision

Renvoie une valeur aléatoire à partir d'une distribution normale avec les paramètres donnés ; mean vaut 0.0 par défaut et stddev vaut 1.0 par défaut.

random_normal(0.0, 1.0) → 0.051285419

setseed ( double precision ) → void

Configure le sel pour les appels suivants à random() et random_normal() ; l'argument doit être compris entre -1.0 et 1.0, valeurs comprises.

setseed(0.12345)

La fonction random() utilise un générateur de nombres pseudo aléatoires déterministique. 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. Ces remarques valent aussi bien pour random_normal().

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`

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`

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