Operators
=========
Operators perform some operation on a given field. In practice an operator can
take the form of an explicit matrix (e.g. stored in a Numpy array) or it may be
implicitly defined as a function (e.g. an FFT operation would not be encoded in
a matrix, but performed using an FFT routine). NIFTY includes a framework for
handling arbitrary operators, and basic methods for manipulating these
operators. Common functions like taking traces and extracting diagonals are
provided.
In order to have a blueprint for operators capable of handling fields, any
application of operators is split into a general and a concrete part. The
general part comprises the correct involvement of normalizations and
transformations, necessary for any operator type, while the concrete part is
unique for each operator subclass. In analogy to the field class, any operator
instance has a set of properties that specify its domain and target as well as
some additional flags.
Operator classes
----------------
NIFTY provides a base class for defining operators, as well as several pre-implemented operator types that are very often needed for signal inference
algorithms.
.. toctree::
:maxdepth: 1
diagonal_operator
fft_operator
composed_operator
response_operator
smoothing_operator
projection_operator
propagator_operator
endomorphic_operator
invertible_operator_mixin
transformations
.. currentmodule:: nifty
The ``LinearOperator`` class -- The base Operator Object
--------------------------------------------------------
.. autoclass:: LinearOperator
:show-inheritance:
:members: