Bibliothèque Math en C#

La bibliothèque Math en C#, fournie par la classe System.Math, contient de nombreuses méthodes et constantes intégrées permettant d’effectuer des calculs mathématiques dans les applications C#. Étant donné que la classe Math est statique, ses méthodes peuvent être utilisées directement sans créer d’instance. Dans cet article, nous allons examiner les méthodes System.Math les plus couramment utilisées en C# à l’aide d’exemples clairs et pratiques.

Valeur absolue (Abs)

La méthode Math.Abs renvoie la valeur absolue d’un nombre en supprimant son signe négatif. Elle est couramment utilisée lorsque la grandeur d’une valeur est importante, indépendamment de son signe.

int a = -15;
Console.WriteLine(Math.Abs(a)); // 15

Minimum et maximum (Min, Max)

Les méthodes Math.Min et Math.Max permettent de comparer deux valeurs numériques et de retourner la plus petite ou la plus grande. Elles sont particulièrement utiles pour les validations et les contrôles de limites.

int x = 8, y = 20;
Console.WriteLine(Math.Min(x, y)); // 8
Console.WriteLine(Math.Max(x, y)); // 20

Racine carrée (Sqrt)

La méthode Math.Sqrt calcule la racine carrée d’un nombre donné. Elle retourne une valeur de type double et est fréquemment utilisée dans les calculs géométriques et scientifiques.

double number = 81;
Console.WriteLine(Math.Sqrt(number)); // 9

Puissance (Pow)

La méthode Math.Pow élève un nombre à la puissance d’un autre nombre. Elle est couramment utilisée pour les calculs exponentiels et retourne une valeur de type double.

Console.WriteLine(Math.Pow(2, 3)); // 8

Arrondi (Round, Ceiling, Floor)

C# fournit plusieurs méthodes d’arrondi via la classe Math. Math.Round arrondit à la valeur la plus proche, Math.Ceiling arrondit toujours à l’entier supérieur, et Math.Floor arrondit toujours à l’entier inférieur.

double d = 4.7;

Console.WriteLine(Math.Round(d));   // 5 (arrondi au plus proche)
Console.WriteLine(Math.Ceiling(d)); // 5 (toujours vers le haut)
Console.WriteLine(Math.Floor(d));   // 4 (toujours vers le bas)

Troncature (Truncate)

La méthode Math.Truncate supprime la partie décimale d’un nombre sans effectuer d’arrondi, en conservant uniquement la partie entière.

double d = 4.9;
Console.WriteLine(Math.Truncate(d)); // 4

Division avec reste (DivRem)

La méthode Math.DivRem effectue une division entière et retourne à la fois le quotient et le reste en une seule opération. Elle est utile dans les calculs sensibles aux performances.

int quotient, remainder;
remainder = Math.DivRem(17, 5, out quotient);

Console.WriteLine("Quotient: " + quotient); // 3
Console.WriteLine("Reste: " + remainder);   // 2

Fonctions trigonométriques (Sin, Cos, Tan)

Les méthodes Math.Sin, Math.Cos et Math.Tan calculent des valeurs trigonométriques en utilisant des radians. Elles sont couramment utilisées en géométrie, en infographie et en physique.

double angle = Math.PI / 4; // 45 degrés (en radians)

Console.WriteLine(Math.Sin(angle)); // 0.707...
Console.WriteLine(Math.Cos(angle)); // 0.707...
Console.WriteLine(Math.Tan(angle)); // 1

Conversion d’angles (Radians/Degrés, constante PI)

Les méthodes trigonométriques en C# fonctionnent avec des radians. À l’aide de la constante Math.PI, il est facile de convertir des degrés en radians lorsque cela est nécessaire.

double degree = 180;
double radian = degree * (Math.PI / 180);

Console.WriteLine(radian); // 3.14159...

Logarithme (Log, Log10)

La méthode Math.Log calcule le logarithme naturel (base e), tandis que Math.Log10 calcule le logarithme en base 10. Ces fonctions sont fréquemment utilisées dans les applications scientifiques et financières.

Console.WriteLine(Math.Log(100));   // logarithme naturel (base e)
Console.WriteLine(Math.Log10(100)); // logarithme en base 10

Valeurs maximale et minimale du type Double

Les constantes double.MaxValue et double.MinValue représentent respectivement les valeurs maximale et minimale qu’une variable de type double peut contenir. Elles sont utiles pour les comparaisons et l’initialisation des variables.

Console.WriteLine(double.MaxValue);
Console.WriteLine(double.MinValue);

Combinaison de racine carrée et de puissance

Les méthodes de la classe Math peuvent être combinées pour effectuer des calculs plus complexes. Dans cet exemple, un nombre est d’abord élevé à une puissance, puis sa racine carrée est calculée.

double number = 256;
double result = Math.Sqrt(Math.Pow(number, 2)); 
Console.WriteLine(result); // 256 (d’abord au carré, puis racine carrée)

Utilisation avec la valeur absolue

La méthode Math.Abs est souvent utilisée dans des calculs où des résultats négatifs peuvent apparaître, comme les différences entre des valeurs. En appliquant Math.Abs, on s’assure que le résultat est toujours positif, ce qui est utile pour les comparaisons et les calculs de distance.

int diff = -50;
Console.WriteLine(Math.Abs(diff)); // 50

Détermination du signe (Sign)

La méthode Math.Sign retourne -1, 0 ou 1 selon qu’un nombre est négatif, nul ou positif. Elle est utile lorsque seule la direction d’une valeur est importante.

Console.WriteLine(Math.Sign(-10)); // -1
Console.WriteLine(Math.Sign(0));   // 0
Console.WriteLine(Math.Sign(25));  // 1

Limitation de valeur (Clamp)

La méthode Math.Clamp limite une valeur à une plage spécifiée. Si la valeur est inférieure au minimum, le minimum est retourné ; si elle est supérieure au maximum, le maximum est retourné.

int value = 120;
int result = Math.Clamp(value, 0, 100);
Console.WriteLine(result); // 100

Fonction exponentielle (Exp)

La méthode Math.Exp calcule e élevé à la puissance spécifiée. Elle est couramment utilisée dans les calculs scientifiques, mathématiques et statistiques.

Console.WriteLine(Math.Exp(1)); // e ≈ 2.71828

TL;DR

Articles connexes