Reference

Note

Expression trees based on this package are picklable as long as no non-picklable data (e.g. pyopencl.array.Array) is referenced from DataWrapper.

Array Interface

class pytato.Array(tags=frozenset({}))

A base class (abstract interface + supplemental functionality) for lazily evaluating array expressions. The interface seeks to maximize numpy compatibility, though not at all costs.

Objects of this type are hashable and support structural equality comparison (and are therefore immutable).

Note

Hashability and equality testing does break numpy compatibility, purposefully so.

FIXME: Point out our equivalent for numpy’s ==.

shape

A tuple of integers or scalar-shaped Arrays. Array-valued shape components may be (at most affinely) symbolic in terms of SizeParams.

Note

Affine-ness is mainly required by code generation for IndexLambda, but IndexLambda is used to produce references to named arrays. Since any array that needs to be referenced in this way needs to obey this restriction anyway, a decision was made to requir the same of all array expressions.

dtype

An instance of numpy.dtype.

tags

A tuple of pytools.tag.Tag instances.

Motivation: RDF triples (subject: implicitly the array being tagged, predicate: the tag, object: the arg).

Inherits from pytools.tag.Taggable.

tagged(tags)

Return a copy of self with the specified tag or tags unioned. If tags is a pytools.tag.UniqueTag and other tags of this type are already present, an error is raised Assumes self.copy(tags=<NEW VALUE>) is implemented.

Parameters

tags (Union[Iterable[Tag], Tag, None]) – An instance of Tag or an iterable with instances therein.

Return type

~T_co

without_tags(tags, verify_existence=True)

Return a copy of self without the specified tags. self.copy(tags=<NEW VALUE>) is implemented.

Parameters

• tags (Union[Iterable[Tag], Tag, None]) – An instance of Tag or an iterable with instances therein.

• verify_existence (bool) – If set to True, this method raises an exception if not all tags specified for removal are present in the original set of tags. Default True.

Return type

~T_co

Array interface:

__getitem__(slice_spec)

Return type

Array

T

__mul__()

__rmul__()

__add__()

__radd__()

__sub__()

__rsub__()

__truediv__()

__rtruediv__()

__neg__()

__pos__()

Derived attributes:

ndim

class pytato.NamedArray(container, name, tags=frozenset({}))

An entry in a AbstractResultWithNamedArrays. Holds a reference back to thecontaining instance as well as the name by which self is known there.

__init__(container, name, tags=frozenset({}))

Constructor for all objects that possess a tags attribute.

Parameters

tags (FrozenSet[Tag]) – a frozenset of Tag objects. Tags can be modified via the tagged() and without_tags() routines. Input checking of tags should be performed before creating a Taggable instance, using check_tag_uniqueness().

class pytato.DictOfNamedArrays(data)

A container of named results, each of which can be computed as an array expression provided to the constructor.

Implements AbstractResultWithNamedArrays.

__init__(data)

Initialize self. See help(type(self)) for accurate signature.

class pytato.AbstractResultWithNamedArrays

An abstract array computation that results in multiple Arrays, each named. The way in which the values of these arrays are computed is determined by concrete subclasses of this class, e.g. pytato.loopy.LoopyCall or DictOfNamedArrays.

__init__()

Initialize self. See help(type(self)) for accurate signature.

abstract __contains__(name)

Return type

bool

abstract __getitem__(name)

Return type

NamedArray

abstract __len__()

Return type

int

Note

This container deliberately does not implement arithmetic.

NumPy-Like Interface

These functions generally follow the interface of the corresponding functions in numpy, but not all NumPy features may be supported.

pytato.matmul(x1, x2)

Matrix multiplication.

Parameters

• x1 (Array) – first argument

• x2 (Array) – second argument

Return type

Array

pytato.roll(a, shift, axis=None)

Roll array elements along a given axis.

Parameters

• a (Array) – input array

• shift (int) – the number of places by which elements are shifted

• axis (Optional[int]) – axis along which the array is shifted

Return type

Array

pytato.transpose(a, axes=None)

Reverse or permute the axes of an array.

Parameters

• a (Array) – input array

