Почему для чисел со знаком предпочитают два дополнения над знаком и величиной?

Мне просто любопытно, есть ли причина, по которой для представления -1 в двоичном виде используется дополнение до двух: переключение битов и добавление 1?

-1 представлен 11111111 (дополнение к двум), а не (для меня более интуитивно понятным) 10000001, который является двоичным 1 с первым битом в качестве отрицательного флага.

Отказ от ответственности: я не полагаюсь на двоичную арифметику для моей работы!

Это сделано для того, чтобы сложение не нуждалось в специальной логике для работы с отрицательными числами. Проверьте статью в Википедии .

Скажем, у вас есть два числа, 2 и -1. В вашем «интуитивном» способе представления чисел они были бы 0010и 1001, соответственно (я придерживаюсь размера 4 бита). В дополнение друг к другу, они есть 0010и 1111. Теперь, допустим, я хочу добавить их.

Дополнение дополнения двух очень просто. Вы обычно добавляете числа, и любой бит переноса в конце отбрасывается. Поэтому они добавлены следующим образом:

  0010
+ 1111
=10001
= 0001 (discard the carry)

0001 равен 1, что является ожидаемым результатом "2 + (- 1)".

Но в вашем «интуитивном» методе добавление сложнее:

  0010
+ 1001
= 1011

Какой -3, верно? Простое дополнение не работает в этом случае. Вы должны отметить, что одно из чисел является отрицательным и использовать другой алгоритм, если это так.

Для этого «интуитивного» метода хранения вычитание - это операция, отличная от сложения, требующая дополнительных проверок чисел перед их добавлением. Поскольку вы хотите, чтобы основные операции (сложение, вычитание и т. Д.) Выполнялись как можно быстрее, вам нужно хранить числа таким образом, чтобы вы могли использовать самые простые алгоритмы.

Кроме того, в «интуитивном» методе хранения есть два нуля:

0000  "zero"
1000  "negative zero"

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

Есть еще один бонус с хранением целых значений таким образом, и именно тогда вам нужно увеличить ширину регистра, в котором хранится значение. С дополнением к двум, сохранение 4-битного числа в 8-битном регистре является вопросом повторения его самый важный бит:

    0001 (one, in four bits)
00000001 (one, in eight bits)
    1110 (negative two, in four bits)
11111110 (negative two, in eight bits)

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

При использовании вашего метода вам необходимо очистить существующий бит, который является дополнительной операцией в дополнение к заполнению:

    0001 (one, in four bits)
00000001 (one, in eight bits)
    1010 (negative two, in four bits)
10000010 (negative two, in eight bits)

Вам все еще нужно установить эти дополнительные 4 бита в обоих случаях, но в «интуитивном» случае вам также необходимо очистить 5-й бит. Это один крошечный дополнительный шаг в одной из самых фундаментальных и распространенных операций, присутствующих в каждом приложении.

Википедия говорит все это:

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

Другими словами, добавление одинаково, независимо от того, является ли число отрицательным.

Хотя этот вопрос старый, позвольте мне поставить свои 2 цента.

Прежде чем я объясню это, давайте вернемся к основам. 2 'дополнение - 1 дополнение + 1. Теперь, что такое дополнение 1 и каково его значение в дополнение.

Сумма любого n-битного числа и его дополнения 1 дает вам максимально возможное число, которое может быть представлено этими n-битами. Пример:

 0010 (2 in 4 bit system)
