Source code for tt.definitions.operators

"""Definitions for tt's built-in Boolean operators."""


[docs]class BooleanOperator(object): """A thin wrapper around a Boolean operator.""" def __init__(self, precedence, eval_func, default_symbol_str, default_plain_english_str): self._precedence = precedence self._eval_func = eval_func self._default_symbol_str = default_symbol_str self._default_plain_english_str = default_plain_english_str def __str__(self): return self._default_plain_english_str def __repr__(self): return '<BooleanOperator "{}">'.format(self._default_plain_english_str) @property def precedence(self): """Precedence of this operator, relative to other operators. :type: :class:`int <python:int>` .. code-block:: python >>> from tt.definitions import TT_AND_OP, TT_OR_OP >>> TT_AND_OP.precedence > TT_OR_OP.precedence True """ return self._precedence @property def eval_func(self): """The evaluation function wrapped by this operator. :type: :data:`Callable <python:typing.Callable>` .. code-block:: python >>> from tt.definitions import TT_XOR_OP >>> TT_XOR_OP.eval_func(0, 0) False >>> TT_XOR_OP.eval_func(True, False) True """ return self._eval_func @property def default_symbol_str(self): """The default symbolic string representation of this operator. Some operators may not have a recognized symbol str, in which case this attribute will be ``None``. :type: :class:`str <python:str>` or ``None`` .. code-block:: python >>> from tt.definitions import TT_AND_OP, TT_NAND_OP >>> print(TT_AND_OP.default_symbol_str) /\\ >>> print(TT_NAND_OP.default_symbol_str) None """ return self._default_symbol_str @property def default_plain_english_str(self): """The default plain English string representation of this operator. Unlike :data:`default_symbol_str`, this attribute should never be ``None``. :type: :class:`str <python:str>` .. code-block:: python >>> from tt.definitions import TT_AND_OP, TT_NAND_OP >>> print(TT_AND_OP.default_plain_english_str) and >>> print(TT_NAND_OP.default_plain_english_str) nand """ return self._default_plain_english_str
_PRECEDENCE = { 'ZERO': 0, 'LOW': 1, 'MEDIUM': 2, 'HIGH': 3 } TT_NOT_OP = BooleanOperator(_PRECEDENCE['HIGH'], lambda a: not a, '~', 'not') """tt's operator implementation of a Boolean NOT. :type: :class:`BooleanOperator` """ TT_IMPL_OP = BooleanOperator(_PRECEDENCE['MEDIUM'], lambda a, b: (not a) or b, '->', 'impl') """tt's operator implementation of a Boolean IMPLIES. :type: :class:`BooleanOperator` """ TT_XOR_OP = BooleanOperator(_PRECEDENCE['MEDIUM'], lambda a, b: a != b, None, 'xor') """tt's operator implementation of a Boolean XOR. :type: :class:`BooleanOperator` """ TT_XNOR_OP = BooleanOperator(_PRECEDENCE['MEDIUM'], lambda a, b: a == b, None, 'xnor') """tt's operator implementation of a Boolean XNOR. :type: :class:`BooleanOperator` """ TT_AND_OP = BooleanOperator(_PRECEDENCE['LOW'], lambda a, b: a and b, '/\\', 'and') """tt's operator implementation of a Boolean AND. :type: :class:`BooleanOperator` """ TT_NAND_OP = BooleanOperator(_PRECEDENCE['LOW'], lambda a, b: not(a and b), None, 'nand') """tt's operator implementation of a Boolean NAND. :type: :class:`BooleanOperator` """ TT_OR_OP = BooleanOperator(_PRECEDENCE['ZERO'], lambda a, b: a or b, '\\/', 'or') """tt's operator implementation of a Boolean OR. :type: :class:`BooleanOperator` """ TT_NOR_OP = BooleanOperator(_PRECEDENCE['ZERO'], lambda a, b: not(a or b), None, 'nor') """tt's operator implementation of a Boolean NOR. :type: :class:`BooleanOperator` """ BINARY_OPERATORS = { TT_AND_OP, TT_IMPL_OP, TT_NAND_OP, TT_NOR_OP, TT_OR_OP, TT_XNOR_OP, TT_XOR_OP } """The set of all binary operators available in tt. :type: Set{:class:`BooleanOperator`} """ NON_PRIMITIVE_OPERATORS = BINARY_OPERATORS - {TT_AND_OP, TT_OR_OP} """The set of non-primitive operators available in tt. This includes all binary operators other than AND and OR. :type: Set{:class:`BooleanOperator`} """ SYMBOLIC_OPERATOR_MAPPING = { '~': TT_NOT_OP, '!': TT_NOT_OP, '->': TT_IMPL_OP, '<->': TT_XNOR_OP, '&&': TT_AND_OP, '&': TT_AND_OP, '/\\': TT_AND_OP, '||': TT_OR_OP, '|': TT_OR_OP, '\\/': TT_OR_OP } """A mapping of Boolean operators. This mapping includes the symbolic variants of the available Boolean operators. :type: Dict{:class:`str <python:str>`: :class:`BooleanOperator`} """ PLAIN_ENGLISH_OPERATOR_MAPPING = { 'not': TT_NOT_OP, 'NOT': TT_NOT_OP, 'xor': TT_XOR_OP, 'XOR': TT_XOR_OP, 'impl': TT_IMPL_OP, 'IMPL': TT_IMPL_OP, 'iff': TT_XNOR_OP, 'IFF': TT_XNOR_OP, 'xnor': TT_XNOR_OP, 'XNOR': TT_XNOR_OP, 'nxor': TT_XNOR_OP, 'NXOR': TT_XNOR_OP, 'and': TT_AND_OP, 'AND': TT_AND_OP, 'nand': TT_NAND_OP, 'NAND': TT_NAND_OP, 'or': TT_OR_OP, 'OR': TT_OR_OP, 'nor': TT_NOR_OP, 'NOR': TT_NOR_OP } """A mapping of Boolean operators. This mapping includes the plain-English variants of the available Boolean operators. :type: Dict{:class:`str <python:str>`: :class:`BooleanOperator`} """ OPERATOR_MAPPING = {} """A mapping of all available Boolean operators. This dictionary is the concatentation of the :data:`PLAIN_ENGLISH_OPERATOR_MAPPING` and :data:`SYMBOLIC_OPERATOR_MAPPING` dictionaries. :type: Dict{:class:`str <python:str>`: :class:`BooleanOperator`} """ OPERATOR_MAPPING.update(PLAIN_ENGLISH_OPERATOR_MAPPING) OPERATOR_MAPPING.update(SYMBOLIC_OPERATOR_MAPPING) MAX_OPERATOR_STR_LEN = max(len(k) for k in OPERATOR_MAPPING.keys()) """The length of the longest operator from :data:`OPERATOR_MAPPING`. :type: :class:`int <python:int>` """