Преобразовать положительное число в отрицательное в C #

Вы можете преобразовать отрицательное число в положительное, например так:

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

Есть ли эквивалентный способ сделать положительное число отрицательным?

Как насчет

myInt = myInt * -1

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

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

Точно так же, как вы делаете все остальное отрицательным: поставьте перед ним отрицательный знак.

var positive = 6;
var negative = -positive;

Примечание для всех, кто ответил

- Math.Abs(myInteger)

или

0 - Math.Abs(myInteger)

или

Math.Abs(myInteger) * -1

как способ сохранить отрицательные числа отрицательными и превратить положительные в отрицательные.

У этого подхода есть один недостаток. Это не работает для всех целых чисел. Диапазон Int32типа от «-2 ³¹ » до «2 ³¹ - 1». Это означает, что есть еще одно «отрицательное» число. Следовательно, Math.Abs(int.MinValue)выбрасывает OverflowException.

Правильный способ заключается в использовании условных операторов:

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

Этот подход работает для "всех" целых чисел.

Простой способ:

myInt *= -1;

int negInt = 0 - myInt;

Или гарантированно будет отрицательным.

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

Чтобы переключить знак целого числа, вы просто используете оператор знака:

myInt = -myInt;

Чтобы сделать его отрицательным независимо от того, является ли исходное значение отрицательным или нет, вы сначала используете метод Abs:

myInt = -Math.Abs(myInt);

Просто для удовольствия:

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

РЕДАКТИРОВАТЬ: Это неправильно для положительных входов ... Я сделал ошибку, забыв, что остальные биты в -x (значение 2s-Complement) являются «противоположными» их значения в + x, а не то же самое. Поэтому простое изменение знака не будет работать для положительных чисел.

Я оставлю это здесь для целей ...

Или хитрый способ (я думаю) ...

int y = x | ~ Int.MaxValue;

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

так

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

и поэтому любой int32 Or'ed с этим установит 1 в бит знака (делая его отрицательным) и оставит все остальные биты такими же ...

РЕДАКТИРОВАТЬ: на самом деле, так как 1000 0000 0000 0000 0000 0000 0000 0000 на самом деле Minvalue, это также должно работать:

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

Несмотря на то, что я опаздываю на вечеринку здесь, я собираюсь присоединиться к некоторым полезным трюкам из моих аппаратных дней. Все они предполагают 2 комплимента для подписанных номеров.

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

Просто для удовольствия:

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

Обновление : прелесть этого подхода в том, что вы можете легко преобразовать его в генератор исключений:

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

я использую myInt = -myInt;

Так просто и легко

Если хочешь иметь только позитив

myInt = myInt>0 ? myInt : -myInt;

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

Никто не сказал, что это должно быть какое-то конкретное отрицательное число.

Может быть, это?

int n;

.... some coding....

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

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

Умножьте это на -1.

Преобразование числа из положительного в отрицательное или из отрицательного в положительное:

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

Просто то, чем я хочу поделиться.

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

Как упоминалось ранее, просто умножить на -1 не круто, так как int.MinValue * -1 == int.MinValue

Это действительно зависит от вашего приложения, но для моего (инвертирование осей джойстика) я хочу убедиться, что все крайности все еще достижимы, и поддерживать как можно большую точность.
С этой целью я сопоставляю Max <-> Min, и все промежуточное значение получает * -1
Использование этой техники, -32767 недоступно при инвертировании.

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

Используйте двоичный файл и удалите последний бит, который отвечает за отрицательный знак.

Или используйте двоичный файл или добавьте знак к типу данных.

Это решение может показаться абсурдным и неполным, но я могу гарантировать, что это самый быстрый метод.

Если вы не экспериментируете с тем, что я опубликовал, этот пост может выглядеть чушью: D

Например, для int:

Int - это 32-битный тип данных, поэтому последний бит (32-й) определяет знак.

И со значением, которое имеет 0 в 32 месте и остальное 1. Это преобразует отрицательное нет в + ve.

Для противоположного или со значением с 1 на 32 месте и отдыха 0.

X=*-1может работать не на всех компиляторах ... так как он читает 'SUBTRACT' 1 умножить вместо NEGATIVE. Чем лучше X=(0-X), тем [ЧТО ОТЛИЧАЕТСЯ ОТ X-=X]