Partager via

Math.Abs Méthode

  • Référence

Définition

Espace de noms:
System
Assembly:
System.Runtime.Extensions.dll
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Retourne la valeur absolue d'un nombre spécifié.

Surcharges

Abs(Decimal)

Retourne la valeur absolue d'un nombre Decimal.
Abs(Double)

Retourne la valeur absolue d'un nombre à virgule flottante double précision.
Abs(Int16)

Retourne la valeur absolue d'un entier signé 16 bits.
Abs(Int32)

Retourne la valeur absolue d'un entier signé 32 bits.
Abs(Int64)

Retourne la valeur absolue d'un entier signé 64 bits.
Abs(IntPtr)

Retourne la valeur absolue d’un entier signé natif.
Abs(SByte)

Retourne la valeur absolue d'un entier signé 8 bits.
Abs(Single)

Retourne la valeur absolue d'un nombre à virgule flottante simple précision.

Abs(Decimal)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Retourne la valeur absolue d'un nombre Decimal.

public:
 static System::Decimal Abs(System::Decimal value);
public static decimal Abs (decimal value);
static member Abs : decimal -> decimal
Public Shared Function Abs (value As Decimal) As Decimal

Paramètres

value
Decimal

Nombre supérieur ou égal à Decimal.MinValue, mais inférieur ou égal à Decimal.MaxValue.

Retours

Decimal

Nombre décimal, x, tel que 0 ≤ x ≤ Decimal.MaxValue.

Exemples

L’exemple suivant utilise la Abs(Decimal) méthode pour obtenir la valeur absolue d’un certain nombre de Decimal valeurs.

decimal[] decimals = { Decimal.MaxValue, 12.45M, 0M, -19.69M,
                       Decimal.MinValue };
foreach (decimal value in decimals)
   Console.WriteLine($"Abs({value}) = {Math.Abs(value)}");

// The example displays the following output:
//       Abs(79228162514264337593543950335) = 79228162514264337593543950335
//       Abs(12.45) = 12.45
//       Abs(0) = 0
//       Abs(-19.69) = 19.69
//       Abs(-79228162514264337593543950335) = 79228162514264337593543950335

open System

let decimals = 
    [ Decimal.MaxValue; 12.45M; 0M
      -19.69M; Decimal.MinValue ]

for value in decimals do
    // The 'abs' function may be used instead.
    printfn $"Abs({value}) = {Math.Abs value}"

// The example displays the following output:
//       Abs(79228162514264337593543950335) = 79228162514264337593543950335
//       Abs(12.45) = 12.45
//       Abs(0) = 0
//       Abs(-19.69) = 19.69
//       Abs(-79228162514264337593543950335) = 79228162514264337593543950335

Remarques

La valeur absolue d’un Decimal est sa valeur numérique sans son signe. Par exemple, la valeur absolue de 1.2 et -1.2 est 1.2.

S’applique à

Abs(Double)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Retourne la valeur absolue d'un nombre à virgule flottante double précision.

public:
 static double Abs(double value);
public static double Abs (double value);
static member Abs : double -> double
Public Shared Function Abs (value As Double) As Double

Paramètres

value
Double

Nombre supérieur ou égal à Double.MinValue, mais inférieur ou égal à Double.MaxValue.

Retours

Double

Nombre à virgule flottante double précision, x, tel que 0 ≤ x ≤ Double.MaxValue.

Exemples

L’exemple suivant utilise la Abs(Double) méthode pour obtenir la valeur absolue d’un certain nombre de Double valeurs.

double[] doubles = { Double.MaxValue, 16.354e-17, 15.098123, 0,
                     -19.069713, -15.058e18, Double.MinValue };
foreach (double value in doubles)
   Console.WriteLine($"Abs({value}) = {Math.Abs(value)}");

// The example displays the following output:
//       Abs(1.79769313486232E+308) = 1.79769313486232E+308
//       Abs(1.6354E-16) = 1.6354E-16
//       Abs(15.098123) = 15.098123
//       Abs(0) = 0
//       Abs(-19.069713) = 19.069713
//       Abs(-1.5058E+19) = 1.5058E+19
//       Abs(-1.79769313486232E+308) = 1.79769313486232E+308

