Логический элемент исключающее или

Эквивалентность, введение и устранение

Исключительная дизъюнкция , или J pq , может быть выражена в терминах конъюнкции («и логического», ), дизъюнкции («или логического», ) и логического отрицания ( ) следующим образом:
п⊕q{\ displaystyle p \ oplus q}∧{\ Displaystyle \ клин}∨{\ displaystyle \ lor}¬{\ Displaystyle \ lnot}

п⊕qзнак равно(п∨q)∧¬(п∧q){\ displaystyle {\ begin {matrix} p \ oplus q & = & (p \ lor q) \ land \ lnot (p \ land q) \ end {matrix}}}

Исключительную дизъюнкцию также можно сформулировать следующим образом:

п⊕q{\ displaystyle p \ oplus q}

п⊕qзнак равно(п∧¬q)∨(¬п∧q){\ displaystyle {\ begin {matrix} p \ oplus q & = & (p \ land \ lnot q) \ lor (\ lnot p \ land q) \ end {matrix}}}

Такое представление XOR может быть полезно при построении схемы или сети, потому что оно имеет только одну операцию и небольшое количество операций и . Доказательство этой идентичности приведено ниже:
¬{\ Displaystyle \ lnot}∧{\ Displaystyle \ клин}∨{\ displaystyle \ lor}

п⊕qзнак равно(п∧¬q)∨(¬п∧q)знак равно((п∧¬q)∨¬п)∧((п∧¬q)∨q)знак равно((п∨¬п)∧(¬q∨¬п))∧((п∨q)∧(¬q∨q))знак равно(¬п∨¬q)∧(п∨q)знак равно¬(п∧q)∧(п∨q){\ displaystyle {\ begin {matrix} p \ oplus q & = & (p \ land \ lnot q) & \ lor & (\ lnot p \ land q) \\ & = & ((p \ land \ lnot q) \ lor \ lnot p) & \ land & ((p \ land \ lnot q) \ lor q) \\ & = & ((p \ lor \ lnot p) \ land (\ lnot q \ lor \ lnot p)) & \ land & ((p \ lor q) \ land (\ lnot q \ lor q)) \\ & = & (\ lnot p \ lor \ lnot q) & \ land & (p \ lor q) \\ & = & \ lnot (p \ land q) & \ land & (p \ lor q) \ end {matrix}}}Иногда полезно отметить следующее:п⊕q{\ displaystyle p \ oplus q}
п⊕qзнак равно¬((п∧q)∨(¬п∧¬q)){\ displaystyle {\ begin {matrix} p \ oplus q & = & \ lnot ((p \ land q) \ lor (\ lnot p \ land \ lnot q)) \ end {matrix}}}

или же:

п⊕qзнак равно(п∨q)∧(¬п∨¬q){\ displaystyle {\ begin {matrix} p \ oplus q & = & (p \ lor q) \ land (\ lnot p \ lor \ lnot q) \ end {matrix}}}

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

Исключающее или также эквивалентно отрицанию логической эквивалентности по правилам материальной импликации.

Таким образом, мы имеем:

п⊕qзнак равно(п∧¬q)∨(¬п∧q)знак равнопq¯+п¯qзнак равно(п∨q)∧(¬п∨¬q)знак равно(п+q)(п¯+q¯)знак равно(п∨q)∧¬(п∧q)знак равно(п+q)(пq¯){\ displaystyle {\ begin {matrix} p \ oplus q & = & (p \ land \ lnot q) & \ lor & (\ lnot p \ land q) & = & p {\ overline {q}} + {\ overline {p}} q \\ & = & (p \ lor q) & \ land & (\ lnot p \ lor \ lnot q) & = & (p + q) ({\ overline {p}} + {\ overline {q}}) \\ & = & (p \ lor q) & \ land & \ lnot (p \ land q) & = & (p + q) ({\ overline {pq} }) \ end {matrix}}}

Операторы, допускающие логическое значение NULL

Для операндов операторы и поддерживают следующую логику с тремя значениями:

  • Оператор возвращает только в том случае, если оба операнда имеют значение . Если или имеет значение , оператор возвращает (даже если другой операнд имеет значение ). В противном случае выражение будет иметь значение .

  • Оператор возвращает только в том случае, если оба операнда имеют значение . Если или имеет значение , оператор возвращает (даже если другой операнд имеет значение ). В противном случае выражение будет иметь значение .

