Lazylinop core module
---------------------

.. automodule:: lazylinop.lazylinop

    - :py:class:`LazyLinOp`: the core class for lazy linear operators.

    .. admonition:: Available operations
        :class: admonition note

        ``+`` (addition), ``-`` (subtraction),
        ``@`` (matrix product), ``*`` (scalar multiplication),
        ``**`` (matrix power for square operators),
        indexing, slicing and others.
        For a nicer introduction you might look at `these tutorials
        <tutorials.html>`_.

        - `LazyLinOp attributes <#attributes>`_: :py:attr:`.LazyLinOp.ndim`,
          :py:attr:`.LazyLinOp._shape`, :py:attr:`.LazyLinOp.T`,
          :py:attr:`.LazyLinOp.H`, :py:attr:`.LazyLinOp.real`,
          :py:attr:`.LazyLinOp.imag`.

        - `LazyLinOp main methods <#methods>`_: :py:func:`.LazyLinOp.toarray`,
          :py:func:`.LazyLinOp.conj`,
          :py:func:`.LazyLinOp.check`,
          :py:func:`.LazyLinOp.__pow__`.

    - `Utility module functions <#module-utility-functions>`_: :py:func:`.islazylinop`,
      :py:func:`.aslazylinop`.

    - `Basic operators <#basicops>`_:

        - `Construction <#basicops-construc>`_:
          :py:func:`.eye`, :py:func:`.anti_eye`, :py:func:`.diag`, :py:func:`.anti_diag`, :py:func:`.ones`, :py:func:`.zeros`,

        - `Agglomeration & Transformation <#basicops-agg-transf>`_:
          :py:func:`.add`, :py:func:`.block_diag`,
          :py:func:`.hstack`, :py:func:`.pad`, :py:func:`.kron`,
          :py:func:`.vstack`.

LazyLinOp class
~~~~~~~~~~~~~~~

.. autoclass:: lazylinop.LazyLinOp

Attributes
==========

    .. autoattribute:: lazylinop.LazyLinOp.T
    .. autoattribute:: lazylinop.LazyLinOp.H
    .. autoattribute:: lazylinop.LazyLinOp.ndim
    .. autoattribute:: lazylinop.LazyLinOp._shape
    .. autoattribute:: lazylinop.LazyLinOp.real
    .. autoattribute:: lazylinop.LazyLinOp.imag

Methods
=======


`LazyLinOp main methods <#methods>`_: :py:func:`.LazyLinOp.toarray`,
:py:func:`.LazyLinOp.conj`,
:py:func:`.LazyLinOp.check`,
:py:func:`.LazyLinOp.__pow__`.

.. autofunction:: lazylinop.LazyLinOp.toarray
.. autofunction:: lazylinop.LazyLinOp.conj
.. autofunction:: lazylinop.LazyLinOp.check
.. autofunction:: lazylinop.LazyLinOp.__pow__

Module utility functions
~~~~~~~~~~~~~~~~~~~~~~~~

.. autofunction:: lazylinop.islazylinop
.. autofunction:: lazylinop.aslazylinop


.. _basicops:

Basic operators
---------------

.. _basicops-construc:
Construction
~~~~~~~~~~~~

Functions for creating a :py:class:`.Lazylinop` from scratch
(providing the related parameters).

.. important::
   - Note that lazylinop provides two closely named functions ``pad`` and ``padder``:

     - ``pad`` takes a lazylinop as input and returns a padded lazylinop, and is part of a family of tools to "glue" various types of lazylinops together.
     - ``padder`` builds a lazylinop that maps a (batch of) *vector(s)* to their (batch of) padded versions.
   - In general, function names such as ``slicer``, ``indexer``, ``padder`` (see also ``padder2d``) also refer to functions that return a LazyLinop which action is described by the verb appearing in their name.

.. autofunction:: lazylinop.anti_diag
.. autofunction:: lazylinop.anti_eye
.. autofunction:: lazylinop.diag
.. autofunction:: lazylinop.diff
.. autofunction:: lazylinop.eye
.. autofunction:: lazylinop.ones
.. autofunction:: lazylinop.tri
.. autofunction:: lazylinop.cumsum
.. autofunction:: lazylinop.zeros
.. autofunction:: lazylinop.padder

.. _basicops-agg-transf:
Agglomeration & Transformation
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Functions for creating a :py:class:`.Lazylinop` from preexisting
linear operators.

.. autofunction:: lazylinop.add
.. autofunction:: lazylinop.block_diag
.. autofunction:: lazylinop.hstack
.. autofunction:: lazylinop.kron
.. autofunction:: lazylinop.pad
.. autofunction:: lazylinop.vstack

.. _basicops-slicing-and-indexing:

Slicing and indexing operators
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

.. autofunction:: lazylinop.basicops.slicer
.. autofunction:: lazylinop.basicops.indexer

.. _basicops-permutations:

Permutations operators
~~~~~~~~~~~~~~~~~~~~~~

The following functions return LazyLinOp's that implement permutations.
These operators are all of shape :math:`\left(N,~N\right)` and orthonormal.

.. autofunction:: lazylinop.basicops.bitrev
.. autofunction:: lazylinop.basicops.flip
.. autofunction:: lazylinop.basicops.roll