Konvertieren Sie eine positive Zahl in eine negative in C #

Sie können eine negative Zahl wie folgt in eine positive umwandeln:

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

Gibt es eine äquivalente Methode, um eine positive Zahl negativ zu machen?

Wie wäre es mit

myInt = myInt * -1

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

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

Genauso wie Sie alles andere negativ machen: Stellen Sie ein negatives Vorzeichen davor.

var positive = 6;
var negative = -positive;

Hinweis an alle, die mit geantwortet haben

- Math.Abs(myInteger)

oder

0 - Math.Abs(myInteger)

oder

Math.Abs(myInteger) * -1

um negative Zahlen negativ zu halten und positive negativ zu machen.

Dieser Ansatz hat einen einzigen Fehler. Es funktioniert nicht für alle ganzen Zahlen. Der Typbereich reicht Int32von "-2 ³¹ " bis "2 ³¹ - 1". Es bedeutet, dass es noch eine "negative" Zahl gibt. Folglich Math.Abs(int.MinValue)wirft ein OverflowException.

Der richtige Weg ist, bedingte Anweisungen zu verwenden:

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

Dieser Ansatz funktioniert für "alle" Ganzzahlen.

Der einfache Weg:

myInt *= -1;

int negInt = 0 - myInt;

Oder garantiert negativ.

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

Um das Vorzeichen einer Ganzzahl zu wechseln, verwenden Sie einfach den Vorzeichenoperator:

myInt = -myInt;

Um es negativ zu machen, unabhängig davon, ob der ursprüngliche Wert negativ ist oder nicht, verwenden Sie zuerst die Abs-Methode:

myInt = -Math.Abs(myInt);

Nur für mehr Spaß:

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: Dies ist falsch für positive Eingaben ... Ich habe fälschlicherweise vergessen, dass die restlichen Bits in -x (2s-Complement-Wert) das "Gegenteil" ihres Wertes in + x sind, nicht dasselbe. Das einfache Ändern des Vorzeichenbits funktioniert also NICHT für positive Zahlen.

Ich werde dies hier für Zwecke lassen ...

Oder der knifflige Weg (glaube ich) ...

int y = x | ~ int.MaxValue;

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

so

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

und deshalb setzt jedes int32 Or'ed damit eine 1 in das Vorzeichenbit (was es negativ macht) und lässt alle anderen Bits gleich ...

EDIT: eigentlich, da der 1000 0000 0000 0000 0000 0000 0000 0000 tatsächlich der Minvalue ist, sollte dies auch funktionieren:

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

Obwohl ich hier viel zu spät zur Party komme, werde ich mich mit einigen nützlichen Tricks aus meiner Hardware-Zeit einmischen. Alle diese setzen die Komplimentdarstellung von 2 für signierte Nummern voraus.

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

Nur zum Spaß:

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

Update : Das Schöne an diesem Ansatz ist, dass Sie ihn einfach in einen Ausnahmegenerator umgestalten können:

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

ich benutze myInt = -myInt;

So einfach und leicht

Wenn Sie nur positiv haben wollen

myInt = myInt>0 ? myInt : -myInt;

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

Niemand sagte, es müsse eine bestimmte negative Zahl sein.

Vielleicht das?

int n;

.... some coding....

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

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

Multiplizieren Sie es mit -1.

Konvertieren einer Zahl von positiv in negativ oder von negativ in positiv:

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

Nur etwas, das ich teilen möchte.

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

Wie bereits erwähnt, ist es nicht cool, nur mit -1 zu multiplizieren int.MinValue * -1 == int.MinValue

Es hängt wirklich von Ihrer Anwendung ab, aber für meine (Invertierende Joystick-Achsen) möchte ich sicherstellen, dass alle Extreme noch erreichbar sind und so genau wie möglich bleiben.
Zu diesem Zweck * -1
ordne ich Max <--> Min zu und alles dazwischen erhält ein. Mit dieser Technik ist -32767 beim Invertieren nicht erreichbar.

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

Verwenden Sie binär und, um das letzte Bit zu entfernen, das für das negative Vorzeichen verantwortlich ist.

Oder verwenden Sie binär oder um einem Datentyp ein Vorzeichen hinzuzufügen.

Diese Lösung mag absurd und unvollständig klingen, aber ich kann garantieren, dass dies die schnellste Methode ist.

Wenn Sie nicht mit dem experimentieren, was ich gepostet habe, sieht dieser Beitrag möglicherweise beschissen aus: D.

ZB für int:

Int ist ein 32-Bit-Datentyp, daher bestimmt das letzte Bit (32.) das Vorzeichen.

Und mit einem Wert, der 0 an der Stelle 32 und Rest 1 hat. Er wandelt das negative Nein in + ve um.

Für genau das Gegenteil oder mit einem Wert mit 1 auf Platz 32 und Rest 0.

X=*-1funktioniert möglicherweise nicht auf allen Compilern ... da es ein 'multiplizieren' 'SUBTRACT' 1 anstelle von NEGATIVE liest. Das bessere alt ist X=(0-X), [WAS IST DIFF VON X-=X]