Эта семантика описывается в следующей таблице:

x y x&y x|y
true true true true
true false false true
true null null true
false true false true
false false false false
false null false null
null true null true
null false false null
null null null null

Поведение этих операторов отличается от типичного поведения операторов, допускающих значение NULL. Как правило, оператор, который определяется для операндов типа значения, можно также использовать с соответствующими операндами типа, допускающего значение NULL. Такой оператор возвращает , если какой-либо из операндов имеет значение . При этом операторы и могут возвращать отличное от NULL значение, даже если один из операндов имеет значение . См. подробнее о поведении операторов, допускающих значение NULL, в разделе в статье Типы, допускающие значение NULL.

Вы также можете также использовать операторы и с операндами , как показано в следующем примере:

Условные логические операторы и не поддерживают операнды типа .

Побитовые И, ИЛИ, НЕ, исключающее ИЛИ

Напомню для начала, что логические операции И, ИЛИ, исключающее ИЛИ и НЕ могут быть описаны с помощью таблиц истинности

Логический оператор И
X Y X AND Y
1
1
1 1 1
Логический оператор ИЛИ
X Y X OR Y
1 1
1 1
1 1 1
Логический оператор исключающее ИЛИ
X Y X XOR Y
1 1
1 1
1 1
Логический оператор НЕ
X NOT X
1
1

В побитовых (bit-wise) операциях значение бита, равное 1, рассматривается как логическая истина, а 0 как ложь. Побитовое И (оператор &) берёт два числа и логически умножает
соответствующие биты. Например, если логически умножить 3 на 8, то получим 0

char a = 3;
char b = 8;
char c = a & b;
printf("%d", c);

Так как в двоичном виде 3 в виде однобайтного целого представляет собой

а 8

Первый бит переменной c равен логическому произведению первого бита числа a и первого бита числа b. И так для каждого бита.

Соответственно, побитовое произведение чисел 31 и 17 даст 17, так как 31 это

, а 17 это

Побитовое произведение чисел 35 и 15 равно 3.

Аналогично работает операция побитового ИЛИ (оператор |), за исключением того, что она логически суммирует соответствующие биты чисел без переноса.

Например,

char a = 15;
char b = 11;
char c = a | b;
printf("%d", c);

выведет 15, так как 15 это , а 11 это 00001011

Побитовое ИЛИ для чисел 33 и 11 вернёт 43, так как 33 это , а 11 это

Побитовое отрицание (оператор ~) работает не для отдельного бита, а для всего числа целиком. Оператор инверсии меняет ложь на истину, а истину на ложь, для каждого бита.
Например,

char a = 65;
char b = ~a;
printf("%d", b);

Выведет -66, так как 65 это , а инверсия даст

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

char a = 107;
char b = ~a + 1;
printf("a = %d, -a = %d", a, b);

Исключающее ИЛИ (оператор ^) применяет побитово операцию XOR. Например, для чисел

char a = 12;
char b = 85;
char c = a ^ b;
printf("%d", c);

будет выведено 89, так как a равно , а b равно . В итоге получим

Иногда логические операторы && и || путают с операторами & и |. Такие ошибки могут существовать в коде достаточно долго,
потому что такой код в ряде случаев будет работать. Например, для чисел 1 и 0. Но так как в си истиной является любое ненулевое значение,
то побитовое умножение чисел 3 и 4 вернёт 0, хотя логическое умножение должно вернуть истину.

int a = 3;
int b = 4;
printf("a & b = %d\n", a & b);	//выведет 0
printf("a && b = %d\n", a && b);//выведет не 0 (конкретнее, 1)

Обозначения[править | править код]

Запись может быть префиксной («польская запись») — знак операции ставится перед операндами, инфиксной — знак операции ставится между операндами и постфиксной — знак операции ставится после операндов. При числе операндов более 2 префиксная и постфиксная записи экономичнее инфиксной записи. Чаще всего встречаются следующие варианты записи:⊕2(a,b), a{\displaystyle \oplus _{2}(a,b),~a} ^ b, a⊕b,a⊕2b,a+2b,{\displaystyle b,~a\oplus b,a\oplus _{2}b,a+_{2}b,} a ≠ b, a≠b,(a,b)⊕2,a XOR b{\displaystyle a\neq b,(a,b)\oplus _{2},a~XOR~b}

