# [gf<imtime>] Matsubara imaginary time

This is a specialisation of gf for imaginary Matsubara time.

## Synopsis

gf<imtime, Target, Opt>


The Target template parameter can take the following values:

Target Meaning
scalar_valued The function is scalar valued (double, complex…).
matrix_valued [default] The function is matrix valued.

## Domain & mesh

The domain is the set of real numbers between 0 and $$\beta$$ since the function is periodic (resp. antiperiodic) for bosons (resp. fermions), i.e.

• $$G(\tau+\beta)=-G(\tau)$$ for fermions
• $$G(\tau+\beta)=G(\tau)$$ for bosons.

The domain is implemented in

The mesh is mesh::imtime.

## Singularity

The singularity is a high frequency expansion, High-Frequency moments of the Green’s function.

## Evaluation method

• Use a linear interpolation between the two closest point of the mesh.
• Return type:
• If Target==scalar_valued: a complex
• If Target==matrix_valued: an object modeling ImmutableMatrix concept.
• When the point is outside of the mesh, the evaluation of the gf returns:
• the evaluation of the high frequency tail

## Data storage

• If Target==scalar_valued :
• data_t: 1d array of complex<double>.
• g.data()(i) is the value of g for the i-th point of the mesh.
• If Target==matrix_valued :
• data_t: 3d array (C ordered) of complex<double>.
• g.data()(i, range::all, range::all) is the value of g for the i-th point of the mesh.

TO DO: complex OR DOUBLE: FIX and document !!

h5 tag: ImTime

## Examples

#include <triqs/gfs.hpp>
#include <triqs/mesh.hpp>
using namespace triqs::gfs;
using namespace triqs;
int main() {
double beta = 10, a = 1;
int n_times = 1000;

// --- first a matrix_valued function ------------

// First give information to build the mesh, second to build the target
auto g1 = gf<imtime, matrix_valued>{{beta, Fermion, n_times}, {1, 1}};

// or a more verbose/explicit form ...
auto g2 = gf<imtime>{{beta, Fermion, n_times}, make_shape(1, 1)};

nda::clef::placeholder<0> tau_;
g1(tau_) << exp(-a * tau_) / (1 + exp(-beta * a));

// evaluation at tau=3.2
std::cout << nda::make_regular(g1(3.2)) << " == " << exp(-a * 3.2) / (1 + exp(-beta * a)) << std::endl;

// --- a scalar_valued function ------------

// same a before, but without the same of the target space ...
auto g3 = gf<imtime, scalar_valued>{{beta, Fermion, n_times}};

g3(tau_) << exp(-a * tau_) / (1 + exp(-beta * a));

// evaluation at tau=3.2
std::cout << g3(3.2) << " == " << exp(-a * 3.2) / (1 + exp(-beta * a)) << std::endl;
}


[[(0.0407608,0)]] == 0.0407604
(0.0407608,0) == 0.0407604