Skip to content

Term class

Bases: Element, ABC

A base class representing a term in an optimization model.

The Term class serves as a base class for representing terms in an optimization model. It is designed to be inherited by subclasses that represent specific types of terms. The Term class itself is an abstract base class (ABC) that defines the common behavior and interface for all terms.

Source code in pyorlib/algebra/terms/term.py 
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
@dataclass
class Term(Element, ABC):
    """
    A base class representing a term in an optimization model.

    The `Term` class serves as a base class for representing terms in an optimization model. It is designed to
    be inherited by subclasses that represent specific types of terms. The `Term` class itself is an abstract
    base class (ABC) that defines the common behavior and interface for all terms.
    """

    __slots__ = ["_term_type", "_value_type"]

    @property
    def term_type(self) -> TermType:
        """
        Retrieves the type of the term.
        :return: A TermType enumeration.
        """
        return self._term_type

    @property
    def value_type(self) -> ValueType:
        """
        Retrieves the type of the term's value.
        :return: A ValueType enumeration
        """
        return self._value_type

    @property
    @abstractmethod
    def name(self) -> str:
        """
        Retrieves the name of the term.
        :return: A string with name of the term.
        """
        pass

    @property
    @abstractmethod
    def lower_bound(self) -> float:
        """
        Retrieves the lower bound of the term's value.
            For variable terms, the lower bound denotes the minimum value that the term can assume.
            For constant terms, the lower bound is equivalent to its value.
        :return: A float representing the lower bound of the term's value. If the upper bound is negative infinity,
            the method returns `-inf` from the math module.
        """
        pass

    @property
    @abstractmethod
    def upper_bound(self) -> float:
        """
        Retrieves the upper bound of the term's value.
            For variable terms, the upper bound denotes the maximum value that the term can assume.
            For constant terms, the upper bound is equivalent to its value.
        :return: A float representing the upper bound of the term's value. If the upper bound is infinity,
            the method returns `inf` from the math module.
        """
        pass

    @property
    @abstractmethod
    def value(self) -> float:
        """
        Retrieves the value of the term.
            For variable terms, the value corresponds to the current value of the term.
            If the term has not been solved yet, the value is `-0.0`.
            For constant terms, the value remains the constant value.
        :return: A float representing the value of the term.
        """
        pass

    @property
    def is_variable(self) -> bool:
        """
        Determines whether the term is a variable or not.
        :return: `True` if the term is a variable, `False` otherwise.
        """
        return self._term_type == TermType.VARIABLE

    @property
    def is_constant(self) -> bool:
        """
        Determines whether the term is a constant or not.
        :return: `True` if the term is a constant, `False` otherwise.
        """
        return self._term_type == TermType.CONSTANT

    def __init__(self, term_type: TermType, value_type: ValueType):
        """
        Initializes a new Term object.
        :param term_type: An enumeration representing the type of the term.
        :param value_type: An enumeration representing the type of the term's value.
        """
        # Applies validations
        if term_type is None:
            raise TermException("Invalid term type.")

        if value_type is None:
            raise TermException("Invalid term value type.")

        # Instance attributes
        self._term_type: TermType = term_type
        """ An enumeration representing the type of the term. """

        self._value_type: ValueType = value_type
        """ An enumeration representing the type of the term's value. """

    def _build_expression(self, expression: Any) -> Element:
        return Expression(expression=expression)

    @abstractmethod
    def get_pretty_string(self, float_precision: int = 6) -> str:
        """
        Returns a formatted string representation of the term.
        :param float_precision: It represents the number of digits used in printing the solution and objective.
        :return: A formatted string representing the term.
        """
        pass

    def __str__(self) -> str:  # pragma: no cover
        return "".join(
            [
                f"Name: {self.name} | ",
                f"Type: {self.term_type.name} | ",
                f"Value type: {self.value_type.name} | ",
                f"lb: {self.lower_bound} | ",
                f"ub: {self.upper_bound} | ",
                f"val: {self.value}",
            ]
        )

    def __iadd__(self, other: Any) -> Element:
        if isinstance(other, Element):
            return self._build_expression(expression=self.raw + other.raw)
        else:
            return self._build_expression(expression=self.raw + other)

    def __isub__(self, other: Any) -> Element:
        if isinstance(other, Element):
            return self._build_expression(expression=self.raw - other.raw)
        else:
            return self._build_expression(expression=self.raw - other)

    def __imul__(self, other: Any) -> Element:
        if isinstance(other, Element):
            return self._build_expression(expression=self.raw * other.raw)
        else:
            return self._build_expression(expression=self.raw * other)

    def __itruediv__(self, other: Any) -> Element:
        if isinstance(other, Element):
            return self._build_expression(expression=self.raw / other.raw)
        else:
            return self._build_expression(expression=self.raw / other)

    def __ifloordiv__(self, other: Any) -> Element:
        if isinstance(other, Element):
            return self._build_expression(expression=self.raw // other.raw)
        else:
            return self._build_expression(expression=self.raw // other)

    def __imod__(self, other: Any) -> Element:
        if isinstance(other, Element):
            return self._build_expression(expression=self.raw % other.raw)
        else:
            return self._build_expression(expression=self.raw % other)

    def __ipow__(self, other: Any) -> Element:
        if isinstance(other, Element):
            return self._build_expression(expression=self.raw**other.raw)
        else:
            return self._build_expression(expression=self.raw**other)

Attributes

raw abstractmethod property 

raw: Any

Returns the raw representation of the mathematical element.

The raw method, when implemented by subclasses, returns the mathematical element in its raw format. The raw format can take various forms, such as an expression used by solvers or engines, or a mathematical expression that represents the entity itself.

RETURNS DESCRIPTION
Any

The raw representation of the mathematical element.

term_type property 

term_type: TermType

Retrieves the type of the term.

RETURNS DESCRIPTION
TermType

A TermType enumeration.

value_type property 

value_type: ValueType

Retrieves the type of the term's value.

RETURNS DESCRIPTION
ValueType

A ValueType enumeration

name abstractmethod property 

name: str

Retrieves the name of the term.

RETURNS DESCRIPTION
str

A string with name of the term.

lower_bound abstractmethod property 

lower_bound: float

Retrieves the lower bound of the term's value. For variable terms, the lower bound denotes the minimum value that the term can assume. For constant terms, the lower bound is equivalent to its value.

RETURNS DESCRIPTION
float

A float representing the lower bound of the term's value. If the upper bound is negative infinity, the method returns -inf from the math module.

upper_bound abstractmethod property 

upper_bound: float

Retrieves the upper bound of the term's value. For variable terms, the upper bound denotes the maximum value that the term can assume. For constant terms, the upper bound is equivalent to its value.

RETURNS DESCRIPTION
float

A float representing the upper bound of the term's value. If the upper bound is infinity, the method returns inf from the math module.

value abstractmethod property 

value: float

Retrieves the value of the term. For variable terms, the value corresponds to the current value of the term. If the term has not been solved yet, the value is -0.0. For constant terms, the value remains the constant value.

RETURNS DESCRIPTION
float

A float representing the value of the term.

is_variable property 

is_variable: bool

Determines whether the term is a variable or not.

RETURNS DESCRIPTION
bool

True if the term is a variable, False otherwise.

is_constant property 

is_constant: bool

Determines whether the term is a constant or not.

RETURNS DESCRIPTION
bool

True if the term is a constant, False otherwise.

Functions

__add__ 

__add__(other: Any) -> Element

Addition operation.

PARAMETER DESCRIPTION
other

The number or Element instance to be added.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the addition.
Source code in pyorlib/algebra/element.py 
56
57
58
59
60
61
62
63
64
65
def __add__(self, other: Any) -> "Element":
    """
    Addition operation.
    :param other: The `number` or `Element` instance to be added.
    :return: A new `Element` instance representing the addition.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw + other.raw)
    else:
        return self._build_expression(expression=self.raw + other)

__radd__ 

__radd__(other: Any) -> Element

Right addition operation.

PARAMETER DESCRIPTION
other

The number or Element instance to be added.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the addition.
Source code in pyorlib/algebra/element.py 
67
68
69
70
71
72
73
74
75
76
def __radd__(self, other: Any) -> "Element":
    """
    Right addition operation.
    :param other: The `number` or `Element` instance to be added.
    :return: A new `Element` instance representing the addition.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=other.raw + self.raw)
    else:
        return self._build_expression(expression=other + self.raw)

__sub__ 

__sub__(other: Any) -> Element

Subtraction operation.

PARAMETER DESCRIPTION
other

The number or Element instance to be subtracted.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the subtraction.
Source code in pyorlib/algebra/element.py 
88
89
90
91
92
93
94
95
96
97
def __sub__(self, other: Any) -> "Element":
    """
    Subtraction operation.
    :param other: The `number` or `Element` instance to be subtracted.
    :return: A new `Element` instance representing the subtraction.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw - other.raw)
    else:
        return self._build_expression(expression=self.raw - other)

__rsub__ 

__rsub__(other: Any) -> Element

Right subtraction operation.

PARAMETER DESCRIPTION
other

The number or Element instance to be subtracted.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the subtraction.
Source code in pyorlib/algebra/element.py 
 99
100
101
102
103
104
105
106
107
108
def __rsub__(self, other: Any) -> "Element":
    """
    Right subtraction operation.
    :param other: The `number` or `Element` instance to be subtracted.
    :return: A new `Element` instance representing the subtraction.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=other.raw - self.raw)
    else:
        return self._build_expression(expression=other - self.raw)

