# Glossary¶

- array-like
Any data structure which can be converted into a

`numpy.ndarray`

by the`numpy.array`

constructor. Includes all`Tensor`

based classes.- convex conjugate
The convex conjugate (also called Fenchel conjugate) is an important tool in convex optimization. For a functional , the convex conjugate is the functional

- discretization
Structure to handle the mapping between abstract objects (e.g. functions) and concrete, finite realizations. It encompasses an abstract

`Set`

, a`Tensor`

as finite data container and the mappings between them, sampling and interpolation.- domain
Set of elements to which an operator can be applied.

- dtype
Short for data type, indicates the way data is represented internally. For example

`float32`

means 32-bit floating point numbers. See numpy dtype for more details.- element
Saying that

`x`

is an element of a given`Set`

`my_set`

means that`x in my_set`

evaluates to`True`

. The term is typically used as “element of <set>” or “<set>” element. When referring to a`LinearSpace`

like, e.g.,`DiscreteLp`

, an element is of the corresponding type`LinearSpaceElement`

, i.e.`DiscreteLpElement`

in the above example. Elements of a set can be created by the`Set.element`

method.- element-like
Any data structure which can be converted into an element of a

`Set`

by the`Set.element`

method. For example, an`rn(3) element-like`

is any array-like object with 3 real entries.Example:

``DiscreteLp` element-like`

means that`DiscreteLp.element`

can create a`DiscreteLpElement`

from the input.- in-place evaluation
Operator evaluation method which uses an existing data container to store the result. Usually more efficient than out-of-place evaluation since no new memory is allocated and no data is copied.

- interpolation
Operator in a discretization mapping a concrete (finite-dimensional) object to an abstract (infinite-dimensional) one. Example:

`LinearInterpolation`

.- meshgrid
Tuple of arrays defining a tensor grid by all possible combinations of entries, one from each array. In 2 dimensions, for example, the arrays

`[1, 2]`

and`[-1, 0, 1]`

define the grid points`(1, -1), (1, 0), (1, 1), (2, -1), (2, 0), (2, 1)`

.- operator
Mathematical notion for a mapping between arbitrary vector spaces. This includes the important special case of an operator taking a (discretized) function as an input and returning another function. For example, the Fourier Transform maps a function to its transformed version. Operators of this type are the most prominent use case in ODL. See the in-depth guide on operators for details on their implementation.

- order
Ordering of the axes in a multi-dimensional array with linear (one-dimensional) storage. For C ordering (

`'C'`

), the last axis has smallest stride (varies fastest), and the first axis has largest stride (varies slowest). Fortran ordering (`'F'`

) is the exact opposite.- out-of-place evaluation
Operator evaluation method which creates a new data container to store the result. Usually less efficient than in-place evaluation since new memory is allocated and data needs to be copied.

- proximal
Given a proper convex functional , the proximal operator is defined by

The term “proximal” is also occasionally used instead of ProxImaL, then refering to the proximal modelling language for the solution of convex optimization problems.

- proximal factory
A proximal factory associated with a functional is a

`callable`

, which returns the proximal of the scaled functional when called with a scalar . This is used due to the fact that optimization methods often use for varying .- range
Set of elements to which an operator maps, i.e. in which the result of an operator evaluation lies.

- sampling
Operator in a discretization mapping an abstract (infinite-dimensional) object to a concrete (finite-dimensional) one. Example:

`PointCollocation`

.- vectorization
Ability of a function to be evaluated on a grid in a single call rather than looping over the grid points. Vectorized evaluation gives a huge performance boost compared to Python loops (at least if there is no JIT) since loops are implemented in optimized C code.

The vectorization concept in ODL differs slightly from the one in NumPy in that arguments have to be passed as a single tuple rather than a number of (positional) arguments. See numpy vectorization for more details.