r"""Container for Green's functions and related quantities. A :class:`~triqs.gfs.gf.Gf` is a container for generic functions defined on meshe

r"""Block-diagonal Green's function. A :class:`~triqs.gfs.block_gf.BlockGf` is an **ordered**, named collection of :class:`~triqs.gfs.gf.Gf`

A node in a lazy expression tree. Each node carries a ``tag`` and a list of ``childs``. Tags are: * ``"T"`` — terminal; ``childs[0]`` is the

r"""Deprecated backward-compatibility alias for :class:`~triqs.gfs.gf.Gf` with a :class:`~triqs.mesh.meshes.MeshImFreq` mesh. Use ``Gf(mesh=

* @brief Generic runtime error thrown in **TRIQS**. * * @details Specialization of triqs::exception used for the most common error case. It only

r"""Hilbert transform of a semicircular density of states. .. math:: g(z) = \int \frac{A(\omega)}{z-\omega}\, d\omega, \qquad

r"""Tag wrapping a mesh-point linear index for use in :class:`~triqs.gfs.gf.Gf` ``[]`` access. ``Idx(i)`` (or ``Idx(i, j, ...)`` for a :clas

Cartesian product of TRIQS meshes. A :class:`MeshProduct` of ``k`` factor meshes describes the set of ``k``-tuples of mesh points, one factor

r"""Lazy Fourier transform between conjugate meshes. Applying ``g_new << Fourier(g_old)`` runs the C++ Fourier transform from ``g_old``'s mes

* @brief Random number generator with a selectable underlying engine. * * @details The following engine names are currently accepted by the cons

* @brief Tight-binding Hamiltonian \f$ H(\mathbf{k}) \f$ on a 3D lattice. * * @details A tight-binding Hamiltonian is defined by a set of lattic

r"""Two-index block-diagonal Green's function. A :class:`~triqs.gfs.block2_gf.Block2Gf` is a rectangular, named collection of :class:`~triqs.

r""" Background thread that pumps the C++ ``stdout`` into Python's. On :meth:`run` the thread creates a pipe, redirects file descriptor ``1`` t

Test in 1d

r"""Deprecated backward-compatibility alias for :class:`~triqs.gfs.gf.Gf` with a :class:`~triqs.mesh.meshes.MeshReFreq` mesh. Use ``Gf(mesh=

r""" Density of states of fermions on a 1D epsilon grid. Stores a discrete representation of .. math:: \rho(\epsilon) \equiv \s

r"""Descriptor wrapping a Python callable. When applied to a Green's function with mesh values :math:`\{x_i\}`, sets ``G.data[i] = function(x

Custom mesh for testing.

r"""Hilbert transform of a flat density of states with cutoff. .. math:: g(z) = \int \frac{A(\omega)}{z-\omega}\, d\omega, \qqua

A tight-binding Hamiltonian on top of a Bravais lattice. Bundles a :class:`BravaisLattice`, a :class:`BrillouinZone` and a :class:`TightBindi

* @brief Type that can represent either a real or a complex number. * * @details Internally stores a `std::complex<double>` and a `bool` flag in

r"""Deprecated backward-compatibility alias for :class:`~triqs.gfs.gf.Gf` with a :class:`~triqs.mesh.meshes.MeshImTime` mesh. Use ``Gf(mesh=

r"""A single Matsubara frequency :math:`i\omega_n`. Castable to :class:`complex` via ``complex(freq)``; arithmetic with scalars is implemente

A simple autoregressive model to test some triqs::stat functionalities. The model is defined as X_t = \phi * X_{t-1} + \epsilon_t, where \phi is the

Forward declarations.

* @brief Output stream with a configurable verbosity level. * * @details It behaves like a `std::ostream` but each operator<<() call is conditio

r"""Constant descriptor. Fills the target Green's function with a constant matrix (or scalar) on a frequency mesh. Used internally by :fu

A point on a Bravais lattice, identified by its integer index vector. Castable to a numpy array of float (the real-space coordinates in the stand

r"""Frequency-variable placeholder descriptor. Implements the function :math:`\omega \mapsto \omega` (real or Matsubara) acting on the diagon

Context manager that captures ``sys.stdout`` into a list of lines. Subclass of :class:`list`. While the ``with`` block is active, ``sys.

* @brief Class representing a histogram on a given interval. * * @details The histogram is defined on the interval \f$ [a, b] \f$ with the follo

* @ingroup triqs-utility-runtime * @brief Accumulating wall-clock timer based on `std::chrono::high_resolution_clock`. * * @details It accumu

Minimal :class:`DistributionOnNodesOneStack` used by the self-test. Overrides :meth:`the_function` with ``x -> (x, x + 1, x + 2)`` so th

r"""Deprecated backward-compatibility alias for :class:`~triqs.gfs.gf.Gf` with a :class:`~triqs.mesh.meshes.MeshLegendre` mesh. Use ``Gf(mes

Evaluation context used by :meth:`~triqs.gfs.gf.Gf.__lshift__`. Wraps a target :class:`~triqs.gfs.gf.Gf` and provides ``__call__`` to reduce

r"""Lazy Legendre → Matsubara basis transform. Parameters ---------- G : Gf or BlockGf Source Green's function on a Legendre mesh

r"""Lazy Matsubara → Legendre basis transform. Parameters ---------- G : Gf or BlockGf Source Green's function on a Matsubara mes

r""" Discrete momentum sum built from a tight-binding lattice. Specialises :class:`SumkDiscrete` by constructing the k-grid directly from

* @brief A Bravais lattice class. * * @details A Bravais lattice in \f$ d \f$ dimensions is defined by * - a set of linear independent d-dime

Functor combining the data shapes of the two operands of a binary expression (shapes must match; a scalar operand takes the shape of the other operand

* @brief Class representing a fundamental operator set. * * @details A fundamental operator set is an ordered set of single particle state indic

* @ingroup triqs-mc-measures * @brief Type erasure class for auxiliary MC measures. * * @details It takes any type that is callable and erase

* @brief Tight-binding Hamiltonian on a Bravais lattice with fully localised orbitals. * * @details The Hamiltonian is parametrised by a set of

Metaclass that injects every callable in :mod:`triqs.gfs.gf_fnt` as a :class:`~triqs.gfs.gf.Gf` method. At class-creation time, iterates ove

A polygonal patch of the Brillouin zone, triangulated for use with :func:`triqs.lattice.tight_binding.dos_patch`. The input polygons are triangul

r"""Base class for every Green's function descriptor. Stores the constructor's keyword arguments as attributes. Subclasses implement ``__call

r"""Block-aware descriptor base. For a single-:class:`~triqs.gfs.gf.Gf` target this behaves like :class:`~triqs.gfs.descriptor_base.Base`. Fo

* @brief %Mesh point of a triqs::mesh::chebyshev mesh. * @details It stores the index \f$ n \f$, the data index \f$ d \f$, the hash value of the