open System

let doubles = 
    [ Double.MaxValue; 16.354e-17; 15.098123; 0
      -19.069713; -15.058e18; Double.MinValue ]

for value in doubles do
    // The 'abs' function may be used instead.
    printfn $"Abs({value}) = {Math.Abs value}"

// The example displays the following output:
//       Abs(1.79769313486232E+308) = 1.79769313486232E+308
//       Abs(1.6354E-16) = 1.6354E-16
//       Abs(15.098123) = 15.098123
//       Abs(0) = 0
//       Abs(-19.069713) = 19.069713
//       Abs(-1.5058E+19) = 1.5058E+19
//       Abs(-1.79769313486232E+308) = 1.79769313486232E+308

Module Example
   Public Sub Main()
      Dim doubles() As Double = { Double.MaxValue, 16.354e-17, 15.098123, 0, _
                                  -19.069713, -15.058e18, Double.MinValue }
      For Each value As Double In doubles
         Console.WriteLine("Abs({0}) = {1}", value, Math.Abs(value))
      Next
   End Sub
End Module
' The example displays the following output:
'       Abs(1.79769313486232E+308) = 1.79769313486232E+308
'       Abs(1.6354E-16) = 1.6354E-16
'       Abs(15.098123) = 15.098123
'       Abs(0) = 0
'       Abs(-19.069713) = 19.069713
'       Abs(-1.5058E+19) = 1.5058E+19
'       Abs(-1.79769313486232E+308) = 1.79769313486232E+308

Remarques

La valeur absolue d’un Double est sa valeur numérique sans son signe. Par exemple, la valeur absolue de 1.2e03 et -1.2e03 est 1.2e03.

Si value est égal à NegativeInfinity ou PositiveInfinity, la valeur de retour est PositiveInfinity. Si value est égal à NaN, la valeur de retour est NaN.

S’applique à

Abs(Int16)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Retourne la valeur absolue d'un entier signé 16 bits.

public:
 static short Abs(short value);
public static short Abs (short value);
static member Abs : int16 -> int16
Public Shared Function Abs (value As Short) As Short

Paramètres

value
Int16

Nombre supérieur à Int16.MinValue, mais inférieur ou égal à Int16.MaxValue.

Retours

Int16

Entier signé 16 bits, x, tel que 0 ≤ x ≤ Int16.MaxValue.

Exceptions

OverflowException

value est égal à Int16.MinValue.

Exemples

L’exemple suivant utilise la Abs(Int16) méthode pour obtenir la valeur absolue d’un certain nombre de Int16 valeurs.

short[] values = { Int16.MaxValue, 10328, 0, -1476, Int16.MinValue };
foreach (short value in values)
{
   try {
      Console.WriteLine($"Abs({value}) = {Math.Abs(value)}");
   }
   catch (OverflowException) {
      Console.WriteLine("Unable to calculate the absolute value of {0}.",
                        value);
   }
}

// The example displays the following output:
//       Abs(32767) = 32767
//       Abs(10328) = 10328
//       Abs(0) = 0
//       Abs(-1476) = 1476
//       Unable to calculate the absolute value of -32768.

open System

let values = 
    [ Int16.MaxValue; 10328s; 0s; -1476s; Int16.MinValue ]

for value in values do
    try
        // The 'abs' function may be used instead.
        printfn $"Abs({value}) = {Math.Abs value}"
    with :? OverflowException ->
        printfn $"Unable to calculate the absolute value of {value}."

// The example displays the following output:
//       Abs(32767) = 32767
//       Abs(10328) = 10328
//       Abs(0) = 0
//       Abs(-1476) = 1476
//       Unable to calculate the absolute value of -32768.

Module Example
   Public Sub Main()
      Dim values() As Short = { Int16.MaxValue, 10328, 0, -1476, Int16.MinValue }
      For Each value As Short In values
         Try
            Console.WriteLine("Abs({0}) = {1}", value, Math.Abs(value))
         Catch e As OverflowException
            Console.WriteLine("Unable to calculate the absolute value of {0}.", _
                              value)
         End Try   
      Next
   End Sub