В Юникоде есть символы для сложения по модулю 2: U+22BB ⊻ xor, U+2295 ⊕ circled plus и U+2A27 ⨧ plus sign with subscript two, U+2A52 ⩒ logical or with dot above, а также символ для суммы по модулю 2: U+2A0A ⨊ modulo two sum.

Короткий цикл вычислений

Для того, чтобы логическое И возвращало true, оба операнда должны быть истинными. Если первый операнд вычисляется как false, то оператор И должен сразу возвращать false независимо от результата второго операнда (даже без его обработки). Это называется коротким циклом вычисления (англ. «short circuit evaluation») и выполняется он, в первую очередь, в целях оптимизации.

Аналогично, если первый операнд логического ИЛИ является true, то и всё условие будет true (даже без обработки второго операнда).

Как и в случае с оператором ИЛИ, новички иногда путают логическое И () с побитовым И ().

Поведение

Элементы Исключающее ИЛИ, Исключающее ИЛИ-НЕ, Нечётность и Чётность вычисляют соответствующую функцию от значений на входах и выдают результат на выход.

По умолчанию, неподключенные входы игнорируются — то есть, если входы действительно не имеют ничего подключенного к ним — даже провода. Таким образом, вы можете добавить 5-входовый элемент, но подключить только два входа, и он будет работать как 2-входовый элемент; это избавляет вас от необходимости беспокоиться о настройке количества входов каждый раз при создании элемента. (Если все входы не подключены, то на выходе значение ошибки X.) Некоторые пользователи, однако, предпочитают, чтобы Logisim настаивал, чтобы все входы были подключены, поскольку это соответствует реальным элементам. Вы можете включить это поведение, выбрав меню Проект > Параметры…, перейдя на вкладку Моделирование, и выбрав вариант Ошибка для неопределённых входов для Выход элемента при неопределённости.

Двухвходовая таблица истинности для элементов следующая.

x y Исключающее ИЛИ Исключающее ИЛИ-НЕ Нечётность Чётность
1 1
1 1 1
1 1 1
1 1 1 1

Как вы можете видеть, элементы Нечётность и Исключающее ИЛИ ведут себя одинаково в случае двух входов; аналогично, элементы Чётность и Исключающее ИЛИ-НЕ ведут себя одинаково. Но если входов с определённым значением больше двух, то элемент Исключающее ИЛИ будет давать на выходе 1, когда единица строго на одном входе, тогда как элемент Нечётность даст на выходе 1, когда единица на нечётном количестве входов. Элемент Исключающее ИЛИ-НЕ будет давать на выходе 1, когда входов с единицей строго не один, тогда как элемент Чётность даст 1, когда входов с единицей чётное количество. Элементы Исключающее ИЛИ и Исключающее ИЛИ-НЕ имеют атрибут, названный Многовходовое поведение, который позволяет настроить их на использование поведения элементов Нечётность и Чётность.

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

Многобитные версии каждого элемента будут выполнять свои однобитные преобразования над входами поразрядно.

Примечание: многие специалисты утверждают, что поведение фигурного элемента Исключающее ИЛИ должно соответствовать поведению элемента Нечётность, но по этому вопросу нет согласия. Поведение Logisim по умолчанию для элемента Исключающее ИЛИ основано на стандарте IEEE 91. Это также согласуется с интуитивным пониманием термина Исключающее ИЛИ: официант, спрашивающий, хотите вы гарнир из картофельного пюре, моркови, зеленого горошка, или шинкованной капусты, примет только один выбор, а не три, независимо от того, что вам могут сказать некоторые специалисты. (Должен признать, однако, что я не подвергал это заявление серьезным испытаниям.) Вы можете настроить элементы Исключающее ИЛИ и Исключающее ИЛИ-НЕ на использование одного из вариантов, меняя его атрибут Многовходовое поведение.

Битовая операция ИЛИ

Следующая битовая операция – поразрядное ИЛИ. Она задается оператором | и
ее таблица истинности выглядит следующим образом.

