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

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

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

var positive = 6;
var negative = -positive;

вы просто используете оператор знака:

myInt = -myInt;

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

myInt = -Math.Abs(myInt);

int negInt = 0 - myInt;

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

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

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

int n;

.... some coding....

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

int.MinValue * -1 == int.MinValue

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

Для этого я сопоставляю Макса <-> Мин и все промежуточное получает* -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; }

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

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

льного в положительное:

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

Это неправильно для положительных входов ... Я сделал ошибку, забыв, что остальные биты в -x (значение 2s-Complement) являются 'напротив' их значения в + х, а не то же самое. ТАК, что просто изменение знакового бита НЕ будет работать для положительных чисел.

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

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

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 или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;

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

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

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

myInt = myInt>0 ? myInt : -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);

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

- Math.Abs(myInteger)

или же

0 - Math.Abs(myInteger)

или же

Math.Abs(myInteger) * -1

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

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

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

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

Этот подход работает для "все" integers.I»

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

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

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

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

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

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

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

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

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

myInt *= -1;

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

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

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

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

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

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

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

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

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

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