Math.Sign Método
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Retorna um inteiro que indica o sinal de um número.
Sign(IntPtr) |
Retorna um inteiro que indica o sinal de um inteiro com sinal de tamanho nativo. |
Sign(Single) |
Retorna um inteiro que indica o sinal de um número de ponto flutuante de precisão única. |
Sign(SByte) |
Retorna um inteiro que indica o sinal de um inteiro com sinal de 8 bits. |
Sign(Int64) |
Retorna um inteiro que indica o sinal de um inteiro com sinal de 64 bits. |
Sign(Double) |
Retorna um inteiro que indica o sinal de um número de ponto flutuante de precisão dupla. |
Sign(Int16) |
Retorna um inteiro que indica o sinal de um inteiro com sinal de 16 bits. |
Sign(Decimal) |
Retorna um inteiro que indica o sinal de um número decimal. |
Sign(Int32) |
Retorna um inteiro que indica o sinal de um inteiro com sinal de 32 bits. |
- Origem:
- Math.cs
- Origem:
- Math.cs
- Origem:
- Math.cs
Retorna um inteiro que indica o sinal de um inteiro com sinal de tamanho nativo.
public:
static int Sign(IntPtr value);
public static int Sign (nint value);
public static int Sign (IntPtr value);
static member Sign : nativeint -> int
Public Shared Function Sign (value As IntPtr) As Integer
Parâmetros
- value
-
IntPtr
nint
nativeint
Um número assinado.
Retornos
Um número que indica o sinal de value
, conforme mostrado na tabela a seguir.
Valor de retorno | Significado |
---|---|
-1 |
value é menor que zero.
|
0 |
value é igual a zero.
|
1 |
value é maior que zero.
|
Exemplos
O exemplo a seguir demonstra como usar o método Sign(IntPtr) para determinar o sinal de um valor IntPtr e exibi-lo no console.
// This example demonstrates Math.Sign()
using System;
class Sample
{
public static void Main()
{
string str = "{0}: {1,3} is {2} zero.";
string nl = Environment.NewLine;
byte xByte1 = 0;
short xShort1 = -2;
int xInt1 = -3;
long xLong1 = -4;
float xSingle1 = 0.0f;
double xDouble1 = 6.0;
Decimal xDecimal1 = -7m;
nint xIntPtr1 = 8;
// The following type is not CLS-compliant.
sbyte xSbyte1 = -101;
Console.WriteLine($"{nl}Test the sign of the following types of values:");
Console.WriteLine(str, "Byte ", xByte1, Test(Math.Sign(xByte1)));
Console.WriteLine(str, "Int16 ", xShort1, Test(Math.Sign(xShort1)));
Console.WriteLine(str, "Int32 ", xInt1, Test(Math.Sign(xInt1)));
Console.WriteLine(str, "Int64 ", xLong1, Test(Math.Sign(xLong1)));
Console.WriteLine(str, "Single ", xSingle1, Test(Math.Sign(xSingle1)));
Console.WriteLine(str, "Double ", xDouble1, Test(Math.Sign(xDouble1)));
Console.WriteLine(str, "Decimal", xDecimal1, Test(Math.Sign(xDecimal1)));
Console.WriteLine(str, "IntPtr", xIntPtr1, Test(Math.Sign(xIntPtr1)));
Console.WriteLine($"{nl}The following type is not CLS-compliant.");
Console.WriteLine(str, "SByte ", xSbyte1, Test(Math.Sign(xSbyte1)));
}
public static string Test(int compare)
{
if (compare == 0)
return "equal to";
else if (compare < 0)
return "less than";
else
return "greater than";
}
}
/*
This example produces the following results:
Test the sign of the following types of values:
Byte : 0 is equal to zero.
Int16 : -2 is less than zero.
Int32 : -3 is less than zero.
Int64 : -4 is less than zero.
Single : 0 is equal to zero.
Double : 6 is greater than zero.
Decimal: -7 is less than zero.
IntPtr: 8 is greater than zero.
The following type is not CLS-compliant.
SByte : -101 is less than zero.
*/
// This example demonstrates Math.Sign()
// In F#, the sign function may be used instead
open System
let test = function
| 0 ->
"equal to"
| x when x < 0 ->
"less than"
| _ ->
"greater than"
let print typ a b =
printfn $"{typ}: {a,3} is {b} zero."
let xByte1 = 0uy
let xShort1 = -2s
let xInt1 = -3
let xLong1 = -4L
let xSingle1 = 0f
let xDouble1 = 6.
let xDecimal1 = -7m
let xIntPtr1 = 8
// The following type is not CLS-compliant.
let xSbyte1 = -101y
printfn "\nTest the sign of the following types of values:"
print "Byte " xByte1 (test (Math.Sign xByte1))
print "Int16 " xShort1 (test (Math.Sign xShort1))
print "Int32 " xInt1 (test (Math.Sign xInt1))
print "Int64 " xLong1 (test (Math.Sign xLong1))
print "Single " xSingle1 (test (Math.Sign xSingle1))
print "Double " xDouble1 (test (Math.Sign xDouble1))
print "Decimal" xDecimal1 (test (Math.Sign xDecimal1))
print "IntPtr" xIntPtr1 (test (Math.Sign xIntPtr1))
printfn "\nThe following type is not CLS-compliant."
print "SByte " xSbyte1 (test (Math.Sign xSbyte1))
// This example produces the following results:
// Test the sign of the following types of values:
// Byte : 0 is equal to zero.
// Int16 : -2 is less than zero.
// Int32 : -3 is less than zero.
// Int64 : -4 is less than zero.
// Single : 0 is equal to zero.
// Double : 6 is greater than zero.
// Decimal: -7 is less than zero.
// IntPtr: 8 is greater than zero.
//
// The following type is not CLS-compliant.
// SByte : -101 is less than zero.
Aplica-se a
.NET 9 e outras versões
Produto | Versões |
---|---|
.NET | 6, 7, 8, 9 |
- Origem:
- Math.cs
- Origem:
- Math.cs
- Origem:
- Math.cs
Retorna um inteiro que indica o sinal de um número de ponto flutuante de precisão única.
public:
static int Sign(float value);
public static int Sign (float value);
static member Sign : single -> int
Public Shared Function Sign (value As Single) As Integer
Parâmetros
- value
- Single
Um número assinado.
Retornos
Um número que indica o sinal de value
, conforme mostrado na tabela a seguir.
Valor de retorno | Significado |
---|---|
-1 |
value é menor que zero.
|
0 |
value é igual a zero.
|
1 |
value é maior que zero.
|
Exceções
value
é igual a NaN.
Exemplos
O exemplo a seguir demonstra como usar o método Sign(Single) para determinar o sinal de um valor Single e exibi-lo no console.
// This example demonstrates Math.Sign()
using namespace System;
String^ Test( int compare )
{
if ( compare == 0 )
return "equal to";
else
if ( compare < 0 )
return "less than";
else
return "greater than";
}
int main()
{
String^ str = "{0}: {1,3} is {2} zero.";
String^ nl = Environment::NewLine;
Byte xByte1 = 0;
short xShort1 = -2;
int xInt1 = -3;
long xLong1 = -4;
float xSingle1 = 0.0f;
double xDouble1 = 6.0;
Decimal xDecimal1 = -7;
// The following type is not CLS-compliant.
SByte xSbyte1 = -101;
Console::WriteLine( "{0}Test the sign of the following types of values:", nl );
Console::WriteLine( str, "Byte ", xByte1, Test( Math::Sign( xByte1 ) ) );
Console::WriteLine( str, "Int16 ", xShort1, Test( Math::Sign( xShort1 ) ) );
Console::WriteLine( str, "Int32 ", xInt1, Test( Math::Sign( xInt1 ) ) );
Console::WriteLine( str, "Int64 ", xLong1, Test( Math::Sign( xLong1 ) ) );
Console::WriteLine( str, "Single ", xSingle1, Test( Math::Sign( xSingle1 ) ) );
Console::WriteLine( str, "Double ", xDouble1, Test( Math::Sign( xDouble1 ) ) );
Console::WriteLine( str, "Decimal", xDecimal1, Test( Math::Sign( xDecimal1 ) ) );
//
Console::WriteLine( "{0}The following type is not CLS-compliant.", nl );
Console::WriteLine( str, "SByte ", xSbyte1, Test( Math::Sign( xSbyte1 ) ) );
}
/*
This example produces the following results:
Test the sign of the following types of values:
Byte : 0 is equal to zero.
Int16 : -2 is less than zero.
Int32 : -3 is less than zero.
Int64 : -4 is less than zero.
Single : 0 is equal to zero.
Double : 6 is greater than zero.
Decimal: -7 is less than zero.
The following type is not CLS-compliant.
SByte : -101 is less than zero.
*/
// This example demonstrates Math.Sign()
using System;
class Sample
{
public static void Main()
{
string str = "{0}: {1,3} is {2} zero.";
string nl = Environment.NewLine;
byte xByte1 = 0;
short xShort1 = -2;
int xInt1 = -3;
long xLong1 = -4;
float xSingle1 = 0.0f;
double xDouble1 = 6.0;
Decimal xDecimal1 = -7m;
nint xIntPtr1 = 8;
// The following type is not CLS-compliant.
sbyte xSbyte1 = -101;
Console.WriteLine($"{nl}Test the sign of the following types of values:");
Console.WriteLine(str, "Byte ", xByte1, Test(Math.Sign(xByte1)));
Console.WriteLine(str, "Int16 ", xShort1, Test(Math.Sign(xShort1)));
Console.WriteLine(str, "Int32 ", xInt1, Test(Math.Sign(xInt1)));
Console.WriteLine(str, "Int64 ", xLong1, Test(Math.Sign(xLong1)));
Console.WriteLine(str, "Single ", xSingle1, Test(Math.Sign(xSingle1)));
Console.WriteLine(str, "Double ", xDouble1, Test(Math.Sign(xDouble1)));
Console.WriteLine(str, "Decimal", xDecimal1, Test(Math.Sign(xDecimal1)));
Console.WriteLine(str, "IntPtr", xIntPtr1, Test(Math.Sign(xIntPtr1)));
Console.WriteLine($"{nl}The following type is not CLS-compliant.");
Console.WriteLine(str, "SByte ", xSbyte1, Test(Math.Sign(xSbyte1)));
}
public static string Test(int compare)
{
if (compare == 0)
return "equal to";
else if (compare < 0)
return "less than";
else
return "greater than";
}
}
/*
This example produces the following results:
Test the sign of the following types of values:
Byte : 0 is equal to zero.
Int16 : -2 is less than zero.
Int32 : -3 is less than zero.
Int64 : -4 is less than zero.
Single : 0 is equal to zero.
Double : 6 is greater than zero.
Decimal: -7 is less than zero.
IntPtr: 8 is greater than zero.
The following type is not CLS-compliant.
SByte : -101 is less than zero.
*/
// This example demonstrates Math.Sign()
// In F#, the sign function may be used instead
open System
let test = function
| 0 ->
"equal to"
| x when x < 0 ->
"less than"
| _ ->
"greater than"
let print typ a b =
printfn $"{typ}: {a,3} is {b} zero."
let xByte1 = 0uy
let xShort1 = -2s
let xInt1 = -3
let xLong1 = -4L
let xSingle1 = 0f
let xDouble1 = 6.
let xDecimal1 = -7m
let xIntPtr1 = 8
// The following type is not CLS-compliant.
let xSbyte1 = -101y
printfn "\nTest the sign of the following types of values:"
print "Byte " xByte1 (test (Math.Sign xByte1))
print "Int16 " xShort1 (test (Math.Sign xShort1))
print "Int32 " xInt1 (test (Math.Sign xInt1))
print "Int64 " xLong1 (test (Math.Sign xLong1))
print "Single " xSingle1 (test (Math.Sign xSingle1))
print "Double " xDouble1 (test (Math.Sign xDouble1))
print "Decimal" xDecimal1 (test (Math.Sign xDecimal1))
print "IntPtr" xIntPtr1 (test (Math.Sign xIntPtr1))
printfn "\nThe following type is not CLS-compliant."
print "SByte " xSbyte1 (test (Math.Sign xSbyte1))
// This example produces the following results:
// Test the sign of the following types of values:
// Byte : 0 is equal to zero.
// Int16 : -2 is less than zero.
// Int32 : -3 is less than zero.
// Int64 : -4 is less than zero.
// Single : 0 is equal to zero.
// Double : 6 is greater than zero.
// Decimal: -7 is less than zero.
// IntPtr: 8 is greater than zero.
//
// The following type is not CLS-compliant.
// SByte : -101 is less than zero.
' This example demonstrates Math.Sign()
Class Sample
Public Shared Sub Main()
Dim str As String = "{0}: {1,3} is {2} zero."
Dim nl As String = Environment.NewLine
Dim xByte1 As Byte = 0
Dim xShort1 As Short = -2
Dim xInt1 As Integer = -3
Dim xLong1 As Long = -4
Dim xSingle1 As Single = 0F
Dim xDouble1 As Double = 6.0
Dim xDecimal1 As [Decimal] = -7D
' The following type is not CLS-compliant.
Dim xSbyte1 As SByte = -101
Console.WriteLine("{0}Test the sign of the following types of values:", nl)
Console.WriteLine(str, "Byte ", xByte1, Test(Math.Sign(xByte1)))
Console.WriteLine(str, "Int16 ", xShort1, Test(Math.Sign(xShort1)))
Console.WriteLine(str, "Int32 ", xInt1, Test(Math.Sign(xInt1)))
Console.WriteLine(str, "Int64 ", xLong1, Test(Math.Sign(xLong1)))
Console.WriteLine(str, "Single ", xSingle1, Test(Math.Sign(xSingle1)))
Console.WriteLine(str, "Double ", xDouble1, Test(Math.Sign(xDouble1)))
Console.WriteLine(str, "Decimal", xDecimal1, Test(Math.Sign(xDecimal1)))
'
Console.WriteLine("{0}The following type is not CLS-compliant.", nl)
Console.WriteLine(str, "SByte ", xSbyte1, Test(Math.Sign(xSbyte1)))
End Sub
'
Public Shared Function Test([compare] As Integer) As [String]
If [compare] = 0 Then
Return "equal to"
ElseIf [compare] < 0 Then
Return "less than"
Else
Return "greater than"
End If
End Function 'Test
End Class
'
'This example produces the following results:
'
'Test the sign of the following types of values:
'Byte : 0 is equal to zero.
'Int16 : -2 is less than zero.
'Int32 : -3 is less than zero.
'Int64 : -4 is less than zero.
'Single : 0 is equal to zero.
'Double : 6 is greater than zero.
'Decimal: -7 is less than zero.
'
'The following type is not CLS-compliant.
'SByte : -101 is less than zero.
Aplica-se a
.NET 9 e outras versões
Produto | Versões |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Origem:
- Math.cs
- Origem:
- Math.cs
- Origem:
- Math.cs
Importante
Esta API não está em conformidade com CLS.
Retorna um inteiro que indica o sinal de um inteiro com sinal de 8 bits.
public:
static int Sign(System::SByte value);
[System.CLSCompliant(false)]
public static int Sign (sbyte value);
[<System.CLSCompliant(false)>]
static member Sign : sbyte -> int
Public Shared Function Sign (value As SByte) As Integer
Parâmetros
- value
- SByte
Um número assinado.
Retornos
Um número que indica o sinal de value
, conforme mostrado na tabela a seguir.
Valor de retorno | Significado |
---|---|
-1 |
value é menor que zero.
|
0 |
value é igual a zero.
|
1 |
value é maior que zero.
|
- Atributos
Exemplos
O exemplo a seguir demonstra como usar o método Sign(SByte) para determinar o sinal de um valor SByte e exibi-lo no console.
// This example demonstrates Math.Sign()
using namespace System;
String^ Test( int compare )
{
if ( compare == 0 )
return "equal to";
else
if ( compare < 0 )
return "less than";
else
return "greater than";
}
int main()
{
String^ str = "{0}: {1,3} is {2} zero.";
String^ nl = Environment::NewLine;
Byte xByte1 = 0;
short xShort1 = -2;
int xInt1 = -3;
long xLong1 = -4;
float xSingle1 = 0.0f;
double xDouble1 = 6.0;
Decimal xDecimal1 = -7;
// The following type is not CLS-compliant.
SByte xSbyte1 = -101;
Console::WriteLine( "{0}Test the sign of the following types of values:", nl );
Console::WriteLine( str, "Byte ", xByte1, Test( Math::Sign( xByte1 ) ) );
Console::WriteLine( str, "Int16 ", xShort1, Test( Math::Sign( xShort1 ) ) );
Console::WriteLine( str, "Int32 ", xInt1, Test( Math::Sign( xInt1 ) ) );
Console::WriteLine( str, "Int64 ", xLong1, Test( Math::Sign( xLong1 ) ) );
Console::WriteLine( str, "Single ", xSingle1, Test( Math::Sign( xSingle1 ) ) );
Console::WriteLine( str, "Double ", xDouble1, Test( Math::Sign( xDouble1 ) ) );
Console::WriteLine( str, "Decimal", xDecimal1, Test( Math::Sign( xDecimal1 ) ) );
//
Console::WriteLine( "{0}The following type is not CLS-compliant.", nl );
Console::WriteLine( str, "SByte ", xSbyte1, Test( Math::Sign( xSbyte1 ) ) );
}
/*
This example produces the following results:
Test the sign of the following types of values:
Byte : 0 is equal to zero.
Int16 : -2 is less than zero.
Int32 : -3 is less than zero.
Int64 : -4 is less than zero.
Single : 0 is equal to zero.
Double : 6 is greater than zero.
Decimal: -7 is less than zero.
The following type is not CLS-compliant.
SByte : -101 is less than zero.
*/
// This example demonstrates Math.Sign()
using System;
class Sample
{
public static void Main()
{
string str = "{0}: {1,3} is {2} zero.";
string nl = Environment.NewLine;
byte xByte1 = 0;
short xShort1 = -2;
int xInt1 = -3;
long xLong1 = -4;
float xSingle1 = 0.0f;
double xDouble1 = 6.0;
Decimal xDecimal1 = -7m;
nint xIntPtr1 = 8;
// The following type is not CLS-compliant.
sbyte xSbyte1 = -101;
Console.WriteLine($"{nl}Test the sign of the following types of values:");
Console.WriteLine(str, "Byte ", xByte1, Test(Math.Sign(xByte1)));
Console.WriteLine(str, "Int16 ", xShort1, Test(Math.Sign(xShort1)));
Console.WriteLine(str, "Int32 ", xInt1, Test(Math.Sign(xInt1)));
Console.WriteLine(str, "Int64 ", xLong1, Test(Math.Sign(xLong1)));
Console.WriteLine(str, "Single ", xSingle1, Test(Math.Sign(xSingle1)));
Console.WriteLine(str, "Double ", xDouble1, Test(Math.Sign(xDouble1)));
Console.WriteLine(str, "Decimal", xDecimal1, Test(Math.Sign(xDecimal1)));
Console.WriteLine(str, "IntPtr", xIntPtr1, Test(Math.Sign(xIntPtr1)));
Console.WriteLine($"{nl}The following type is not CLS-compliant.");
Console.WriteLine(str, "SByte ", xSbyte1, Test(Math.Sign(xSbyte1)));
}
public static string Test(int compare)
{
if (compare == 0)
return "equal to";
else if (compare < 0)
return "less than";
else
return "greater than";
}
}
/*
This example produces the following results:
Test the sign of the following types of values:
Byte : 0 is equal to zero.
Int16 : -2 is less than zero.
Int32 : -3 is less than zero.
Int64 : -4 is less than zero.
Single : 0 is equal to zero.
Double : 6 is greater than zero.
Decimal: -7 is less than zero.
IntPtr: 8 is greater than zero.
The following type is not CLS-compliant.
SByte : -101 is less than zero.
*/
// This example demonstrates Math.Sign()
// In F#, the sign function may be used instead
open System
let test = function
| 0 ->
"equal to"
| x when x < 0 ->
"less than"
| _ ->
"greater than"
let print typ a b =
printfn $"{typ}: {a,3} is {b} zero."
let xByte1 = 0uy
let xShort1 = -2s
let xInt1 = -3
let xLong1 = -4L
let xSingle1 = 0f
let xDouble1 = 6.
let xDecimal1 = -7m
let xIntPtr1 = 8
// The following type is not CLS-compliant.
let xSbyte1 = -101y
printfn "\nTest the sign of the following types of values:"
print "Byte " xByte1 (test (Math.Sign xByte1))
print "Int16 " xShort1 (test (Math.Sign xShort1))
print "Int32 " xInt1 (test (Math.Sign xInt1))
print "Int64 " xLong1 (test (Math.Sign xLong1))
print "Single " xSingle1 (test (Math.Sign xSingle1))
print "Double " xDouble1 (test (Math.Sign xDouble1))
print "Decimal" xDecimal1 (test (Math.Sign xDecimal1))
print "IntPtr" xIntPtr1 (test (Math.Sign xIntPtr1))
printfn "\nThe following type is not CLS-compliant."
print "SByte " xSbyte1 (test (Math.Sign xSbyte1))
// This example produces the following results:
// Test the sign of the following types of values:
// Byte : 0 is equal to zero.
// Int16 : -2 is less than zero.
// Int32 : -3 is less than zero.
// Int64 : -4 is less than zero.
// Single : 0 is equal to zero.
// Double : 6 is greater than zero.
// Decimal: -7 is less than zero.
// IntPtr: 8 is greater than zero.
//
// The following type is not CLS-compliant.
// SByte : -101 is less than zero.
' This example demonstrates Math.Sign()
Class Sample
Public Shared Sub Main()
Dim str As String = "{0}: {1,3} is {2} zero."
Dim nl As String = Environment.NewLine
Dim xByte1 As Byte = 0
Dim xShort1 As Short = -2
Dim xInt1 As Integer = -3
Dim xLong1 As Long = -4
Dim xSingle1 As Single = 0F
Dim xDouble1 As Double = 6.0
Dim xDecimal1 As [Decimal] = -7D
' The following type is not CLS-compliant.
Dim xSbyte1 As SByte = -101
Console.WriteLine("{0}Test the sign of the following types of values:", nl)
Console.WriteLine(str, "Byte ", xByte1, Test(Math.Sign(xByte1)))
Console.WriteLine(str, "Int16 ", xShort1, Test(Math.Sign(xShort1)))
Console.WriteLine(str, "Int32 ", xInt1, Test(Math.Sign(xInt1)))
Console.WriteLine(str, "Int64 ", xLong1, Test(Math.Sign(xLong1)))
Console.WriteLine(str, "Single ", xSingle1, Test(Math.Sign(xSingle1)))
Console.WriteLine(str, "Double ", xDouble1, Test(Math.Sign(xDouble1)))
Console.WriteLine(str, "Decimal", xDecimal1, Test(Math.Sign(xDecimal1)))
'
Console.WriteLine("{0}The following type is not CLS-compliant.", nl)
Console.WriteLine(str, "SByte ", xSbyte1, Test(Math.Sign(xSbyte1)))
End Sub
'
Public Shared Function Test([compare] As Integer) As [String]
If [compare] = 0 Then
Return "equal to"
ElseIf [compare] < 0 Then
Return "less than"
Else
Return "greater than"
End If
End Function 'Test
End Class
'
'This example produces the following results:
'
'Test the sign of the following types of values:
'Byte : 0 is equal to zero.
'Int16 : -2 is less than zero.
'Int32 : -3 is less than zero.
'Int64 : -4 is less than zero.
'Single : 0 is equal to zero.
'Double : 6 is greater than zero.
'Decimal: -7 is less than zero.
'
'The following type is not CLS-compliant.
'SByte : -101 is less than zero.
Aplica-se a
.NET 9 e outras versões
Produto | Versões |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Origem:
- Math.cs
- Origem:
- Math.cs
- Origem:
- Math.cs
Retorna um inteiro que indica o sinal de um inteiro com sinal de 64 bits.
public:
static int Sign(long value);
public static int Sign (long value);
static member Sign : int64 -> int
Public Shared Function Sign (value As Long) As Integer
Parâmetros
- value
- Int64
Um número assinado.
Retornos
Um número que indica o sinal de value
, conforme mostrado na tabela a seguir.
Valor de retorno | Significado |
---|---|
-1 |
value é menor que zero.
|
0 |
value é igual a zero.
|
1 |
value é maior que zero.
|
Exemplos
O exemplo a seguir demonstra como usar o método Sign(Int64) para determinar o sinal de um valor Int64 e exibi-lo no console.
// This example demonstrates Math.Sign()
using namespace System;
String^ Test( int compare )
{
if ( compare == 0 )
return "equal to";
else
if ( compare < 0 )
return "less than";
else
return "greater than";
}
int main()
{
String^ str = "{0}: {1,3} is {2} zero.";
String^ nl = Environment::NewLine;
Byte xByte1 = 0;
short xShort1 = -2;
int xInt1 = -3;
long xLong1 = -4;
float xSingle1 = 0.0f;
double xDouble1 = 6.0;
Decimal xDecimal1 = -7;
// The following type is not CLS-compliant.
SByte xSbyte1 = -101;
Console::WriteLine( "{0}Test the sign of the following types of values:", nl );
Console::WriteLine( str, "Byte ", xByte1, Test( Math::Sign( xByte1 ) ) );
Console::WriteLine( str, "Int16 ", xShort1, Test( Math::Sign( xShort1 ) ) );
Console::WriteLine( str, "Int32 ", xInt1, Test( Math::Sign( xInt1 ) ) );
Console::WriteLine( str, "Int64 ", xLong1, Test( Math::Sign( xLong1 ) ) );
Console::WriteLine( str, "Single ", xSingle1, Test( Math::Sign( xSingle1 ) ) );
Console::WriteLine( str, "Double ", xDouble1, Test( Math::Sign( xDouble1 ) ) );
Console::WriteLine( str, "Decimal", xDecimal1, Test( Math::Sign( xDecimal1 ) ) );
//
Console::WriteLine( "{0}The following type is not CLS-compliant.", nl );
Console::WriteLine( str, "SByte ", xSbyte1, Test( Math::Sign( xSbyte1 ) ) );
}
/*
This example produces the following results:
Test the sign of the following types of values:
Byte : 0 is equal to zero.
Int16 : -2 is less than zero.
Int32 : -3 is less than zero.
Int64 : -4 is less than zero.
Single : 0 is equal to zero.
Double : 6 is greater than zero.
Decimal: -7 is less than zero.
The following type is not CLS-compliant.
SByte : -101 is less than zero.
*/
// This example demonstrates Math.Sign()
using System;
class Sample
{
public static void Main()
{
string str = "{0}: {1,3} is {2} zero.";
string nl = Environment.NewLine;
byte xByte1 = 0;
short xShort1 = -2;
int xInt1 = -3;
long xLong1 = -4;
float xSingle1 = 0.0f;
double xDouble1 = 6.0;
Decimal xDecimal1 = -7m;
nint xIntPtr1 = 8;
// The following type is not CLS-compliant.
sbyte xSbyte1 = -101;
Console.WriteLine($"{nl}Test the sign of the following types of values:");
Console.WriteLine(str, "Byte ", xByte1, Test(Math.Sign(xByte1)));
Console.WriteLine(str, "Int16 ", xShort1, Test(Math.Sign(xShort1)));
Console.WriteLine(str, "Int32 ", xInt1, Test(Math.Sign(xInt1)));
Console.WriteLine(str, "Int64 ", xLong1, Test(Math.Sign(xLong1)));
Console.WriteLine(str, "Single ", xSingle1, Test(Math.Sign(xSingle1)));
Console.WriteLine(str, "Double ", xDouble1, Test(Math.Sign(xDouble1)));
Console.WriteLine(str, "Decimal", xDecimal1, Test(Math.Sign(xDecimal1)));
Console.WriteLine(str, "IntPtr", xIntPtr1, Test(Math.Sign(xIntPtr1)));
Console.WriteLine($"{nl}The following type is not CLS-compliant.");
Console.WriteLine(str, "SByte ", xSbyte1, Test(Math.Sign(xSbyte1)));
}
public static string Test(int compare)
{
if (compare == 0)
return "equal to";
else if (compare < 0)
return "less than";
else
return "greater than";
}
}
/*
This example produces the following results:
Test the sign of the following types of values:
Byte : 0 is equal to zero.
Int16 : -2 is less than zero.
Int32 : -3 is less than zero.
Int64 : -4 is less than zero.
Single : 0 is equal to zero.
Double : 6 is greater than zero.
Decimal: -7 is less than zero.
IntPtr: 8 is greater than zero.
The following type is not CLS-compliant.
SByte : -101 is less than zero.
*/
// This example demonstrates Math.Sign()
// In F#, the sign function may be used instead
open System
let test = function
| 0 ->
"equal to"
| x when x < 0 ->
"less than"
| _ ->
"greater than"
let print typ a b =
printfn $"{typ}: {a,3} is {b} zero."
let xByte1 = 0uy
let xShort1 = -2s
let xInt1 = -3
let xLong1 = -4L
let xSingle1 = 0f
let xDouble1 = 6.
let xDecimal1 = -7m
let xIntPtr1 = 8
// The following type is not CLS-compliant.
let xSbyte1 = -101y
printfn "\nTest the sign of the following types of values:"
print "Byte " xByte1 (test (Math.Sign xByte1))
print "Int16 " xShort1 (test (Math.Sign xShort1))
print "Int32 " xInt1 (test (Math.Sign xInt1))
print "Int64 " xLong1 (test (Math.Sign xLong1))
print "Single " xSingle1 (test (Math.Sign xSingle1))
print "Double " xDouble1 (test (Math.Sign xDouble1))
print "Decimal" xDecimal1 (test (Math.Sign xDecimal1))
print "IntPtr" xIntPtr1 (test (Math.Sign xIntPtr1))
printfn "\nThe following type is not CLS-compliant."
print "SByte " xSbyte1 (test (Math.Sign xSbyte1))
// This example produces the following results:
// Test the sign of the following types of values:
// Byte : 0 is equal to zero.
// Int16 : -2 is less than zero.
// Int32 : -3 is less than zero.
// Int64 : -4 is less than zero.
// Single : 0 is equal to zero.
// Double : 6 is greater than zero.
// Decimal: -7 is less than zero.
// IntPtr: 8 is greater than zero.
//
// The following type is not CLS-compliant.
// SByte : -101 is less than zero.
' This example demonstrates Math.Sign()
Class Sample
Public Shared Sub Main()
Dim str As String = "{0}: {1,3} is {2} zero."
Dim nl As String = Environment.NewLine
Dim xByte1 As Byte = 0
Dim xShort1 As Short = -2
Dim xInt1 As Integer = -3
Dim xLong1 As Long = -4
Dim xSingle1 As Single = 0F
Dim xDouble1 As Double = 6.0
Dim xDecimal1 As [Decimal] = -7D
' The following type is not CLS-compliant.
Dim xSbyte1 As SByte = -101
Console.WriteLine("{0}Test the sign of the following types of values:", nl)
Console.WriteLine(str, "Byte ", xByte1, Test(Math.Sign(xByte1)))
Console.WriteLine(str, "Int16 ", xShort1, Test(Math.Sign(xShort1)))
Console.WriteLine(str, "Int32 ", xInt1, Test(Math.Sign(xInt1)))
Console.WriteLine(str, "Int64 ", xLong1, Test(Math.Sign(xLong1)))
Console.WriteLine(str, "Single ", xSingle1, Test(Math.Sign(xSingle1)))
Console.WriteLine(str, "Double ", xDouble1, Test(Math.Sign(xDouble1)))
Console.WriteLine(str, "Decimal", xDecimal1, Test(Math.Sign(xDecimal1)))
'
Console.WriteLine("{0}The following type is not CLS-compliant.", nl)
Console.WriteLine(str, "SByte ", xSbyte1, Test(Math.Sign(xSbyte1)))
End Sub
'
Public Shared Function Test([compare] As Integer) As [String]
If [compare] = 0 Then
Return "equal to"
ElseIf [compare] < 0 Then
Return "less than"
Else
Return "greater than"
End If
End Function 'Test
End Class
'
'This example produces the following results:
'
'Test the sign of the following types of values:
'Byte : 0 is equal to zero.
'Int16 : -2 is less than zero.
'Int32 : -3 is less than zero.
'Int64 : -4 is less than zero.
'Single : 0 is equal to zero.
'Double : 6 is greater than zero.
'Decimal: -7 is less than zero.
'
'The following type is not CLS-compliant.
'SByte : -101 is less than zero.
Aplica-se a
.NET 9 e outras versões
Produto | Versões |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Origem:
- Math.cs
- Origem:
- Math.cs
- Origem:
- Math.cs
Retorna um inteiro que indica o sinal de um número de ponto flutuante de precisão dupla.
public:
static int Sign(double value);
public static int Sign (double value);
static member Sign : double -> int
Public Shared Function Sign (value As Double) As Integer
Parâmetros
- value
- Double
Um número assinado.
Retornos
Um número que indica o sinal de value
, conforme mostrado na tabela a seguir.
Valor de retorno | Significado |
---|---|
-1 |
value é menor que zero.
|
0 |
value é igual a zero.
|
1 |
value é maior que zero.
|
Exceções
value
é igual a NaN.
Exemplos
O exemplo a seguir demonstra como usar o método Sign(Double) para determinar o sinal de um valor Double e exibi-lo no console.
// This example demonstrates Math.Sign()
using namespace System;
String^ Test( int compare )
{
if ( compare == 0 )
return "equal to";
else
if ( compare < 0 )
return "less than";
else
return "greater than";
}
int main()
{
String^ str = "{0}: {1,3} is {2} zero.";
String^ nl = Environment::NewLine;
Byte xByte1 = 0;
short xShort1 = -2;
int xInt1 = -3;
long xLong1 = -4;
float xSingle1 = 0.0f;
double xDouble1 = 6.0;
Decimal xDecimal1 = -7;
// The following type is not CLS-compliant.
SByte xSbyte1 = -101;
Console::WriteLine( "{0}Test the sign of the following types of values:", nl );
Console::WriteLine( str, "Byte ", xByte1, Test( Math::Sign( xByte1 ) ) );
Console::WriteLine( str, "Int16 ", xShort1, Test( Math::Sign( xShort1 ) ) );
Console::WriteLine( str, "Int32 ", xInt1, Test( Math::Sign( xInt1 ) ) );
Console::WriteLine( str, "Int64 ", xLong1, Test( Math::Sign( xLong1 ) ) );
Console::WriteLine( str, "Single ", xSingle1, Test( Math::Sign( xSingle1 ) ) );
Console::WriteLine( str, "Double ", xDouble1, Test( Math::Sign( xDouble1 ) ) );
Console::WriteLine( str, "Decimal", xDecimal1, Test( Math::Sign( xDecimal1 ) ) );
//
Console::WriteLine( "{0}The following type is not CLS-compliant.", nl );
Console::WriteLine( str, "SByte ", xSbyte1, Test( Math::Sign( xSbyte1 ) ) );
}
/*
This example produces the following results:
Test the sign of the following types of values:
Byte : 0 is equal to zero.
Int16 : -2 is less than zero.
Int32 : -3 is less than zero.
Int64 : -4 is less than zero.
Single : 0 is equal to zero.
Double : 6 is greater than zero.
Decimal: -7 is less than zero.
The following type is not CLS-compliant.
SByte : -101 is less than zero.
*/
// This example demonstrates Math.Sign()
using System;
class Sample
{
public static void Main()
{
string str = "{0}: {1,3} is {2} zero.";
string nl = Environment.NewLine;
byte xByte1 = 0;
short xShort1 = -2;
int xInt1 = -3;
long xLong1 = -4;
float xSingle1 = 0.0f;
double xDouble1 = 6.0;
Decimal xDecimal1 = -7m;
nint xIntPtr1 = 8;
// The following type is not CLS-compliant.
sbyte xSbyte1 = -101;
Console.WriteLine($"{nl}Test the sign of the following types of values:");
Console.WriteLine(str, "Byte ", xByte1, Test(Math.Sign(xByte1)));
Console.WriteLine(str, "Int16 ", xShort1, Test(Math.Sign(xShort1)));
Console.WriteLine(str, "Int32 ", xInt1, Test(Math.Sign(xInt1)));
Console.WriteLine(str, "Int64 ", xLong1, Test(Math.Sign(xLong1)));
Console.WriteLine(str, "Single ", xSingle1, Test(Math.Sign(xSingle1)));
Console.WriteLine(str, "Double ", xDouble1, Test(Math.Sign(xDouble1)));
Console.WriteLine(str, "Decimal", xDecimal1, Test(Math.Sign(xDecimal1)));
Console.WriteLine(str, "IntPtr", xIntPtr1, Test(Math.Sign(xIntPtr1)));
Console.WriteLine($"{nl}The following type is not CLS-compliant.");
Console.WriteLine(str, "SByte ", xSbyte1, Test(Math.Sign(xSbyte1)));
}
public static string Test(int compare)
{
if (compare == 0)
return "equal to";
else if (compare < 0)
return "less than";
else
return "greater than";
}
}
/*
This example produces the following results:
Test the sign of the following types of values:
Byte : 0 is equal to zero.
Int16 : -2 is less than zero.
Int32 : -3 is less than zero.
Int64 : -4 is less than zero.
Single : 0 is equal to zero.
Double : 6 is greater than zero.
Decimal: -7 is less than zero.
IntPtr: 8 is greater than zero.
The following type is not CLS-compliant.
SByte : -101 is less than zero.
*/
// This example demonstrates Math.Sign()
// In F#, the sign function may be used instead
open System
let test = function
| 0 ->
"equal to"
| x when x < 0 ->
"less than"
| _ ->
"greater than"
let print typ a b =
printfn $"{typ}: {a,3} is {b} zero."
let xByte1 = 0uy
let xShort1 = -2s
let xInt1 = -3
let xLong1 = -4L
let xSingle1 = 0f
let xDouble1 = 6.
let xDecimal1 = -7m
let xIntPtr1 = 8
// The following type is not CLS-compliant.
let xSbyte1 = -101y
printfn "\nTest the sign of the following types of values:"
print "Byte " xByte1 (test (Math.Sign xByte1))
print "Int16 " xShort1 (test (Math.Sign xShort1))
print "Int32 " xInt1 (test (Math.Sign xInt1))
print "Int64 " xLong1 (test (Math.Sign xLong1))
print "Single " xSingle1 (test (Math.Sign xSingle1))
print "Double " xDouble1 (test (Math.Sign xDouble1))
print "Decimal" xDecimal1 (test (Math.Sign xDecimal1))
print "IntPtr" xIntPtr1 (test (Math.Sign xIntPtr1))
printfn "\nThe following type is not CLS-compliant."
print "SByte " xSbyte1 (test (Math.Sign xSbyte1))
// This example produces the following results:
// Test the sign of the following types of values:
// Byte : 0 is equal to zero.
// Int16 : -2 is less than zero.
// Int32 : -3 is less than zero.
// Int64 : -4 is less than zero.
// Single : 0 is equal to zero.
// Double : 6 is greater than zero.
// Decimal: -7 is less than zero.
// IntPtr: 8 is greater than zero.
//
// The following type is not CLS-compliant.
// SByte : -101 is less than zero.
' This example demonstrates Math.Sign()
Class Sample
Public Shared Sub Main()
Dim str As String = "{0}: {1,3} is {2} zero."
Dim nl As String = Environment.NewLine
Dim xByte1 As Byte = 0
Dim xShort1 As Short = -2
Dim xInt1 As Integer = -3
Dim xLong1 As Long = -4
Dim xSingle1 As Single = 0F
Dim xDouble1 As Double = 6.0
Dim xDecimal1 As [Decimal] = -7D
' The following type is not CLS-compliant.
Dim xSbyte1 As SByte = -101
Console.WriteLine("{0}Test the sign of the following types of values:", nl)
Console.WriteLine(str, "Byte ", xByte1, Test(Math.Sign(xByte1)))
Console.WriteLine(str, "Int16 ", xShort1, Test(Math.Sign(xShort1)))
Console.WriteLine(str, "Int32 ", xInt1, Test(Math.Sign(xInt1)))
Console.WriteLine(str, "Int64 ", xLong1, Test(Math.Sign(xLong1)))
Console.WriteLine(str, "Single ", xSingle1, Test(Math.Sign(xSingle1)))
Console.WriteLine(str, "Double ", xDouble1, Test(Math.Sign(xDouble1)))
Console.WriteLine(str, "Decimal", xDecimal1, Test(Math.Sign(xDecimal1)))
'
Console.WriteLine("{0}The following type is not CLS-compliant.", nl)
Console.WriteLine(str, "SByte ", xSbyte1, Test(Math.Sign(xSbyte1)))
End Sub
'
Public Shared Function Test([compare] As Integer) As [String]
If [compare] = 0 Then
Return "equal to"
ElseIf [compare] < 0 Then
Return "less than"
Else
Return "greater than"
End If
End Function 'Test
End Class
'
'This example produces the following results:
'
'Test the sign of the following types of values:
'Byte : 0 is equal to zero.
'Int16 : -2 is less than zero.
'Int32 : -3 is less than zero.
'Int64 : -4 is less than zero.
'Single : 0 is equal to zero.
'Double : 6 is greater than zero.
'Decimal: -7 is less than zero.
'
'The following type is not CLS-compliant.
'SByte : -101 is less than zero.
Aplica-se a
.NET 9 e outras versões
Produto | Versões |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Origem:
- Math.cs
- Origem:
- Math.cs
- Origem:
- Math.cs
Retorna um inteiro que indica o sinal de um inteiro com sinal de 16 bits.
public:
static int Sign(short value);
public static int Sign (short value);
static member Sign : int16 -> int
Public Shared Function Sign (value As Short) As Integer
Parâmetros
- value
- Int16
Um número assinado.
Retornos
Um número que indica o sinal de value
, conforme mostrado na tabela a seguir.
Valor de retorno | Significado |
---|---|
-1 |
value é menor que zero.
|
0 |
value é igual a zero.
|
1 |
value é maior que zero.
|
Exemplos
O exemplo a seguir demonstra como usar o método Sign(Int16) para determinar o sinal de um valor Int16 e exibi-lo no console.
// This example demonstrates Math.Sign()
using namespace System;
String^ Test( int compare )
{
if ( compare == 0 )
return "equal to";
else
if ( compare < 0 )
return "less than";
else
return "greater than";
}
int main()
{
String^ str = "{0}: {1,3} is {2} zero.";
String^ nl = Environment::NewLine;
Byte xByte1 = 0;
short xShort1 = -2;
int xInt1 = -3;
long xLong1 = -4;
float xSingle1 = 0.0f;
double xDouble1 = 6.0;
Decimal xDecimal1 = -7;
// The following type is not CLS-compliant.
SByte xSbyte1 = -101;
Console::WriteLine( "{0}Test the sign of the following types of values:", nl );
Console::WriteLine( str, "Byte ", xByte1, Test( Math::Sign( xByte1 ) ) );
Console::WriteLine( str, "Int16 ", xShort1, Test( Math::Sign( xShort1 ) ) );
Console::WriteLine( str, "Int32 ", xInt1, Test( Math::Sign( xInt1 ) ) );
Console::WriteLine( str, "Int64 ", xLong1, Test( Math::Sign( xLong1 ) ) );
Console::WriteLine( str, "Single ", xSingle1, Test( Math::Sign( xSingle1 ) ) );
Console::WriteLine( str, "Double ", xDouble1, Test( Math::Sign( xDouble1 ) ) );
Console::WriteLine( str, "Decimal", xDecimal1, Test( Math::Sign( xDecimal1 ) ) );
//
Console::WriteLine( "{0}The following type is not CLS-compliant.", nl );
Console::WriteLine( str, "SByte ", xSbyte1, Test( Math::Sign( xSbyte1 ) ) );
}
/*
This example produces the following results:
Test the sign of the following types of values:
Byte : 0 is equal to zero.
Int16 : -2 is less than zero.
Int32 : -3 is less than zero.
Int64 : -4 is less than zero.
Single : 0 is equal to zero.
Double : 6 is greater than zero.
Decimal: -7 is less than zero.
The following type is not CLS-compliant.
SByte : -101 is less than zero.
*/
// This example demonstrates Math.Sign()
using System;
class Sample
{
public static void Main()
{
string str = "{0}: {1,3} is {2} zero.";
string nl = Environment.NewLine;
byte xByte1 = 0;
short xShort1 = -2;
int xInt1 = -3;
long xLong1 = -4;
float xSingle1 = 0.0f;
double xDouble1 = 6.0;
Decimal xDecimal1 = -7m;
nint xIntPtr1 = 8;
// The following type is not CLS-compliant.
sbyte xSbyte1 = -101;
Console.WriteLine($"{nl}Test the sign of the following types of values:");
Console.WriteLine(str, "Byte ", xByte1, Test(Math.Sign(xByte1)));
Console.WriteLine(str, "Int16 ", xShort1, Test(Math.Sign(xShort1)));
Console.WriteLine(str, "Int32 ", xInt1, Test(Math.Sign(xInt1)));
Console.WriteLine(str, "Int64 ", xLong1, Test(Math.Sign(xLong1)));
Console.WriteLine(str, "Single ", xSingle1, Test(Math.Sign(xSingle1)));
Console.WriteLine(str, "Double ", xDouble1, Test(Math.Sign(xDouble1)));
Console.WriteLine(str, "Decimal", xDecimal1, Test(Math.Sign(xDecimal1)));
Console.WriteLine(str, "IntPtr", xIntPtr1, Test(Math.Sign(xIntPtr1)));
Console.WriteLine($"{nl}The following type is not CLS-compliant.");
Console.WriteLine(str, "SByte ", xSbyte1, Test(Math.Sign(xSbyte1)));
}
public static string Test(int compare)
{
if (compare == 0)
return "equal to";
else if (compare < 0)
return "less than";
else
return "greater than";
}
}
/*
This example produces the following results:
Test the sign of the following types of values:
Byte : 0 is equal to zero.
Int16 : -2 is less than zero.
Int32 : -3 is less than zero.
Int64 : -4 is less than zero.
Single : 0 is equal to zero.
Double : 6 is greater than zero.
Decimal: -7 is less than zero.
IntPtr: 8 is greater than zero.
The following type is not CLS-compliant.
SByte : -101 is less than zero.
*/
// This example demonstrates Math.Sign()
// In F#, the sign function may be used instead
open System
let test = function
| 0 ->
"equal to"
| x when x < 0 ->
"less than"
| _ ->
"greater than"
let print typ a b =
printfn $"{typ}: {a,3} is {b} zero."
let xByte1 = 0uy
let xShort1 = -2s
let xInt1 = -3
let xLong1 = -4L
let xSingle1 = 0f
let xDouble1 = 6.
let xDecimal1 = -7m
let xIntPtr1 = 8
// The following type is not CLS-compliant.
let xSbyte1 = -101y
printfn "\nTest the sign of the following types of values:"
print "Byte " xByte1 (test (Math.Sign xByte1))
print "Int16 " xShort1 (test (Math.Sign xShort1))
print "Int32 " xInt1 (test (Math.Sign xInt1))
print "Int64 " xLong1 (test (Math.Sign xLong1))
print "Single " xSingle1 (test (Math.Sign xSingle1))
print "Double " xDouble1 (test (Math.Sign xDouble1))
print "Decimal" xDecimal1 (test (Math.Sign xDecimal1))
print "IntPtr" xIntPtr1 (test (Math.Sign xIntPtr1))
printfn "\nThe following type is not CLS-compliant."
print "SByte " xSbyte1 (test (Math.Sign xSbyte1))
// This example produces the following results:
// Test the sign of the following types of values:
// Byte : 0 is equal to zero.
// Int16 : -2 is less than zero.
// Int32 : -3 is less than zero.
// Int64 : -4 is less than zero.
// Single : 0 is equal to zero.
// Double : 6 is greater than zero.
// Decimal: -7 is less than zero.
// IntPtr: 8 is greater than zero.
//
// The following type is not CLS-compliant.
// SByte : -101 is less than zero.
' This example demonstrates Math.Sign()
Class Sample
Public Shared Sub Main()
Dim str As String = "{0}: {1,3} is {2} zero."
Dim nl As String = Environment.NewLine
Dim xByte1 As Byte = 0
Dim xShort1 As Short = -2
Dim xInt1 As Integer = -3
Dim xLong1 As Long = -4
Dim xSingle1 As Single = 0F
Dim xDouble1 As Double = 6.0
Dim xDecimal1 As [Decimal] = -7D
' The following type is not CLS-compliant.
Dim xSbyte1 As SByte = -101
Console.WriteLine("{0}Test the sign of the following types of values:", nl)
Console.WriteLine(str, "Byte ", xByte1, Test(Math.Sign(xByte1)))
Console.WriteLine(str, "Int16 ", xShort1, Test(Math.Sign(xShort1)))
Console.WriteLine(str, "Int32 ", xInt1, Test(Math.Sign(xInt1)))
Console.WriteLine(str, "Int64 ", xLong1, Test(Math.Sign(xLong1)))
Console.WriteLine(str, "Single ", xSingle1, Test(Math.Sign(xSingle1)))
Console.WriteLine(str, "Double ", xDouble1, Test(Math.Sign(xDouble1)))
Console.WriteLine(str, "Decimal", xDecimal1, Test(Math.Sign(xDecimal1)))
'
Console.WriteLine("{0}The following type is not CLS-compliant.", nl)
Console.WriteLine(str, "SByte ", xSbyte1, Test(Math.Sign(xSbyte1)))
End Sub
'
Public Shared Function Test([compare] As Integer) As [String]
If [compare] = 0 Then
Return "equal to"
ElseIf [compare] < 0 Then
Return "less than"
Else
Return "greater than"
End If
End Function 'Test
End Class
'
'This example produces the following results:
'
'Test the sign of the following types of values:
'Byte : 0 is equal to zero.
'Int16 : -2 is less than zero.
'Int32 : -3 is less than zero.
'Int64 : -4 is less than zero.
'Single : 0 is equal to zero.
'Double : 6 is greater than zero.
'Decimal: -7 is less than zero.
'
'The following type is not CLS-compliant.
'SByte : -101 is less than zero.
Aplica-se a
.NET 9 e outras versões
Produto | Versões |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Origem:
- Math.cs
- Origem:
- Math.cs
- Origem:
- Math.cs
Retorna um inteiro que indica o sinal de um número decimal.
public:
static int Sign(System::Decimal value);
public static int Sign (decimal value);
static member Sign : decimal -> int
Public Shared Function Sign (value As Decimal) As Integer
Parâmetros
- value
- Decimal
Um número decimal assinado.
Retornos
Um número que indica o sinal de value
, conforme mostrado na tabela a seguir.
Valor de retorno | Significado |
---|---|
-1 |
value é menor que zero.
|
0 |
value é igual a zero.
|
1 |
value é maior que zero.
|
Exemplos
O exemplo a seguir demonstra como usar o método Sign(Decimal) para determinar o sinal de um valor Decimal e exibi-lo no console.
// This example demonstrates Math.Sign()
using namespace System;
String^ Test( int compare )
{
if ( compare == 0 )
return "equal to";
else
if ( compare < 0 )
return "less than";
else
return "greater than";
}
int main()
{
String^ str = "{0}: {1,3} is {2} zero.";
String^ nl = Environment::NewLine;
Byte xByte1 = 0;
short xShort1 = -2;
int xInt1 = -3;
long xLong1 = -4;
float xSingle1 = 0.0f;
double xDouble1 = 6.0;
Decimal xDecimal1 = -7;
// The following type is not CLS-compliant.
SByte xSbyte1 = -101;
Console::WriteLine( "{0}Test the sign of the following types of values:", nl );
Console::WriteLine( str, "Byte ", xByte1, Test( Math::Sign( xByte1 ) ) );
Console::WriteLine( str, "Int16 ", xShort1, Test( Math::Sign( xShort1 ) ) );
Console::WriteLine( str, "Int32 ", xInt1, Test( Math::Sign( xInt1 ) ) );
Console::WriteLine( str, "Int64 ", xLong1, Test( Math::Sign( xLong1 ) ) );
Console::WriteLine( str, "Single ", xSingle1, Test( Math::Sign( xSingle1 ) ) );
Console::WriteLine( str, "Double ", xDouble1, Test( Math::Sign( xDouble1 ) ) );
Console::WriteLine( str, "Decimal", xDecimal1, Test( Math::Sign( xDecimal1 ) ) );
//
Console::WriteLine( "{0}The following type is not CLS-compliant.", nl );
Console::WriteLine( str, "SByte ", xSbyte1, Test( Math::Sign( xSbyte1 ) ) );
}
/*
This example produces the following results:
Test the sign of the following types of values:
Byte : 0 is equal to zero.
Int16 : -2 is less than zero.
Int32 : -3 is less than zero.
Int64 : -4 is less than zero.
Single : 0 is equal to zero.
Double : 6 is greater than zero.
Decimal: -7 is less than zero.
The following type is not CLS-compliant.
SByte : -101 is less than zero.
*/
// This example demonstrates Math.Sign()
using System;
class Sample
{
public static void Main()
{
string str = "{0}: {1,3} is {2} zero.";
string nl = Environment.NewLine;
byte xByte1 = 0;
short xShort1 = -2;
int xInt1 = -3;
long xLong1 = -4;
float xSingle1 = 0.0f;
double xDouble1 = 6.0;
Decimal xDecimal1 = -7m;
nint xIntPtr1 = 8;
// The following type is not CLS-compliant.
sbyte xSbyte1 = -101;
Console.WriteLine($"{nl}Test the sign of the following types of values:");
Console.WriteLine(str, "Byte ", xByte1, Test(Math.Sign(xByte1)));
Console.WriteLine(str, "Int16 ", xShort1, Test(Math.Sign(xShort1)));
Console.WriteLine(str, "Int32 ", xInt1, Test(Math.Sign(xInt1)));
Console.WriteLine(str, "Int64 ", xLong1, Test(Math.Sign(xLong1)));
Console.WriteLine(str, "Single ", xSingle1, Test(Math.Sign(xSingle1)));
Console.WriteLine(str, "Double ", xDouble1, Test(Math.Sign(xDouble1)));
Console.WriteLine(str, "Decimal", xDecimal1, Test(Math.Sign(xDecimal1)));
Console.WriteLine(str, "IntPtr", xIntPtr1, Test(Math.Sign(xIntPtr1)));
Console.WriteLine($"{nl}The following type is not CLS-compliant.");
Console.WriteLine(str, "SByte ", xSbyte1, Test(Math.Sign(xSbyte1)));
}
public static string Test(int compare)
{
if (compare == 0)
return "equal to";
else if (compare < 0)
return "less than";
else
return "greater than";
}
}
/*
This example produces the following results:
Test the sign of the following types of values:
Byte : 0 is equal to zero.
Int16 : -2 is less than zero.
Int32 : -3 is less than zero.
Int64 : -4 is less than zero.
Single : 0 is equal to zero.
Double : 6 is greater than zero.
Decimal: -7 is less than zero.
IntPtr: 8 is greater than zero.
The following type is not CLS-compliant.
SByte : -101 is less than zero.
*/
// This example demonstrates Math.Sign()
// In F#, the sign function may be used instead
open System
let test = function
| 0 ->
"equal to"
| x when x < 0 ->
"less than"
| _ ->
"greater than"
let print typ a b =
printfn $"{typ}: {a,3} is {b} zero."
let xByte1 = 0uy
let xShort1 = -2s
let xInt1 = -3
let xLong1 = -4L
let xSingle1 = 0f
let xDouble1 = 6.
let xDecimal1 = -7m
let xIntPtr1 = 8
// The following type is not CLS-compliant.
let xSbyte1 = -101y
printfn "\nTest the sign of the following types of values:"
print "Byte " xByte1 (test (Math.Sign xByte1))
print "Int16 " xShort1 (test (Math.Sign xShort1))
print "Int32 " xInt1 (test (Math.Sign xInt1))
print "Int64 " xLong1 (test (Math.Sign xLong1))
print "Single " xSingle1 (test (Math.Sign xSingle1))
print "Double " xDouble1 (test (Math.Sign xDouble1))
print "Decimal" xDecimal1 (test (Math.Sign xDecimal1))
print "IntPtr" xIntPtr1 (test (Math.Sign xIntPtr1))
printfn "\nThe following type is not CLS-compliant."
print "SByte " xSbyte1 (test (Math.Sign xSbyte1))
// This example produces the following results:
// Test the sign of the following types of values:
// Byte : 0 is equal to zero.
// Int16 : -2 is less than zero.
// Int32 : -3 is less than zero.
// Int64 : -4 is less than zero.
// Single : 0 is equal to zero.
// Double : 6 is greater than zero.
// Decimal: -7 is less than zero.
// IntPtr: 8 is greater than zero.
//
// The following type is not CLS-compliant.
// SByte : -101 is less than zero.
' This example demonstrates Math.Sign()
Class Sample
Public Shared Sub Main()
Dim str As String = "{0}: {1,3} is {2} zero."
Dim nl As String = Environment.NewLine
Dim xByte1 As Byte = 0
Dim xShort1 As Short = -2
Dim xInt1 As Integer = -3
Dim xLong1 As Long = -4
Dim xSingle1 As Single = 0F
Dim xDouble1 As Double = 6.0
Dim xDecimal1 As [Decimal] = -7D
' The following type is not CLS-compliant.
Dim xSbyte1 As SByte = -101
Console.WriteLine("{0}Test the sign of the following types of values:", nl)
Console.WriteLine(str, "Byte ", xByte1, Test(Math.Sign(xByte1)))
Console.WriteLine(str, "Int16 ", xShort1, Test(Math.Sign(xShort1)))
Console.WriteLine(str, "Int32 ", xInt1, Test(Math.Sign(xInt1)))
Console.WriteLine(str, "Int64 ", xLong1, Test(Math.Sign(xLong1)))
Console.WriteLine(str, "Single ", xSingle1, Test(Math.Sign(xSingle1)))
Console.WriteLine(str, "Double ", xDouble1, Test(Math.Sign(xDouble1)))
Console.WriteLine(str, "Decimal", xDecimal1, Test(Math.Sign(xDecimal1)))
'
Console.WriteLine("{0}The following type is not CLS-compliant.", nl)
Console.WriteLine(str, "SByte ", xSbyte1, Test(Math.Sign(xSbyte1)))
End Sub
'
Public Shared Function Test([compare] As Integer) As [String]
If [compare] = 0 Then
Return "equal to"
ElseIf [compare] < 0 Then
Return "less than"
Else
Return "greater than"
End If
End Function 'Test
End Class
'
'This example produces the following results:
'
'Test the sign of the following types of values:
'Byte : 0 is equal to zero.
'Int16 : -2 is less than zero.
'Int32 : -3 is less than zero.
'Int64 : -4 is less than zero.
'Single : 0 is equal to zero.
'Double : 6 is greater than zero.
'Decimal: -7 is less than zero.
'
'The following type is not CLS-compliant.
'SByte : -101 is less than zero.
Aplica-se a
.NET 9 e outras versões
Produto | Versões |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Origem:
- Math.cs
- Origem:
- Math.cs
- Origem:
- Math.cs
Retorna um inteiro que indica o sinal de um inteiro com sinal de 32 bits.
public:
static int Sign(int value);
public static int Sign (int value);
static member Sign : int -> int
Public Shared Function Sign (value As Integer) As Integer
Parâmetros
- value
- Int32
Um número assinado.
Retornos
Um número que indica o sinal de value
, conforme mostrado na tabela a seguir.
Valor de retorno | Significado |
---|---|
-1 |
value é menor que zero.
|
0 |
value é igual a zero.
|
1 |
value é maior que zero.
|
Exemplos
O exemplo a seguir demonstra como usar o método Sign(Int32) para determinar o sinal de um valor Int32 e exibi-lo no console.
// This example demonstrates Math.Sign()
using namespace System;
String^ Test( int compare )
{
if ( compare == 0 )
return "equal to";
else
if ( compare < 0 )
return "less than";
else
return "greater than";
}
int main()
{
String^ str = "{0}: {1,3} is {2} zero.";
String^ nl = Environment::NewLine;
Byte xByte1 = 0;
short xShort1 = -2;
int xInt1 = -3;
long xLong1 = -4;
float xSingle1 = 0.0f;
double xDouble1 = 6.0;
Decimal xDecimal1 = -7;
// The following type is not CLS-compliant.
SByte xSbyte1 = -101;
Console::WriteLine( "{0}Test the sign of the following types of values:", nl );
Console::WriteLine( str, "Byte ", xByte1, Test( Math::Sign( xByte1 ) ) );
Console::WriteLine( str, "Int16 ", xShort1, Test( Math::Sign( xShort1 ) ) );
Console::WriteLine( str, "Int32 ", xInt1, Test( Math::Sign( xInt1 ) ) );
Console::WriteLine( str, "Int64 ", xLong1, Test( Math::Sign( xLong1 ) ) );
Console::WriteLine( str, "Single ", xSingle1, Test( Math::Sign( xSingle1 ) ) );
Console::WriteLine( str, "Double ", xDouble1, Test( Math::Sign( xDouble1 ) ) );
Console::WriteLine( str, "Decimal", xDecimal1, Test( Math::Sign( xDecimal1 ) ) );
//
Console::WriteLine( "{0}The following type is not CLS-compliant.", nl );
Console::WriteLine( str, "SByte ", xSbyte1, Test( Math::Sign( xSbyte1 ) ) );
}
/*
This example produces the following results:
Test the sign of the following types of values:
Byte : 0 is equal to zero.
Int16 : -2 is less than zero.
Int32 : -3 is less than zero.
Int64 : -4 is less than zero.
Single : 0 is equal to zero.
Double : 6 is greater than zero.
Decimal: -7 is less than zero.
The following type is not CLS-compliant.
SByte : -101 is less than zero.
*/
// This example demonstrates Math.Sign()
using System;
class Sample
{
public static void Main()
{
string str = "{0}: {1,3} is {2} zero.";
string nl = Environment.NewLine;
byte xByte1 = 0;
short xShort1 = -2;
int xInt1 = -3;
long xLong1 = -4;
float xSingle1 = 0.0f;
double xDouble1 = 6.0;
Decimal xDecimal1 = -7m;
nint xIntPtr1 = 8;
// The following type is not CLS-compliant.
sbyte xSbyte1 = -101;
Console.WriteLine($"{nl}Test the sign of the following types of values:");
Console.WriteLine(str, "Byte ", xByte1, Test(Math.Sign(xByte1)));
Console.WriteLine(str, "Int16 ", xShort1, Test(Math.Sign(xShort1)));
Console.WriteLine(str, "Int32 ", xInt1, Test(Math.Sign(xInt1)));
Console.WriteLine(str, "Int64 ", xLong1, Test(Math.Sign(xLong1)));
Console.WriteLine(str, "Single ", xSingle1, Test(Math.Sign(xSingle1)));
Console.WriteLine(str, "Double ", xDouble1, Test(Math.Sign(xDouble1)));
Console.WriteLine(str, "Decimal", xDecimal1, Test(Math.Sign(xDecimal1)));
Console.WriteLine(str, "IntPtr", xIntPtr1, Test(Math.Sign(xIntPtr1)));
Console.WriteLine($"{nl}The following type is not CLS-compliant.");
Console.WriteLine(str, "SByte ", xSbyte1, Test(Math.Sign(xSbyte1)));
}
public static string Test(int compare)
{
if (compare == 0)
return "equal to";
else if (compare < 0)
return "less than";
else
return "greater than";
}
}
/*
This example produces the following results:
Test the sign of the following types of values:
Byte : 0 is equal to zero.
Int16 : -2 is less than zero.
Int32 : -3 is less than zero.
Int64 : -4 is less than zero.
Single : 0 is equal to zero.
Double : 6 is greater than zero.
Decimal: -7 is less than zero.
IntPtr: 8 is greater than zero.
The following type is not CLS-compliant.
SByte : -101 is less than zero.
*/
// This example demonstrates Math.Sign()
// In F#, the sign function may be used instead
open System
let test = function
| 0 ->
"equal to"
| x when x < 0 ->
"less than"
| _ ->
"greater than"
let print typ a b =
printfn $"{typ}: {a,3} is {b} zero."
let xByte1 = 0uy
let xShort1 = -2s
let xInt1 = -3
let xLong1 = -4L
let xSingle1 = 0f
let xDouble1 = 6.
let xDecimal1 = -7m
let xIntPtr1 = 8
// The following type is not CLS-compliant.
let xSbyte1 = -101y
printfn "\nTest the sign of the following types of values:"
print "Byte " xByte1 (test (Math.Sign xByte1))
print "Int16 " xShort1 (test (Math.Sign xShort1))
print "Int32 " xInt1 (test (Math.Sign xInt1))
print "Int64 " xLong1 (test (Math.Sign xLong1))
print "Single " xSingle1 (test (Math.Sign xSingle1))
print "Double " xDouble1 (test (Math.Sign xDouble1))
print "Decimal" xDecimal1 (test (Math.Sign xDecimal1))
print "IntPtr" xIntPtr1 (test (Math.Sign xIntPtr1))
printfn "\nThe following type is not CLS-compliant."
print "SByte " xSbyte1 (test (Math.Sign xSbyte1))
// This example produces the following results:
// Test the sign of the following types of values:
// Byte : 0 is equal to zero.
// Int16 : -2 is less than zero.
// Int32 : -3 is less than zero.
// Int64 : -4 is less than zero.
// Single : 0 is equal to zero.
// Double : 6 is greater than zero.
// Decimal: -7 is less than zero.
// IntPtr: 8 is greater than zero.
//
// The following type is not CLS-compliant.
// SByte : -101 is less than zero.
' This example demonstrates Math.Sign()
Class Sample
Public Shared Sub Main()
Dim str As String = "{0}: {1,3} is {2} zero."
Dim nl As String = Environment.NewLine
Dim xByte1 As Byte = 0
Dim xShort1 As Short = -2
Dim xInt1 As Integer = -3
Dim xLong1 As Long = -4
Dim xSingle1 As Single = 0F
Dim xDouble1 As Double = 6.0
Dim xDecimal1 As [Decimal] = -7D
' The following type is not CLS-compliant.
Dim xSbyte1 As SByte = -101
Console.WriteLine("{0}Test the sign of the following types of values:", nl)
Console.WriteLine(str, "Byte ", xByte1, Test(Math.Sign(xByte1)))
Console.WriteLine(str, "Int16 ", xShort1, Test(Math.Sign(xShort1)))
Console.WriteLine(str, "Int32 ", xInt1, Test(Math.Sign(xInt1)))
Console.WriteLine(str, "Int64 ", xLong1, Test(Math.Sign(xLong1)))
Console.WriteLine(str, "Single ", xSingle1, Test(Math.Sign(xSingle1)))
Console.WriteLine(str, "Double ", xDouble1, Test(Math.Sign(xDouble1)))
Console.WriteLine(str, "Decimal", xDecimal1, Test(Math.Sign(xDecimal1)))
'
Console.WriteLine("{0}The following type is not CLS-compliant.", nl)
Console.WriteLine(str, "SByte ", xSbyte1, Test(Math.Sign(xSbyte1)))
End Sub
'
Public Shared Function Test([compare] As Integer) As [String]
If [compare] = 0 Then
Return "equal to"
ElseIf [compare] < 0 Then
Return "less than"
Else
Return "greater than"
End If
End Function 'Test
End Class
'
'This example produces the following results:
'
'Test the sign of the following types of values:
'Byte : 0 is equal to zero.
'Int16 : -2 is less than zero.
'Int32 : -3 is less than zero.
'Int64 : -4 is less than zero.
'Single : 0 is equal to zero.
'Double : 6 is greater than zero.
'Decimal: -7 is less than zero.
'
'The following type is not CLS-compliant.
'SByte : -101 is less than zero.
Aplica-se a
.NET 9 e outras versões
Produto | Versões |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
Comentários do .NET
O .NET é um projeto código aberto. Selecione um link para fornecer comentários: