Udostępnij za pośrednictwem

Math.Abs Metoda

  • Odwołanie

Definicja

Przestrzeń nazw:
System
Zestaw:
System.Runtime.Extensions.dll
Zestaw:
System.Runtime.dll
Zestaw:
mscorlib.dll
Zestaw:
netstandard.dll

Zwraca wartość bezwzględną określonej liczby.

Przeciążenia

Abs(Decimal)

Zwraca wartość bezwzględną Decimal liczby.
Abs(Double)

Zwraca wartość bezwzględną liczby zmiennoprzecinkowej o podwójnej precyzji.
Abs(Int16)

Zwraca wartość bezwzględną 16-bitowej liczby całkowitej ze znakiem.
Abs(Int32)

Zwraca wartość bezwzględną 32-bitowej liczby całkowitej ze znakiem.
Abs(Int64)

Zwraca wartość bezwzględną 64-bitowej liczby całkowitej ze znakiem.
Abs(IntPtr)

Zwraca wartość bezwzględną natywnej liczby całkowitej ze znakiem.
Abs(SByte)

Zwraca wartość bezwzględną 8-bitowej liczby całkowitej ze znakiem.
Abs(Single)

Zwraca wartość bezwzględną liczby zmiennoprzecinkowej o pojedynczej precyzji.

Abs(Decimal)

Źródło:
Math.cs
Źródło:
Math.cs
Źródło:
Math.cs

Zwraca wartość bezwzględną Decimal liczby.

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

Parametry

value
Decimal

Liczba większa lub równa wartości Dziesiętnej.MinValue, ale mniejsza lub równa wartości Decimal.MaxValue.

Zwraca

Decimal

Liczba dziesiętna, x, tak aby 0 ≤ x ≤ Decimal.MaxValue.

Przykłady

W poniższym przykładzie użyto Abs(Decimal) metody , aby uzyskać wartość bezwzględną liczby Decimal wartości.

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

Uwagi

Wartość bezwzględna elementu Decimal to jego wartość liczbowa bez znaku. Na przykład wartość bezwzględna 1.2 i -1.2 to 1.2.

Dotyczy

Abs(Double)

Źródło:
Math.cs
Źródło:
Math.cs
Źródło:
Math.cs

Zwraca wartość bezwzględną liczby zmiennoprzecinkowej o podwójnej precyzji.

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

Parametry

value
Double

Liczba większa lub równa wartości Double.MinValue, ale mniejsza lub równa wartości Double.MaxValue.

Zwraca

Double

Liczba zmiennoprzecinkowa o podwójnej precyzji x, taka jak 0 ≤ x ≤ Double.MaxValue.

Przykłady

W poniższym przykładzie użyto Abs(Double) metody , aby uzyskać wartość bezwzględną liczby Double wartości.

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

Uwagi

Wartość bezwzględna elementu Double to jego wartość liczbowa bez znaku. Na przykład wartość bezwzględna 1.2e03 i -1.2e03 to 1.2e03.

Jeśli value wartość jest równa NegativeInfinity lub PositiveInfinity, zwracana wartość to PositiveInfinity. Jeśli value wartość jest równa NaN, zwracana wartość to NaN.

Dotyczy

Abs(Int16)

Źródło:
Math.cs
Źródło:
Math.cs
Źródło:
Math.cs

Zwraca wartość bezwzględną 16-bitowej liczby całkowitej ze znakiem.

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

Parametry

value
Int16

Liczba większa niż Int16.MinValue, ale mniejsza niż lub równa Int16.MaxValue.

Zwraca

Int16

16-bitowa liczba całkowita ze znakiem x, taka jak 0 ≤ x ≤ Int16.MaxValue.

Wyjątki

OverflowException

value equals Int16.MinValue.

Przykłady

W poniższym przykładzie użyto Abs(Int16) metody , aby uzyskać wartość bezwzględną liczby Int16 wartości.

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.

Uwagi

Wartość bezwzględna obiektu Int16 jest wartością liczbową bez znaku. Na przykład wartość bezwzględna 123 i -123 to 123.

Dotyczy

Abs(Int32)

Źródło:
Math.cs
Źródło:
Math.cs
Źródło:
Math.cs