__mul__ 

__mul__(other: Any) -> Element

Multiplication operation.

PARAMETER DESCRIPTION
other

The number or Element instance to be multiplied.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the multiplication.
Source code in pyorlib/algebra/element.py 
120
121
122
123
124
125
126
127
128
129
def __mul__(self, other: Any) -> "Element":
    """
    Multiplication operation.
    :param other: The `number` or `Element` instance to be multiplied.
    :return: A new `Element` instance representing the multiplication.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw * other.raw)
    else:
        return self._build_expression(expression=self.raw * other)

__rmul__ 

__rmul__(other: Any) -> Element

Right multiplication operation.

PARAMETER DESCRIPTION
other

The number or Element instance to be multiplied.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the multiplication.
Source code in pyorlib/algebra/element.py 
131
132
133
134
135
136
137
138
139
140
def __rmul__(self, other: Any) -> "Element":
    """
    Right multiplication operation.
    :param other: The `number` or `Element` instance to be multiplied.
    :return: A new `Element` instance representing the multiplication.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=other.raw * self.raw)
    else:
        return self._build_expression(expression=other * self.raw)

__truediv__ 

__truediv__(other: Any) -> Element

Division operation.

PARAMETER DESCRIPTION
other

The number or Element instance to be divided.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the division.
Source code in pyorlib/algebra/element.py 
152
153
154
155
156
157
158
159
160
161
def __truediv__(self, other: Any) -> "Element":
    """
    Division operation.
    :param other: The `number` or `Element` instance to be divided.
    :return: A new `Element` instance representing the division.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw / other.raw)
    else:
        return self._build_expression(expression=self.raw / other)

__rtruediv__ 

__rtruediv__(other: Any) -> Element

Right division operation.

PARAMETER DESCRIPTION
other

The number or Element instance to be divided.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the division.
Source code in pyorlib/algebra/element.py 
163
164
165
166
167
168
169
170
171
172
def __rtruediv__(self, other: Any) -> "Element":
    """
    Right division operation.
    :param other: The `number` or `Element` instance to be divided.
    :return: A new `Element` instance representing the division.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=other.raw / self.raw)
    else:
        return self._build_expression(expression=other / self.raw)