End Module
' The example displays the following output:
'       Abs(32767) = 32767
'       Abs(10328) = 10328
'       Abs(0) = 0
'       Abs(-1476) = 1476
'       Unable to calculate the absolute value of -32768.

Remarques

La valeur absolue d’un Int16 est sa valeur numérique sans son signe. Par exemple, la valeur absolue de 123 et -123 est 123.

S’applique à

Abs(Int32)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Retourne la valeur absolue d'un entier signé 32 bits.

public:
 static int Abs(int value);
public static int Abs (int value);
static member Abs : int -> int
Public Shared Function Abs (value As Integer) As Integer

Paramètres

value
Int32

Nombre supérieur à Int32.MinValue, mais inférieur ou égal à Int32.MaxValue.

Retours

Int32

Entier signé 32 bits, x, tel que 0 ≤ x ≤ Int32.MaxValue.

Exceptions

OverflowException

value est égal à Int32.MinValue.

Exemples

L’exemple suivant utilise la Abs(Int32) méthode pour obtenir la valeur absolue d’un certain nombre de Int32 valeurs.

int[] values = { Int32.MaxValue, 16921, 0, -804128, Int32.MinValue };
foreach (int value in values)
{
   try {
      Console.WriteLine($"Abs({value}) = {Math.Abs(value)}");
   }
   catch (OverflowException) {
      Console.WriteLine("Unable to calculate the absolute value of {0}.",
                        value);
   }
}

// The example displays the following output:
//       Abs(2147483647) = 2147483647
//       Abs(16921) = 16921
//       Abs(0) = 0
//       Abs(-804128) = 804128
//       Unable to calculate the absolute value of -2147483648.

open System

let values = 
    [ Int32.MaxValue; 16921; 0; -804128; Int32.MinValue ]

for value in values do
    try 
        // The 'abs' function may be used instead.
        printfn $"Abs({value}) = {Math.Abs(value)}"
    with :? OverflowException ->
        printfn $"Unable to calculate the absolute value of {value}."

// The example displays the following output:
//       Abs(2147483647) = 2147483647
//       Abs(16921) = 16921
//       Abs(0) = 0
//       Abs(-804128) = 804128
//       Unable to calculate the absolute value of -2147483648.

Module Example
   Public Sub Main()
      Dim values() As Integer = { Int32.MaxValue, 16921, 0, -804128, Int32.MinValue }
      For Each value As Integer In values
         Try
            Console.WriteLine("Abs({0}) = {1}", value, Math.Abs(value))
         Catch e As OverflowException
            Console.WriteLine("Unable to calculate the absolute value of {0}.", _
                              value)
         End Try   
      Next
   End Sub
End Module
' The example displays the following output:
'       Abs(2147483647) = 2147483647
'       Abs(16921) = 16921
'       Abs(0) = 0
'       Abs(-804128) = 804128
'       Unable to calculate the absolute value of -2147483648.

Remarques

La valeur absolue d’un Int32 est sa valeur numérique sans son signe. Par exemple, la valeur absolue de 123 et -123 est 123.

S’applique à

Abs(Int64)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Retourne la valeur absolue d'un entier signé 64 bits.

public:
 static long Abs(long value);
public static long Abs (long value);
static member Abs : int64 -> int64
Public Shared Function Abs (value As Long) As Long

Paramètres

value
Int64

Nombre supérieur à Int64.MinValue, mais inférieur ou égal à Int64.MaxValue.

Retours

Int64

Entier signé 64 bits, x, tel que 0 ≤ x ≤ Int64.MaxValue.

Exceptions

OverflowException

value est égal à Int64.MinValue.

Exemples

L’exemple suivant utilise la Abs(Int64) méthode pour obtenir la valeur absolue d’un certain nombre de Int64 valeurs.

long[] values = { Int64.MaxValue, 109013, 0, -6871982, Int64.MinValue };
foreach (long value in values)
{
   try {
      Console.WriteLine($"Abs({value}) = {Math.Abs(value)}");
   }
   catch (OverflowException) {
      Console.WriteLine("Unable to calculate the absolute value of {0}.",
                        value);
   }
}

