Converta um número positivo em negativo em C #

Você pode converter um número negativo em positivo assim:

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

Existe um método equivalente para tornar um número positivo negativo?

E se

myInt = myInt * -1

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

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

Da mesma maneira que você torna qualquer outra coisa negativa: coloque um sinal negativo na frente.

var positive = 6;
var negative = -positive;

Nota para todos que responderam com

- Math.Abs(myInteger)

ou

0 - Math.Abs(myInteger)

ou

Math.Abs(myInteger) * -1

como uma maneira de manter números negativos negativos e tornar positivos números negativos.

Essa abordagem tem uma única falha. Não funciona para todos os números inteiros. O intervalo do Int32tipo é de "-2 ³¹ " a "2 ³¹ - 1." Isso significa que há mais um número "negativo". Consequentemente, Math.Abs(int.MinValue)lança um OverflowException.

A maneira correta é usar instruções condicionais:

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

Essa abordagem funciona para "todos" números inteiros.

O caminho fácil:

myInt *= -1;

int negInt = 0 - myInt;

Ou garantido para ser negativo.

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

Para mudar o sinal de um número inteiro, basta usar o operador de sinal:

myInt = -myInt;

Para torná-lo negativo, independentemente de o valor original ser negativo ou não, primeiro use o método Abs:

myInt = -Math.Abs(myInt);

Apenas para mais diversão:

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: Isso está errado para entradas positivas ... Eu cometi o erro de esquecer que o resto dos bits em -x (valor do complemento 2s) são o 'oposto' do seu valor em + x, não é o mesmo. Portanto, simplesmente alterar o bit do sinal NÃO funcionará para números positivos.

Vou deixar isso aqui para fins ...

Ou da maneira mais complicada (eu acho) ...

int y = x | ~ int.MaxValue;

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

tão

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

e, portanto, qualquer int32 Or'ed com isso colocará 1 no bit de sinal (tornando-o negativo) e deixará todos os outros bits iguais ...

EDIT: na verdade, como 1000 1000 0000 0000 0000 0000 0000 0000 0000 é realmente o Minvalue, isso também deve funcionar:

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

Mesmo que eu esteja muito atrasado para a festa aqui, vou falar com alguns truques úteis dos meus dias de hardware. Todos eles assumem a representação de elogio de 2 para números assinados.

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

Apenas por diversão:

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

Atualização : a beleza dessa abordagem é que você pode facilmente refatorá-la em um gerador de exceções:

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

eu uso myInt = -myInt;

Tão simples e fácil

Se você quer ter apenas positivo

myInt = myInt>0 ? myInt : -myInt;

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

Ninguém disse que tinha que haver um número negativo em particular .

Talvez isto?

int n;

.... some coding....

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

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

Multiplique por -1.

Convertendo um número de positivo para negativo ou negativo para positivo:

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

Apenas algo que eu quero compartilhar.

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

Como mencionado anteriormente, apenas multiplicar por -1 não é legal, pois int.MinValue * -1 == int.MinValue

Realmente depende da sua aplicação, mas para os meus (eixos de inversão do joystick), quero garantir que todos os extremos ainda sejam alcançáveis ​​e manter a maior fidelidade possível.
Para esse fim, * -1
mapeio Max <--> Min e tudo o que é intermediário recebe um. Usando esta técnica, -32767 é inacessível ao inverter.

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

Use binário e para remover o último bit responsável pelo sinal negativo.

Ou use binário ou para adicionar sinal a um tipo de dados.

Este soln pode parecer absurdo e incompleto, mas posso garantir que este é o método mais rápido.

Se você não experimentar o que eu publiquei, este post pode parecer uma porcaria: D

Por exemplo, para int:

Int é um tipo de dados de 32 bits, portanto o último bit (32º) determina o sinal.

E com um valor que tenha 0 no lugar 32 e resto 1. Ele converterá não negativo em + ve.

Pelo contrário ou com um valor com 1 no 32º lugar e descanse 0.

X=*-1pode não funcionar em todos os compiladores ... uma vez que lê um 'multiply' 'SUBTRACT' 1 em vez de NEGATIVE O melhor alt é X=(0-X), [QUAL É DIFERENTE DE X-=X]