Condividi tramite

Math.Abs Metodo

  • Riferimento

Definizione

Spazio dei nomi:
System
Assembly:
System.Runtime.Extensions.dll
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Restituisce il valore assoluto di un numero specificato.

Overload

Abs(Decimal)

Restituisce il valore assoluto di un numero Decimal.
Abs(Double)

Restituisce il valore assoluto di un numero a virgola mobile e precisione doppia.
Abs(Int16)

Restituisce il valore assoluto di un intero con segno a 16 bit.
Abs(Int32)

Restituisce il valore assoluto di un intero con segno a 32 bit.
Abs(Int64)

Restituisce il valore assoluto di un intero con segno a 64 bit.
Abs(IntPtr)

Restituisce il valore assoluto di un intero con segno nativo.
Abs(SByte)

Restituisce il valore assoluto di un intero con segno a 8 bit.
Abs(Single)

Restituisce il valore assoluto di un numero a virgola mobile e precisione singola.

Abs(Decimal)

Origine:
Math.cs
Origine:
Math.cs
Origine:
Math.cs

Restituisce il valore assoluto di un numero 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

Parametri

value
Decimal

Numero maggiore o uguale a Decimal.MinValue, ma minore o uguale a Decimal.MaxValue.

Restituisce

Decimal

Numero decimale, x, in modo che 0 ≤ x ≤ Decimal.MaxValue.

Esempio

Nell'esempio seguente viene utilizzato il Abs(Decimal) metodo per ottenere il valore assoluto di un numero di Decimal valori.

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

Commenti

Il valore assoluto di un Decimal oggetto è il valore numerico senza il segno. Ad esempio, il valore assoluto di 1,2 e -1,2 è 1,2.

Si applica a

Abs(Double)

Origine:
Math.cs
Origine:
Math.cs
Origine:
Math.cs

Restituisce il valore assoluto di un numero a virgola mobile e precisione doppia.

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

Parametri

value
Double

Numero maggiore o uguale a Double.MinValue, ma minore o uguale a Double.MaxValue.

Restituisce

Double

Numero a virgola mobile e precisione doppia, x, in modo che 0 ≤ x ≤ Double.MaxValue.

Esempio

Nell'esempio seguente viene utilizzato il Abs(Double) metodo per ottenere il valore assoluto di un numero di Double valori.

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

Commenti

Il valore assoluto di un Double oggetto è il valore numerico senza il segno. Ad esempio, il valore assoluto di 1,2e03 e -1,2e03 è 1,2e03.

Se value è uguale a NegativeInfinity o PositiveInfinity, il valore restituito è PositiveInfinity. Se value è uguale a NaN, il valore restituito è NaN.

Si applica a

Abs(Int16)

Origine:
Math.cs
Origine:
Math.cs
Origine:
Math.cs

Restituisce il valore assoluto di un intero con segno a 16 bit.

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

Parametri

value
Int16

Numero maggiore di Int16.MinValue, ma minore o uguale a Int16.MaxValue.

Restituisce

Int16

Intero con segno a 16 bit, x, in modo che 0 ≤ x ≤ Int16.MaxValue.

Eccezioni

OverflowException

value è uguale a Int16.MinValue.

Esempio

Nell'esempio seguente viene utilizzato il Abs(Int16) metodo per ottenere il valore assoluto di un numero di Int16 valori.

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.

Commenti

Il valore assoluto di un Int16 oggetto è il valore numerico senza il segno. Ad esempio, il valore assoluto di 123 e -123 è 123.

Si applica a

Abs(Int32)

Origine:
Math.cs
Origine:
Math.cs
Origine:
Math.cs

Restituisce il valore assoluto di un intero con segno a 32 bit.

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

Parametri

value
Int32

Numero maggiore di Int32.MinValue, ma minore o uguale a Int32.MaxValue.

Restituisce

Int32

Intero con segno a 32 bit, x, in modo che 0 ≤ x ≤ Int32.MaxValue.

Eccezioni

OverflowException

value è uguale a Int32.MinValue.

Esempio

Nell'esempio seguente viene utilizzato il Abs(Int32) metodo per ottenere il valore assoluto di un numero di Int32 valori.

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.

Commenti

Il valore assoluto di un Int32 oggetto è il valore numerico senza il segno. Ad esempio, il valore assoluto di 123 e -123 è 123.

Si applica a

Abs(Int64)

Origine:
Math.cs
Origine:
Math.cs
Origine:
Math.cs

Restituisce il valore assoluto di un intero con segno a 64 bit.

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

Parametri

value
Int64

Numero maggiore di Int64.MinValue, ma minore o uguale a Int64.MaxValue.

Restituisce

Int64

Intero con segno a 64 bit, x, in modo che 0 ≤ x ≤ Int64.MaxValue.

Eccezioni

OverflowException

value è uguale a Int64.MinValue.

Esempio

Nell'esempio seguente viene utilizzato il Abs(Int64) metodo per ottenere il valore assoluto di un numero di Int64 valori.

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.

Commenti

Il valore assoluto di un Int64 oggetto è il valore numerico senza il segno. Ad esempio, il valore assoluto di 123 e -123 è 123.

Si applica a

Abs(IntPtr)

Origine:
Math.cs
Origine:
Math.cs
Origine:
Math.cs

Restituisce il valore assoluto di un intero con segno nativo.

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

Parametri

value
IntPtr

nint

nativeint

Numero maggiore di MinValue, ma minore o uguale a MaxValue.

Restituisce

IntPtr

nint

nativeint

Intero con segno nativo, x, in modo che 0 ≤ x ≤ MaxValue.

Si applica a

Abs(SByte)

Origine:
Math.cs
Origine:
Math.cs
Origine:
Math.cs

Importante

Questa API non è conforme a CLS.

Restituisce il valore assoluto di un intero con segno a 8 bit.

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

Parametri

value
SByte

Numero maggiore di SByte.MinValue, ma minore o uguale a SByte.MaxValue.

Restituisce

SByte

Intero con segno a 8 bit, x, in modo che 0 ≤ x ≤ SByte.MaxValue.

Attributi
CLSCompliantAttribute

Eccezioni

OverflowException

value è uguale a SByte.MinValue.

Esempio

Nell'esempio seguente viene utilizzato il Abs(SByte) metodo per ottenere il valore assoluto di un numero di SByte valori.

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.

Commenti

Il valore assoluto di un byte firmato è il valore numerico senza il segno. Ad esempio, il valore assoluto di 12 e -12 è 12.

Si applica a

Abs(Single)

Origine:
Math.cs
Origine:
Math.cs
Origine:
Math.cs

Restituisce il valore assoluto di un numero a virgola mobile e precisione singola.

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

Parametri

value
Single

Numero maggiore o uguale a Single.MinValue, ma minore o uguale a Single.MaxValue.

Restituisce

Single

Numero a virgola mobile a precisione singola, x, in modo che 0 ≤ x ≤ Single.MaxValue.

Esempio

Nell'esempio seguente viene utilizzato il Abs(Single) metodo per ottenere il valore assoluto di un numero di Single valori.

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

Commenti

Il valore assoluto di un Single oggetto è il valore numerico senza il segno. Ad esempio, il valore assoluto di 1,2e-03 e -1,2e03 è 1,2e03.

Se value è uguale a NegativeInfinity o PositiveInfinity, il valore restituito è PositiveInfinity. Se value è uguale a NaN, il valore restituito è NaN.

Si applica a