• axes (Optional[Sequence[int]]) – if specified, a permutation of [0, 1, ..., a.ndim-1]. Defaults to range(a.ndim)[::-1]. The returned axis at index i corresponds to the input axis axes[i].

Return type

Array

pytato.stack(arrays, axis=0)

Join a sequence of arrays along a new axis.

The axis parameter specifies the position of the new axis in the result.

Example:

>>> arrays = [pt.zeros(3)] * 4
>>> pt.stack(arrays, axis=0).shape
(4, 3)

Parameters

• arrays (Sequence[Array]) – a finite sequence, each of whose elements is an Array of the same shape

• axis (int) – the position of the new axis, which will have length len(arrays)

Return type

Array

pytato.concatenate(arrays, axis=0)

Join a sequence of arrays along an existing axis.

Example:

>>> arrays = [pt.zeros(3)] * 4
>>> pt.concatenate(arrays, axis=0).shape
(12,)

Parameters

• arrays (Sequence[Array]) – a finite sequence, each of whose elements is an Array . The arrays are of the same shape except along the axis dimension.

• axis (int) – The axis along which the arrays will be concatenated.

Return type

Array

pytato.abs(x)

Return type

Union[Array, Number, bool_, bool]

pytato.sqrt(x)

Return type

Union[Array, Number, bool_, bool]

pytato.sin(x)

Return type

Union[Array, Number, bool_, bool]

pytato.cos(x)

Return type

Union[Array, Number, bool_, bool]

pytato.tan(x)

Return type

Union[Array, Number, bool_, bool]

pytato.arcsin(x)

Return type

Union[Array, Number, bool_, bool]

pytato.arccos(x)

Return type

Union[Array, Number, bool_, bool]

pytato.arctan(x)

Return type

Union[Array, Number, bool_, bool]

pytato.sinh(x)

Return type

Union[Array, Number, bool_, bool]

pytato.cosh(x)

Return type

Union[Array, Number, bool_, bool]

pytato.tanh(x)

Return type

Union[Array, Number, bool_, bool]

pytato.exp(x)

Return type

Union[Array, Number, bool_, bool]

pytato.log(x)

Return type

Union[Array, Number, bool_, bool]

pytato.log10(x)

Return type

Union[Array, Number, bool_, bool]

pytato.isnan(x)

Return type

Union[Array, Number, bool_, bool]

pytato.zeros(shape, dtype=<class 'float'>, order='C')

Returns an array of shape shape with all entries equal to 0.

Return type

Array

pytato.ones(shape, dtype=<class 'float'>, order='C')

Returns an array of shape shape with all entries equal to 1.

Return type

Array

pytato.full(shape, fill_value, dtype, order='C')

Returns an array of shape shape with all entries equal to fill_value.

Return type

Array

pytato.equal(x1, x2)

Returns (x1 == x2) element-wise.

Return type

Union[Array, bool]

pytato.not_equal(x1, x2)

Returns (x1 != x2) element-wise.

Return type

Union[Array, bool]

pytato.less(x1, x2)

Returns (x1 < x2) element-wise.

Return type

Union[Array, bool]

pytato.less_equal(x1, x2)

Returns (x1 <= x2) element-wise.

Return type

Union[Array, bool]

pytato.greater(x1, x2)

Returns (x1 > x2) element-wise.

Return type

Union[Array, bool]

pytato.greater_equal(x1, x2)

Returns (x1 >= x2) element-wise.

Return type

Union[Array, bool]

pytato.logical_or(x1, x2)

Returns the element-wise logical OR of x1 and x2.

Return type

Union[Array, bool]

pytato.logical_and(x1, x2)

Returns the element-wise logical AND of x1 and x2.

Return type

Union[Array, bool]

pytato.logical_not(x)

Returns the element-wise logical NOT of x.

Return type

Union[Array, bool]

pytato.where(condition, x=None, y=None)

Elementwise selector between x and y depending on condition.

Return type

Union[Array, Number, bool_, bool]

pytato.maximum(x1, x2)

Returns the elementwise maximum of x1, x2. x1, x2 being array-like objects that could be broadcasted together. NaNs are propagated.

Return type