x

y

ИЛИ

1

1

1

1

1

1

1

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

byte flags = 8;  //двоичный вид:  00001000
byte mask = 5;   //двоичный вид:  00000101
 
flags = (byte)(flags | mask);   //двоичная запись 00001101 (число 13)
 
System.out.println(flags);

Здесь мы имеем
такую картину.

flags=

1

mask=

1

1

flags=

1

1

1

то есть,
операция поразрядное ИЛИ, как бы собирает все единички из обеих переменных и
получается такое своеобразное сложение. Кстати, в этом случае действительно
получилось 8+5=13. Но это будет не всегда так, например, если

byte flags = 9;  //двоичный вид:  00001001

то результат
тоже будет 13, так как операция ИЛИ включает бит вне зависимости был ли он уже
включен или нет, все равно на выходе будет единица. И здесь уже 9+5=13, что
математически неверно.

Альтернативные символы

Символ, используемый для исключительной дизъюнкции, варьируется от одной области приложения к другой и даже зависит от свойств, которые подчеркиваются в данном контексте обсуждения. В дополнение к аббревиатуре «XOR» также может быть виден любой из следующих символов:

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

 п{\ displaystyle p}   q{\ displaystyle q}  п+q{\ displaystyle p + q}
1 1
1 1
1 1
  • ⊕{\ displaystyle \ oplus}, измененный знак плюса; этот символ также используется в математике для прямой суммы алгебраических структур
  • J, как в J pq
  • Инклюзивный символ дизъюнкции ( ), который каким-либо образом модифицируется, например
    ∨{\ Displaystyle \ lor}
  • ^, каретка , используемая в нескольких языках программирования , таких как C , C ++ , C # , D , Java , Perl , Ruby , PHP и Python , обозначающая побитовый оператор XOR; не используется вне контекста программирования, потому что его слишком легко спутать с другими вариантами использования каретки
  • , иногда пишется как
    • > <
    • > — <
  • = 1, в символике IEC

Синхронизирующие устройства

Синхронизирующие устройства определяют порядок работы и взаимодействие узлов и систем преобразователя. Наиболее простыми и распространенными являются схемы с трансформаторами (рис. 8, а). На первичные обмотки трехфазного трансформатора подаются напряжения управления со сдвигом 120°.

Рис. 8. Синхронизирующее устройство и векторная диаграмма выходных напряжений

Импульсы снимаются со вторичных обмоток и представляют собой напряжения между концами обмоток и нулевым проводом. Каждый тиристор может быть открыт одну треть периода и работает по одной шестой периода с двумя тиристорами второй группы (например, 4-й — с 3-м и 5-м). 

Импульсы тиристоров одной группы сдвигаются на 120°, концы вторичных обмоток соединяются с управляющими векторами тиристоров согласно векторной диаграмме выходных напряжений (рис. 8, б). Вентили в цепи тока управления предохраняют тиристоры от возникновения отрицательного потенциала на управляющем электроде и от короткого замыкания между фазами переменного напряжения, которое подается на управляемый мост.

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

На рис. 9, а показаны нуль-орган с использованием логического элемента ИЛИ — НЕ. Напряжение Uвх на вторичной обмотке трансформатора преобразуется в два напряжения Uвх1 и Uвх2, находящихся в противофазе (рис. 9, б), так как одно напряжение направлено от конца обмотки к нулевой точке, а другое — наоборот. В каждый полупериод эти напряжения создают ток через стабилитроны Ст1 и Ст2. 

Рис. 9. Нуль-орган с использованием логических элементов ИЛИ-НЕ

Напряжение стабилизации стабилитронов ограничивается напряжением Uогр. Резисторы R1 и RЗ служат добавочными и совместно со стабилитронами создают схемы стабилизации напряжения. Каждый полупериод стабилизированное напряжение подается на вход транзистора Т. Резисторы R2 и R4 ограничивают базовый ток транзистора. 