__floordiv__ 

__floordiv__(other: Any) -> Element

Floor division operation.

PARAMETER DESCRIPTION
other

The number or Element instance to be floor divided.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the floor division.
Source code in pyorlib/algebra/element.py 
184
185
186
187
188
189
190
191
192
193
def __floordiv__(self, other: Any) -> "Element":
    """
    Floor division operation.
    :param other: The `number` or `Element` instance to be floor divided.
    :return: A new `Element` instance representing the floor division.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw // other.raw)
    else:
        return self._build_expression(expression=self.raw // other)

__rfloordiv__ 

__rfloordiv__(other: Any) -> Element

Right floor division operation.

PARAMETER DESCRIPTION
other

The number or Element instance to be floor divided.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the floor division.
Source code in pyorlib/algebra/element.py 
195
196
197
198
199
200
201
202
203
204
def __rfloordiv__(self, other: Any) -> "Element":
    """
    Right floor division operation.
    :param other: The `number` or `Element` instance to be floor divided.
    :return: A new `Element` instance representing the floor division.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=other.raw // self.raw)
    else:
        return self._build_expression(expression=other // self.raw)

__mod__ 

__mod__(other: Any) -> Element

Modulo operation.

PARAMETER DESCRIPTION
other

The number or Element instance to be used for modulo.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the modulo operation.
Source code in pyorlib/algebra/element.py 
216
217
218
219
220
221
222
223
224
225
def __mod__(self, other: Any) -> "Element":
    """
    Modulo operation.
    :param other: The `number` or `Element` instance to be used for modulo.
    :return: A new `Element` instance representing the modulo operation.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw % other.raw)
    else:
        return self._build_expression(expression=self.raw % other)

__rmod__ 

__rmod__(other: Any) -> Element

Right modulo operation.

PARAMETER DESCRIPTION
other

The number or Element instance to be used for modulo.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the modulo operation.
Source code in pyorlib/algebra/element.py 
227
228
229
230
231
232
233
234
235
236
def __rmod__(self, other: Any) -> "Element":
    """
    Right modulo operation.
    :param other: The `number` or `Element` instance to be used for modulo.
    :return: A new `Element` instance representing the modulo operation.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=other.raw % self.raw)
    else:
        return self._build_expression(expression=other % self.raw)