+1101 (1's complement of 2)
___________________________
 1111  (the highest number that we can represent by 4 bits)

Что будет, если мы попытаемся добавить еще 1 к результату. Это приведет к переполнению.

Результат будет 1 0000равен 0 (так как мы работаем с 4-битными числами (1 слева - переполнение)

Так ,

Any n-bit number + its 1's complement = max n-bit number
Any n-bit number + its 1'complement + 1 = 0 ( as explained above, overflow will occur as we are adding 1 to max n-bit number)

Затем кто-то решил назвать дополнение 1 + 1 как дополнение 2. Таким образом, вышеприведенное утверждение становится следующим: любое n-битное число + его дополнение 2 = 0, что означает дополнение 2 числа = - (этого числа)

Все это приводит к еще одному вопросу: почему мы можем использовать только (n-1) из n битов для представления положительного числа и почему самый левый n-й бит представляет знак (0 на крайнем левом бите означает + ve число, а 1 означает -вый номер). например, почему мы используем только первые 31 бит типа int в java для представления положительного числа, если 32-й бит равен 1, то есть -ve.

 1100 (lets assume 12 in 4 bit system)
+0100(2's complement of 12)
___________________________

1 0000 (результат равен нулю, переполнение переноса 1)

Таким образом, система (n + 2'полнение n) = 0 все еще работает. Единственная двусмысленность здесь состоит в том, что дополнение 2 к 12 равно 0100, что также неоднозначно представляет +8, кроме представления -12 в системе дополнения 2s.

Эта проблема будет решена, если положительные числа всегда имеют 0 в левом крайнем углу. В этом случае их дополнение 2 всегда будет иметь 1 в левом крайнем бите, и мы не будем иметь неоднозначность того же набора битов, представляющих номер дополнения 2, а также номер + ve.

Дополнение Two позволяет сложению и вычитанию выполняться обычным образом (например, для чисел без знака). Он также предотвращает -0 (отдельный способ представления 0, который не будет равен 0 при обычном побитовом методе сравнения чисел).

это для упрощения сумм и разностей чисел. сумма отрицательного числа и положительного числа, кодифицированного в 2-х дополнениях, равна сумме их обычного суммирования.

Обычная реализация операции - «перевернуть биты и добавить 1», но есть другой способ определить его, который, вероятно, делает обоснование более ясным. Дополнение 2 - это форма, которую вы получите, если взять обычное представление без знака, где каждый бит контролирует следующую степень 2, и просто сделать наиболее значимый член отрицательным.

Принимая 8-битное значение a ₇ a ₆ a ₅ a ₄ a ₃ a ₂ a ₁ a ₀

Обычная двоичная интерпретация без знака:
2 ⁷ * a ₇ + 2 ⁶ * a ₆ + 2 ⁵ * a ₅ + 2 ⁴ * a ₄ + 2 ³ * a ₃ + 2 ² * a ₂ + 2 ¹ * a ₁ + 2 ⁰ * a ₀
11111111 = 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255

Интерпретация двух дополнений:
-2 ⁷ * a ₇ + 2 ⁶ * a ₆ + 2 ⁵ * a ₅ + 2 ⁴ * a ₄ + 2 ³ * a ₃ + 2 ² * a ₂ + 2 ¹ * a ₁ + 2 ⁰ * a ₀
11111111 = -128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = -1

Ни один из других битов не меняет значения вообще, и перенос в ₇ является «переполнением» и не должен работать, так что почти все арифметические операции работают без изменений (как отметили другие). Величина знака обычно проверяет бит знака и использует другую логику.

Дополнение Two позволяет добавлять отрицательные и положительные числа без какой-либо специальной логики.

Если вы попытались добавить 1 и -1, используя ваш метод
10000001 (-1)
+00000001 (1),
вы получите
10000010 (-2)

Вместо этого, используя два дополнения, мы можем добавить

11111111 (-1)
+00000001 (1) вы получите
00000000 (0)

То же самое относится и к вычитанию.

Кроме того, если вы попытаетесь вычесть 4 из 6 (два положительных числа), вы можете дополнить 2 до 4 и сложить их вместе 6 + (-4) = 6 - 4 = 2

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

Чтобы расширить на другие ответы:

В двух дополнениях

• Добавление является тем же механизмом, что и добавление простых положительных целых чисел.
• Вычитание тоже не меняется
• Умножение тоже!

Деление требует другого механизма.

Все это верно, потому что дополнение к двум - это просто нормальная модульная арифметика, где мы выбираем смотреть на некоторые числа как отрицательные, вычитая по модулю.

Читая ответы на этот вопрос, я наткнулся на этот комментарий [отредактировано].

Дополнение 2 к 0100 (4) будет 1100. Теперь 1100 - это 12, если я скажу нормально. Итак, когда я говорю нормальное 1100, тогда это 12, но когда я говорю, что 2 дополняют 1100, тогда это -4? Кроме того, в Java, когда хранится 1100 (предположим, что на данный момент 4 бита), то как определяется, что это +12 или -4 ?? - Хагравал 2 июля в 16:53

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

ВОПРОС - Как система может установить, как один или несколько смежных байтов должны интерпретироваться? В частности, как система может установить, является ли данная последовательность байтов простым двоичным числом или номером дополнения 2?

ОТВЕТ - Система устанавливает, как интерпретировать последовательность байтов через типы. Типы определяют

• сколько байтов нужно учитывать
• как эти байты должны быть интерпретированы

ПРИМЕР - Ниже мы предполагаем, что

• charдлиной 1 байт
• shortдлиной 2 байта
• ints и floats длиной 4 байта

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

Прежде всего, мы определяем массив, содержащий 4 байта, и инициализируем их все двоичным числом 10111101, соответствующим шестнадцатеричному числу BD.

// BD(hexadecimal) = 10111101 (binary)
unsigned char   l_Just4Bytes[ 4 ]   =   { 0xBD, 0xBD, 0xBD, 0xBD };

Затем мы читаем содержимое массива, используя разные типы.

unsigned char и signed char

// 10111101 as a PLAIN BINARY number equals 189
printf( "l_Just4Bytes as unsigned char  -> %hi\n", *( ( unsigned char* )l_Just4Bytes ) );

// 10111101 as a 2'S COMPLEMENT number equals -67
printf( "l_Just4Bytes as signed char    -> %i\n", *( ( signed char* )l_Just4Bytes ) );

unsigned short и short

// 1011110110111101 as a PLAIN BINARY number equals 48573
printf( "l_Just4Bytes as unsigned short -> %hu\n", *( ( unsigned short* )l_Just4Bytes ) );

// 1011110110111101 as a 2'S COMPLEMENT number equals -16963
printf( "l_Just4Bytes as short          -> %hi\n", *( ( short* )l_Just4Bytes ) );

unsigned int, intиfloat

// 10111101101111011011110110111101 as a PLAIN BINARY number equals 3183328701
printf( "l_Just4Bytes as unsigned int   -> %u\n", *( ( unsigned int* )l_Just4Bytes ) );

// 10111101101111011011110110111101 as a 2'S COMPLEMENT number equals -1111638595
printf( "l_Just4Bytes as int            -> %i\n", *( ( int* )l_Just4Bytes ) );

// 10111101101111011011110110111101 as a IEEE 754 SINGLE-PRECISION number equals -0.092647
printf( "l_Just4Bytes as float          -> %f\n", *( ( float* )l_Just4Bytes ) );

4 байта в оперативной памяти (l_Just4Bytes[ 0..3 ] ) всегда остаются одинаковыми. Единственное, что меняется, это то, как мы их интерпретируем.

Опять же, мы говорим системе, как интерпретировать их через типы .

Например, выше мы использовали следующие типы для интерпретации содержимого l_Just4Bytesмассива

• unsigned char: 1 байт в простом двоичном
• signed char: 1 байт в 2-х дополнениях
• unsigned short: 2 байта в простой двоичной записи
• short: 2 байта в дополнении 2
• unsigned int: 4 байта в простой двоичной записи
• int: 4 байта в дополнении 2
• float: 4 байта в нотации IEEE 754 с одинарной точностью

[EDIT] Это сообщение было отредактировано после комментария user4581301. Спасибо, что нашли время, чтобы отбросить эти несколько полезных строк!

Вы можете посмотреть, как профессор Джерри Кейн из Стэнфорда объясняет их дополнение во второй лекции (объяснение относительно дополнения 2 начинается около 13:00) в серии лекций под названием «Парадигмы программирования», доступных для просмотра на канале Standford на YouTube. Вот ссылка на серию лекций: http://www.youtube.com/view_play_list?p=9D558D49CA734A02 .

Дополнение Two используется потому, что его проще реализовать в схемах, а также не допускает отрицательный ноль.

Если есть x битов, два дополнения будут в диапазоне от + (2 ^ x / 2 + 1) до - (2 ^ x / 2). Его дополнение будет работать от + (2 ^ x / 2) до - (2 ^ x / 2), но разрешит отрицательный ноль (0000 равно 1000 в системе дополнения 4 бита 1).

Ну, на самом деле ваше намерение не в том, чтобы обратить все биты вашего двоичного числа. Фактически вычитать каждую цифру из 1. Это просто удачное совпадение, что вычитание 1 из 1 приводит к 0, а вычитание 0 из 1 - 1. Таким образом, переворачивание битов эффективно выполняет это вычитание.

Но почему вы находите разницу каждой цифры от 1? Ну, нет. Ваше реальное намерение - вычислить разницу данного двоичного числа от другого двоичного числа, которое имеет такое же количество цифр, но содержит только 1. Например, если ваш номер 10110001, когда вы переворачиваете все эти биты, вы эффективно вычисляете (11111111 - 10110001).

Это объясняет первый шаг в вычислении дополнения двух. Теперь давайте включим второй шаг - добавление 1 - также на картинке.

Добавьте 1 к приведенному выше двоичному уравнению:

11111111 - 10110001 + 1

Что вы получаете? Это:

100000000 - 10110001

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

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

Мы выполняем только операции сложения как для сложения, так и для вычитания. Мы добавляем второй операнд к первому операнду для добавления. Для вычитания мы добавляем дополнение 2 второго операнда к первому операнду.

С представлением дополнения в 2 нам не нужны отдельные цифровые компоненты для вычитания - используются только сумматоры и дополнители.

Стоит отметить, что на некоторых ранних машинах добавления, до дней цифровых компьютеров, вычитание выполнялось, когда оператор вводил значения, используя разные цветные условные обозначения для каждой клавиши (так, чтобы каждая клавиша вводила девять минус число, которое будет вычесть), и нажмите специальную кнопку, будет принимать перенос в расчет. Таким образом, на шестизначном компьютере, чтобы вычесть 1234 из значения, оператор нажимал бы на клавиши, которые обычно указывали бы «998,765», и нажимал кнопку, чтобы добавить это значение плюс один к текущему вычислению. Арифметика дополнения двух - это просто двоичный эквивалент этой ранней арифметики «дополнения десятки».

Преимущество выполнения вычитания методом дополнения заключается в уменьшении
сложности аппаратного обеспечения. Нет необходимости в разных цифровых схемах для сложения и вычитания. Оба сложения и вычитания выполняются только сумматором.

Основное преимущество представления с двумя дополнительными числами, которое здесь еще не было упомянуто, состоит в том, что младшие биты суммы, разности или произведения с двумя дополнительными дополнениями зависят только от соответствующих битов операндов. Причина того, что 8-битное значение со знаком для -1 состоит в 11111111том, что вычитание любого целого числа, чьи младшие 8 битов получены 00000001из любого другого целого числа, чьи младшие 8 битов 0000000будут, даст целое число, чьи младшие 8 битов равны11111111, Математически, значение -1 будет бесконечной строкой из 1, но все значения в пределах диапазона определенного целочисленного типа будут либо всеми 1, либо всеми 0 после определенной точки, поэтому компьютерам удобно "расширять знак" старший значащий бит числа, как если бы он представлял собой бесконечное число единиц или нулей.

Дополнение Two - это почти единственное представление числа со знаком, которое хорошо работает при работе с типами, превышающими естественный размер слова двоичной машины, поскольку при выполнении сложения или вычитания код может извлекать наименьшую порцию каждого операнда, вычисляя наименьшую порцию результат и сохраните его, затем загрузите следующий фрагмент каждого операнда, вычислите следующий фрагмент результата, сохраните его и т. д. Таким образом, даже процессор, который требует, чтобы все сложения и вычитания проходили через один 8-битный регистр может обрабатывать 32-разрядные числа со знаком достаточно эффективно (медленнее, чем с 32-разрядным регистром, конечно, но все же работоспособно).

При использовании любых других представлений со знаком, разрешенных Стандартом C, каждый бит результата может потенциально зависеть от любого бита операндов, что делает необходимым либо хранить целое значение в регистрах сразу, либо выполнять последующие вычисления с дополнительными шаг, который, по крайней мере, в некоторых случаях потребует чтения, изменения и перезаписи каждого фрагмента результата.

Существуют различные типы представлений:

1. представление числа без знака
2. представление числа с подписью
3. свое дополняющее представление
4. Дополняющее представление двух

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

Представление чисел со знаком используется для представления положительного, а также отрицательного числа. В представлении числа со знаком MSB бит представляет собой знаковый бит, а остальные биты представляют число. Когда MSB равен 0, это означает, что число положительное, а когда MSB равно 1, это означает, что число является отрицательным.

Проблема с представлением чисел со знаком состоит в том, что есть два значения для 0.

Проблема с представлением дополнения состоит в том, что есть два значения для 0.

Но если мы используем представление дополнения Two, тогда будет только одно значение для 0, поэтому мы представляем отрицательные числа в форме дополнения к двум.

Источник: почему отрицательные числа хранятся в двух дополнительных байтах в гигабайтах

Один из удовлетворительных ответов о том, почему Дополнение Two2 используется для представления отрицательных чисел, а не системы Дополнения One, состоит в том, что система Дополнения Two решает проблему множественных представлений 0 и необходимость сквозного переноса, которые существуют в системе дополнения One для представления отрицательных чисел. номера.

Для получения дополнительной информации посетите https://en.wikipedia.org/wiki/Signed_number_representations

Для сквозного переноса Посетите https://en.wikipedia.org/wiki/End-around_carry