Напряжение стабилизации выбирается больше напряжения смещения Еб, и транзистор открыт большую часть полупериода. В момент перехода напряжения через нуль напряжение смещения закрывает транзистор и на выходе возникает импульс Uвых, примерно равный напряжению питания Ек. Функцию ИЛИ — НЕ осуществляет транзистор в схеме. Если напряжение входа больше напряжения смещения Uвх > Еб, импульса нет, если Uвх меньше Еб — импульс есть. Для синхронизации работы многофазного выпрямителя такая схема должна быть включена в каждую фазу.

Продвинутые и редко используемые логические символы

Эти символы отсортированы по их значению Unicode:

  • U + 0305  ̅ ОБЪЕДИНЕНИЕ   СТРОКИ , используется как сокращение для стандартных цифр ( теория типографских чисел ). Например, использование стиля HTML «4̅» является сокращением для стандартной цифры «SSSS0».
    • Overline также является редко используемым форматом для обозначения чисел Гёделя : например, « A ∨ B » означает число Гёделя «(A ∨ B)».
    • Overline также является способом обозначения отрицания, используемого в основном в электронике: например, « A ∨ B » то же самое, что и «¬ (A ∨ B)».
  • U + 2191 ↑ СТРЕЛКА ВВЕРХ или U + 007C | ВЕРТИКАЛЬНАЯ ЛИНИЯ : штрих Шеффера , знак оператора И-НЕ (отрицание соединения).
  • U + 2193 ↓ СТРЕЛКА ВНИЗ Стрелка Пирса , знак оператора ИЛИ (отрицание дизъюнкции).
  • U + 2299 ⊙ CIRCLED DOT OPERATOR знак для оператора XNOR (отрицание исключительной дизъюнкции).
  • U + 2201 ∁ COMPLEMENT
  • U + 2204 ∄ ТАМ НЕ СУЩЕСТВУЕТ : зачеркнуть экзистенциальный квантор, то же, что и «¬∃»
  • U + 2234 ∴ ПОЭТОМУ : Поэтому
  • U + 2235 ∵ : потому что
  • U + 22A7 ⊧ МОДЕЛИ : это модель (или «удовлетворительная оценка «)
  • U + 22A8 ⊨ ИСТИНА : верно для
  • U + 22AC ⊬ НЕ ДОКАЗЫВАЕТСЯ : отрицание ⊢, знак «не доказывает», например, T P говорит: « P не является теоремой для T »
  • U + 22AD ⊭ НЕ ИСТИНА : неверно
  • U + 2020 † DAGGER : Оператор подтверждения (читай: «это правда, что …»)
  • U + 22BC ⊼ NAND : оператор NAND.
  • U + 22BD ⊽ NOR : оператор NOR.
  • U + 25C7 ◇ БЕЛЫЙ АЛМАЗ : модальный оператор для «возможно, что», «это не обязательно не обязательно» или редко «это, вероятно, не так» (в большинстве модальных логик он определяется как «¬¬»)
  • U + 22C6 ⋆ СТАР ОПЕРАТОР : обычно используются для Времнных операторов
  • U + 22A5 ⊥ ВВЕРХ или U + 2193 ↓ СТРЕЛКА ВНИЗ : оператор Уэбба или стрелка Пирса, знак для NOR . Как ни странно, «⊥» также является знаком противоречия или абсурда.
  • U + 2310 ⌐ ПЕРЕВЕРНУТЫЙ НЕ ЗНАК
  • U + 231C ⌜ ВЕРХНИЙ ЛЕВЫЙ УГОЛ и U + 231D ⌝ ВЕРХНИЙ ПРАВЫЙ УГОЛ : угловые кавычки, также называемые «кавычками Куайна»; для квази-цитирования, т. е. цитирования определенного контекста неопределенных («переменных») выражений; также используется для обозначения числа Гёделя ; например, «⌜G⌝» обозначает гёделевское число G. (Типографское примечание: хотя кавычки отображаются как «пара» в Юникоде (231C и 231D), они не симметричны в некоторых шрифтах. И в некоторых шрифтах (например, Arial) они симметричны только в определенных размерах. В качестве альтернативы кавычки могут быть представлены как ⌈ и ⌉ (U + 2308 и U + 2309) или с использованием символа отрицания и символа обратного отрицания ⌐ ¬ в режиме надстрочного индекса.)
  • U + 25FB WHITE MEDIUM SQUARE или U + 25A1 □ WHITE SQUARE : модальный оператор для «необходимо, что» (в модальной логике ), или «это доказуемо» (в логике доказуемости ), или «это обязательно, что» (в деонтической логике ) или «считается, что» (в доксастической логике ); также как (альтернативы:и ⊥).∅{\ displaystyle \ emptyset}
  • U + 27DB ⟛ LEFT AND RIGHT TACK : семантический эквивалент

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

  • U + 27E1 ⟡ БЕЛЫЙ Вогнутый алмаз : модальный оператор никогда
  • U + 27E2 ⟢ БЕЛЫЙ Вогнутый бриллиант с левой галочкой : модальный оператор для никогда не был
  • U + 27E3 ⟣ БЕЛЫЙ Вогнутый бриллиант с галочкой вправо : модальный оператор for никогда не будет
  • U + 25A1 □ WHITE SQUARE : модальный оператор для Always
  • U + 27E4 ⟤ БЕЛЫЙ КВАДРАТ С ЛЕВОЙ КАРТИНКОЙ : модальный оператор для всегда был
  • U + 27E5 ⟥ БЕЛЫЙ КВАДРАТ С ТИПОМ ВПРАВО : модальный оператор для всегда будет
  • U + 297D ⥽ ПРАВЫЙ
  • U + 2A07 ⨇ ДВА ЛОГИКА И ОПЕРАТОРА