Union[Array, Number, bool_, bool]

pytato.minimum(x1, x2)

Returns the elementwise minimum of x1, x2. x1, x2 being array-like objects that could be broadcasted together. NaNs are propagated.

Return type

Union[Array, Number, bool_, bool]

pytato.sum(a, axis=None)

Sums array a’s elements along the axis axes.

Parameters

• a (Array) – The pytato.Array on which to perform the reduction.

• axis (Union[int, Tuple[int], None]) – The axes along which the elements are to be sum-reduced. Defaults to all axes of the input array.

Return type

Array

pytato.amin(a, axis=None)

Returns the min of array a’s elements along the axis axes.

Parameters

• a (Array) – The pytato.Array on which to perform the reduction.

• axis (Union[int, Tuple[int], None]) – The axes along which the elements are to be min-reduced. Defaults to all axes of the input array.

Return type

Array

pytato.amax(a, axis=None)

Returns the max of array a’s elements along the axis axes.

Parameters

• a (Array) – The pytato.Array on which to perform the reduction.

• axis (Union[int, Tuple[int], None]) – The axes along which the elements are to be max-reduced. Defaults to all axes of the input array.

Return type

Array

pytato.prod(a, axis=None)

Returns the product of array a’s elements along the axis axes.

Parameters

• a (Array) – The pytato.Array on which to perform the reduction.

• axis (Union[int, Tuple[int], None]) – The axes along which the elements are to be product-reduced. Defaults to all axes of the input array.

Return type

Array

Supporting Functionality

Concrete Array Data

class pytato.array.DataInterface(*args, **kwargs)

A protocol specifying the minimal interface requirements for concrete array data supported by DataWrapper.

See typing.Protocol for more information about protocols.

Code generation targets may impose additional restrictions on the kinds of concrete array data they support.

shape

dtype

Pre-Defined Tags

class pytato.array.ImplementAs(strategy)

strategy

class pytato.array.ImplementationStrategy

class pytato.array.CountNamed(name)

name

class pytato.array.ImplStored

class pytato.array.ImplInlined

class pytato.array.ImplDefault

Built-in Expression Nodes

class pytato.array.IndexLambda(expr, shape, dtype, bindings=None, tags=frozenset({}))

Represents an array that can be computed by evaluating expr for every value of the input indices. The input indices are represented by Variables with names _1, _2, and so on.

expr

A scalar-valued pymbolic expression such as a[_1] + b[_2, _1].

Identifiers in the expression are resolved, in order, by lookups in bindings.

Scalar functions in this expression must be identified by a dotted name representing a Python object (e.g. pytato.c99.sin).

bindings

A dict mapping strings that are valid Python identifiers to objects implementing the Array interface, making array expressions available for use in expr.

class pytato.array.Einsum(tags=frozenset({}))

class pytato.array.MatrixProduct(x1, x2, tags=frozenset({}))

A product of two matrices, or a matrix and a vector.

The semantics of this operation follow PEP 465 [pep465], i.e., the Python matmul (@) operator.

x1

x2

pep465

https://www.python.org/dev/peps/pep-0465/

class pytato.array.Stack(arrays, axis, tags=frozenset({}))

Join a sequence of arrays along an axis.

arrays

The sequence of arrays to join

axis

The output axis

class pytato.array.Concatenate(arrays, axis, tags=frozenset({}))

Join a sequence of arrays along an existing axis.

arrays

An instance of tuple of the arrays to join. The arrays must have same shape except for the dimension corresponding to axis.

axis

The axis along which the arrays are to be concatenated.

Index Remapping

class pytato.array.IndexRemappingBase(array, tags=frozenset({}))

Base class for operations that remap the indices of an array.

Note that index remappings can also be expressed via IndexLambda.

array

The input Array

class pytato.array.Roll(array, shift, axis, tags=frozenset({}))

Roll an array along an axis.

shift

Shift amount.

axis

Shift axis.

class pytato.array.AxisPermutation(array, axes, tags=frozenset({}))

Permute the axes of an array.

axes

A permutation of the input axes.

class pytato.array.Reshape(array, newshape, order, tags=frozenset({}))

Reshape an array.

array

