concepts.dsl.executors.tensor_value_executor.TensorValueExecutorBase#

class TensorValueExecutorBase[source]#

Bases: DSLExecutorBase

The base class for tensor value executors.

Methods

`check_constraint`(constraint[, state])
`check_eq_constraint`(dtype, x, y, target[, state])
`execute`(expression[, state, bounded_variables])	Execute an expression.
`get_bounded_variable`(variable)	Get the value of a bounded variable.
`get_function_implementation`(name)	Get the implementation of a function.
`has_function_implementation`(name)	Check whether the executor has an implementation for a function.
`new_bounded_variables`(bvdict)	A context manager to add additional bounded variables to the executor.
`parse`(expression)	Parse an expression.
`register_function`(name, func)	Register an implementation for a function to the executor.
`register_function_implementation`(name, func)	Register an implementation for a function.
`retrieve_bounded_variable_by_name`(name)	Retrieve a bounded variable by its name.
`set_parser`(parser)	Set the parser for the executor.
`with_bounded_variables`(bvdict[, ...])	A context manager to set the bounded variables for the executor.
`with_state`([state])	A context manager to temporarily set the state of the executor.

Attributes

`bounded_variables`	The bounded variables for the execution.
`domain`	The domain of the executor.
`function_implementations`	The implementations of functions, which is a mapping from function names to implementations.
`parser`	The parser for the domain.
`pyobj_store`	The Python object store.
`state`	The current state of the environment.
`value_quantizer`	The value quantizer.

__init__(domain, parser=None)[source]#

Initialize the base class for tensor value executors.

Parameters:

domain (DSLDomainBase) – the domain of the executor.
parser (ParserBase | None) – the parser to use. If None, no parser will be used.

__new__(**kwargs)#

check_constraint(constraint, state=None)[source]#

Parameters:

constraint (Constraint)
state (TensorState | None)

check_eq_constraint(dtype, x, y, target, state=None)[source]#

Parameters:

dtype (TensorValueTypeBase)
x (TensorValue)
y (TensorValue)
target (bool)
state (TensorState | None)

Return type:

bool

execute(expression, state=None, bounded_variables=None)[source]#

Execute an expression.

Parameters:

expression (Expression | str) – the expression to execute.
state (TensorState | None) – the state to use. If None, the current state of the executor will be used.
bounded_variables (None | Sequence[Variable] | Dict[str | Variable, str | int | slice | bool | float | Tensor | TensorValue | ObjectConstant | StateObjectReference] | Dict[str, Dict[str, StateObjectReference | slice | TensorValue]]) – the bounded variables to use. If None, the current bounded variables of the executor will be used.

Returns:

the TensorValue object.

Return type:

get_bounded_variable(variable)[source]#

Get the value of a bounded variable.

Parameters:: variable (Variable) – the variable.
Returns:: the value of the variable.
Return type:: TensorValue | slice | StateObjectReference

get_function_implementation(name)#

Get the implementation of a function. When the executor does not have an implementation for the function, the implementation of the function in the domain will be returned. If that is also None, a KeyError will be raised.

Parameters:: name (str) – the name of the function.
Returns:: the implementation of the function.
Return type:: Callable

has_function_implementation(name)#

Check whether the executor has an implementation for a function.

Parameters:: name (str) – the name of the function.
Returns:: whether the executor has an implementation for the function.
Return type:: bool

new_bounded_variables(bvdict)[source]#

A context manager to add additional bounded variables to the executor.

Parameters:: bvdict (None | Sequence[Variable] | Dict[str | Variable, str | int | slice | bool | float | Tensor | TensorValue | ObjectConstant | StateObjectReference] | Dict[str, Dict[str, StateObjectReference | slice | TensorValue]]) – the new bounded variables.

parse(expression)[source]#

Parse an expression.

Parameters:: expression (Expression | str) – the expression to parse. When the input is already an expression, it will be returned directly.
Returns:: the parsed expression.

register_function(name, func)#

Parameters:

name (str) – the name of the function.
func (Callable) – the implementation of the function.

register_function_implementation(name, func)#

Parameters:

name (str) – the name of the function.
func (Callable) – the implementation of the function.

retrieve_bounded_variable_by_name(name)[source]#

Retrieve a bounded variable by its name.

Parameters:: name (str) – the name of the variable.
Returns:: the value of the variable.
Return type:: TensorValue | slice | StateObjectReference

set_parser(parser)[source]#

Set the parser for the executor.

Parameters:: parser (ParserBase) – the parser.

with_bounded_variables(bvdict, bypass_bounded_variable_check=False)[source]#

A context manager to set the bounded variables for the executor.

Parameters:

bvdict (None | Sequence[Variable] | Dict[str | Variable, str | int | slice | bool | float | Tensor | TensorValue | ObjectConstant | StateObjectReference] | Dict[str, Dict[str, StateObjectReference | slice | TensorValue]]) – the bounded variables.
bypass_bounded_variable_check (bool) – whether to bypass the check for the bounded variables. If True, the input bounded variables will be used directly without any modification. Otherwise, the input bounded variables will be composed with the current state of the executor.

with_state(state=None)[source]#

A context manager to temporarily set the state of the executor.

Parameters:: state (TensorState | None)

property bounded_variables: Dict[str, Dict[str, StateObjectReference | slice | TensorValue]]#: The bounded variables for the execution. Note that most of the time you should use the get_bounded_variable() method to get values for the bounded variable.

property domain: DSLDomainBase#: The domain of the executor.

property function_implementations: Dict[str, Callable]#: The implementations of functions, which is a mapping from function names to implementations.

property parser: ParserBase | None#: The parser for the domain.

property pyobj_store: PyObjectStore#: The Python object store.

property state: TensorState | None#: The current state of the environment.

property value_quantizer: ValueQuantizer#: The value quantizer.