Math.Abs Methode

  • Referenz

Definition

Namespace:
System
Assembly:
System.Runtime.Extensions.dll
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Gibt den absoluten Wert einer angegebenen Zahl zurück.

Überlädt

Abs(Decimal)

Gibt den Absolutbetrag einer Decimal-Zahl zurück.
Abs(Double)

Gibt den absoluten Wert einer Gleitkommazahl mit doppelter Genauigkeit zurück.
Abs(Int16)

Gibt den absoluten Wert einer 16-Bit-Ganzzahl mit Vorzeichen zurück.
Abs(Int32)

Gibt den absoluten Wert einer 32-Bit-Ganzzahl mit Vorzeichen zurück.
Abs(Int64)

Gibt den absoluten Wert einer 64-Bit-Ganzzahl mit Vorzeichen zurück.
Abs(IntPtr)

Gibt den absoluten Wert einer systemeigenen ganzzahligen Zahl mit Vorzeichen zurück.
Abs(SByte)

Gibt den absoluten Wert einer 8-Bit-Ganzzahl mit Vorzeichen zurück.
Abs(Single)

Gibt den absoluten Wert einer Gleitkommazahl mit einfacher Genauigkeit zurück.

Abs(Decimal)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Gibt den Absolutbetrag einer Decimal-Zahl zurück.

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

Parameter

value
Decimal

Eine Zahl, die größer oder gleich Decimal.MinValue, aber kleiner oder gleich Decimal.MaxValue ist.

Gibt zurück

Decimal

Eine Dezimalzahl x, sodass 0 ≤ x ≤ Decimal.MaxValue.

Beispiele

Im folgenden Beispiel wird die Abs(Decimal) -Methode verwendet, um den absoluten Wert einer Reihe von Decimal Werten abzurufen.

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

Hinweise

Der absolute Wert eines Decimal ist sein numerischer Wert ohne dessen Vorzeichen. Der absolute Wert von 1,2 und -1,2 ist beispielsweise 1,2.

Gilt für:

Abs(Double)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Gibt den absoluten Wert einer Gleitkommazahl mit doppelter Genauigkeit zurück.

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

Parameter

value
Double

Eine Zahl, die größer oder gleich Double.MinValue, aber kleiner oder gleich Double.MaxValue ist.

Gibt zurück

Double

Eine Gleitkommazahl mit doppelter Genauigkeit, x, sodass 0 ≤ x ≤ Double.MaxValue.

Beispiele

Im folgenden Beispiel wird die Abs(Double) -Methode verwendet, um den absoluten Wert einer Reihe von Double Werten abzurufen.

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

Hinweise

Der absolute Wert eines Double ist sein numerischer Wert ohne dessen Vorzeichen. Der absolute Wert von 1,2e03 und -1,2e03 ist beispielsweise 1,2e03.

Wenn value gleich NegativeInfinity oder PositiveInfinityist, ist PositiveInfinityder Rückgabewert . Wenn value gleich ist, NaNist NaNder Rückgabewert .

Gilt für:

Abs(Int16)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Gibt den absoluten Wert einer 16-Bit-Ganzzahl mit Vorzeichen zurück.

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

Parameter

value
Int16

Eine Zahl, die größer als Int16.MinValue, aber kleiner oder gleich Int16.MaxValue ist.

Gibt zurück

Int16

Eine 16-Bit-Ganzzahl mit Vorzeichen(x), sodass 0 ≤ x ≤ Int16.MaxValue.

Ausnahmen

OverflowException

value entspricht Int16.MinValue.

Beispiele

Im folgenden Beispiel wird die Abs(Int16) -Methode verwendet, um den absoluten Wert einer Reihe von Int16 Werten abzurufen.

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.

Hinweise

Der absolute Wert eines Int16 ist sein numerischer Wert ohne sein Vorzeichen. Beispielsweise ist der absolute Wert von 123 und -123 123.

Gilt für:

Abs(Int32)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Gibt den absoluten Wert einer 32-Bit-Ganzzahl mit Vorzeichen zurück.

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

Parameter

value
Int32