The array to be reshaped

newshape

The output shape

order

Output layout order, either C or F.

class pytato.array.Slice(array, starts, stops, tags=frozenset({}))

Extracts a slice of constant size from an array.

starts

stops

Input Arguments

class pytato.array.InputArgumentBase(name, tags=frozenset({}))

Base class for input arguments.

name

The name by which a value is supplied for the argument once computation begins. If None, a unique name will be assigned during code-generation.

Note

Creating multiple instances of any input argument with the same name in an expression is not allowed.

class pytato.array.DataWrapper(name, data, shape, tags=frozenset({}))

Takes concrete array data and packages it to be compatible with the Array interface.

data

A concrete array (containing data), given as, for example, a numpy.ndarray, or a pyopencl.array.Array. This must offer shape and dtype attributes but is otherwise considered opaque. At evaluation time, its type must be understood by the appropriate execution backend.

Starting with the construction of the DataWrapper, this array may not be updated in-place.

class pytato.array.Placeholder(name, shape, dtype, tags=frozenset({}))

A named placeholder for an array whose concrete value is supplied by the user during evaluation.

name

__init__(name, shape, dtype, tags=frozenset({}))

Should not be called directly. Use make_placeholder() instead.

class pytato.array.SizeParam(name, tags=frozenset({}))

A named placeholder for a scalar that may be used as a variable in symbolic expressions for array sizes.

User-Facing Node Creation

Node constructors such as Placeholder.__init__ and __init__ offer limited input validation (in favor of faster execution). Node creation from outside pytato should use the following interfaces:

class pytato.array.ShapeComponent

class pytato.array.ConvertibleToShape

pytato.array.make_dict_of_named_arrays(data)

Make a DictOfNamedArrays object.

Parameters

data (Dict[str, Array]) – member keys and arrays

Return type

DictOfNamedArrays

pytato.array.make_placeholder(shape, dtype, name=None, tags=frozenset({}))

Make a Placeholder object.

Parameters

• name (Optional[str]) – name of the placeholder array, generated automatically if not given

• shape (Union[int, Array, Sequence[Union[int, Array]]]) – shape of the placeholder array

• dtype (Any) – dtype of the placeholder array (must be convertible to numpy.dtype)

• tags (FrozenSet[Tag]) – implementation tags

Return type

Placeholder

pytato.array.make_size_param(name, tags=frozenset({}))

Make a SizeParam.

Size parameters may be used as variables in symbolic expressions for array sizes.

Parameters

• name (str) – name

• tags (FrozenSet[Tag]) – implementation tags

Return type

SizeParam

pytato.array.make_data_wrapper(data, name=None, shape=None, tags=frozenset({}))

Make a DataWrapper.

Parameters

• data (DataInterface) – an instance obeying the DataInterface

• name (Optional[str]) – an optional name, generated automatically if not given

• shape (Union[int, Array, Sequence[Union[int, Array]], None]) – optional shape of the array, inferred from data if not given

• tags (FrozenSet[Tag]) – implementation tags

Return type

DataWrapper

Internal stuff that is only here because the documentation tool wants it

class pytato.array.T_co

A covariant type variable used in, e.g. pytools.tag.Taggable.copy().

Scalar Expressions

pytato.scalar_expr.ScalarExpression

A type for scalar-valued symbolic expressions. Expressions are composable and manipulable via pymbolic.

Concretely, this is an alias for Union[Number, np.bool_, bool, pymbolic.primitives.Expression].

pytato.scalar_expr.parse(s)

Return type

Union[Number, bool_, bool, Expression]

pytato.scalar_expr.get_dependencies(expression, include_idx_lambda_indices=True)

Return the set of variable names in an expression.

Parameters

expression (Any) – A scalar expression, or an expression derived from such (e.g., a tuple of scalar expressions)

Return type

FrozenSet[str]

pytato.scalar_expr.substitute(expression, variable_assigments)

Perform variable substitution in an expression.

Parameters

• expression (Any) – A scalar expression, or an expression derived from such (e.g., a tuple of scalar expressions)

• variable_assigments (Optional[Mapping[str, Any]]) – A mapping from variable names to substitutions