__pow__ 

__pow__(other: Any) -> Element

Exponentiation operation.

PARAMETER DESCRIPTION
other

The number or Element instance to be used as the exponent.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the exponentiation.
Source code in pyorlib/algebra/element.py 
248
249
250
251
252
253
254
255
256
257
def __pow__(self, other: Any) -> "Element":
    """
    Exponentiation operation.
    :param other: The `number` or `Element` instance to be used as the exponent.
    :return: A new `Element` instance representing the exponentiation.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw**other.raw)
    else:
        return self._build_expression(expression=self.raw**other)

__rpow__ 

__rpow__(other: Any) -> Element

Right exponentiation operation.

PARAMETER DESCRIPTION
other

The number or Element instance to be used as the base.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the exponentiation.
Source code in pyorlib/algebra/element.py 
259
260
261
262
263
264
265
266
267
268
def __rpow__(self, other: Any) -> "Element":
    """
    Right exponentiation operation.
    :param other: The `number` or `Element` instance to be used as the base.
    :return: A new `Element` instance representing the exponentiation.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=other.raw**self.raw)
    else:
        return self._build_expression(expression=other**self.raw)

__neg__ 

__neg__() -> Element

Negation operation.

RETURNS DESCRIPTION
Element

A new Element instance representing the negation.
Source code in pyorlib/algebra/element.py 
280
281
282
283
284
285
def __neg__(self) -> "Element":
    """
    Negation operation.
    :return: A new `Element` instance representing the negation.
    """
    return self._build_expression(expression=-self.raw)

