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 faites quelque chose de négatif: 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 les rendre négatifs.

Cette approche a un seul défaut. Cela ne fonctionne pas pour tous les entiers. La plage du type Int32 est comprise entre “-2 31 ” et “2 31 – 1.” Cela signifie qu’il y a un autre nombre “négatif”. Par conséquent, Math.Abs(int.MinValue) génère une Math.Abs(int.MinValue) OverflowException .

La manière correcte consiste à utiliser des instructions conditionnelles:

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

Cette approche fonctionne pour "tous" les entiers.

Le moyen facile:

 myInt *= -1; 
 int negInt = 0 - myInt; 

Ou garanti d’être négatif.

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

Pour changer le signe d’un entier, il 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, vous devez d’abord utiliser la méthode Abs:

 myInt = -Math.Abs(myInt); 

EDIT: Ceci est faux pour les entrées positives … J’ai commis une erreur en oubliant que le rest des bits dans -x (valeur 2s-Complement) est le contraire de leur valeur dans + x, pas la même chose. Tout simplement changer le bit de signe ne fonctionnera pas pour les nombres positifs.

Je vais laisser cela ici pour des fins …

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, comme le 1000 0000 0000 0000 0000 0000 0000 0000 est en fait la Minvalue, cela devrait aussi fonctionner:

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

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); 

Juste pour le fun:

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

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

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

Même si je suis en retard à la fête ici, je vais vous donner quelques astuces utiles de mes jours de matériel. Tous ceux-ci assument la représentation complémentaire de 2 pour les numéros signés.

 int negate = ~i+1; int positiveMagnitude = (i ^ (i>>31)) - (i>>31); int negativeMagnitude = (i>>31) - (i ^ (i>>31)); 
 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); 

J’utilise myInt = -myInt;

Si simple et facile

Si vous voulez avoir seulement positif

 myInt = myInt>0 ? myInt : -myInt; 

Multipliez-le par -1.

Le moyen le plus simple a = -a fera la faveur

Convertir un nombre de positif à négatif, ou négatif à 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, il ne suffit pas de multiplier par -1, car int.MinValue * -1 == int.MinValue

Cela dépend vraiment de votre application, mais pour la mienne (Inversion des axes du joystick), je veux m’assurer que tous les extrêmes sont toujours accessibles et conserver 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; }

X=*-1 peut ne pas fonctionner sur tous les compilateurs … car il lit un ‘SUBTRACT’ ‘multiplie’ au lieu de NEGATIF ​​Le meilleur alt est X=(0-X) ,

Utilisez binary et supprimez le dernier bit responsable du signe négatif.

Ou utilisez des fichiers binarys ou pour append un signe à un type de données.

Cette soln peut paraître absurde et incomplète mais je peux vous garantir que c’est la méthode la plus rapide.

Si vous n’essayez pas avec ce que j’ai posté ce post peut sembler merdique: D

Par exemple pour int:

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

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

Pour le contraire ou avec une valeur avec 1 à la 32ème place et rest 0.