Return type

Any

Transforming Computations

class pytato.transform.CopyMapper

Performs a deep copy of a pytato.array.Array. The typical use of this mapper is to override individual map_ methods in subclasses to permit term rewriting on an expression graph.

class pytato.transform.DependencyMapper

Maps a pytato.array.Array to a frozenset of pytato.array.Array’s it depends on.

class pytato.transform.WalkMapper

A mapper that walks over all the arrays in a pytato.array.Array.

Users may override the specific mapper methods in a derived class or override WalkMapper.visit() and WalkMapper.post_visit().

visit(expr)

If this method returns True, expr is traversed during the walk. If this method returns False, expr is not traversed as a part of the walk.

Return type

bool

post_visit(expr)

Callback after expr has been traversed.

Return type

None

pytato.transform.copy_dict_of_named_arrays(source_dict, copy_mapper)

Copy the elements of a DictOfNamedArrays into a DictOfNamedArrays.

Parameters

• source_dict (DictOfNamedArrays) – The DictOfNamedArrays to copy

• copy_mapper (CopyMapper) – A mapper that performs copies different array types

Return type

DictOfNamedArrays

Returns

A new DictOfNamedArrays containing copies of the items in source_dict

pytato.transform.get_dependencies(expr)

Returns the dependencies of each named array in expr.

Return type

Dict[str, FrozenSet[Array]]

Code Generation Targets

class pytato.target.Target

An abstract code generation target.

bind_program(program, bound_arguments)

Create a BoundProgram for this code generation target.

Parameters

• program (Any) – the loopy program

• bound_arguments (Mapping[str, Any]) – a mapping from argument names to outputs

Return type

BoundProgram

class pytato.target.BoundProgram(program, bound_arguments, target)

A container for the result of code generation along with data bindings for already-bound arguments.

target

The code generation target.

program

Description of the program as per BoundProgram.target.

bound_arguments

A map from names to pre-bound kernel arguments.

__call__()

It is expected that every concrete subclass of this class have a __call__ method to run the generated code, however interfaces may vary based on the specific subclass.

Available targets

class pytato.target.loopy.LoopyTarget

An loopy target.

get_loopy_target()

Return the corresponding loopy target.

Return type

TargetBase

class pytato.target.loopy.LoopyPyOpenCLTarget(device=None)

A pyopencl code generation target.

device

The pyopencl device used to construct the loopy.PyOpenCLTarget, or None.

class pytato.target.loopy.BoundPyOpenCLProgram(program, bound_arguments, target)

A wrapper around a loopy kernel for execution with pyopencl.

__call__(queue, *args, **kwargs)

Convenience function for launching a pyopencl computation.

Return type

Any

Generating code

pytato.target.loopy.codegen.generate_loopy(result, target=None, options=None, *, cl_device=None)

Code generation entry point.

Parameters

• result (Union[Array, DictOfNamedArrays, Dict[str, Array]]) – Outputs of the computation.

• target (Optional[LoopyTarget]) – Code generation target.

• options (Optional[Options]) – Code generation options for the kernel.

Return type

BoundProgram

Returns

A pytato.target.BoundProgram wrapping the generated loopy program.

If result is a dict or a pytato.DictOfNamedArrays and options is not supplied, then the Loopy option return_dict will be set to True.

class pytato.target.loopy.codegen.LoopyExpressionContext(state, num_indices, _depends_on=<factory>, local_namespace=<factory>, reduction_bounds=<factory>)

Mutable state used while generating loopy expressions. Wraps CodeGenState with more expression-specific information.

This data is passed through InlinedExpressionGenMapper via arguments, and is also used by ImplementedResult.to_loopy_expression() to retrieve contextual data.

state

The CodeGenState.

local_namespace

A (read-only) local name mapping used for name lookup when generating code.

num_indices

The number of indices of the form _0, _1, allowed in the expression.

depends_on

The set of statement IDs that need to be included in loopy.InstructionBase.depends_on.

reduction_bounds

A mapping from inames to reduction bounds in the expression.

update_depends_on(other)

Return type

None

lookup(name)

Return type

Array

class pytato.target.loopy.codegen.ImplementedResult