Битовая операция НЕ

Начнем с самой
простой битовой операции НЕ, которая выполняет инверсию бит в соответствии с
такой табличкой:

x

НЕ

1

1

На языке Java она
записывается как ~ тильда. И приведем такую программу.

int var = 121;  //двоичный вид: 00000000 00000000 00000000 01111001
int not_v = ~var; //результат:  11111111 11111111 11111111 10000110 (число -122)
 
System.out.println(not_v);

Здесь мы сначала
задаем переменную var со значением 121, затем, выполняем ее
побитовую инверсию, и выводим результат на экран.

Запустим
программу и видим на экране число -122, что и должно быть, так как инверсия
последних 7 бит дает

1111001 = 121+1

значит, это
число -122.

Обозначения [ | ]

Запись может быть префиксной («польская запись ») — знак операции ставится перед операндами, инфиксной — знак операции ставится между операндами и постфиксной — знак операции ставится после операндов. При числе операндов более 2 префиксная и постфиксная записи экономичнее инфиксной записи. Чаще всего встречаются следующие варианты записи:

2
(a
,
b)
,
a
{\displaystyle \oplus _{2}(a,b),~a}
^
b
,
a

b
,
a

2
b
,
a
+
2
b
,
{\displaystyle b,~a\oplus b,a\oplus _{2}b,a+_{2}b,}
a ≠ b,
a

b
,
(a
,
b)

2
,
a
X
O
R
b
{\displaystyle a\neq b,(a,b)\oplus _{2},a~XOR~b}

В таблице символов Юникод есть символы для сложения по модулю 2: XOR — U+22BB (⊻), CIRCLED PLUS — U+2295 (⊕) и PLUS SIGN WITH SUCSCRIPT TWO — U+2A27 (⨧), а также символ для суммы по модулю 2: MODULO TWO SUM — U+2A0A (⨊).

Побитовые операторы И, ИЛИ и исключающее ИЛИ (XOR)

Побитовые операторы И () и ИЛИ () работают аналогично логическим операторам И и ИЛИ. Однако, побитовые операторы применяются к каждому биту отдельно! Например, рассмотрим выражение . В двоичной системе это . В любой побитовой операции операнды лучше всего размещать следующим образом:

А затем применять операцию к каждому столбцу с битами по отдельности. Как вы помните, логическое ИЛИ возвращает true (1), если один из двух или оба операнды истинны (1). Аналогичным образом работает и побитовое ИЛИ. Выражение обрабатывается следующим образом:

Результат:

Также можно обрабатывать и комплексные выражения ИЛИ, например, . Если хоть один бит в столбце равен 1, то результат целого столбца — 1. Например:

Результатом является десятичное .

Побитовое И работает аналогично логическому И — возвращается true, только если оба бита в столбце равны 1. Рассмотрим выражение :

Также можно решать и комплексные выражения И, например, . Только при условии, что все биты в столбце равны 1, результатом столбца будет 1.

