Transformer

Transformer()

Operations that transform an expression.

Methods

Name Description
chain Chain several transformers. chain(A,B,C) is the same as A.B.C,
check_interrupt Create a transformer that checks for a Python interrupt,
deduplicate Create a transformer that removes elements from a list if they occur
derivative Create a transformer that derives self w.r.t the variable x.
execute Execute the transformer.
expand Create a transformer that expands products and powers.
for_each Create a transformer that applies a transformer chain to every argument of the arg() function.
from_coeff Create a transformer that extracts a rational polynomial from a coefficient.
map Create a transformer that applies a Python function.
nargs Create a transformer that returns the number of arguments.
partitions Create a transformer that partitions a list of arguments into named bins of a given length,
permutations Create a transformer that generates all permutations of a list of arguments.
print Create a transformer that prints the expression.
prod Create a transformer that computes the product of a list of arguments.
repeat Create a transformer that repeatedly executes the arguments in order
replace_all Create a transformer that replaces all subexpressions matching the pattern pat by the right-hand side rhs.
series Create a transformer that series expands in x around expansion_point to depth depth.
sort Create a transformer that sorts a list of arguments.
split Create a transformer that split a sum or product into a list of arguments.
stats Print statistics of a transformer, tagging it with tag.
sum Create a transformer that computes the sum of a list of arguments.

chain

Transformer.chain(*transformers)

Chain several transformers. chain(A,B,C) is the same as A.B.C, where A, B, C are transformers.

Examples

>>> from symbolica import Expression
>>> x_ = Expression.symbol('x_')
>>> f = Expression.symbol('f')
>>> e = Expression.parse("f(5)")
>>> e = e.transform().chain(
>>>     Transformer().expand(),
>>>     Transformer().replace_all(f(x_), f(5))
>>> ).execute()

check_interrupt

Transformer.check_interrupt()

Create a transformer that checks for a Python interrupt, such as ctrl-c and aborts the current transformer.

Examples

>>> from symbolica import *
>>> x_ = Expression.symbol('x_')
>>> f = Expression.symbol('f')
>>> f(10).transform().repeat(Transformer().replace_all(
>>> f(x_), f(x_+1)).check_interrupt()).execute()

deduplicate

Transformer.deduplicate()

Create a transformer that removes elements from a list if they occur earlier in the list as well.

Examples

>>> from symbolica import Expression, Transformer
>>> x__ = Expression.symbol('x__')
>>> f = Expression.symbol('f')
>>> e = f(1,2,1,2).replace_all(f(x__), x__.transform().deduplicate())
>>> print(e)

Yields f(1,2).

derivative

Transformer.derivative(x)

Create a transformer that derives self w.r.t the variable x.

execute

Transformer.execute()

Execute the transformer.

Examples

>>> from symbolica import Expression
>>> x = Expression.symbol('x')
>>> e = (x+1)**5
>>> e = e.transform().expand().execute()
>>> print(e)

expand

Transformer.expand(var=None)

Create a transformer that expands products and powers.

Examples

>>> from symbolica import Expression, Transformer
>>> x, x_ = Expression.symbols('x', 'x_')
>>> f = Expression.symbol('f')
>>> e = f((x+1)**2).replace_all(f(x_), x_.transform().expand())
>>> print(e)

for_each

Transformer.for_each(*transformers)

Create a transformer that applies a transformer chain to every argument of the arg() function. If the input is not arg(), the transformer is applied to the input.

Examples

>>> from symbolica import Expression
>>> x = Expression.symbol('x')
>>> f = Expression.symbol('f')
>>> e = (1+x).transform().split().for_each(Transformer().map(f)).execute()

from_coeff

Transformer.from_coeff()

Create a transformer that extracts a rational polynomial from a coefficient.

Examples

>>> from symbolica import Expression, Function
>>> e = Expression.COEFF((x^2+1)/y^2).transform().from_coeff()
>>> print(e)

map

Transformer.map(f)

Create a transformer that applies a Python function.

Examples

>>> from symbolica import Expression, Transformer
>>> x_ = Expression.symbol('x_')
>>> f = Expression.symbol('f')
>>> e = f(2).replace_all(f(x_), x_.transform().map(lambda r: r**2))
>>> print(e)

nargs

Transformer.nargs(only_for_arg_fun=False)

Create a transformer that returns the number of arguments. If the argument is not a function, return 0.

If only_for_arg_fun is True, only count the number of arguments in the arg() function and return 1 if the input is not arg. This is useful for obtaining the length of a range during pattern matching.

Examples

>>> from symbolica import Expression, Transformer
>>> x__ = Expression.symbol('x__')
>>> f = Expression.symbol('f')
>>> e = f(2,3,4).replace_all(f(x__), x__.transform().nargs())
>>> print(e)

partitions

Transformer.partitions(bins, fill_last=False, repeat=False)

Create a transformer that partitions a list of arguments into named bins of a given length, returning all partitions and their multiplicity.

If the unordered list elements is larger than the bins, setting the flag fill_last will add all remaining elements to the last bin.

Setting the flag repeat means that the bins will be repeated to exactly fit all elements, if possible.

Note that the functions names to be provided for the bin names must be generated through Expression.var.

Examples

>>> from symbolica import Expression, Transformer
>>> x_, f_id, g_id = Expression.symbols('x__', 'f', 'g')
>>> f = Expression.symbol('f')
>>> e = f(1,2,1,3).replace_all(f(x_), x_.transform().partitions([(f_id, 2), (g_id, 1), (f_id, 1)]))
>>> print(e)