Generated code for a node in the computation graph (i.e., an array expression).

to_loopy_expression(indices, expr_context)

Return a loopy expression for this result.

Parameters

• indices (Tuple[Union[int, Expression], …]) – symbolic expressions for the indices of the array

• expr_context (LoopyExpressionContext) –

  the associated expression context. The fields are treated as follows:

  • depends_on is populated with any dependencies needed for the generated expression.

  • reduction_bounds is populated with reduction bounds for the reduction inames in the returned expression. If reduction_bounds is nonempty, then the returned inames are ensured to be disjoint from those present.

Return type

Union[Number, bool_, bool, Expression]

class pytato.target.loopy.codegen.StoredResult(name, num_indices, depends_on)

An array expression generated as a loopy array.

See also: pytato.array.ImplStored.

class pytato.target.loopy.codegen.InlinedResult(expr, num_indices, reduction_bounds, depends_on)

An array expression generated as a loopy expression containing inlined sub-expressions.

See also: pytato.array.ImplInlined.

class pytato.target.loopy.codegen.SubstitutionRuleResult

class pytato.target.loopy.codegen.CodeGenState(_program, results)

A container for data kept by CodeGenMapper.

_program

The partial loopy.LoopKernel or loopy.TranslationUnit being built.

results

A mapping from pytato.Array instances to instances of ImplementedResult.

var_name_gen

insn_id_gen

update_kernel(kernel)

Return type

None

class pytato.target.loopy.codegen.CodeGenMapper

A mapper for generating code for nodes in the computation graph.

class pytato.target.loopy.codegen.InlinedExpressionGenMapper(codegen_mapper)

A mapper for generating loopy expressions with inlined sub-expressions.

The inputs to this mapper are scalar expression as found in pytato.array.IndexLambda, or expressions that are compatible (e.g., shape expressions).

The outputs of this mapper are scalar expressions suitable for wrapping in InlinedResult.

pytato.target.loopy.codegen.domain_for_shape(dim_names, shape, reductions)

Create an islpy.BasicSet that expresses an appropriate index domain for an array of (potentially symbolic) shape shape having reduction dimensions reductions.

Parameters

• dim_names (Tuple[str, …]) – A tuple of strings, the names of the axes. These become set dimensions in the returned domain.

• shape (Tuple[Union[Number, bool_, bool, Expression], …]) – A tuple of constant or quasi-affine pymbolic expressions. The variables in these expressions become parameter dimensions in the returned set. Must have the same length as dim_names.

• reductions (Dict[str, Tuple[Union[Number, bool_, bool, Expression], Union[Number, bool_, bool, Expression]]]) – A map from reduction inames to (lower, upper) bounds (as half-open integer ranges). The variables in the bounds become parameter dimensions in the returned set.

Return type

BasicSet

pytato.target.loopy.codegen.get_loopy_temporary(name, expr, cgen_mapper, state)

Return type

TemporaryVariable

pytato.target.loopy.codegen.add_store(name, expr, result, state, cgen_mapper, output_to_temporary=False)

Add an instruction that stores to a variable in the kernel.

Parameters

• name (str) – name of the output array, which is created

• expr (Array) – the Array to store

• result (ImplementedResult) – the corresponding ImplementedResult

• state (CodeGenState) – code generation state

• output_to_temporary (bool) – whether to generate an output argument (default) or a temporary variable

Return type

str

Returns

the id of the generated instruction

pytato.target.loopy.codegen.rename_reductions(loopy_expr, loopy_expr_context, var_name_gen)

Rename the reduction variables in loopy_expr and loopy_expr_context using the callable var_name_gen.

Return type

Union[Number, bool_, bool, Expression]

pytato.target.loopy.codegen.normalize_outputs(result)

Convert outputs of a computation to the canonical form.

Performs a conversion to DictOfNamedArrays if necessary.

Parameters

result (Union[Array, DictOfNamedArrays, Dict[str, Array]]) – Outputs of the computation.

Return type

DictOfNamedArrays

pytato.target.loopy.codegen.get_initial_codegen_state(target, options)

Return type

CodeGenState

class pytato.loopy.LoopyCall(translation_unit, bindings, entrypoint)

An array expression node representing a call to an entrypoint in a loopy translation unit.

class pytato.loopy.LoopyCallResult(loopy_call, name, tags=frozenset({}))

Named array for LoopyCall’s result. Inherits from NamedArray.

pytato.loopy.call_loopy(translation_unit, bindings, entrypoint=None)

Invokes an entry point of a loopy.TranslationUnit on the array inputs as specified by bindings.

Restrictions on the structure of translation_unit[entrypoint]:

• array arguments of translation_unit[entrypoint] must either be either input-only or output-only.

• all input-only arguments of translation_unit[entrypoint] must appear in bindings.

• all output-only arguments of translation_unit[entrypoint] must appear in bindings.

• if translation_unit has been declared with multiple entrypoints, entrypoint can not be None.

Parameters

• translation_unit (TranslationUnit) – the translation unit to call.

• bindings (Dict[str, Union[Array, Number]]) – mapping from argument names of translation_unit[entrypoint] to pytato.array.Array.

• entrypoint (Optional[str]) – the entrypoint of the translation_unit parameter.

Return type

LoopyCall

References

class pytato.codegen.DictOfNamedArrays

Should be referenced as pytato.DictOfNamedArrays.

class pytato.codegen.DataInterface

Should be referenced as pytato.array.DataInterface.

Code Generation Helpers

class pytato.codegen.CodeGenPreprocessor(target)

A mapper that preprocesses graphs to simplify code generation.

The following node simplifications are performed:

Source Node Type	Target Node Type
DataWrapper	Placeholder
Roll	IndexLambda
AxisPermutation	IndexLambda
Slice	IndexLambda
Reshape	IndexLambda
Concatenate	IndexLambda
MatrixProduct	IndexLambda

class pytato.codegen.PreprocessResult(outputs, compute_order, bound_arguments)

pytato.codegen.preprocess(outputs, target)

Preprocess a computation for code generation.

Return type

PreprocessResult

pytato.codegen.normalize_outputs(result)

Convert outputs of a computation to the canonical form.

Performs a conversion to DictOfNamedArrays if necessary.

Parameters

result (Union[Array, DictOfNamedArrays, Dict[str, Array]]) – Outputs of the computation.

Return type

DictOfNamedArrays

Graph Visualization

pytato.get_dot_graph(result)

Return a string in the dot language depicting the graph of the computation of result.

Parameters

result (Union[Array, DictOfNamedArrays]) – Outputs of the computation (cf. pytato.target.loopy.codegen.generate_loopy()).

Return type

str

pytato.show_dot_graph(result)

Show a graph representing the computation of result in a browser.

Parameters

result (Union[Array, DictOfNamedArrays]) – Outputs of the computation (cf. pytato.target.loopy.codegen.generate_loopy()).

Return type

None

Helper routines

pytato.utils.are_shape_components_equal(dim1, dim2)

Returns True iff dim1 and dim2 are have equal SizeParam coefficients in their expressions.

Return type

bool

pytato.utils.are_shapes_equal(shape1, shape2)

Returns True iff shape1 and shape2 have the same dimensionality and the correpsonding components are equal as defined by are_shape_components_equal().

Return type

bool

pytato.utils.get_shape_after_broadcasting(exprs)

Returns the shape after broadcasting exprs in an operation.

Return type

Tuple[Union[int, Array], …]

pytato.utils.dim_to_index_lambda_components(expr, vng)

Returns the scalar expressions and bindings to use the shape component within an index lambda.

>>> n = pt.make_size_param("n")
>>> expr, bnds = dim_to_index_lambda_components(3*n+8, UniqueNameGenerator())
>>> print(expr)
3*_in + 8
>>> bnds  
{'_in': <pytato.array.SizeParam ...>}

Return type

Tuple[Union[Number, bool_, bool, Expression], Dict[str, SizeParam]]

Pytato-specific exceptions

class pytato.diagnostic.NameClashError

Raised when 2 non-identical InputArgumentBase’s are reachable in an Array’s DAG and share the same name. Here, we refer to 2 objects a and b as being identical iff a is b.