Какой смысл в программировании, помимо И / ИЛИ / НЕ, от других логических операторов?

Собираюсь закрыть этот вопрос после того, как Not Equals / XOR. Из 16 возможных операторов программисты используют 9 из них:

FALSE, TRUE, X, Y, !X, !Y, AND (or ==), OR, XOR (or !=)

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

X NAND Y = Alternative Denial = NOT (X AND Y), !X OR !Y
X NOR Y = Joint Denial = NOT (X OR Y), !X AND !Y
X ⊅ Y = Material Nonimplication = X AND !Y, NOT(!X OR Y), (X XOR Y) AND X, ???
X ⊃ Y = Material Implication = !X OR Y, NOT(X AND !Y), (X XNOR Y) OR X, ???
X ⊄ Y = Converse Nonimplication = !X AND Y, NOT(X OR !Y), (X XOR Y) AND Y, ???
X ⊂ Y = Converse Implication = X OR !Y, NOT(!X AND Y), (X XNOR Y) OR Y, ???
X XNOR Y = Biconditional = X IFF Y, NOT (X XOR Y), !X AND !Y

Возможно, позже для них найдется место, потому что NAND / NOR кажется довольно удобным и более чистым, чем ввод NOT (X xxx Y).

Учти это:

  if(an odd number of conditions are true) then return 1 else return 0

Используя и / или / нет, вы можете попробовать

  if(one is true || three are true || ... 2n+1 are true) then return 1 else return 0

Это довольно уродливо, потому что вам приходится указывать каждый из наборов 1, 3, 5, ..., 2n + 1, которые являются подмножествами набора ваших условий. Хотя версия XOR довольно элегантна ...

  if(C1 XOR C2 XOR ... XOR CN) then return 1 else return 0

Для большого или переменного N это, вероятно, лучше обрабатывать с помощью системы цикла и счетчика, но когда N не слишком велико (~ 10), и вы еще не сохраняете условия в виде массива, это не очень плохо. Аналогично работает для проверки четного числа условий.

Вы можете придумать аналогичные примеры и для других. Интересным упражнением было бы попробовать запрограммировать что-нибудь вроде

  if((A && !B) || (!A && B)) then return 1 else return 0

И посмотрите, испускает ли компилятор язык ассемблера для операторов AND, OR и NOT, или он достаточно умен, чтобы распознать, что это XOR, и на основе этого выдает (возможно, более дешевую) инструкцию XOR.

При программировании на java я обычно использую следующие логические функции:

• не !
• и &&
• or ||
• xnor ==
• xor !=,

распространяя это на другие основные функции:

• материальное значение A || !B
• обратное значение !A || B
• материальное неприкрытие !A && B
• обратное неимпликация A && !B

Знание того, когда использовать xor и xnor, сводится к упрощению логики. В общем, когда у вас сложная функция:

1) упростить до CNF («конъюнктивная нормальная форма», также известная как «сумма над произведением») или DNF («дизъюнктивная нормальная форма», также известная как «произведение над суммой»). *

2) удалить лишние термины _10 _, _ 11_ -> A

2) упростить _13 _, _ 14_ -> A == B

3) упростить _16 _, _ 17_ -> A != B

Использование этих трех упрощений может привести к гораздо более чистому коду с использованием функций xor и xnor.

* Следует отметить, что логическая функция может быть намного проще в DNF, чем CNF, или наоборот.

«Пункты 11–14 кажутся интересными, но я никогда не видел их в программировании».
Я не согласен. пункт 12, «Влияние материала» - это, по сути, оператор «ЕСЛИ», он присутствует везде в программировании. Я вижу материальное значение так же, как:

 if(A) {
    return B
 }

Существенный вариант использования без импликации / абъюнкции

Теперь у меня есть пример, в котором я хотел бы выполнить материальное непереполнение / отречение.

Таблица правды

╔═══╦═══╦══════════╗
║ P ║ Q ║ P -/-> Q ║
╠═══╬═══╬══════════╣
║ T ║ T ║ F        ║
║ T ║ F ║ T        ║ <-- all I care about. True followed by false.
║ F ║ T ║ F        ║
║ F ║ F ║ F        ║
╚═══╩═══╩══════════╝

Я имею дело с несколькими разрешениями (все, к счастью, _2 _ / _ 3_) для нескольких сущностей одновременно, и у меня есть ситуация с ролями и правами, когда я хочу увидеть, может ли системный пользователь изменить разрешения другого пользователя. Та же операция выполняется сразу для всех сущностей.

Во-первых, мне нужна разница между старым состоянием разрешений объекта и новым общепринятым состоянием разрешений для всех объектов.

Затем я хочу сравнить эту дельту с правами на изменение текущего пользователя для этой конкретной сущности.

• Меня не волнуют разрешения, в которых дельта не требует изменения.
• Мне нужен только true флаг, когда действие должно быть заблокировано.

Пример

before:          10001
proposed after:  11001
delta:           01000 <<< I want a material nonimplication...
user rights      10101 <<< ... between these two...
blocked actions: 01000 <<< ... to produce this flag set

Прямо сейчас я просто делаю XOR, а затем AND, что одно и то же.

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