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 $f$ , the convex conjugate $f^*$ is the functional

$f^*(x^*) = \sup_x \big( \langle x, x^* \rangle - f(x) \big).$

discretization¶

Mathematical structure to handle mapping between abstract objects (e.g. functions) and concrete, finite realizations, e.g., Tensor's. The mapping from abstract to concrete is here called sampling, and the opposite mapping interpolation.

domain¶

Set of admissible inputs to a mapping, e.g., a function or an operator.

dtype¶

Short for data type, indicating the way data is represented internally. For instance, 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., DiscretizedSpace, an element is of the corresponding type LinearSpaceElement, i.e. DiscretizedSpaceElement 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 instance, an rn(3) element-like is any array-like object with 3 real entries.

in-place evaluation¶

Operator evaluation method which uses an existing data container to store the result. Often, this mode of evaluation is more efficient than out-of-place evaluation since memory allocation can be skipped.

interpolation¶

Operation in the context of a discretization that turns a finite data container into a function based on the values in the container. For instance, linear interpolation creates a function that linearly interpolates between the values in the container based on grid nodes.

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). Note that the resulting grid has the broadcast shape, here (2, 3), broadcast from (2, 1) and (1, 3) (expressed in code: result_shape = np.broadcast(shape1, shape2).shape).

operator¶

Mathematical notion for a mapping between vector spaces. This includes the important special case of an operator taking a (discretized) function as an input and returning another function. See the in-depth guide on operators for details on their usage and 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 that creates a new data container to store the result. Often, this mode of evaluation is less efficient than in-place evaluation since new memory must be allocated.

proximal¶

Given a proper and convex functional $S$ , the proximal operator is defined by

$\text{prox}_S(v) = \arg\min_x \big( S(x) + \frac{1}{2}||x - v||_2^2 \big)$

proximal factory¶

A proximal factory associated with a functional $S$ is a function that takes a scalar $\sigma$ and returns the proximal of the scaled functional $\sigma S$ . This indirection is needed since optimization methods typically use scaled proximals $\text{prox}_{\sigma S}$ for varying $\sigma$ , and that the scaled proximal cannot be inferred from the unscaled one alone.

range¶

Set in which a mapping, e.g., a function or operator, takes values.

sampling¶

Operation in the context of discretization that turns a function into a finite data container. The primary example is the evaluation ("collocation") of the function on a set of points.

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 the ODL vectorization guide and the NumPy vectorization documentation for more details.