Convertir un nombre positif en négatif en C #

Vous pouvez convertir un nombre négatif en positif comme ceci:

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

Existe-t-il une méthode équivalente pour rendre un nombre positif négatif?

Que diriez-vous

myInt = myInt * -1

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

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

De la même manière que vous rendez toute autre chose négative: mettez un signe négatif devant.

var positive = 6;
var negative = -positive;

Note à tous ceux qui ont répondu avec

- Math.Abs(myInteger)

ou

0 - Math.Abs(myInteger)

ou

Math.Abs(myInteger) * -1

comme moyen de garder les nombres négatifs négatifs et de transformer les positifs en négatifs.

Cette approche a un seul défaut. Cela ne fonctionne pas pour tous les entiers. La plage de Int32caractères va de "-2 ³¹ " à "2 ³¹ - 1". Cela signifie qu'il y a encore un nombre «négatif». Par conséquent, Math.Abs(int.MinValue)jette un fichier OverflowException.

La bonne façon est d'utiliser des instructions conditionnelles:

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

Cette approche fonctionne pour "tous" les entiers.

Le moyen le plus simple:

myInt *= -1;

int negInt = 0 - myInt;

Ou garanti négatif.

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

Pour changer le signe d'un entier, il vous suffit d'utiliser l'opérateur de signe:

myInt = -myInt;

Pour le rendre négatif, que la valeur d'origine soit négative ou non, utilisez d'abord la méthode Abs:

myInt = -Math.Abs(myInt);

Juste pour plus de plaisir:

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: C'est faux pour les entrées positives ... J'ai fait l'erreur d'oublier que le reste des bits en -x (2s-Complement value) sont à l'opposé de leur valeur en + x, pas les mêmes. Donc, changer simplement le bit de signe ne fonctionnera PAS pour les nombres positifs.

Je vais laisser ceci ici pour des raisons ...

Ou la manière délicate (je pense) ...

int y = x | ~ int.MaxValue;

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

alors

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

et donc tout int32 Or'ed avec qui mettra un 1 dans le bit de signe, (le rendant négatif), et laissera tous les autres bits identiques ...

EDIT: en fait, puisque le 1000 0000 0000 0000 0000 0000 0000 0000 est en fait la valeur minimale, cela devrait également fonctionner:

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

Même si je suis bien en retard à la fête ici, je vais ajouter quelques astuces utiles de mes jours de matériel. Tous ces éléments supposent la représentation complémentaire de 2 pour les nombres signés.

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

Juste pour le fun:

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

Mise à jour : la beauté de cette approche est que vous pouvez facilement la refactoriser en un générateur d'exceptions:

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

j'utilise myInt = -myInt;

Si simple et facile

Si vous ne voulez avoir que du positif

myInt = myInt>0 ? myInt : -myInt;

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

Personne n'a dit qu'il devait s'agir d' un nombre négatif particulier .

Peut être ça?

int n;

.... some coding....

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

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

Multipliez-le par -1.

Conversion d'un nombre de positif en négatif ou de négatif en positif:

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

Juste quelque chose que je veux partager.

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

Comme mentionné précédemment, multiplier simplement par -1 n'est pas cool, car int.MinValue * -1 == int.MinValue

Cela dépend vraiment de votre application, mais pour la mienne (Inverser les axes du joystick), je veux m'assurer que tous les extrêmes sont toujours accessibles et maintenir autant de fidélité que possible.
À cette fin, je mappe Max <--> Min et tout ce qui se trouve entre les deux obtient un. * -1
En utilisant cette technique, -32767 est inaccessible lors de l'inversion.

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

Utilisez binaire et pour supprimer le dernier bit responsable du signe négatif.

Ou utilisez binaire ou pour ajouter un signe à un type de données.

Cette solution peut sembler absurde et incomplète, mais je peux garantir que c'est la méthode la plus rapide.

Si vous n'expérimentez pas avec ce que j'ai publié, cet article peut sembler nul: D

Par exemple pour int:

Int est un type de données 32 bits donc le dernier bit (32e) détermine le signe.

Et avec une valeur qui a 0 à la place 32 et reste 1. Il convertira le non négatif en + ve.

Pour juste le contraire ou avec une valeur avec 1 à la 32e place et reste 0.

X=*-1peut ne pas fonctionner sur tous les compilateurs ... car il lit un 'multiplier' 'SUBTRACT' 1 au lieu de NÉGATIF ​​Le meilleur alt est X=(0-X), [WHICH IS DIFF FROM X-=X]