Converti un numero positivo in negativo in C #

Puoi convertire un numero negativo in positivo in questo modo:

int myInt = System.Math.Abs(-5);

Esiste un metodo equivalente per rendere negativo un numero positivo?

Che ne dite di

myInt = myInt * -1

int myNegInt = System.Math.Abs(myNumber) * (-1);

int negInt = -System.Math.Abs(myInt)

Allo stesso modo in cui rendi qualsiasi altra cosa negativa: metti un segno negativo davanti.

var positive = 6;
var negative = -positive;

Nota a tutti coloro che hanno risposto

- Math.Abs(myInteger)

o

0 - Math.Abs(myInteger)

o

Math.Abs(myInteger) * -1

come un modo per mantenere negativi i numeri negativi e negativi quelli negativi.

Questo approccio ha un unico difetto. Non funziona per tutti i numeri interi. L'intervallo del Int32tipo è compreso tra "-2 ³¹ " e "2 ³¹ - 1." Significa che c'è un altro numero "negativo". Di conseguenza, Math.Abs(int.MinValue)genera un OverflowException.

Il modo corretto è utilizzare le istruzioni condizionali:

int neg = n < 0 ? n : -n;

Questo approccio funziona per "tutti" numeri interi.

Il modo semplice:

myInt *= -1;

int negInt = 0 - myInt;

O garantito per essere negativo.

int negInt = -System.Math.Abs(someInt);

Per cambiare il segno di un numero intero, basta usare l'operatore segno:

myInt = -myInt;

Per renderlo negativo indipendentemente dal fatto che il valore originale sia negativo o meno, devi prima utilizzare il metodo Abs:

myInt = -Math.Abs(myInt);

Solo per più divertimento:

int myInt = Math.Min(hisInt, -hisInt);

int myInt = -(int)Math.Sqrt(Math.Pow(Math.Sin(1), 2) + Math.Pow(Math.Cos(-1), 2))
            * Math.Abs(hisInt);

EDIT: Questo è sbagliato per gli input positivi ... Ho fatto l'errore di dimenticare che il resto dei bit in -x (valore del complemento 2s) è "opposto" al loro valore in + x, non è lo stesso. Quindi, semplicemente cambiando il bit di segno NON funzionerà per numeri positivi.

Lascio questo qui per dentro per scopi ...

O il modo complicato (penso) ...

int y = x | ~ Int.MaxValue;

cause int.MaxValue is 0111 1111 1111 1111 1111 1111 1111 1111

così

~int.MaxValue is      1000 0000 0000 0000 0000 0000 0000 0000

e quindi qualsiasi int32 Or'ed con quello metterà un 1 nel bit del segno, (rendendolo negativo), e lascerà tutti gli altri bit uguali ...

EDIT: in realtà, poiché 1000 0000 0000 0000 0000 0000 0000 0000 è in realtà il valore minimo, questo dovrebbe funzionare anche:

   int y = x | int.MinValue; // or, to do it to itself,
   x |= int.MinValue;

Anche se sono in ritardo alla festa qui, vado avanti con alcuni trucchi utili dai miei giorni hardware. Tutti questi assumono la rappresentazione complimento di 2 per i numeri firmati.

int negate = ~i+1;
int positiveMagnitude = (i ^ (i>>31)) - (i>>31);
int negativeMagnitude = (i>>31) - (i ^ (i>>31));

Solo per divertimento:

int negativeInt = int.Parse(String.Format("{0}{1}", 
    "-", positiveInt.ToString()));

Aggiornamento : il bello di questo approccio è che puoi facilmente trasformarlo in un generatore di eccezioni:

int negativeInt = int.Parse(String.Format("{0}{1}", 
    "thisisthedumbestquestioninstackoverflowhistory", positiveInt.ToString()));

Io uso myInt = -myInt;

Così semplice e facile

Se vuoi avere solo positivi

myInt = myInt>0 ? myInt : -myInt;

long negativeNumber = (long)positiveInt - (long)(int.MaxValue + 1);

Nessuno ha detto che doveva essere un numero negativo particolare .

Forse questo?

int n;

.... some coding....

n = n<=0? n:0-n;

int myInt = - System.Math.Abs(-5);

Moltiplicalo per -1.

Conversione di un numero da positivo a negativo o negativo a positivo:

public static decimal Reverse(this decimal source)
{
     return source * decimal.MinusOne;
}

Solo qualcosa che voglio condividere.

public decimal NumberReevaluate(decimal number, bool isPositive)
{
    var tempNumber = System.Math.Abs(number);
    return isPositive ? tempNumber : -tempNumber;
}

Come accennato in precedenza, moltiplicare solo per -1 non è interessante, come int.MinValue * -1 == int.MinValue

Dipende molto dalla tua applicazione, ma per i miei (invertire gli assi del joystick) voglio assicurarmi che tutti gli estremi siano ancora raggiungibili e mantenere la massima fedeltà possibile.
A tal fine, * -1
eseguo il mapping di Max <--> Min e tutto ciò che sta nel mezzo ottiene un Utilizzando questa tecnica, -32767 è irraggiungibile quando si inverte.

private static int Invert(int value) { if (value == int.MaxValue) return int.MinValue; if (value == int.MinValue) return int.MaxValue; return value * -1; }

Utilizzare binario e per rimuovere l'ultimo bit responsabile del segno negativo.

Oppure usa binario o per aggiungere un segno a un tipo di dati.

Questo soln può sembrare assurdo e incompleto, ma posso garantire che questo è il metodo più veloce.

Se non fai esperimenti con quello che ho pubblicato questo post può sembrare una schifezza: D

Ad esempio per int:

Int è un tipo di dati a 32 bit, quindi l'ultimo bit (32 °) determina il segno.

E con un valore che ha 0 al posto di 32 e riposo 1. Converte no negativo in + ve.

Per il contrario o con un valore con 1 al 32 ° posto e resto 0.

X=*-1potrebbe non funzionare su tutti i compilatori ... poiché legge un "moltiplicare" "SOTTRATTO" 1 anziché NEGATIVO Il migliore alt è X=(0-X), [CHE È DIFFEROSO X-=X]