Eine Zahl, die größer als Int32.MinValue, aber kleiner oder gleich Int32.MaxValue ist.

Gibt zurück

Int32

Eine 32-Bit-Ganzzahl mit Vorzeichen( x), sodass 0 ≤ x ≤ Int32.MaxValue.

Ausnahmen

OverflowException

value entspricht Int32.MinValue.

Beispiele

Im folgenden Beispiel wird die Abs(Int32) -Methode verwendet, um den absoluten Wert einer Reihe von Int32 Werten abzurufen.

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.

Hinweise

Der absolute Wert eines Int32 ist sein numerischer Wert ohne sein Vorzeichen. Beispielsweise ist der absolute Wert von 123 und -123 123.

Gilt für:

Abs(Int64)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Gibt den absoluten Wert einer 64-Bit-Ganzzahl mit Vorzeichen zurück.

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

Parameter

value
Int64

Eine Zahl, die größer als Int64.MinValue, aber kleiner oder gleich Int64.MaxValue ist.

Gibt zurück

Int64

Eine 64-Bit-Ganzzahl mit Vorzeichen(x), sodass 0 ≤ x ≤ Int64.MaxValue.

Ausnahmen

OverflowException

value entspricht Int64.MinValue.

Beispiele

Im folgenden Beispiel wird die Abs(Int64) -Methode verwendet, um den absoluten Wert einer Reihe von Int64 Werten abzurufen.

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.

Hinweise

Der absolute Wert eines Int64 ist sein numerischer Wert ohne sein Vorzeichen. Beispielsweise ist der absolute Wert von 123 und -123 123.

Gilt für:

Abs(IntPtr)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Gibt den absoluten Wert einer systemeigenen ganzzahligen Zahl mit Vorzeichen zurück.

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

Parameter

value
IntPtr

nint

nativeint

Eine Zahl, die größer als MinValue, aber kleiner oder gleich MaxValue ist.

Gibt zurück

IntPtr

nint

nativeint

Eine systemeigene ganze Zahl mit Vorzeichen( x), sodass 0 ≤ x ≤ MaxValue.

Gilt für:

Abs(SByte)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Gibt den absoluten Wert einer 8-Bit-Ganzzahl mit Vorzeichen zurück.

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

Parameter

value
SByte

Eine Zahl, die größer als SByte.MinValue, aber kleiner oder gleich SByte.MaxValue ist.

Gibt zurück

SByte

Eine 8-Bit-Ganzzahl mit Vorzeichen(x), sodass 0 ≤ x ≤ SByte.MaxValue.

Attribute
CLSCompliantAttribute

Ausnahmen

OverflowException

value entspricht SByte.MinValue.

Beispiele

Im folgenden Beispiel wird die Abs(SByte) -Methode verwendet, um den absoluten Wert einer Reihe von SByte Werten abzurufen.

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.

Hinweise

Der absolute Wert eines signierten Byte ist sein numerischer Wert ohne dessen Vorzeichen. Beispielsweise ist der absolute Wert von 12 und -12 12.

Gilt für:

Abs(Single)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Gibt den absoluten Wert einer Gleitkommazahl mit einfacher Genauigkeit zurück.

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

Parameter

value
Single

Eine Zahl, die größer oder gleich Single.MinValue, aber kleiner oder gleich Single.MaxValue ist.

Gibt zurück

Single

Eine Gleitkommazahl mit einfacher Genauigkeit, x, sodass 0 ≤ x ≤ Single.MaxValue.

Beispiele

Im folgenden Beispiel wird die Abs(Single) -Methode verwendet, um den absoluten Wert einer Reihe von Single Werten abzurufen.

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

Hinweise

Der absolute Wert eines Single ist sein numerischer Wert ohne dessen Vorzeichen. Beispielsweise ist der absolute Wert von 1,2e-03 und -1,2e03 1,2e03.

Wenn value gleich NegativeInfinity oder PositiveInfinityist, ist PositiveInfinityder Rückgabewert . Wenn value gleich ist, NaNist NaNder Rückgabewert .

Gilt für: