TensorEvaluator

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

`TensorEvaluator`

class TensorEvaluator

Symbolica evaluator returning component tensors in their original logical layout.

Construct with Tensor.evaluator. The scalar_evaluator property exposes the underlying Symbolica Evaluator for precision evaluation, export and inspection.

Attributes

Name	Description
`input_size`	Number of entries in an input row.
`output_shape`	Logical shape of each output tensor, excluding the batch dimension.
`parameters`	Symbolic inputs in evaluation order.
`scalar_evaluator`	Underlying Symbolica Evaluator, with outputs in logical component order
`supports_real`	Whether all exact coefficients are real.

`input_size`

TensorEvaluator.input_size: builtins.int

Number of entries in an input row.

`output_shape`

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

Logical shape of each output tensor, excluding the batch dimension.

`parameters`

TensorEvaluator.parameters: builtins.list[Expression]

Symbolic inputs in evaluation order.

`scalar_evaluator`

TensorEvaluator.scalar_evaluator: Evaluator

Underlying Symbolica Evaluator, with outputs in logical component order.

Use for arbitrary-precision evaluation, export, or instruction inspection. These operations return scalar components; they do not wrap tensor metadata.

`supports_real`

TensorEvaluator.supports_real: builtins.bool

Whether all exact coefficients are real.

Methods

Name	Description
`__repr__`
`compile`	Compile a native evaluator with the same options as Evaluator.compile
`evaluate`	Evaluate real inputs using Symbolica’s ArrayLike input conventions
`evaluate_complex`	Evaluate complex inputs; returns one Tensor per input row.
`jit_compile`	Enable or disable JIT compilation with Symbolica’s settings.
`set_real_params`	Mark real parameters using the same assumptions as Evaluator.set_real_params.

`repr`

TensorEvaluator.__repr__() -> builtins.str

`compile`

TensorEvaluator.compile(
    function_name: builtins.str,
    filename: builtins.str,
    library_name: builtins.str,
    number_type: builtins.str,
    inline_asm: builtins.str = 'default',
    optimization_level: builtins.int = 3,
    native: builtins.bool = True,
    compiler_path: typing.Optional[builtins.str] = None,
    compiler_flags: typing.Optional[typing.Sequence[builtins.str]] = None,
    custom_header: typing.Optional[builtins.str] = None,
    cuda_number_of_evaluations: builtins.int = 1,
    cuda_block_size: builtins.int = 512,
) -> CompiledTensorEvaluator

Compile a native evaluator with the same options as Evaluator.compile.

number_type selects real, complex, real_4x, complex_4x, cuda_real or cuda_complex. The returned object’s evaluate method uses that number type and returns tensors. Source and library files are written to the given paths.

`evaluate`

TensorEvaluator.evaluate(inputs: numpy.typing.ArrayLike) -> builtins.list[Tensor]

Evaluate real inputs using Symbolica’s ArrayLike input conventions.

Returns one Tensor per row. A flat input array is also accepted, with the same reshaping and validation as Evaluator.evaluate.

`evaluate_complex`

TensorEvaluator.evaluate_complex(inputs: numpy.typing.ArrayLike) -> builtins.list[Tensor]

Evaluate complex inputs; returns one Tensor per input row.

`jit_compile`

TensorEvaluator.jit_compile(
    jit_compile: builtins.bool,
    direct_translation: typing.Optional[builtins.bool] = None,
    optimization_level: typing.Optional[builtins.int] = None,
    options: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
) -> None

Enable or disable JIT compilation with Symbolica’s settings.

`set_real_params`

TensorEvaluator.set_real_params(
    real_params: typing.Sequence[builtins.int],
    sqrt_real: builtins.bool = False,
    log_real: builtins.bool = False,
    powf_real: builtins.bool = False,
    real_if_args_real: builtins.bool = False,
    verbose: builtins.bool = False,
) -> None

Mark real parameters using the same assumptions as Evaluator.set_real_params.