Partage via

Opérateurs arithmétiques

  • Article

Cette rubrique décrit les opérateurs arithmétiques disponibles dans F#.

Résumé des opérateurs arithmétiques binaires

Les opérations arithmétiques en F# peuvent être effectuées selon deux modes : Unchecked (non vérifié) et Checked (vérifié). Par défaut, les opérations arithmétiques utilisent un comportement non vérifié, qui hiérarchise les performances, mais autorise le dépassement de capacité/sous-flux. Les opérateurs vérifiés hiérarchisent la sécurité en lançant des exceptions dans de tels cas.

Opérateurs arithmétiques non vérifiés

Le tableau suivant résume les opérateurs arithmétiques binaires disponibles pour l'arithmétique non vérifiée avec les types intégral et à virgule flottante non vérifiés.

Opérateur binaire Notes
+ (addition, plus) Décoché. Condition de dépassement possible lorsque les nombres sont ajoutés ensemble et que la somme dépasse la valeur absolue maximale prise en charge par le type.
- (soustraction, moins) Décoché. Condition de sous-flux possible lorsque les types non signés sont soustraits ou lorsque les valeurs à virgule flottante sont trop petites pour être représentées par le type.
* (multiplication, fois) Décoché. Condition de dépassement possible lorsque les nombres sont multipliés et que le produit dépasse la valeur absolue maximale prise en charge par le type.
/ (division, divisé par) La division par zéro entraîne une DivideByZeroException pour les types intégraux. Pour les types à virgule flottante, la division par zéro vous donne les valeurs à virgule flottante spéciales infinity ou -infinity. Il existe également une condition de sous-flux possible lorsqu’un nombre à virgule flottante est trop petit pour être représenté par le type.
% (reste, rem) Renvoie le reste d'une opération de division. Le signe du résultat est identique au signe du premier opérande.
** (exponentiation, à la puissance de) Condition de dépassement possible lorsque le résultat dépasse la valeur absolue maximale du type.

L'opérateur d'exponentiation ne fonctionne qu'avec les types à virgule flottante.

Le comportement non vérifié ne lève pas d'exception en cas de débordement ou de sous-débordement, ce qui le rend moins sûr pour l'arithmétique sur les grandes valeurs ou les valeurs marginales.

Opérateurs arithmétiques vérifiés

Le tableau suivant récapitule les opérateurs arithmétiques binaires disponibles pour arithmétique vérifiée avec des types intégraux non encadrés. Les opérateurs vérifiés assurent que les calculs sont vérifiés pour le dépassement de capacité ou le sous-débordement, offrant une arithmétique plus sûre pour les applications critiques.

Opérateur binaire Notes
+ (addition, plus) Lève une OverflowException si le résultat dépasse la valeur maximale ou dépasse la valeur minimale prise en charge par le type. Le débordement et le sous-débordement sont tous deux possibles.
- (soustraction, moins) Lève une OverflowException si le résultat dépasse la valeur maximale ou dépasse la valeur minimale prise en charge par le type. Le débordement et le sous-débordement sont tous deux possibles.
* (multiplication, fois) Lève une OverflowException si le produit dépasse la valeur maximale ou dépasse la valeur minimale prise en charge par le type. Le débordement et le sous-débordement sont tous deux possibles.

Les opérateurs vérifiés sont utiles pour s’assurer que les dépassements arithmétiques sont interceptés et gérés explicitement.

Voici un exemple :

open Microsoft.FSharp.Core.Operators.Checked

let safeAddition () =
    try
        let result = 2147483647 + 1 // Attempt to add integers at their maximum boundary
        printfn "Result: %d" result
    with
    | :? System.OverflowException as ex ->
        printfn "Overflow occurred: %s" ex.Message

safeAddition()

// Output:
// Overflow occurred: Arithmetic operation resulted in an overflow.

Choix entre opérateurs activés et désactivés

Opérateurs vérifiés : Idéal pour les scénarios dans lesquels les erreurs de débordement doivent être détectées et traitées explicitement.

