r"""Raw storage of the Green's function. The storage convention is .. math:: \texttt{data}[x_1, \ldots, x_r,\, n_1, \ld

* @brief Build a Green's function on the conjugate mesh by Fourier transform. * * @details Applies to every overload. The supported conjugate me

The mesh of the Green's function. Returns ------- Mesh or MeshProduct The underlying mesh — a single :mod:`triqs.

Get the size \f$ N \f$ of the mesh, i.e. the product of the sizes of its components.

scalar_valued * @brief Fourier transform a Green's function in place from one mesh to its conjugate. * * @details Applies to every overload. The

* @brief Get the determinant of the original matrix \f$ F^{(n)} \f$. * @return Determinant \f$ \det(F^{(n)}) = s^{(n)} \det(G^{(n)}) \f$. */

* @brief Get the original matrix \f$ F^{(n)} \f$. * @details Warning: this is slow, since it creates a new matrix and re-evaluates the matrix bui

* @brief Evaluate the expression template depending on the operator tag. * * @details The following expressions are supported: * - \f$

* @brief Write a triqs::mesh::dlr mesh to HDF5. * * @param g `h5::group` to be written to. * @param name Name of the subgroup. * @

* @brief Get the index of the \f$ \mathbf{k} \f$-vector corresponding to the evaluated expression. * * @details See value() for the supporte

* @brief Read a triqs::mesh::dlr mesh from HDF5. * * @param g `h5::group` to be read from. * @param name Name of the subgroup. * @

r"""Element-wise inverse with lazy-expression support. Parameters ---------- x : Gf, BlockGf, LazyExpr or numeric Object to inver

* @brief Insert one row and column. * @details Wrapper for try_insert() followed by a complete_operation() call. See try_insert() for details.

r"""Mesh rank — number of mesh axes. Returns ------- int ``1`` for a single mesh, otherwise ``len(mesh.components

make_gf_dlr: single mesh DLR conversions * @brief Transform a DLR imaginary-time or DLR Matsubara Green's function to its DLR-coefficient representati

Get an iterator to the beginning of the mesh.

* @brief Map a data index tuple \f$ \mathbf{d} \f$ to its corresponding index tuple \f$ \mathbf{n}(\mathbf{d}) * \f$. * * @param d Data

fit_gf_dlr: imtime -> dlr * @brief Fit an imaginary-time Green's function with a Discrete Lehmann Representation. * * @details Applies to every

make_gf_imfreq: from dlr, dlr_imtime, dlr_imfreq * @brief Build a uniform Matsubara Green's function from any DLR representation. * * @details A

make_gf_imtime: from dlr, dlr_imtime, dlr_imfreq * @brief Build a uniform imaginary-time Green's function from any DLR representation. * * @deta

make_gf_dlr_imfreq: from dlr and dlr_imtime * @brief Build a DLR Matsubara Green's function from a DLR-coefficient or DLR-imaginary-time input. *

* @brief Get an element of the inverse matrix. * * @details The inverse matrix is given by * \f[ * [F^{(n)}]^{-1} = (P^{(n)}_r G

Return an independent deep copy of ``self``. Returns ------- Gf Copy with freshly allocated mesh and data arrays.

* @brief Map an index \f$ n \in \{0, 1, \ldots, N-1\} \f$ to its corresponding value \f$ m(n) \f$. * * @param n Index \f$ n \f$ to map.

r""" Assert that two arrays are equal in maximum absolute difference. Computes :math:`d = \max_i |a_i - b_i|` and requires ``d < precisio

* @brief Swap two views. * @param a First view. * @param b Second view. */

r"""Inverse temperature :math:`\beta`. Returns ------- float :math:`\beta`.

Get an iterator to the end of the mesh.

Check two Matsubara frequencies for equality.

Resize the working vectors for a matrix of size N.

make_gf_dlr_imtime: from dlr and dlr_imfreq * @brief Build a DLR imaginary-time Green's function from a DLR-coefficient or DLR-Matsubara input. *

Get the data index tuple \f$ \mathbf{d} \f$ of the mesh point.

* @brief Complete the last try-operation. * * @details It completes the last try-operation by calling the correct completion function depend

Shape of the target space. Returns ------- tuple of int Target-space dimensions, e.g. ``(2, 2)`` for a 2x2 matrix

Get an iterator to the beginning of the mesh.

* @brief Map an index tuple \f$ \mathbf{n} \f$ to its corresponding data index tuple \f$ \mathbf{d}(\mathbf{n}) * \f$. * * @param n Ind

* @ingroup triqs-meshes-imag * @brief Create the adjoint imaginary-frequency mesh to a given imaginary-time mesh. * * @details If \f$ N_{i\om

* @brief Reserve memory and resize the data storages. * * @details Like for `std::vector`, this reserves memory for a bigger matrix size. It

* @brief Get the Fock state \f$ \lvert f \rangle \f$ corresponding to a given integer \f$ f \f$. * * @details It throws an exception if \f$

Get the name of the underlying RNG.

* @brief Get the current size of the matrix. * @return Number of rows/columns of the matrix. */

* @brief Compute the density from a Green's function. * * @param g Input Green's function. * @return The density (matrix). */

* @brief Calculate the (elementwise) absolute square of an array/view/scalar. * * @details The return type depends on the input type. * *

Return names of non-None fields.

* @brief Get the position of the center of the n-th bin. * * @param n Index of the bin. * @return Position of the n-th bin center, i.e.

r"""Transpose in target space with lazy-expression support. Parameters ---------- x : Gf, BlockGf or LazyExpr Object to transpose

Start (or resume) the timer.

Identity overload for `std::string`.

Get the number of measurements performed.

* @brief Get the current size of the matrix. * @return Number of rows/columns of the matrix. */

Get the dimension of the associated Hilbert (Fock) space, i.e. \f$ \dim(\mathcal{F}^{(m)}) \f$.