Convierta un número positivo a negativo en C #

Puede convertir un número negativo a positivo de esta manera:

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

¿Existe un método equivalente para hacer que un número positivo sea negativo?

Qué tal si

myInt = myInt * -1

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

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

De la misma manera que haces cualquier otra cosa negativa: pon un signo negativo delante de ella.

var positive = 6;
var negative = -positive;

Nota para todos los que respondieron con

- Math.Abs(myInteger)

o

0 - Math.Abs(myInteger)

o

Math.Abs(myInteger) * -1

como una forma de mantener los números negativos negativos y convertir los positivos en negativos.

Este enfoque tiene un solo defecto. No funciona para todos los enteros. El rango de Int32tipo es de "-2 ³¹ " a "2 ³¹ - 1." Significa que hay un número "negativo" más. En consecuencia, Math.Abs(int.MinValue)lanza un OverflowException.

La forma correcta es usar declaraciones condicionales:

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

Este enfoque funciona para "todos" los enteros.

La manera fácil:

myInt *= -1;

int negInt = 0 - myInt;

O garantizado para ser negativo.

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

Para cambiar el signo de un entero, solo usa el operador de signo:

myInt = -myInt;

Para hacerlo negativo independientemente de si el valor original es negativo o no, primero use el método Abs:

myInt = -Math.Abs(myInt);

Solo por más diversión:

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

EDITAR: Esto es incorrecto para entradas positivas ... Cometí el error de olvidar que el resto de los bits en -x (valor 2s-Complemento) son el 'opuesto' de su valor en + x, no es lo mismo. Entonces, simplemente cambiar el bit de signo NO funcionará para números positivos.

Dejaré esto aquí para fines ...

O la forma complicada (creo) ...

int y = x | ~ int.MaxValue;

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

entonces

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

y, por lo tanto, cualquier int32 Or'ed con eso pondrá un 1 en el bit de signo (haciéndolo negativo) y dejará todos los demás bits iguales ...

EDITAR: en realidad, dado que 1000 0000 0000 0000 0000 0000 0000 0000 es en realidad el Minvalue, esto también debería funcionar:

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

Aunque llego tarde a la fiesta aquí, voy a intervenir con algunos trucos útiles de mis días de hardware. Todos estos asumen la representación del cumplido de 2 para los números con signo.

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

Solo por diversión:

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

Actualización : la belleza de este enfoque es que puede refactorizarlo fácilmente en un generador de excepciones:

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

yo suelo myInt = -myInt;

Tan simple y fácil

Si quieres tener solo positivo

myInt = myInt>0 ? myInt : -myInt;

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

Nadie dijo que tenía que ser un número negativo en particular .

¿Tal vez esto?

int n;

.... some coding....

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

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

Multiplícalo por -1.

Convertir un número de positivo a negativo, o negativo a positivo:

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

Solo algo que quiero compartir.

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

Como se mencionó anteriormente, simplemente multiplicar por -1 no es genial, ya que int.MinValue * -1 == int.MinValue

Realmente depende de su aplicación, pero para el mío (Invertir los ejes de Joystick) quiero asegurarme de que todos los extremos aún sean alcanzables y mantener la mayor fidelidad posible.
Con este fin, mapeo Max <--> Min y todo lo que está en el medio obtiene un * -1
Uso de esta técnica, -32767 es inalcanzable al invertir.

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

Use binario y para eliminar el último bit responsable del signo negativo.

O use binario o para agregar signos a un tipo de datos.

Esta solución puede sonar absurda e incompleta, pero puedo garantizar que este es el método más rápido.

Si no experimentas con lo que he publicado esta publicación puede parecer una mierda: D

Por ejemplo, para int:

Int es un tipo de datos de 32 bits, por lo que el último bit (el número 32) determina el signo.

Y con un valor que tiene 0 en el lugar 32 y resto 1. Convertirá no negativo a + ve.

Por el contrario o con un valor con 1 en el lugar 32 y resto 0.

X=*-1es posible que no funcione en todos los compiladores ... ya que lee un 'sustrato' multiplicado '1 en lugar de NEGATIVO. La mejor alternativa es X=(0-X), [QUE ES DIFERENTE X-=X]