Opérateurs non vérifiés : Par défaut, F# utilise l’arithmétique non cochée pour des raisons de performances. Ces opérations peuvent produire des résultats incorrects en mode silencieux quand un dépassement de capacité ou un sous-flux se produit. Utilisez avec précaution.

Résumé des opérateurs arithmétiques unaires

Le tableau suivant récapitule les opérateurs arithmétiques unaires disponibles pour les types intégraux et à virgule flottante.

Opérateurs unaires Notes
+ (positif) Peut être appliqué à n’importe quelle expression arithmétique. Ne modifie pas le signe de la valeur.
- (négation, négatif) Peut être appliqué à n’importe quelle expression arithmétique. Change le signe de la valeur.

Le comportement en cas de débordement ou de sous-débordement pour les types intégraux est de s'enrouler autour de la valeur. Cela provoque un résultat incorrect. Le dépassement d’entier est un problème potentiellement grave qui peut contribuer aux problèmes de sécurité lorsque le logiciel n’est pas écrit pour en tenir compte. Si cela pose un problème pour votre application, envisagez d'utiliser les opérateurs vérifiés dans Microsoft.FSharp.Core.Operators.Checked.

Résumé des opérateurs de comparaison binaire

Le tableau suivant présente les opérateurs de comparaison binaires disponibles pour les types intégraux et à virgule flottante. Ces opérateurs retournent des valeurs de type bool.

Les nombres à virgule flottante ne doivent jamais être comparés directement pour l’égalité, car la représentation à virgule flottante IEEE ne prend pas en charge une opération d’égalité exacte. Deux nombres que vous pouvez facilement vérifier être égaux en inspectant le code peut avoir des représentations binaires différentes.

Opérateur Notes
= (égalité, égal) Il ne s'agit pas d'un opérateur d'affectation. Il est utilisé uniquement pour la comparaison. Il s’agit d’un opérateur générique.
> (supérieur à) Il s’agit d’un opérateur générique.
< (inférieur à) Il s’agit d’un opérateur générique.
>= (supérieur ou égal) Il s’agit d’un opérateur générique.
<= (inférieur ou égal) Il s’agit d’un opérateur générique.
<> (non égal) Il s’agit d’un opérateur générique.

Opérateurs surchargés et génériques

Tous les opérateurs abordés dans cette rubrique sont définis dans l’espace de noms Microsoft.FSharp.Core.Operators. Certains des opérateurs sont définis à l’aide de paramètres de type résolus statiquement. Cela signifie qu’il existe des définitions individuelles pour chaque type spécifique qui fonctionne avec cet opérateur. Tous les opérateurs arithmétiques et logiques unaires et binaires se trouvent dans cette catégorie. Les opérateurs de comparaison sont génériques et fonctionnent donc avec n’importe quel type, pas seulement les types arithmétiques primitifs. Les unions discriminées et les types d’enregistrements ont leurs propres implémentations personnalisées générées par le compilateur F#. Les types de classes utilisent la méthode Equals.

Les opérateurs génériques sont personnalisables. Pour personnaliser les fonctions de comparaison, remplacez Equals pour fournir votre propre comparaison d’égalité personnalisée, puis implémentez IComparable. L’interface System.IComparable a une méthode unique, la méthode CompareTo.

Opérateurs et inférence de type

L’utilisation d’un opérateur dans une expression limite l’inférence de type sur cet opérateur. En outre, l’utilisation d’opérateurs empêche la généralisation automatique, car l’utilisation d’opérateurs implique un type arithmétique. En l’absence d’autres informations, le compilateur F# déduit int comme type d’expressions arithmétiques. Vous pouvez remplacer ce comportement en spécifiant un autre type. Ainsi, les types d’arguments et le type de retour de function1 dans le code suivant sont déduits comme int, mais les types pour function2 sont déduits comme float.

// x, y and return value inferred to be int
// function1: int -> int -> int
let function1 x y = x + y

// x, y and return value inferred to be float
// function2: float -> float -> float
let function2 (x: float) y = x + y

Voir aussi