// The example displays the following output:
//       Abs(9223372036854775807) = 9223372036854775807
//       Abs(109013) = 109013
//       Abs(0) = 0
//       Abs(-6871982) = 6871982
//       Unable to calculate the absolute value of -9223372036854775808.

open System

let values = 
    [ Int64.MaxValue; 109013; 0; -6871982; Int64.MinValue ]

for value in values do
    try
        // The 'abs' function may be used instead.
        printfn $"Abs({value}) = {Math.Abs value}"
    with :? OverflowException ->
        printfn $"Unable to calculate the absolute value of {value}."

// The example displays the following output:
//       Abs(9223372036854775807) = 9223372036854775807
//       Abs(109013) = 109013
//       Abs(0) = 0
//       Abs(-6871982) = 6871982
//       Unable to calculate the absolute value of -9223372036854775808.

Module Example
   Public Sub Main()
      Dim values() As Long = { Int64.MaxValue, 109013, 0, -6871982, Int64.MinValue }
      For Each value As Long In values
         Try
            Console.WriteLine("Abs({0}) = {1}", value, Math.Abs(value))
         Catch e As OverflowException
            Console.WriteLine("Unable to calculate the absolute value of {0}.", _
                              value)
         End Try   
      Next
   End Sub
End Module
' The example displays the following output:
'       Abs(9223372036854775807) = 9223372036854775807
'       Abs(109013) = 109013
'       Abs(0) = 0
'       Abs(-6871982) = 6871982
'       Unable to calculate the absolute value of -9223372036854775808.

Remarques

La valeur absolue d’un Int64 est sa valeur numérique sans son signe. Par exemple, la valeur absolue de 123 et -123 est 123.

S’applique à

Abs(IntPtr)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Retourne la valeur absolue d’un entier signé natif.

public:
 static IntPtr Abs(IntPtr value);
public static nint Abs (nint value);
public static IntPtr Abs (IntPtr value);
static member Abs : nativeint -> nativeint
Public Shared Function Abs (value As IntPtr) As IntPtr

Paramètres

value
IntPtr

nint

nativeint

Nombre qui est supérieur à MinValue, mais inférieur ou égal à MaxValue.

Retours

IntPtr

nint

nativeint

Entier signé natif, x, tel que 0 ≤ x ≤ MaxValue.

S’applique à

Abs(SByte)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Important

Cette API n’est pas conforme CLS.

Retourne la valeur absolue d'un entier signé 8 bits.

public:
 static System::SByte Abs(System::SByte value);
[System.CLSCompliant(false)]
public static sbyte Abs (sbyte value);
[<System.CLSCompliant(false)>]
static member Abs : sbyte -> sbyte
Public Shared Function Abs (value As SByte) As SByte

Paramètres

value
SByte

Nombre supérieur à SByte.MinValue, mais inférieur ou égal à SByte.MaxValue.

Retours

SByte

Entier signé 8 bits, x, tel que 0 ≤ x ≤ SByte.MaxValue.

Attributs
CLSCompliantAttribute

Exceptions

OverflowException

value est égal à SByte.MinValue.

Exemples

L’exemple suivant utilise la Abs(SByte) méthode pour obtenir la valeur absolue d’un certain nombre de SByte valeurs.

sbyte[] values = { SByte.MaxValue, 98, 0, -32, SByte.MinValue };
foreach (sbyte value in values)
{
   try {
      Console.WriteLine($"Abs({value}) = {Math.Abs(value)}");
   }
   catch (OverflowException) {
      Console.WriteLine("Unable to calculate the absolute value of {0}.",
                        value);
   }
}

// The example displays the following output:
//       Abs(127) = 127
//       Abs(98) = 98
//       Abs(0) = 0
//       Abs(-32) = 32
//       Unable to calculate the absolute value of -128.

open System

let values = 
    [ SByte.MaxValue; 98y; 0y; -32y; SByte.MinValue ]

for value in values do
    try
        // The 'abs' function may be used instead.
        printfn $"Abs({value}) = {Math.Abs value}"
    with :? OverflowException ->
        printfn $"Unable to calculate the absolute value of {value}."

