Add NAND and NOR number operations

AUTHORS

@@ -278,6 +278,7 @@ kyle-compute <[email protected]>
 DongKwanKho <[email protected]>
 Ikem Peter <[email protected]>
 Josh Kelley <[email protected]>
+Kryonn <[email protected]>
 Richard Taylor <[email protected]>
 NilsDietrich <[email protected]>
 

src/expression/embeddedDocs/embeddedDocs.js

@@ -111,9 +111,11 @@ import { helpDocs } from './function/expression/help.js'
 import { distanceDocs } from './function/geometry/distance.js'
 import { intersectDocs } from './function/geometry/intersect.js'
 import { andDocs } from './function/logical/and.js'
+import { nandDocs } from './function/logical/nand.js'
 import { notDocs } from './function/logical/not.js'
 import { nullishDocs } from './function/logical/nullish.js'
 import { orDocs } from './function/logical/or.js'
+import { norDocs } from './function/logical/nor.js'
 import { xorDocs } from './function/logical/xor.js'
 import { mapSlicesDocs } from './function/matrix/mapSlices.js'
 import { columnDocs } from './function/matrix/column.js'
@@ -448,9 +450,11 @@ export const embeddedDocs = {
 
   // functions - logical
   and: andDocs,
+  nand: nandDocs,
   not: notDocs,
   nullish: nullishDocs,
   or: orDocs,
+  nor: norDocs,
   xor: xorDocs,
 
   // functions - matrix

src/expression/embeddedDocs/function/logical/nand.js

@@ -0,0 +1,17 @@
+export const nandDocs = {
+  name: 'nand',
+  category: 'Logical',
+  syntax: [
+    'x nand y',
+    'nand(x, y)'
+  ],
+  description: 'Logical nand. Test whether at least one of values is zero.',
+  examples: [
+    'nand(true, false)',
+    'nand(true, true)',
+    'nand(2, 4)'
+  ],
+  seealso: [
+    'not', 'or', 'xor'
+  ]
+}

src/expression/embeddedDocs/function/logical/nor.js

@@ -0,0 +1,17 @@
+export const norDocs = {
+  name: 'nor',
+  category: 'Logical',
+  syntax: [
+    'x nor y',
+    'nor(x, y)'
+  ],
+  description: 'Logical nor. Test if both values are zero',
+  examples: [
+    'nor(true, false)',
+    'nor(false, false)',
+    'nor(0, 4)'
+  ],
+  seealso: [
+    'not', 'or', 'xor'
+  ]
+}

src/expression/operators.js

@@ -38,6 +38,12 @@ export const properties = [
       op: 'or',
       associativity: 'left',
       associativeWith: []
+    },
+    // logical nand
+    'OperatorNode:nand': {
+      op: 'nand',
+      associativity: 'left',
+      associativeWith: []
     }
   },
   { // logical xor
@@ -52,6 +58,12 @@ export const properties = [
       op: 'and',
       associativity: 'left',
       associativeWith: []
+    },
+    // logical nor
+    'OperatorNode:nor': {
+      op: 'nor',
+      associativity: 'left',
+      associativeWith: []
     }
   },
   { // bitwise or

src/expression/parse.js

@@ -174,7 +174,9 @@ export const createParse = /* #__PURE__ */ factory(name, dependencies, ({
     and: true,
     xor: true,
     or: true,
-    not: true
+    nand: true,
+    not: true,
+    nor: true
   }
 
   const CONSTANTS = {
@@ -726,7 +728,7 @@ export const createParse = /* #__PURE__ */ factory(name, dependencies, ({
    * @private
    */
   function parseConditional (state) {
-    let node = parseLogicalOr(state)
+    let node = parseLogicalOrNand(state)
 
     while (state.token === '?') { // eslint-disable-line no-unmodified-loop-condition
       // set a conditional level, the range operator will be ignored as long
@@ -756,15 +758,17 @@ export const createParse = /* #__PURE__ */ factory(name, dependencies, ({
 
   /**
    * logical or, 'x or y'
+   * logical nand, 'x nand y'
    * @return {Node} node
    * @private
    */
-  function parseLogicalOr (state) {
+  function parseLogicalOrNand (state) {
     let node = parseLogicalXor(state)
 
-    while (state.token === 'or') { // eslint-disable-line no-unmodified-loop-condition
+    while (state.token === 'or' || state.token === 'nand') { // eslint-disable-line no-unmodified-loop-condition
+      const op = state.token
       getTokenSkipNewline(state)
-      node = new OperatorNode('or', 'or', [node, parseLogicalXor(state)])
+      node = new OperatorNode(op, op, [node, parseLogicalXor(state)])
     }
 
     return node
@@ -776,27 +780,29 @@ export const createParse = /* #__PURE__ */ factory(name, dependencies, ({
    * @private
    */
   function parseLogicalXor (state) {
-    let node = parseLogicalAnd(state)
+    let node = parseLogicalAndNor(state)
 
     while (state.token === 'xor') { // eslint-disable-line no-unmodified-loop-condition
       getTokenSkipNewline(state)
-      node = new OperatorNode('xor', 'xor', [node, parseLogicalAnd(state)])
+      node = new OperatorNode('xor', 'xor', [node, parseLogicalAndNor(state)])
     }
 
     return node
   }
 
   /**
    * logical and, 'x and y'
+   * logical nor, 'x nor y'
    * @return {Node} node
    * @private
    */
-  function parseLogicalAnd (state) {
+  function parseLogicalAndNor (state) {
     let node = parseBitwiseOr(state)
 
-    while (state.token === 'and') { // eslint-disable-line no-unmodified-loop-condition
+    while (state.token === 'and' || state.token === 'nor') { // eslint-disable-line no-unmodified-loop-condition
+      const op = state.token
       getTokenSkipNewline(state)
-      node = new OperatorNode('and', 'and', [node, parseBitwiseOr(state)])
+      node = new OperatorNode(op, op, [node, parseBitwiseOr(state)])
     }
 
     return node

src/factoriesAny.js

@@ -70,6 +70,8 @@ export { createRe } from './function/complex/re.js'
 export { createNot } from './function/logical/not.js'
 export { createNullish } from './function/logical/nullish.js'
 export { createOr } from './function/logical/or.js'
+export { createNor } from './function/logical/nor.js'
+export { createNand } from './function/logical/nand.js'
 export { createXor } from './function/logical/xor.js'
 export { createConcat } from './function/matrix/concat.js'
 export { createColumn } from './function/matrix/column.js'

src/factoriesNumber.js

@@ -48,9 +48,11 @@ import {
   modNumber,
   multiplyNumber,
   normNumber,
+  norNumber,
   notNumber,
   nthRootNumber,
   orNumber,
+  nandNumber,
   powNumber,
   rightArithShiftNumber,
   rightLogShiftNumber,
@@ -204,9 +206,11 @@ export { createParserClass } from './expression/Parser.js'
 
 // logical
 export const createAnd = /* #__PURE__ */ createNumberFactory('and', andNumber)
+export const createNand = /* #__PURE__ */ createNumberFactory('nand', nandNumber)
 export const createNot = /* #__PURE__ */ createNumberFactory('not', notNumber)
 export const createOr = /* #__PURE__ */ createNumberFactory('or', orNumber)
 export const createXor = /* #__PURE__ */ createNumberFactory('xor', xorNumber)
+export const createNor = /* #__PURE__ */ createNumberFactory('nor', norNumber)
 
 // matrix
 export { createMapSlices } from './function/matrix/mapSlices.js'

src/function/logical/nand.js

@@ -0,0 +1,51 @@
+import { factory } from '../../utils/factory.js'
+import { nandNumber } from '../../plain/number/logical.js'
+
+const name = 'nand'
+const dependencies = [
+  'typed',
+  'and',
+  'not'
+]
+
+export const createNand = /* #__PURE__ */ factory(name, dependencies, ({ typed, and, not }) => {
+  /**
+   * Logical `nand`. Test if at least one of the inputs is zero.
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.nand(x, y)
+   *
+   * Examples:
+   *
+   *    math.nand(2, 4)   // returns false
+   *
+   *    a = [2, 5, 0]
+   *    b = [0, 22, 0]
+   *    c = 0
+   *
+   *    math.nand(a, b)   // returns [true, false, true]
+   *    math.nand(b, c)   // returns [true, true, true]
+   *
+   * See also:
+   *
+   *    and, or, not, xor
+   *
+   * @param  {number | BigNumber | bigint | Complex | Unit | Array | Matrix} x First value to check
+   * @param  {number | BigNumber | bigint | Complex | Unit | Array | Matrix} y Second value to check
+   * @return {boolean | Array | Matrix}
+   *            Returns true when at least one of the inputs is zero
+   */
+  return typed(
+    name,
+    {
+      'number, number': nandNumber,
+      'bigint, bigint': nandNumber,
+
+      'any, any': function (x, y) {
+        return not(and(x, y))
+      }
+    }
+  )
+})

src/function/logical/nor.js

@@ -0,0 +1,51 @@
+import { factory } from '../../utils/factory.js'
+import { norNumber } from '../../plain/number/logical.js'
+
+const name = 'nor'
+const dependencies = [
+  'typed',
+  'or',
+  'not'
+]
+
+export const createNor = /* #__PURE__ */ factory(name, dependencies, ({ typed, or, not }) => {
+  /**
+   * Logical `nor`. Test if both of values are defined with zero.
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.nor(x, y)
+   *
+   * Examples:
+   *
+   *    math.nor(2, 4)   // returns false
+   *
+   *    a = [2, 5, 0]
+   *    b = [0, 22, 0]
+   *    c = 0
+   *
+   *    math.nor(a, b)   // returns [false, false, true]
+   *    math.nor(b, c)   // returns [true, false, true]
+   *
+   * See also:
+   *
+   *    and, or, not, xor
+   *
+   * @param  {number | BigNumber | bigint | Complex | Unit | Array | Matrix} x First value to check
+   * @param  {number | BigNumber | bigint | Complex | Unit | Array | Matrix} y Second value to check
+   * @return {boolean | Array | Matrix}
+   *            Returns true when both inputs are zero
+   */
+  return typed(
+    name,
+    {
+      'number, number': norNumber,
+      'bigint, bigint': norNumber,
+
+      'any, any': function (x, y) {
+        return not(or(x, y))
+      }
+    }
+  )
+})

src/plain/number/logical.js

@@ -11,6 +11,11 @@ export function orNumber (x, y) {
 }
 orNumber.signature = n2
 
+export function norNumber (x, y) {
+  return !(x || y)
+}
+norNumber.signature = n2
+
 export function xorNumber (x, y) {
   return !!x !== !!y
 }
@@ -20,3 +25,8 @@ export function andNumber (x, y) {
   return !!(x && y)
 }
 andNumber.signature = n2
+
+export function nandNumber (x, y) {
+  return !(x && y)
+}
+nandNumber.signature = n2

src/utils/latex.js

@@ -105,8 +105,10 @@ export const latexOperators = {
   bitXor: '\\underline{|}',
   bitOr: '|',
   and: '\\wedge',
+  nand: '\\uparrow',
   xor: '\\veebar',
-  or: '\\vee'
+  or: '\\vee',
+  nor: '\\downarrow'
 }
 
 export const latexFunctions = {
@@ -179,8 +181,10 @@ export const latexFunctions = {
 
   // logical
   and: { 2: `\\left(\${args[0]}${latexOperators.and}\${args[1]}\\right)` },
+  nand: { 2: `\\left(\${args[0]}${latexOperators.nand}\${args[1]}\\right)` },
   not: { 1: latexOperators.not + '\\left(${args[0]}\\right)' },
   or: { 2: `\\left(\${args[0]}${latexOperators.or}\${args[1]}\\right)` },
+  nor: { 2: `\\left(\${args[0]}${latexOperators.nor}\${args[1]}\\right)` },
   xor: { 2: `\\left(\${args[0]}${latexOperators.xor}\${args[1]}\\right)` },
 
   // matrix