HeldExpression

`HeldExpression`

HeldExpression()

Methods

Name	Description
`__add__`	Add this transformer to `other`, returning the result.
`__call__`	Execute a bound transformer
`__eq__`	Compare two transformers.
`__ge__`	Compare two transformers
`__gt__`	Compare two transformers
`__le__`	Compare two transformers
`__lt__`	Compare two transformers
`__mul__`	Add this transformer to `other`, returning the result.
`__neg__`	Negate the current transformer, returning the result.
`__neq__`	Compare two transformers.
`__pow__`	Take `self` to power `exp`, returning the result.
`__radd__`	Add this transformer to `other`, returning the result.
`__rmul__`	Add this transformer to `other`, returning the result.
`__rpow__`	Take `base` to power `self`, returning the result.
`__rsub__`	Subtract this transformer from `other`, returning the result.
`__rtruediv__`	Divide `other` by this transformer, returning the result.
`__rxor__`	Returns a warning that `**` should be used instead of `^` for taking a power.
`__sub__`	Subtract `other` from this transformer, returning the result.
`__truediv__`	Divide this transformer by `other`, returning the result.
`__xor__`	Returns a warning that `**` should be used instead of `^` for taking a power.
`contains`	Create a transformer that checks if the expression contains the given `element`.
`is_type`	Test if the transformed expression is of a certain type.
`matches`	Create a transformer that tests whether the pattern is found in the expression

`add`

HeldExpression.__add__(other: HeldExpression | Expression | int | float | complex | Decimal) -> HeldExpression

Add this transformer to other, returning the result.

`call`

HeldExpression.__call__() -> Expression

Execute a bound transformer. If the transformer is unbound, you can call it with an expression as an argument.

Examples

from symbolica import *
x = S('x')
e = (x+1)**5
e = e.hold(T().expand())()
print(e)

`eq`

HeldExpression.__eq__(other: HeldExpression | Expression | int | float | complex | Decimal) -> Condition

Compare two transformers.

`ge`

HeldExpression.__ge__(other: HeldExpression | Expression | int | float | complex | Decimal) -> Condition

Compare two transformers. If any of the two expressions is not a rational number, an interal ordering is used.

`gt`

HeldExpression.__gt__(other: HeldExpression | Expression | int | float | complex | Decimal) -> Condition

Compare two transformers. If any of the two expressions is not a rational number, an interal ordering is used.

`le`

HeldExpression.__le__(other: HeldExpression | Expression | int | float | complex | Decimal) -> Condition

Compare two transformers. If any of the two expressions is not a rational number, an interal ordering is used.

`lt`

HeldExpression.__lt__(other: HeldExpression | Expression | int | float | complex | Decimal) -> Condition

Compare two transformers. If any of the two expressions is not a rational number, an interal ordering is used.

`mul`

HeldExpression.__mul__(other: HeldExpression | Expression | int | float | complex | Decimal) -> HeldExpression

Add this transformer to other, returning the result.

`neg`

HeldExpression.__neg__() -> HeldExpression

Negate the current transformer, returning the result.

`neq`

HeldExpression.__neq__(other: HeldExpression | Expression | int | float | complex | Decimal) -> Condition

Compare two transformers.

`pow`

HeldExpression.__pow__(exp: HeldExpression | Expression | int | float | complex | Decimal) -> HeldExpression

Take self to power exp, returning the result.

`radd`

HeldExpression.__radd__(other: HeldExpression | Expression | int | float | complex | Decimal) -> HeldExpression

Add this transformer to other, returning the result.

`rmul`

HeldExpression.__rmul__(other: HeldExpression | Expression | int | float | complex | Decimal) -> HeldExpression

Add this transformer to other, returning the result.

`rpow`

HeldExpression.__rpow__(base: HeldExpression | Expression | int | float | complex | Decimal) -> HeldExpression

Take base to power self, returning the result.

`rsub`

HeldExpression.__rsub__(other: HeldExpression | Expression | int | float | complex | Decimal) -> HeldExpression

Subtract this transformer from other, returning the result.

`rtruediv`

HeldExpression.__rtruediv__(other: HeldExpression | Expression | int | float | complex | Decimal) -> HeldExpression

Divide other by this transformer, returning the result.

`rxor`

HeldExpression.__rxor__(a: Any) -> HeldExpression

Returns a warning that ** should be used instead of ^ for taking a power.

`sub`

HeldExpression.__sub__(other: HeldExpression | Expression | int | float | complex | Decimal) -> HeldExpression

Subtract other from this transformer, returning the result.

`truediv`

HeldExpression.__truediv__(other: HeldExpression | Expression | int | float | complex | Decimal) -> HeldExpression

Divide this transformer by other, returning the result.

`xor`

HeldExpression.__xor__(a: Any) -> HeldExpression

Returns a warning that ** should be used instead of ^ for taking a power.

`contains`

HeldExpression.contains(element: HeldExpression | Expression | int | float | complex | Decimal) -> Condition

Create a transformer that checks if the expression contains the given element.

`is_type`

HeldExpression.is_type(atom_type: AtomType) -> Condition

Test if the transformed expression is of a certain type.

`matches`

HeldExpression.matches(
    lhs: Expression | int | float | complex | Decimal,
    cond: Optional[PatternRestriction | Condition] = None,
    min_level: int = 0,
    max_level: Optional[int] = None,
    level_range: Optional[Tuple[int, Optional[int]]] = None,
    level_is_tree_depth: bool = False,
    partial: bool = True,
    allow_new_wildcards_on_rhs: bool = False,
) -> Condition

Create a transformer that tests whether the pattern is found in the expression. Restrictions on the pattern can be supplied through cond.