Skip to content

operators

operators #

Boolean and numeric operators bound onto Procedure.

Each is a shorthand for constructing the matching operator node (BoolNot, BoolAnd, NumberLessThan, …) exactly as building it by hand would. They are imported into the Procedure class body, so the node imports are lazy.

__and__(self, other) #

a & b — a BoolAnd node.

Source code in capturegraph-lib/capturegraph/procedures/procedure/methods/operators.py 
34
35
36
37
38
39
40
41
42
43
44
def __and__(
    self: Procedure[Bool],
    other: Procedure[Bool],
) -> Procedure[Bool]:
    """``a & b`` — a ``BoolAnd`` node."""
    from capturegraph.procedures.nodes.process.operators.boolean import BoolAnd

    return BoolAnd(
        left=self,
        right=other,
    )

__ge__(self, other) #

a >= b — BoolNot(NumberLessThan(a, b)).

Source code in capturegraph-lib/capturegraph/procedures/procedure/methods/operators.py 
94
95
96
97
98
99
def __ge__(
    self: Procedure[Number],
    other: Procedure[Number],
) -> Procedure[Bool]:
    """``a >= b`` — ``BoolNot(NumberLessThan(a, b))``."""
    return ~(self < other)

__gt__(self, other) #

a > b — NumberLessThan with the operands swapped.

Source code in capturegraph-lib/capturegraph/procedures/procedure/methods/operators.py 
78
79
80
81
82
83
def __gt__(
    self: Procedure[Number],
    other: Procedure[Number],
) -> Procedure[Bool]:
    """``a > b`` — ``NumberLessThan`` with the operands swapped."""
    return other < self

__invert__(self) #

~a — a BoolNot node.

Source code in capturegraph-lib/capturegraph/procedures/procedure/methods/operators.py 
27
28
29
30
31
def __invert__(self: Procedure[Bool]) -> Procedure[Bool]:
    """``~a`` — a ``BoolNot`` node."""
    from capturegraph.procedures.nodes.process.operators.boolean import BoolNot

    return BoolNot(value=self)

__le__(self, other) #

a <= b — BoolNot(NumberLessThan(b, a)).

Source code in capturegraph-lib/capturegraph/procedures/procedure/methods/operators.py 
86
87
88
89
90
91
def __le__(
    self: Procedure[Number],
    other: Procedure[Number],
) -> Procedure[Bool]:
    """``a <= b`` — ``BoolNot(NumberLessThan(b, a))``."""
    return ~(other < self)

__lt__(self, other) #

a < b — a NumberLessThan node.

Source code in capturegraph-lib/capturegraph/procedures/procedure/methods/operators.py 
63
64
65
66
67
68
69
70
71
72
73
74
75
def __lt__(
    self: Procedure[Number],
    other: Procedure[Number],
) -> Procedure[Bool]:
    """``a < b`` — a ``NumberLessThan`` node."""
    from capturegraph.procedures.nodes.process.operators.number import (
        NumberLessThan,
    )

    return NumberLessThan(
        left=self,
        right=other,
    )

__or__(self, other) #

a | b — a BoolOr node.

Source code in capturegraph-lib/capturegraph/procedures/procedure/methods/operators.py 
47
48
49
50
51
52
53
54
55
56
57
def __or__(
    self: Procedure[Bool],
    other: Procedure[Bool],
) -> Procedure[Bool]:
    """``a | b`` — a ``BoolOr`` node."""
    from capturegraph.procedures.nodes.process.operators.boolean import BoolOr

    return BoolOr(
        left=self,
        right=other,
    )