Test DLR mesh.

default-constructed

default-constructed

-----------------------------------------------------------------------------

Test that std::mt19937 and boost::random::mt19937 produce the same numbers. Conclusion: The std and boost generator give the same numbers.

r"""Modulus :math:`|i\omega_n|`. Returns ------- float ``abs(complex(self))``.

Build the lazy node ``self + y``. Parameters ---------- y : LazyExpr, descriptor or scalar Returns -------

Addition forwarded to :attr:`value`. Parameters ---------- x : object Right-hand side operand. Returns

Always raises :exc:`NotImplementedError`. Parameters ---------- *args Unused. Raises ------

r"""Evaluate the Green's function at the given point(s). Parameters ---------- *args One value per mesh axis. Eac

Build the lazy function-application node ``self(*args)``. Parameters ---------- *args Arguments to bind into the

Reduce a leaf of a lazy expression. If ``x`` is a descriptor, evaluate it on a fresh copy of the captured target and return the resul

Fill ``G.data`` with ``function`` evaluated at every mesh point. Parameters ---------- G : Gf Target Green's func

Fill ``G.data`` with the stored constant on every mesh point. Parameters ---------- G : Gf Target Green's functio

Fill ``G.data`` with ``omega * I`` on every frequency mesh point. Parameters ---------- G : Gf Target Green's fun

Fill ``G.data`` with the single-fermion imaginary-time propagator. Parameters ---------- G : Gf Target Green's fu

Fill ``G.data`` with the semicircular Hilbert transform on its mesh. Parameters ---------- G : Gf Target Green's

Fill ``G.data`` with the flat-DOS Hilbert transform on its mesh. Parameters ---------- G : Gf Target Green's func

Run the Fourier transform from ``self.G`` into ``G2``. Parameters ---------- G2 : Gf Target Green's function on t

Run the Legendre → Matsubara transform from ``self.G`` into ``G2``. Parameters ---------- G2 : Gf Target Green's

Run the Matsubara → Legendre transform from ``self.G`` into ``G2``. Parameters ---------- G2 : Gf Target Green's

r""" Evaluate the Hilbert transform with the given self-energy. Parameters ---------- Sigma : Gf or callable

Forward the call to :attr:`value`. Parameters ---------- *args, **kw Arguments passed through to ``self.value(*ar

r""" Evaluate the fitted model at ``x``. Parameters ---------- x : array_like or float Point(s) at which

r""" Compute the momentum-summed local Green's function. Evaluates .. math:: G(i\omega_n) = \sum_k w_k \bigl[ (

Cast to :class:`complex`. Returns ------- complex ``complex(self.value)``.

r"""Cast to :class:`complex`. Returns ------- complex :math:`i\omega_n = i\,(2n + \mathrm{is\_fermion})\,\pi/\bet

Allow 'G_iw' in result checks.

Redirect ``sys.stdout`` to an internal buffer and return ``self``.

Two contexts are equal iff their captured targets are mesh-compatible. Parameters ---------- y : object Other con

Equality test on :attr:`n`, :attr:`beta` and :attr:`statistic`. Parameters ---------- other : object Right-hand s

Equality test comparing the tuples of factor meshes elementwise. Parameters ---------- other : MeshProduct Right-

Restore ``sys.stdout`` and append the captured lines to ``self``.

Cast to :class:`float`. Returns ------- float ``float(self.value)``.

r"""Return a mesh point, a sliced view, or a target-space sub-block. The bracket operator dispatches on the type of ``key``: * ``g[:

Access a single block by name pair. Parameters ---------- key : tuple of (hashable, hashable) ``(bn1, bn2)`` bloc

Access a block by string name or integer position. Parameters ---------- key : str or int Block name (e.g. ``'up'

Forward item access to :attr:`value`. Parameters ---------- *args Index / slice arguments passed through to ``sel

Return the ``i``-th factor mesh from :attr:`components`. Parameters ---------- i : int Position of the factor mes

Allow dict-style access: result['G_iw'].

In-place addition ``self += arg`` (element-wise on ``self.data``). Parameters ---------- arg : Gf, descriptor, lazy expressio

In-place lazy addition ``self += y`` via :meth:`~triqs.gfs.lazy_expressions.LazyExpr.set_from`. Parameters ----------

In-place block-wise addition ``self += arg``. Parameters ---------- arg : Block2Gf, sequence, or anything accepted by :meth:`

In-place block-wise addition ``self += arg``. Parameters ---------- arg : BlockGf, sequence, or anything accepted by :meth:`~

In-place multiplication ``self *= arg`` (alias for :meth:`~triqs.gfs.gf.Gf.__imatmul__`). Parameters ---------- arg : Gf, sca

In-place lazy multiplication ``self *= y``. Parameters ---------- y : LazyExpr, descriptor or scalar Returns

In-place block-wise multiplication ``self *= arg``. Parameters ---------- arg : Block2Gf, sequence, or anything accepted by :

In-place block-wise multiplication ``self *= arg``. Parameters ---------- arg : BlockGf or anything accepted by :meth:`~triqs