yields:

2*f(1)*f(1,2)*g(3)+2*f(1)*f(1,3)*g(2)+2*f(1)*f(2,3)*g(1)+f(2)*f(1,1)*g(3)+2*f(2)*f(1,3)*g(1)+f(3)*f(1,1)*g(2)+2*f(3)*f(1,2)*g(1)

permutations

Transformer.permutations(function_name)

Create a transformer that generates all permutations of a list of arguments.

Examples

>>> from symbolica import Expression, Transformer
>>> x_, f_id = Expression.symbols('x__', 'f')
>>> f = Expression.symbol('f')
>>> e = f(1,2,1,2).replace_all(f(x_), x_.transform().permutations(f_id)
>>> print(e)

yields:

4*f(1,1,2,2)+4*f(1,2,1,2)+4*f(1,2,2,1)+4*f(2,1,1,2)+4*f(2,1,2,1)+4*f(2,2,1,1)

print

Transformer.print(terms_on_new_line=False, color_top_level_sum=True, color_builtin_symbols=True, print_finite_field=True, symmetric_representation_for_finite_field=False, explicit_rational_polynomial=False, number_thousands_separator=None, multiplication_operator='*', square_brackets_for_function=False, num_exp_as_superscript=True, latex=False)

Create a transformer that prints the expression.

Examples

>>> Expression.parse('f(10)').transform().print(terms_on_new_line = True).execute()

prod

Transformer.prod()

Create a transformer that computes the product of a list of arguments.

Examples

>>> from symbolica import Expression, Transformer
>>> x__ = Expression.symbol('x__')
>>> f = Expression.symbol('f')
>>> e = f(2,3).replace_all(f(x__), x__.transform().prod())
>>> print(e)

repeat

Transformer.repeat(*transformers)

Create a transformer that repeatedly executes the arguments in order until there are no more changes. The output from one transformer is inserted into the next.

Examples

>>> from symbolica import Expression
>>> x_ = Expression.symbol('x_')
>>> f = Expression.symbol('f')
>>> e = Expression.parse("f(5)")
>>> e = e.transform().repeat(
>>>     Transformer().expand(),
>>>     Transformer().replace_all(f(x_), f(x_ - 1) + f(x_ - 2), x_.req_gt(1))
>>> ).execute()

replace_all

Transformer.replace_all(pat, rhs, cond=None, non_greedy_wildcards=None, level_range=None, level_is_tree_depth=False)

Create a transformer that replaces all subexpressions matching the pattern pat by the right-hand side rhs.

Examples

>>> x, w1_, w2_ = Expression.symbols('x','w1_','w2_')
>>> f = Expression.symbol('f')
>>> e = f(3,x)
>>> r = e.transform().replace_all(f(w1_,w2_), f(w1_ - 1, w2_**2), (w1_ >= 1) & w2_.is_var())
>>> print(r)

Parameters

Name Type Description Default
pat symbolica.Transformer | symbolica.Expression | int required
rhs symbolica.Transformer | symbolica.Expression | int required
cond typing.Optional[symbolica.PatternRestriction] None
non_greedy_wildcards typing.Optional[typing.Sequence[symbolica.Expression]] None
level_range typing.Optional[typing.Tuple[int, typing.Optional[int]]] None
level_is_tree_depth typing.Optional[bool] False
repeat required

series

Transformer.series(x, expansion_point, depth, depth_denom=1)

Create a transformer that series expands in x around expansion_point to depth depth.

Examples

>>> from symbolica import Expression
>>> x, y = Expression.symbols('x', 'y')
>>> f = Expression.symbol('f')
>>>
>>> e = 2* x**2 * y + f(x)
>>> e = e.series(x, 0, 2)
>>>
>>> print(e)

yields f(0)+x*der(1,f(0))+1/2*x^2*(der(2,f(0))+4*y).

sort

Transformer.sort()

Create a transformer that sorts a list of arguments.

Examples

>>> from symbolica import Expression, Transformer
>>> x__ = Expression.symbol('x__')
>>> f = Expression.symbol('f')
>>> e = f(3,2,1).replace_all(f(x__), x__.transform().sort())
>>> print(e)

split

Transformer.split()

Create a transformer that split a sum or product into a list of arguments.

Examples

>>> from symbolica import Expression, Transformer
>>> x, x__ = Expression.symbols('x', 'x__')
>>> f = Expression.symbol('f')
>>> e = (x + 1).replace_all(x__, f(x_.transform().split()))
>>> print(e)

stats

Transformer.stats(tag, transformer, color_medium_change_threshold=10.0, color_large_change_threshold=100.0)

Print statistics of a transformer, tagging it with tag.

Examples

>>> from symbolica import Expression
>>> x_ = Expression.symbol('x_')
>>> f = Expression.symbol('f')
>>> e = Expression.parse("f(5)")
>>> e = e.transform().stats('replace', Transformer().replace_all(f(x_), 1)).execute()

yields

Stats for replace:
    In  │ 1 │  10.00 B │
    Out │ 1 │   3.00 B │ ⧗ 40.15µs

sum

Transformer.sum()

Create a transformer that computes the sum of a list of arguments.

Examples

>>> from symbolica import Expression, Transformer
>>> x__ = Expression.symbol('x__')
>>> f = Expression.symbol('f')
>>> e = f(2,3).replace_all(f(x__), x__.transform().sum())
>>> print(e)