// The example displays the following output:
//       Abs(127) = 127
//       Abs(98) = 98
//       Abs(0) = 0
//       Abs(-32) = 32
//       Unable to calculate the absolute value of -128.

Module Example
   Public Sub Main()
      Dim values() As SByte = { SByte.MaxValue, 98, 0, -32, SByte.MinValue }
      For Each value As SByte In values
         Try
            Console.WriteLine("Abs({0}) = {1}", value, Math.Abs(value))
         Catch e As OverflowException
            Console.WriteLine("Unable to calculate the absolute value of {0}.", _
                              value)
         End Try   
      Next
   End Sub
End Module
' The example displays the following output:
'       Abs(127) = 127
'       Abs(98) = 98
'       Abs(0) = 0
'       Abs(-32) = 32
'       Unable to calculate the absolute value of -128.

Remarques

La valeur absolue d’un octet signé est sa valeur numérique sans son signe. Par exemple, la valeur absolue de 12 et -12 est 12.

S’applique à

Abs(Single)

Source:
Math.cs
Source:
Math.cs
Source:
Math.cs

Retourne la valeur absolue d'un nombre à virgule flottante simple précision.

public:
 static float Abs(float value);
public static float Abs (float value);
static member Abs : single -> single
Public Shared Function Abs (value As Single) As Single

Paramètres

value
Single

Nombre supérieur ou égal à Single.MinValue, mais inférieur ou égal à Single.MaxValue.

Retours

Single

Nombre à virgule flottante simple précision, x, tel que 0 ≤ x ≤ Single.MaxValue.

Exemples

L’exemple suivant utilise la Abs(Single) méthode pour obtenir la valeur absolue d’un certain nombre de Single valeurs.

float[] values= { Single.MaxValue, 16.354e-12F, 15.098123F, 0F,
                  -19.069713F, -15.058e17F, Single.MinValue };
foreach (float value in values)
   Console.WriteLine($"Abs({value}) = {Math.Abs(value)}");

// The example displays the following output:
//       Abs(3.402823E+38) = 3.402823E+38
//       Abs(1.6354E-11) = 1.6354E-11
//       Abs(15.09812) = 15.09812
//       Abs(0) = 0
//       Abs(-19.06971) = 19.06971
//       Abs(-1.5058E+18) = 1.5058E+18
//       Abs(-3.402823E+38) = 3.402823E+38

open System

let values = 
    [ Single.MaxValue; 16.354e-12f; 15.098123f; 0f
      -19.069713f; -15.058e17f; Single.MinValue ]

for value in values do
    // The 'abs' function may be used instead.
    printfn $"Abs({value}) = {Math.Abs value}"

// The example displays the following output:
//       Abs(3.402823E+38) = 3.402823E+38
//       Abs(1.6354E-11) = 1.6354E-11
//       Abs(15.09812) = 15.09812
//       Abs(0) = 0
//       Abs(-19.06971) = 19.06971
//       Abs(-1.5058E+18) = 1.5058E+18
//       Abs(-3.402823E+38) = 3.402823E+38

Module Example
   Public Sub Main()
      Dim values() As Single = { Single.MaxValue, 16.354e-12, 15.098123, 0, _
                                  -19.069713, -15.058e17, Single.MinValue }
      For Each value As Single In values
         Console.WriteLine("Abs({0}) = {1}", value, Math.Abs(value))
      Next
   End Sub
End Module
' The example displays the following output:
'       Abs(3.402823E+38) = 3.402823E+38
'       Abs(1.6354E-11) = 1.6354E-11
'       Abs(15.09812) = 15.09812
'       Abs(0) = 0
'       Abs(-19.06971) = 19.06971
'       Abs(-1.5058E+18) = 1.5058E+18
'       Abs(-3.402823E+38) = 3.402823E+38

Remarques

La valeur absolue d’un Single est sa valeur numérique sans son signe. Par exemple, la valeur absolue de 1.2e-03 et -1.2e03 est 1.2e03.

Si value est égal à NegativeInfinity ou PositiveInfinity, la valeur de retour est PositiveInfinity. Si value est égal à NaN, la valeur de retour est NaN.

S’applique à