Zwraca wartość bezwzględną 32-bitowej liczby całkowitej ze znakiem.

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

Parametry

value
Int32

Liczba większa niż Int32.MinValue, ale mniejsza lub równa Int32.MaxValue.

Zwraca

Int32

32-bitowa liczba całkowita ze znakiem x, taka jak 0 ≤ x ≤ Int32.MaxValue.

Wyjątki

OverflowException

value equals Int32.MinValue.

Przykłady

W poniższym przykładzie użyto Abs(Int32) metody , aby uzyskać wartość bezwzględną liczby Int32 wartości.

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.

Uwagi

Wartość bezwzględna obiektu Int32 jest wartością liczbową bez znaku. Na przykład wartość bezwzględna 123 i -123 to 123.

Dotyczy

Abs(Int64)

Źródło:
Math.cs
Źródło:
Math.cs
Źródło:
Math.cs

Zwraca wartość bezwzględną 64-bitowej liczby całkowitej ze znakiem.

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

Parametry

value
Int64

Liczba większa niż Int64.MinValue, ale mniejsza lub równa Int64.MaxValue.

Zwraca

Int64

64-bitowa liczba całkowita ze znakiem x, taka jak 0 ≤ x ≤ Int64.MaxValue.

Wyjątki

OverflowException

value equals Int64.MinValue.

Przykłady

W poniższym przykładzie użyto Abs(Int64) metody , aby uzyskać wartość bezwzględną liczby Int64 wartości.

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.

Uwagi

Wartość bezwzględna obiektu Int64 jest wartością liczbową bez znaku. Na przykład wartość bezwzględna 123 i -123 to 123.

Dotyczy

Abs(IntPtr)

Źródło:
Math.cs
Źródło:
Math.cs
Źródło:
Math.cs

Zwraca wartość bezwzględną natywnej liczby całkowitej ze znakiem.

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

Parametry

value
IntPtr

nint

nativeint

Liczba większa niż MinValue, ale mniejsza niż lub równa MaxValue.

Zwraca

IntPtr

nint

nativeint

Natywna liczba całkowita ze znakiem x, taka jak 0 ≤ x ≤ MaxValue.

Dotyczy

Abs(SByte)

Źródło:
Math.cs
Źródło:
Math.cs
Źródło:
Math.cs

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Zwraca wartość bezwzględną 8-bitowej liczby całkowitej ze znakiem.

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

Parametry

value
SByte

Liczba większa niż SByte.MinValue, ale mniejsza niż lub równa wartości SByte.MaxValue.

Zwraca

SByte

8-bitowa liczba całkowita ze znakiem x, taka jak 0 ≤ x ≤ SByte.MaxValue.

Atrybuty
CLSCompliantAttribute

Wyjątki

OverflowException

value równa SByte.MinValue.

Przykłady

W poniższym przykładzie użyto Abs(SByte) metody , aby uzyskać wartość bezwzględną liczby SByte wartości.

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.

Uwagi

Wartość bezwzględna podpisanego bajtu jest jego wartością liczbową bez znaku. Na przykład wartość bezwzględna 12 i -12 wynosi 12.

Dotyczy

Abs(Single)

Źródło:
Math.cs
Źródło:
Math.cs
Źródło:
Math.cs

Zwraca wartość bezwzględną liczby zmiennoprzecinkowej o pojedynczej precyzji.

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

Parametry

value
Single

Liczba większa lub równa wartości Single.MinValue, ale mniejsza lub równa wartości Single.MaxValue.

Zwraca

Single

Liczba zmiennoprzecinkowa o pojedynczej precyzji x, taka jak 0 ≤ x ≤ Single.MaxValue.

Przykłady

W poniższym przykładzie użyto Abs(Single) metody , aby uzyskać wartość bezwzględną liczby Single wartości.

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

Uwagi

Wartość bezwzględna elementu Single to jego wartość liczbowa bez znaku. Na przykład wartość bezwzględna 1.2e-03 i -1.2e03 to 1.2e03.

Jeśli value wartość jest równa NegativeInfinity lub PositiveInfinity, zwracana wartość to PositiveInfinity. Jeśli value wartość jest równa NaN, zwracana wartość to NaN.

Dotyczy