Последний оператор — побитовое исключающее ИЛИ () (сокр. «XOR» от англ. «eXclusive OR«). При обработке двух операндов, исключающее ИЛИ возвращает true (1), только если один и только один из операндов является истинным (1). Если таких нет или все операнды равны 1, то результатом будет false (0). Рассмотрим выражение :

Также можно решать и комплексные выражения XOR, например, . Если единиц в столбце чётное количество, то результатом будет 0, если же нечётное количество, то результат — 1. Например:

Программирование [ | ]

В языках /C++ , Java , , Ruby , PHP , JavaScript , Python и т. д. битовая операция поразрядного дополнения обозначается символом « ^ », в языках Паскаль , Delphi , Ada , Visual Basic — зарезервированным словом xor , в языке ассемблера — одноимённой логической командой. При этом сложение по модулю 2 выполняется для всех битов левого и правого операнда попарно. Например,

Если

A
=
01100101
2
{\displaystyle a=01100101_{2}}

B
=
00101001
2
{\displaystyle b=00101001_{2}}
, начиная со стандарта C99 , оператор « ^ » над операндами логического типа возвращает результат применения логической операции XOR. В С++ оператор « ^ » для логического типа bool возвращает результат согласно описанным правилам, для остальных же типов производится его побитовое применение.

Чётность в 32-разрядных двойных словах

Ну а если надо определить чётность в 32-разрядном числе?

Тогда число разбивается на четыре байта, и поочерёдно с этими байтами выполняется операция исключающего ИЛИ.

Например, мы разбили 32-разрядное число B на четыре байта
B0, B1, B2, B3,
где В0 — это младший байт.

Тогда для определения чётности числа В нам надо будет использовать следующую формулу:

Но в ассемблере такая запись недопустима. Поэтому придётся немного подумать.

Ну и напоследок о происхождении мнемоники XOR. В английском языке
есть слово eXception — исключение. Сокращением от этого слова
является буква Х (так повелось). Вы наверняка встречали такое в
рекламе или в названии продуктов, производители которых претендуют (ну или думают,
что претендуют) на исключительность. Например, Лада XRAY, Sony XPeria и т.п.
Так что XOR — это аббревиатура, собранная из двух слов — eXception OR — исключающее ИЛИ.

Булева алгебра [ | ]

В булевой алгебре сложение по модулю 2 — это функция двух, трёх и более переменных (они же — операнды операции, они же — аргументы функции). Переменные могут принимать значения из множества . Результат также принадлежит множеству
{
0
,
1
}
{\displaystyle \{0,1\}}
. Вычисление результата производится по простому правилу, либо по таблице истинности . Вместо значений
0
,
1
{\displaystyle 0,1}
может использоваться любая другая пара подходящих символов, например
f
a
l
s
e
,
t
r
u
e
{\displaystyle false,true}
или
F
,
T
{\displaystyle F,T}
или «ложь», «истина», но при этом необходимо доопределять старшинство, например,
t
r
u
e
>
f
a
l
s
e
{\displaystyle true>false}
.

Таблицы истинности:

a
{\displaystyle a}

b
{\displaystyle b}

a

b
{\displaystyle a\oplus b}

1 1
1 1
1 1

Правило: результат равен , если оба операнда равны; во всех остальных случаях результат равен
1
{\displaystyle 1}

.

a
{\displaystyle a}

b
{\displaystyle b}

c
{\displaystyle c}

a

b

c
{\displaystyle a\oplus b\oplus c}

1 1
1 1
1 1
1 1
1 1
1 1
1 1 1 1

Правило: результат равен , если нет операндов, равных
1
{\displaystyle 1}

, либо их чётное количество.

Логические операторы C#

Унарные:

логическое отрицание (!)

Бинарные:

  • логическое И (),
  • логическое ИЛИ (),
  • логическое исключающее ИЛИ  ().
  • условное логическое И ()
  • условное логическое ИЛИ  ()

Операторы равенства:

  • равенство ()
  • неравенство ()

Операторы сравнения

  • меньше чем (),
  • больше чем (),
  • меньше или равно ()
  • больше или равно ()

Условный оператор if

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

if (условие)
  (действие 1);