__pos__ 

__pos__() -> Element

Positive operation.

RETURNS DESCRIPTION
Element

A new Element instance representing the positive value.
Source code in pyorlib/algebra/element.py 
287
288
289
290
291
292
def __pos__(self) -> "Element":
    """
    Positive operation.
    :return: A new `Element` instance representing the positive value.
    """
    return self._build_expression(expression=+self.raw)

__abs__ 

__abs__() -> Element

Absolute value operation.

RETURNS DESCRIPTION
Element

A new Element instance representing the absolute value.
Source code in pyorlib/algebra/element.py 
294
295
296
297
298
299
def __abs__(self) -> "Element":
    """
    Absolute value operation.
    :return: A new `Element` instance representing the absolute value.
    """
    return self._build_expression(expression=abs(self.raw))

__eq__ 

__eq__(other: Any) -> Element

Equal to comparison.

PARAMETER DESCRIPTION
other

The number or Element instance to be compared.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the comparison result.
Source code in pyorlib/algebra/element.py 
302
303
304
305
306
307
308
309
310
311
def __eq__(self, other: Any) -> "Element":  # type: ignore[override]
    """
    Equal to comparison.
    :param other: The `number` or `Element` instance to be compared.
    :return: A new `Element` instance representing the comparison result.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw == other.raw)
    else:
        return self._build_expression(expression=self.raw == other)

__ne__ 

__ne__(other: Any) -> Element

Not equal to comparison.

PARAMETER DESCRIPTION
other

The number or Element instance to be compared.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the comparison result.
Source code in pyorlib/algebra/element.py 
313
314
315
316
317
318
319
320
321
322
def __ne__(self, other: Any) -> "Element":  # type: ignore[override]
    """
    Not equal to comparison.
    :param other: The `number` or `Element` instance to be compared.
    :return: A new `Element` instance representing the comparison result.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw != other.raw)
    else:
        return self._build_expression(expression=self.raw != other)

__lt__ 

__lt__(other: Any) -> Element

Less than comparison.

PARAMETER DESCRIPTION
other

The number or Element instance to be compared.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the comparison result.
Source code in pyorlib/algebra/element.py 
324
325
326
327
328
329
330
331
332
333
def __lt__(self, other: Any) -> "Element":
    """
    Less than comparison.
    :param other: The `number` or `Element` instance to be compared.
    :return: A new `Element` instance representing the comparison result.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw < other.raw)
    else:
        return self._build_expression(expression=self.raw < other)

__le__ 

__le__(other: Any) -> Element

Less than or equal to comparison.

PARAMETER DESCRIPTION
other

The number or Element instance to be compared.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the comparison result.
Source code in pyorlib/algebra/element.py 
335
336
337
338
339
340
341
342
343
344
def __le__(self, other: Any) -> "Element":
    """
    Less than or equal to comparison.
    :param other: The `number` or `Element` instance to be compared.
    :return: A new `Element` instance representing the comparison result.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw <= other.raw)
    else:
        return self._build_expression(expression=self.raw <= other)

__gt__ 

__gt__(other: Any) -> Element

Greater than comparison.

PARAMETER DESCRIPTION
other

