Come posso verificare se un numero è positivo o negativo in C#?

Question

Come si verifica se un numero è positivo o negativo in C#?

Answer 1

bool positive = number > 0; 
bool negative = number < 0; 

Answer 2

num < 0 // number is negative 

Answer 3

if (num < 0) { 
    //negative 
} 
if (num > 0) { 
    //positive 
} 
if (num == 0) { 
    //neither positive or negative, 
} 

o utilizzare "altro se"

Answer 4

Overkill!

public static class AwesomeExtensions 
{ 
    public static bool IsPositive(this int number) 
    { 
     return number > 0; 
    } 

    public static bool IsNegative(this int number) 
    { 
     return number < 0; 
    } 

    public static bool IsZero(this int number) 
    { 
     return number == 0; 
    } 

    public static bool IsAwesome(this int number) 
    { 
     return IsNegative(number) && IsPositive(number) && IsZero(number); 
    } 
} 

Answer 5

Voi giovani e i vostri segni di fantasia.

Nel mio giorno abbiamo dovuto usare Math.abs(num) != num //number is negative!

Answer 6

Il Math.Sign method è un modo per andare. Restituirà -1 per i numeri negativi, 1 per i numeri positivi e 0 per i valori pari a zero (vale a dire zero non ha alcun segno). Le variabili di precisione doppie e singole causeranno un'eccezione (ArithmeticException) da lanciare se sono uguali a NaN.

Answer 7

int j = num * -1; 

if (j - num == j) 
{ 
    // Num is equal to zero 
} 
else if (j < i) 
{ 
     // Num is positive 
} 
else if (j > i) 
{ 
    // Num is negative 
} 

Answer 8

Per un intero con segno a 32 bit, come ad esempio System.Int32, alias int in C#:

bool isNegative = (num & (1 << 31)) != 0; 

Answer 9

Naturalmente nessuno è in realtà dato la risposta corretta,

num != 0 // num is positive *or* negative! 

Answer 10

public static bool IsPositive<T>(T value) 
     where T : struct, IComparable<T> 
    { 
     return value.CompareTo(default(T)) > 0; 
    } 

Answer 11

public static bool IsNegative<T>(T value) 
    where T : struct, IComparable<T> 
{ 
    return value.CompareTo(default(T)) < 0; 
} 

Answer 12

Devi solo confrontare se il valore & suo valore assoluto sono uguali: versione

if (value == Math.abs(value)) 
    return "Positif" 
else return "Negatif" 

Answer 13

nativa del programmatore. Il comportamento è corretto per i sistemi little-endian.

bool IsPositive(int number) 
{ 
    bool result = false; 
    IntPtr memory = IntPtr.Zero; 
    try 
    { 
     memory = Marshal.AllocHGlobal(4); 
     if (memory == IntPtr.Zero) 
      throw new OutOfMemoryException(); 

     Marshal.WriteInt32(memory, number); 

     result = Marshal.ReadByte(memory, 3) & 0x80 == 0; 
    } 
    finally 
    { 
     if (memory != IntPtr.Zero) 
      Marshal.FreeHGlobal(memory); 
    } 
} 

Non usarlo mai.

Answer 14

Questo è lo standard del settore:

int is_negative(float num) 
{ 
    char *p = (char*) malloc(20); 
    sprintf(p, "%f", num); 
    return p[0] == '-'; 
} 

Answer 15

bool isNegative(int n) { 
    int i; 
    for (i = 0; i <= Int32.MaxValue; i++) { 
    if (n == i) 
     return false; 
    } 
    return true; 
} 

Answer 16

Questo codice sfrutta le istruzioni SIMD per migliorare le prestazioni.

public static bool IsPositive(int n) 
{ 
    var v = new Vector<int>(n); 
    var result = Vector.GreaterThanAll(v, Vector<int>.Zero); 
    return result; 
}