else
  (действие 2);

Здесь, в отличие от Delphi, можно увидеть, что: во-первых, в C# нет перед первым условием и, во-вторых, после первого действия обязательно ставиться точка с запятой, чего в Delphi делать не надо. В остальном же, действие оператора точно такое же как и в Delphi и любых других языках программирования — если выполняется условие, то программы переходит на , иначе — на .

Теперь перейдем к логическим операторам в C#.

Унарный логический оператор ()

Унарный префиксный оператор выполняет логическое отрицание операнда, то есть, возвращает , если операнд имеет значение , и, наоборот, , если операнд имеет значение .

Например,

bool b = true;
Console.WriteLine(!b);

вернет нам в консоль строку

False

Логическое И ()

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

bool a = true;
bool b = true;
Console.WriteLine(a & b); //TRUE - оба операнда true
//один из операторов False
bool a = true;
bool b = false;
Console.WriteLine(a & b);//FALSE - правый операнд False
//оба оператора имеют значение False
bool a = true;
bool b = false;
Console.WriteLine(!a & b);//FALSE
//оба оператора имеют значение True
bool a = true;
bool b = false;
Console.WriteLine(a & !b);//TRUE

Логическое ИЛИ ()

Так же, как и предыдущий оператор, логическое ИЛИ обрабатывает оба операнда. В отличие от логического И этот оператор вернет , если хотя бы один операнд будет иметь значение .

bool a = true;
bool b = false;
Console.WriteLine(a | b); //TRUE

Логическое исключающее ИЛИ  ().

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

a b Результат ^ 
True True False
False False False
True False True
False True True

Ниже представлен код, демонстрирующий данные из таблицы:

bool a = true;
bool b = true;
Console.WriteLine(a ^ b); //False

a = false;
b = false;
Console.WriteLine(a ^ b); //False

a = true;
b = false;
Console.WriteLine(a ^ b); //True

a = false;
b = true;
Console.WriteLine(a ^ b); //True

Условное логическое И ()

В отличие от предыдущих бинарных логических операторов C# этот оператор обрабатывает правый операнд только тогда, когда это необходимо. Действие этого оператора следующее — он возвращает только тогда, когда оба оператора равны .

a b Результат && 
True True True (правый операнд обработан)
False False False (правый операнд не обработан)
True False False (правый операнд обработан)
False True False (правый операнд не обработан

Код, демонстрирующий работу оператора представлен ниже

class Program
    {
        static bool Eval(bool b)
        {
            Console.WriteLine("Правый операнд обработан");
            return b;
        }
        static void Main(string[] args)
        {
            bool a = true;
            bool b = true;
            Console.WriteLine(a && Eval(b)); 

            a = false;
            b = false;
            Console.WriteLine(a && Eval(b)); 

            a = true;
            b = false;
            Console.WriteLine(a && Eval(b)); 

            a = false;
            b = true;
            Console.WriteLine(a && Eval(b)); 

            Console.ReadLine();
        }
    }
    }

Вывод консоли будет следующим

Правый операнд обработан

True

False

Правый операнд обработан

False

False

Условное логическое ИЛИ  ()

Также, как и предыдущий оператор, условное логическое ИЛИ обрабатывает правый оператор только когда необходимо. При этом результат выполнения условного логического ИЛИ будет , если хотя бы один из операндов равен .

a b Результат || 
True True True (правый не операнд обработан)
False False False (правый операнд  обработан)
True False True (правый не операнд обработан)
False True True (правый операнд  обработан

Код, демонстрирующий поведение уловного логического ИЛИ представлен ниже:

class Program
    {
        static bool Eval(bool b)
        {
            Console.WriteLine("Правый операнд обработан");
            return b;
        }
        static void Main(string[] args)
        {
            bool a = true;
            bool b = true;
            Console.WriteLine(a || Eval(b)); 

            a = false;
            b = false;
            Console.WriteLine(a || Eval(b)); 

            a = true;
            b = false;
            Console.WriteLine(a || Eval(b)); 

            a = false;
            b = true;
            Console.WriteLine(a || Eval(b)); 

            Console.ReadLine();
        }
    }

Вывод консоли будет следующим:

True

Правый операнд обработан

False

True

Правый операнд обработан

True