The number or Element instance to be compared.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the comparison result.
Source code in pyorlib/algebra/element.py 
346
347
348
349
350
351
352
353
354
355
def __gt__(self, other: Any) -> "Element":
    """
    Greater than comparison.
    :param other: The `number` or `Element` instance to be compared.
    :return: A new `Element` instance representing the comparison result.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw > other.raw)
    else:
        return self._build_expression(expression=self.raw > other)

__ge__ 

__ge__(other: Any) -> Element

Greater than or equal to comparison.

PARAMETER DESCRIPTION
other

The number or Element instance to be compared.

TYPE: Any

RETURNS DESCRIPTION
Element

A new Element instance representing the comparison result.
Source code in pyorlib/algebra/element.py 
357
358
359
360
361
362
363
364
365
366
def __ge__(self, other: Any) -> "Element":
    """
    Greater than or equal to comparison.
    :param other: The `number` or `Element` instance to be compared.
    :return: A new `Element` instance representing the comparison result.
    """
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw >= other.raw)
    else:
        return self._build_expression(expression=self.raw >= other)

__init__ 

__init__(term_type: TermType, value_type: ValueType)

Initializes a new Term object.

PARAMETER DESCRIPTION
term_type

An enumeration representing the type of the term.

TYPE: TermType

value_type

An enumeration representing the type of the term's value.

TYPE: ValueType

Source code in pyorlib/algebra/terms/term.py 
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
def __init__(self, term_type: TermType, value_type: ValueType):
    """
    Initializes a new Term object.
    :param term_type: An enumeration representing the type of the term.
    :param value_type: An enumeration representing the type of the term's value.
    """
    # Applies validations
    if term_type is None:
        raise TermException("Invalid term type.")

    if value_type is None:
        raise TermException("Invalid term value type.")

    # Instance attributes
    self._term_type: TermType = term_type
    """ An enumeration representing the type of the term. """

    self._value_type: ValueType = value_type
    """ An enumeration representing the type of the term's value. """

get_pretty_string abstractmethod 

get_pretty_string(float_precision: int = 6) -> str

Returns a formatted string representation of the term.

PARAMETER DESCRIPTION
float_precision

It represents the number of digits used in printing the solution and objective.

TYPE: int DEFAULT: 6

RETURNS DESCRIPTION
str

A formatted string representing the term.
Source code in pyorlib/algebra/terms/term.py 
123
124
125
126
127
128
129
130
@abstractmethod
def get_pretty_string(self, float_precision: int = 6) -> str:
    """
    Returns a formatted string representation of the term.
    :param float_precision: It represents the number of digits used in printing the solution and objective.
    :return: A formatted string representing the term.
    """
    pass

__iadd__ 

__iadd__(other: Any) -> Element
Source code in pyorlib/algebra/terms/term.py 
144
145
146
147
148
def __iadd__(self, other: Any) -> Element:
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw + other.raw)
    else:
        return self._build_expression(expression=self.raw + other)

__isub__ 

__isub__(other: Any) -> Element
Source code in pyorlib/algebra/terms/term.py 
150
151
152
153
154
def __isub__(self, other: Any) -> Element:
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw - other.raw)
    else:
        return self._build_expression(expression=self.raw - other)

__imul__ 

__imul__(other: Any) -> Element
Source code in pyorlib/algebra/terms/term.py 
156
157
158
159
160
def __imul__(self, other: Any) -> Element:
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw * other.raw)
    else:
        return self._build_expression(expression=self.raw * other)

__itruediv__ 

__itruediv__(other: Any) -> Element
Source code in pyorlib/algebra/terms/term.py 
162
163
164
165
166
def __itruediv__(self, other: Any) -> Element:
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw / other.raw)
    else:
        return self._build_expression(expression=self.raw / other)

__ifloordiv__ 

__ifloordiv__(other: Any) -> Element
Source code in pyorlib/algebra/terms/term.py 
168
169
170
171
172
def __ifloordiv__(self, other: Any) -> Element:
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw // other.raw)
    else:
        return self._build_expression(expression=self.raw // other)

__imod__ 

__imod__(other: Any) -> Element
Source code in pyorlib/algebra/terms/term.py 
174
175
176
177
178
def __imod__(self, other: Any) -> Element:
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw % other.raw)
    else:
        return self._build_expression(expression=self.raw % other)

__ipow__ 

__ipow__(other: Any) -> Element
Source code in pyorlib/algebra/terms/term.py 
180
181
182
183
184
def __ipow__(self, other: Any) -> Element:
    if isinstance(other, Element):
        return self._build_expression(expression=self.raw**other.raw)
    else:
        return self._build_expression(expression=self.raw**other)