CompiledTensorEvaluator

Symbolica documentation for getting started, symbolic expressions, numerical evaluation, pattern matching, and APIs in Python and Rust.

`CompiledTensorEvaluator`

class CompiledTensorEvaluator

A tensor evaluator compiled into a loaded native library.

Create this object with TensorEvaluator.compile. Its input ordering, output shape, and real/complex evaluation rules match TensorEvaluator. Compilation requires a C++ compiler and writes source and library files.

Examples

from symbolica import S
from symbolica.community.tensor import Tensor, TensorName, Representation
x = S("x")
values = Tensor.dense(TensorName.vector("eval_v")(Representation.euc(2)), [x, x**2])
evaluator = values.evaluator({}, {}, [x], iterations=1, n_cores=1)
from tempfile import TemporaryDirectory
directory = TemporaryDirectory()
compiled = evaluator.compile("eval", directory.name + "/eval.cpp", directory.name + "/eval", inline_asm="none")
compiled.evaluate([[2.0]])[0][1]
4.0
directory.cleanup()

Attributes

Name	Description
`input_size`	Number of values required in each evaluation row.
`output_shape`	Logical component shape of each result tensor.
`parameters`	Symbolic inputs in the required evaluation order.
`supports_real`	Whether a real-valued evaluation path is available.

`input_size`

CompiledTensorEvaluator.input_size: builtins.int

Number of values required in each evaluation row.

Returns

int Length of parameters.

Examples

from symbolica import S
from symbolica.community.tensor import Tensor, TensorName, Representation
x = S("x")
values = Tensor.dense(TensorName.vector("eval_v")(Representation.euc(2)), [x, x**2])
evaluator = values.evaluator({}, {}, [x], iterations=1, n_cores=1)
from tempfile import TemporaryDirectory
directory = TemporaryDirectory()
compiled = evaluator.compile("eval", directory.name + "/eval.cpp", directory.name + "/eval", inline_asm="none")
compiled.input_size
1
directory.cleanup()

`output_shape`

CompiledTensorEvaluator.output_shape: tuple[int, ...]

Logical component shape of each result tensor.

Returns

tuple of int Shape excluding the batch dimension.

Examples

from symbolica import S
from symbolica.community.tensor import Tensor, TensorName, Representation
x = S("x")
values = Tensor.dense(TensorName.vector("eval_v")(Representation.euc(2)), [x, x**2])
evaluator = values.evaluator({}, {}, [x], iterations=1, n_cores=1)
from tempfile import TemporaryDirectory
directory = TemporaryDirectory()
compiled = evaluator.compile("eval", directory.name + "/eval.cpp", directory.name + "/eval", inline_asm="none")
compiled.output_shape
(2,)
directory.cleanup()

`parameters`

CompiledTensorEvaluator.parameters: builtins.list[Expression]

Symbolic inputs in the required evaluation order.

Returns

list of Expression One entry for each value in an input row.

Examples

from symbolica import S
from symbolica.community.tensor import Tensor, TensorName, Representation
x = S("x")
values = Tensor.dense(TensorName.vector("eval_v")(Representation.euc(2)), [x, x**2])
evaluator = values.evaluator({}, {}, [x], iterations=1, n_cores=1)
from tempfile import TemporaryDirectory
directory = TemporaryDirectory()
compiled = evaluator.compile("eval", directory.name + "/eval.cpp", directory.name + "/eval", inline_asm="none")
compiled.parameters == [x]
True
directory.cleanup()

`supports_real`

CompiledTensorEvaluator.supports_real: builtins.bool

Whether a real-valued evaluation path is available.

Returns

bool False when the formulas contain complex coefficients; use evaluate_complex in that case.

Examples

from symbolica import S
from symbolica.community.tensor import Tensor, TensorName, Representation
x = S("x")
values = Tensor.dense(TensorName.vector("eval_v")(Representation.euc(2)), [x, x**2])
evaluator = values.evaluator({}, {}, [x], iterations=1, n_cores=1)
from tempfile import TemporaryDirectory
directory = TemporaryDirectory()
compiled = evaluator.compile("eval", directory.name + "/eval.cpp", directory.name + "/eval", inline_asm="none")
compiled.supports_real
True
directory.cleanup()

Methods

Name	Description
`__repr__`	Return a description of the tensor layout and available numerical kernels.
`evaluate`	Evaluate a batch of real input rows.
`evaluate_complex`	Evaluate a batch of complex input rows.

`repr`

CompiledTensorEvaluator.__repr__() -> builtins.str

Return a description of the tensor layout and available numerical kernels.

Examples

from symbolica.community import tensor as sp
from symbolica import E, S
r = sp.Representation.euc(2)
A = sp.TensorName("docs::A")(r, r)
x = S("docs::x")
tensor = sp.Tensor.dense(A, [x, E("0"), E("0"), x + 1])
evaluator = tensor.evaluator({}, {}, [x], iterations=1, n_cores=1)
from pathlib import Path
from tempfile import TemporaryDirectory
with TemporaryDirectory() as directory:
    folder = Path(directory)
    compiled = evaluator.compile("docs_eval", str(folder / "eval.cpp"), str(folder / "eval.so"), inline_asm="none", optimization_level=0)
    results = compiled.evaluate([[2.0], [3.0]])
    text = repr(compiled)

`evaluate`

CompiledTensorEvaluator.evaluate(inputs: typing.Sequence[typing.Sequence[builtins.float]]) -> builtins.list[Tensor]

Evaluate a batch of real input rows.

Parameters

inputs (sequence of sequences of float) One row per evaluation, with input_size entries in parameters order.

Returns

list of Tensor One real component tensor per input row, each with output_shape.

Raises

ValueError: A row has the wrong size, or the formulas contain complex coefficients. Use evaluate_complex for those formulas.

Examples

from symbolica import S
from symbolica.community.tensor import Tensor, TensorName, Representation
x = S("x")
values = Tensor.dense(TensorName.vector("eval_v")(Representation.euc(2)), [x, x**2])
evaluator = values.evaluator({}, {}, [x], iterations=1, n_cores=1)
from tempfile import TemporaryDirectory
directory = TemporaryDirectory()
compiled = evaluator.compile("eval", directory.name + "/eval.cpp", directory.name + "/eval", inline_asm="none")
compiled.evaluate([[2.0]])[0][1]
4.0
directory.cleanup()

`evaluate_complex`

CompiledTensorEvaluator.evaluate_complex(inputs: typing.Sequence[typing.Sequence[builtins.complex]]) -> builtins.list[Tensor]

Evaluate a batch of complex input rows.

Parameters

inputs (sequence of sequences of complex) One row per evaluation, with input_size entries in parameters order.

Returns

list of Tensor One complex component tensor per input row, each with output_shape.

Raises

ValueError: A row has the wrong size.

Examples

from symbolica import S
from symbolica.community.tensor import Tensor, TensorName, Representation
x = S("x")
values = Tensor.dense(TensorName.vector("eval_v")(Representation.euc(2)), [x, x**2])
evaluator = values.evaluator({}, {}, [x], iterations=1, n_cores=1)
from tempfile import TemporaryDirectory
directory = TemporaryDirectory()
compiled = evaluator.compile("eval", directory.name + "/eval.cpp", directory.name + "/eval", inline_asm="none")
compiled.evaluate_complex([[2.0]])[0][1]
(4+0j)
directory.cleanup()