* @brief Get the number of cluster sites in one superlattice unit cell. * * @return Number of cluster sites. */

* @brief Subscript operator to access a mesh point by its data index tuple \f$ \mathbf{d} \f$. * * @details Each data index \f$ d_i \f$ in t

r""" Plot a protocol-aware object onto a matplotlib axes. Thin wrapper around :func:`matplotlib.pyplot.plot` that dispatches ``obj`` thro

Names of the orbitals in the unit cell. Returns ------- list of str One name per orbital, in the same order as :a

Positions of the orbitals inside the unit cell. Returns ------- list Orbital positions :math:`\\{ \\mathbf{r}_1,

Reduce the four-index U matrix to two-index matrices for parallel and anti-parallel spins. Parameters ---------- U_4index : numpy.ndarray

* @brief Optional callback function if the proposed move is rejected. * @details Does nothing if the original type does not implement a `%reject(

r""" (Re)allocate the k-grid arrays for ``nk`` points. Sets: * :attr:`hopping` to a zero array of shape ``(nk, n_o

* @brief Find the value \f$ x \f$ that solves \f$ f(x) = y \f$ using the requested root-finding method. * * @details This is the main entry poin

Generate a sample of the autoregressive process.

Get the size \f$ N \f$ of the mesh, i.e. the DLR rank \f$ r \f$.

Size of each factor mesh. Returns ------- generator of int Generator yielding ``len(m)`` for each factor mesh ``m

* @brief Compute an estimate for the integrated auto-correlation time from variances. * * @details The integrated autocorrelation time is estima

Test a basic MC simulation with specific parameters.

Return ``(x, x + 1, x + 2)`` as the per-input computation.

* @brief Map a Matsubara index \f$ n \in \{ n_{\text{min}}, \dots, n_{\text{max}} \} \f$ to its corresponding data * index \f$ d(n) \f$. *

* @brief Get the captured stack trace. * @return Null-terminated C string holding the C++ stack trace (empty if none was captured). */

Append the worker result as ``(node, x)`` to the result list.

Get the value \f$ \omega_l \f$ of the mesh point.

r"""Create a component of the orbital angular-momentum vector operator. .. math:: \hat{L}_{z,+,-} &= \sum_{ii'\sigma} \hat{c}^\dagger_{i\

r"""Create a component of the spin vector operator. .. math:: \hat{S}_{x,y,z} = \frac{1}{2}\sum_{i\sigma\sigma'} \hat{c}^\dagger_{i\sigma

Compute the radial Slater integrals :math:`F_k` from ``U_int`` and ``J_hund``. Parameters ---------- l : int Angular momentum of

r"""Negate the Matsubara frequency. Returns ------- MatsubaraFreq New :class:`MatsubaraFreq` representing :math:`

Internal: drive the plot protocol on ``obj`` and dispatch each curve dictionary to the matplotlib drawing call ``top.<plot_function>``. A

Check G(iw_n + mu) values against the brute-force Hilbert transform.

Double every backslash that starts an invalid escape (value-preserving); returns body unchanged when there are none.

Find the smallest w_max such that DLR round-trip error < eps.

Check whether a NumPy array of SymPy elements contains a complex exponential. Parameters ---------- matrix : numpy.ndarray

Check whether a NumPy array of SymPy elements is Hermitian. Parameters ---------- matrix : numpy.ndarray Input ar

Compute the max error of a DLR round-trip on a single Gf.

Wrappers for set_from_gf_data_mul_LR, rank 3

Check that all DLR mesh indices fit within the ImFreq mesh.

* @brief Solve \f$ f(x) = y \f$ on a bracketing interval using the bisection method. * * @details Given an interval \f$ [x_\mathrm{low}, x_\math

* @brief Optional callback function to calibrate the move. * @details Does nothing if the original type does not implement a `calibrate(mpi::comm

Get a const iterator to the end of the mesh.

Remove all measures from the set.

r""" Return the slice selecting entries of an ordered array within a window. Parameters ---------- x_array : array_like 1D se

T::complex_t: real targets -> complex, complex targets unchanged.

Check if a given vector \f$ \mathbf{k} \f$ is part of the domain.

r"""Hybridization function :math:`\Delta(i\omega_n)` extracted from a non-interacting Green's function. Computes :math:`\Delta = i\omega_n -

Get the inverse of the step size of the mesh, i.e. \f$ 1 / \Delta \f$.

Compile already-read source and return [(lineno, message)] for every SyntaxWarning it raises (operates in memory so the caller reads once).

* @brief Convert a coefficient dictionary to a matrix, given a GF structure. * * @param d The 2-index/4-index dictionary. * @param gf_struct

* @brief Construct a discrete mesh of a given size \f$ N \geq 0 \f$. * @param N Size of the mesh. */

Compute the density of states of a tight-binding Hamiltonian on a triangular Brillouin-zone patch. Only supported for 2-dimensional lattices.

Get the number of effective samples accumulated in each bin.

Get a const iterator past the end of the map that contains the monomials and their coefficients.

* @brief Evaluate the DLR approximation of a function \f$ f \f$ at a given imaginary time point \f$ \tau \in [0, * \beta] \f$. * * @details W

------------------------------------------------------ * @brief Find a lower and an upper bound that bracket the solution of \f$ f(x) = y \f$. *