Lazylinop’s documentation

Lazylinop is a python toolbox to ease and accelerate computations with (“matrix-free”) linear operators. It provides glue to combine linear operators as easily as NumPy arrays, PyTorch/CuPy compatibility, standard signal/image processing linear operators, as well as advanced tools to approximate large matrices by efficient butterfly operators.

Lazylinop philosophy – what is a LazyLinOp object?

A LazyLinOp is a high-level linear operator based on an arbitrary underlying implementation, such as:

• custom Python functions,

• a NumPy array,

• a SciPy matrix,

• a CuPy array,

• a torch tensor,

• a Faust object,

• any Python linear operator.

Thanks to the Lazylinop API, this operator can be easily manipulated, transformed or aggregated with other linear operators to form more complex LazyLinOp objects. Thus, many operations are available such as the addition, concatenation, adjoint etc.

These operations are all ruled by the lazy paradigm: their evaluation is delayed until the resulting LazyLinOp is actually applied to a vector (or to a collection of vectors, seen as a matrix).

Main benefits of Lazylinop

Lazylinop aims at providing:

• a unified NumPy/SciPy-like API for any underlying implementation (including transparent use of efficient third-party libraries for advanced linear operators such as wavelets, etc.),

• an easy way to combine existing operators into more complex operators with all the LazyLinOp operations at your fingertips (and in particular the adjoint),

• potential performance gains & memory sparing offered by the lazy paradigm,

• many pre-built operators and related APIs, delivered in specialized Lazylinop sub-packages (polynomials of operators, signal-processing oriented operators, etc.).

• easy convertion to SciPy LinearOperator-s <https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse. linalg.LinearOperator.html> to use compatible algorithms: svds, eigsh, etc.

Lazylinop is also an alternative or a complement to other related libraries that harness the power of the lazy paradigm. See the section Related lazy libraries for more details.

Beta stage

Lazylinop is currently in a beta stage of development. It is thus intensively evolving and we invite you to consult this documentation regularly. We welcome all beta testers and any feedback.

Getting started with lazylinop

Quick install using Anaconda

conda config --add channels conda-forge
conda config --add channels lazylinop
conda install lazylinop

Quick install using PIP

pip install lazylinop

Python beginners willing to safely install Lazylinop with a virtual environment can consult this guide.

Installing all extra/optional dependencies

pip install -r lz_requirements.txt

Download the dependency file lz_requirements.txt

Quick introduction

For a quick introduction to the use of Lazylinop go to this notebook. The raw notebook is available here.

Related lazy libraries

LazyLinOp-s are complementary to other “lazy” objects such as LazyTensors in KeOps, or the ones of lazyarray, WeldNumpy and PyLops libraries, which, to the best of our knowledge, primarily provide compact descriptions of arrays which entries can be evaluated efficiently on the fly.

It’s worth noting that the way PyLops exhibits SciPy LinearOperator-s in its API is different. Indeed, PyLops provides Python classes (like Kronecker) while Lazylinop rather provides Python functions in the SciPy style (as kron ).

Contents:

• Lazylinop news
  • 2026-02-12
  • 2025-12-03
  • 2025-10-13
  • 2025-09-15
  • 2025-07-23
  • 2025-06-27
  • 2025-06-05
  • 2025-06-03
• Installing lazylinop
  • Installing lazylinop with PIP
    • Creating a virtual environment
    • Installing the lazylinop package
  • Installing lazylinop with Anaconda
• API documentation
  • Lazylinop core module
    • LazyLinOp class
    • Module utility functions
  • Basic operators
    • Construction
    • Agglomeration & Transformation
    • Slicing and indexing operators
    • Permutations operators
  • Butterfly module
    • Preamble
    • References
    • Butterfly construction
    • Chain class
    • Chain methods
    • Utilities
    • I/O (load/save)
    • Plot
  • Quantization module
    • References
    • Rank one quantization
    • Monarch quantization
    • Butterfly quantization
    • Utils
  • Linear algebra module
    • lazylinop.linalg.svds()
  • Polynomial module
    • Polynomial classes
    • Polynomial functions
  • Signal module
    • List of transforms
    • Padding or cropping
    • Inverse transforms
    • Other normalizations
    • Transforms
    • Utility functions
  • 2d signal module
    • List of transforms
    • Input (and output) vector shape
    • Padding or cropping
    • Inverse transforms
    • Various normalizations
    • Transforms
    • Utility functions
  • Work-in-Progress modules
    • Linear algebra module
    • Special matrices module
    • Parallel computing
    • Random functions
    • Basicops operators (WIP)
    • Butterfly module
• Tutorials
  • Getting Started with Lazylinop
    • Contents
    • 1. Core concept of Lazylinop: what is a LazyLinOp?
    • 2. Creating a LazyLinOp from a Python linear operator
    • 3. Transformation & Aggregation: from simple to complex LazyLinOp-s
    • 4. Vector/matrix multiplication & Computation times
    • 5. Creating a LazyLinOp from custom matmat/vec: the FFT example
    • 6. Compatibility with SciPy: the SVD example
    • 7. Prebuilt Lazylinop operators
  • Using the polynomial module
    • 0. Needed imports
    • 1. Introduction
    • 2. N-th power of an operator
    • 3. Basics operations
    • 4. Changing a polynomial to Chebyshev basis
    • 5. Approaching the exponential of a Kronecker product using Polynomial
    • 6. Benchmarking the exponential of a Kronecker product
  • WIP

Indices and tables

• Index

• Module Index

• Search Page