triqs.gfs.gf_factories.gf_factories_fourier.make_gf_from_fourier

triqs.gfs.gf_factories.gf_factories_fourier.make_gf_from_fourier()

Dispatched C++ function(s).

[1] (gin: Gf[MeshImFreq, 0], n_tau: int = -1)
  -> Gf[MeshImTime, 0]

[2] (gin: Gf[MeshImFreq, 1], n_tau: int = -1)
  -> Gf[MeshImTime, 1]

[3] (gin: Gf[MeshImFreq, 2], n_tau: int = -1)
  -> Gf[MeshImTime, 2]

[4] (gin: Gf[MeshImFreq, 3], n_tau: int = -1)
  -> Gf[MeshImTime, 3]

[5] (gin: Gf[MeshImFreq, 4], n_tau: int = -1)
  -> Gf[MeshImTime, 4]

[6] (gin: Gf[MeshImTime, 0], n_iw: int = -1)
  -> Gf[MeshImFreq, 0]

[7] (gin: Gf[MeshImTime, 0], n_iw: int = -1)
  -> Gf[MeshImFreq, 0]

[8] (gin: Gf[MeshImTime, 1], n_iw: int = -1)
  -> Gf[MeshImFreq, 1]

[9] (gin: Gf[MeshImTime, 1], n_iw: int = -1)
  -> Gf[MeshImFreq, 1]

[10] (gin: Gf[MeshImTime, 2], n_iw: int = -1)
  -> Gf[MeshImFreq, 2]

[11] (gin: Gf[MeshImTime, 2], n_iw: int = -1)
  -> Gf[MeshImFreq, 2]

[12] (gin: Gf[MeshImTime, 3], n_iw: int = -1)
  -> Gf[MeshImFreq, 3]

[13] (gin: Gf[MeshImTime, 3], n_iw: int = -1)
  -> Gf[MeshImFreq, 3]

[14] (gin: Gf[MeshImTime, 4], n_iw: int = -1)
  -> Gf[MeshImFreq, 4]

[15] (gin: Gf[MeshImTime, 4], n_iw: int = -1)
  -> Gf[MeshImFreq, 4]

[16] (gin: Gf[MeshReFreq, 0], shift_half_bin: bool = False)
  -> Gf[MeshReTime, 0]

[17] (gin: Gf[MeshReFreq, 1], shift_half_bin: bool = False)
  -> Gf[MeshReTime, 1]

[18] (gin: Gf[MeshReFreq, 2], shift_half_bin: bool = False)
  -> Gf[MeshReTime, 2]

[19] (gin: Gf[MeshReFreq, 3], shift_half_bin: bool = False)
  -> Gf[MeshReTime, 3]

[20] (gin: Gf[MeshReFreq, 4], shift_half_bin: bool = False)
  -> Gf[MeshReTime, 4]

[21] (gin: Gf[MeshReTime, 0], shift_half_bin: bool = False)
  -> Gf[MeshReFreq, 0]

[22] (gin: Gf[MeshReTime, 0], shift_half_bin: bool = False)
  -> Gf[MeshReFreq, 0]

[23] (gin: Gf[MeshReTime, 1], shift_half_bin: bool = False)
  -> Gf[MeshReFreq, 1]

[24] (gin: Gf[MeshReTime, 1], shift_half_bin: bool = False)
  -> Gf[MeshReFreq, 1]

[25] (gin: Gf[MeshReTime, 2], shift_half_bin: bool = False)
  -> Gf[MeshReFreq, 2]

[26] (gin: Gf[MeshReTime, 2], shift_half_bin: bool = False)
  -> Gf[MeshReFreq, 2]

[27] (gin: Gf[MeshReTime, 3], shift_half_bin: bool = False)
  -> Gf[MeshReFreq, 3]

[28] (gin: Gf[MeshReTime, 3], shift_half_bin: bool = False)
  -> Gf[MeshReFreq, 3]

[29] (gin: Gf[MeshReTime, 4], shift_half_bin: bool = False)
  -> Gf[MeshReFreq, 4]

[30] (gin: Gf[MeshReTime, 4], shift_half_bin: bool = False)
  -> Gf[MeshReFreq, 4]

[31] (g: BlockGf[MeshImTime, 0])
  -> BlockGf[MeshImFreq, 0]

[32] (g: BlockGf[MeshImTime, 0])
  -> BlockGf[MeshImFreq, 0]

[33] (g: BlockGf[MeshImTime, 0], x: int)
  -> BlockGf[MeshImFreq, 0]

[34] (g: BlockGf[MeshImTime, 0], x: int)
  -> BlockGf[MeshImFreq, 0]

[35] (g: Block2Gf[MeshImTime, 0])
  -> Block2Gf[MeshImFreq, 0]

[36] (g: Block2Gf[MeshImTime, 0])
  -> Block2Gf[MeshImFreq, 0]

[37] (g: Block2Gf[MeshImTime, 0], x: int)
  -> Block2Gf[MeshImFreq, 0]

[38] (g: Block2Gf[MeshImTime, 0], x: int)
  -> Block2Gf[MeshImFreq, 0]

[39] (g: BlockGf[MeshImFreq, 0])
  -> BlockGf[MeshImTime, 0]

[40] (g: BlockGf[MeshImFreq, 0], x: int)
  -> BlockGf[MeshImTime, 0]

[41] (g: Block2Gf[MeshImFreq, 0])
  -> Block2Gf[MeshImTime, 0]

[42] (g: Block2Gf[MeshImFreq, 0], x: int)
  -> Block2Gf[MeshImTime, 0]

[43] (g: BlockGf[MeshReTime, 0])
  -> BlockGf[MeshReFreq, 0]

[44] (g: BlockGf[MeshReTime, 0])
  -> BlockGf[MeshReFreq, 0]

[45] (g: BlockGf[MeshReTime, 0], x: bool)
  -> BlockGf[MeshReFreq, 0]

[46] (g: BlockGf[MeshReTime, 0], x: bool)
  -> BlockGf[MeshReFreq, 0]

[47] (g: Block2Gf[MeshReTime, 0])
  -> Block2Gf[MeshReFreq, 0]

[48] (g: Block2Gf[MeshReTime, 0])
  -> Block2Gf[MeshReFreq, 0]

[49] (g: Block2Gf[MeshReTime, 0], x: bool)
  -> Block2Gf[MeshReFreq, 0]

[50] (g: Block2Gf[MeshReTime, 0], x: bool)
  -> Block2Gf[MeshReFreq, 0]

[51] (g: BlockGf[MeshReFreq, 0])
  -> BlockGf[MeshReTime, 0]

[52] (g: BlockGf[MeshReFreq, 0], x: bool)
  -> BlockGf[MeshReTime, 0]

[53] (g: Block2Gf[MeshReFreq, 0])
  -> Block2Gf[MeshReTime, 0]

[54] (g: Block2Gf[MeshReFreq, 0], x: bool)
  -> Block2Gf[MeshReTime, 0]

[55] (g: Gf[MeshImTime, 0], m: MeshImFreq, km: ndarray[complex, 1])
  -> Gf[MeshImFreq, 0]

[56] (g: Gf[MeshImTime, 0], m: MeshImFreq, km: ndarray[complex, 1])
  -> Gf[MeshImFreq, 0]

[57] (g: BlockGf[MeshImTime, 0], m: MeshImFreq, km: [ndarray[complex, 1]])
  -> BlockGf[MeshImFreq, 0]

[58] (g: BlockGf[MeshImTime, 0], m: MeshImFreq, km: [ndarray[complex, 1]])
  -> BlockGf[MeshImFreq, 0]

[59] (g: Block2Gf[MeshImTime, 0],
     m: MeshImFreq,
     km: [[ndarray[complex, 1]]])
  -> Block2Gf[MeshImFreq, 0]

[60] (g: Block2Gf[MeshImTime, 0],
     m: MeshImFreq,
     km: [[ndarray[complex, 1]]])
  -> Block2Gf[MeshImFreq, 0]

[61] (g: Gf[MeshImFreq, 0], m: MeshImTime, km: ndarray[complex, 1])
  -> Gf[MeshImTime, 0]

[62] (g: BlockGf[MeshImFreq, 0], m: MeshImTime, km: [ndarray[complex, 1]])
  -> BlockGf[MeshImTime, 0]

[63] (g: Block2Gf[MeshImFreq, 0],
     m: MeshImTime,
     km: [[ndarray[complex, 1]]])
  -> Block2Gf[MeshImTime, 0]

[64] (g: Gf[MeshReTime, 0], m: MeshReFreq, km: ndarray[complex, 1])
  -> Gf[MeshReFreq, 0]

[65] (g: Gf[MeshReTime, 0], m: MeshReFreq, km: ndarray[complex, 1])
  -> Gf[MeshReFreq, 0]

[66] (g: BlockGf[MeshReTime, 0], m: MeshReFreq, km: [ndarray[complex, 1]])
  -> BlockGf[MeshReFreq, 0]

[67] (g: BlockGf[MeshReTime, 0], m: MeshReFreq, km: [ndarray[complex, 1]])
  -> BlockGf[MeshReFreq, 0]

[68] (g: Block2Gf[MeshReTime, 0],
     m: MeshReFreq,
     km: [[ndarray[complex, 1]]])
  -> Block2Gf[MeshReFreq, 0]

[69] (g: Block2Gf[MeshReTime, 0],
     m: MeshReFreq,
     km: [[ndarray[complex, 1]]])
  -> Block2Gf[MeshReFreq, 0]

[70] (g: Gf[MeshReFreq, 0], m: MeshReTime, km: ndarray[complex, 1])
  -> Gf[MeshReTime, 0]

[71] (g: BlockGf[MeshReFreq, 0], m: MeshReTime, km: [ndarray[complex, 1]])
  -> BlockGf[MeshReTime, 0]

[72] (g: Block2Gf[MeshReFreq, 0],
     m: MeshReTime,
     km: [[ndarray[complex, 1]]])
  -> Block2Gf[MeshReTime, 0]

[73] (g: Gf[MeshBrZone, 0])
  -> Gf[MeshCycLat, 0]

[74] (g: BlockGf[MeshBrZone, 0])
  -> BlockGf[MeshCycLat, 0]

[75] (g: Block2Gf[MeshBrZone, 0])
  -> Block2Gf[MeshCycLat, 0]

[76] (g: Gf[MeshCycLat, 0])
  -> Gf[MeshBrZone, 0]

[77] (g: BlockGf[MeshCycLat, 0])
  -> BlockGf[MeshBrZone, 0]

[78] (g: Block2Gf[MeshCycLat, 0])
  -> Block2Gf[MeshBrZone, 0]

[79] (g: BlockGf[MeshImTime, 1])
  -> BlockGf[MeshImFreq, 1]

[80] (g: BlockGf[MeshImTime, 1])
  -> BlockGf[MeshImFreq, 1]

[81] (g: BlockGf[MeshImTime, 1], x: int)
  -> BlockGf[MeshImFreq, 1]

[82] (g: BlockGf[MeshImTime, 1], x: int)
  -> BlockGf[MeshImFreq, 1]

[83] (g: Block2Gf[MeshImTime, 1])
  -> Block2Gf[MeshImFreq, 1]

[84] (g: Block2Gf[MeshImTime, 1])
  -> Block2Gf[MeshImFreq, 1]

[85] (g: Block2Gf[MeshImTime, 1], x: int)
  -> Block2Gf[MeshImFreq, 1]

[86] (g: Block2Gf[MeshImTime, 1], x: int)
  -> Block2Gf[MeshImFreq, 1]

[87] (g: BlockGf[MeshImFreq, 1])
  -> BlockGf[MeshImTime, 1]

[88] (g: BlockGf[MeshImFreq, 1], x: int)
  -> BlockGf[MeshImTime, 1]

[89] (g: Block2Gf[MeshImFreq, 1])
  -> Block2Gf[MeshImTime, 1]

[90] (g: Block2Gf[MeshImFreq, 1], x: int)
  -> Block2Gf[MeshImTime, 1]

[91] (g: BlockGf[MeshReTime, 1])
  -> BlockGf[MeshReFreq, 1]

[92] (g: BlockGf[MeshReTime, 1])
  -> BlockGf[MeshReFreq, 1]

[93] (g: BlockGf[MeshReTime, 1], x: bool)
  -> BlockGf[MeshReFreq, 1]

[94] (g: BlockGf[MeshReTime, 1], x: bool)
  -> BlockGf[MeshReFreq, 1]

[95] (g: Block2Gf[MeshReTime, 1])
  -> Block2Gf[MeshReFreq, 1]

[96] (g: Block2Gf[MeshReTime, 1])
  -> Block2Gf[MeshReFreq, 1]

[97] (g: Block2Gf[MeshReTime, 1], x: bool)
  -> Block2Gf[MeshReFreq, 1]

[98] (g: Block2Gf[MeshReTime, 1], x: bool)
  -> Block2Gf[MeshReFreq, 1]

[99] (g: BlockGf[MeshReFreq, 1])
  -> BlockGf[MeshReTime, 1]

[100] (g: BlockGf[MeshReFreq, 1], x: bool)
  -> BlockGf[MeshReTime, 1]

[101] (g: Block2Gf[MeshReFreq, 1])
  -> Block2Gf[MeshReTime, 1]

[102] (g: Block2Gf[MeshReFreq, 1], x: bool)
  -> Block2Gf[MeshReTime, 1]

[103] (g: Gf[MeshImTime, 1], m: MeshImFreq, km: ndarray[complex, 2])
  -> Gf[MeshImFreq, 1]

[104] (g: Gf[MeshImTime, 1], m: MeshImFreq, km: ndarray[complex, 2])
  -> Gf[MeshImFreq, 1]

[105] (g: BlockGf[MeshImTime, 1], m: MeshImFreq, km: [ndarray[complex, 2]])
  -> BlockGf[MeshImFreq, 1]

[106] (g: BlockGf[MeshImTime, 1], m: MeshImFreq, km: [ndarray[complex, 2]])
  -> BlockGf[MeshImFreq, 1]

[107] (g: Block2Gf[MeshImTime, 1],
     m: MeshImFreq,
     km: [[ndarray[complex, 2]]])
  -> Block2Gf[MeshImFreq, 1]

[108] (g: Block2Gf[MeshImTime, 1],
     m: MeshImFreq,
     km: [[ndarray[complex, 2]]])
  -> Block2Gf[MeshImFreq, 1]

[109] (g: Gf[MeshImFreq, 1], m: MeshImTime, km: ndarray[complex, 2])
  -> Gf[MeshImTime, 1]

[110] (g: BlockGf[MeshImFreq, 1], m: MeshImTime, km: [ndarray[complex, 2]])
  -> BlockGf[MeshImTime, 1]

[111] (g: Block2Gf[MeshImFreq, 1],
     m: MeshImTime,
     km: [[ndarray[complex, 2]]])
  -> Block2Gf[MeshImTime, 1]

[112] (g: Gf[MeshReTime, 1], m: MeshReFreq, km: ndarray[complex, 2])
  -> Gf[MeshReFreq, 1]

[113] (g: Gf[MeshReTime, 1], m: MeshReFreq, km: ndarray[complex, 2])
  -> Gf[MeshReFreq, 1]

[114] (g: BlockGf[MeshReTime, 1], m: MeshReFreq, km: [ndarray[complex, 2]])
  -> BlockGf[MeshReFreq, 1]

[115] (g: BlockGf[MeshReTime, 1], m: MeshReFreq, km: [ndarray[complex, 2]])
  -> BlockGf[MeshReFreq, 1]

[116] (g: Block2Gf[MeshReTime, 1],
     m: MeshReFreq,
     km: [[ndarray[complex, 2]]])
  -> Block2Gf[MeshReFreq, 1]

[117] (g: Block2Gf[MeshReTime, 1],
     m: MeshReFreq,
     km: [[ndarray[complex, 2]]])
  -> Block2Gf[MeshReFreq, 1]

[118] (g: Gf[MeshReFreq, 1], m: MeshReTime, km: ndarray[complex, 2])
  -> Gf[MeshReTime, 1]

[119] (g: BlockGf[MeshReFreq, 1], m: MeshReTime, km: [ndarray[complex, 2]])
  -> BlockGf[MeshReTime, 1]

[120] (g: Block2Gf[MeshReFreq, 1],
     m: MeshReTime,
     km: [[ndarray[complex, 2]]])
  -> Block2Gf[MeshReTime, 1]

[121] (g: Gf[MeshBrZone, 1])
  -> Gf[MeshCycLat, 1]

[122] (g: BlockGf[MeshBrZone, 1])
  -> BlockGf[MeshCycLat, 1]

[123] (g: Block2Gf[MeshBrZone, 1])
  -> Block2Gf[MeshCycLat, 1]

[124] (g: Gf[MeshCycLat, 1])
  -> Gf[MeshBrZone, 1]

[125] (g: BlockGf[MeshCycLat, 1])
  -> BlockGf[MeshBrZone, 1]

[126] (g: Block2Gf[MeshCycLat, 1])
  -> Block2Gf[MeshBrZone, 1]

[127] (g: BlockGf[MeshImTime, 2])
  -> BlockGf[MeshImFreq, 2]

[128] (g: BlockGf[MeshImTime, 2])
  -> BlockGf[MeshImFreq, 2]

[129] (g: BlockGf[MeshImTime, 2], x: int)
  -> BlockGf[MeshImFreq, 2]

[130] (g: BlockGf[MeshImTime, 2], x: int)
  -> BlockGf[MeshImFreq, 2]

[131] (g: Block2Gf[MeshImTime, 2])
  -> Block2Gf[MeshImFreq, 2]

[132] (g: Block2Gf[MeshImTime, 2])
  -> Block2Gf[MeshImFreq, 2]

[133] (g: Block2Gf[MeshImTime, 2], x: int)
  -> Block2Gf[MeshImFreq, 2]

[134] (g: Block2Gf[MeshImTime, 2], x: int)
  -> Block2Gf[MeshImFreq, 2]

[135] (g: BlockGf[MeshImFreq, 2])
  -> BlockGf[MeshImTime, 2]

[136] (g: BlockGf[MeshImFreq, 2], x: int)
  -> BlockGf[MeshImTime, 2]

[137] (g: Block2Gf[MeshImFreq, 2])
  -> Block2Gf[MeshImTime, 2]

[138] (g: Block2Gf[MeshImFreq, 2], x: int)
  -> Block2Gf[MeshImTime, 2]

[139] (g: BlockGf[MeshReTime, 2])
  -> BlockGf[MeshReFreq, 2]

[140] (g: BlockGf[MeshReTime, 2])
  -> BlockGf[MeshReFreq, 2]

[141] (g: BlockGf[MeshReTime, 2], x: bool)
  -> BlockGf[MeshReFreq, 2]

[142] (g: BlockGf[MeshReTime, 2], x: bool)
  -> BlockGf[MeshReFreq, 2]

[143] (g: Block2Gf[MeshReTime, 2])
  -> Block2Gf[MeshReFreq, 2]

[144] (g: Block2Gf[MeshReTime, 2])
  -> Block2Gf[MeshReFreq, 2]

[145] (g: Block2Gf[MeshReTime, 2], x: bool)
  -> Block2Gf[MeshReFreq, 2]

[146] (g: Block2Gf[MeshReTime, 2], x: bool)
  -> Block2Gf[MeshReFreq, 2]

[147] (g: BlockGf[MeshReFreq, 2])
  -> BlockGf[MeshReTime, 2]

[148] (g: BlockGf[MeshReFreq, 2], x: bool)
  -> BlockGf[MeshReTime, 2]

[149] (g: Block2Gf[MeshReFreq, 2])
  -> Block2Gf[MeshReTime, 2]

[150] (g: Block2Gf[MeshReFreq, 2], x: bool)
  -> Block2Gf[MeshReTime, 2]

[151] (g: Gf[MeshImTime, 2], m: MeshImFreq, km: ndarray[complex, 3])
  -> Gf[MeshImFreq, 2]

[152] (g: Gf[MeshImTime, 2], m: MeshImFreq, km: ndarray[complex, 3])
  -> Gf[MeshImFreq, 2]

[153] (g: BlockGf[MeshImTime, 2], m: MeshImFreq, km: [ndarray[complex, 3]])
  -> BlockGf[MeshImFreq, 2]

[154] (g: BlockGf[MeshImTime, 2], m: MeshImFreq, km: [ndarray[complex, 3]])
  -> BlockGf[MeshImFreq, 2]

[155] (g: Block2Gf[MeshImTime, 2],
     m: MeshImFreq,
     km: [[ndarray[complex, 3]]])
  -> Block2Gf[MeshImFreq, 2]

[156] (g: Block2Gf[MeshImTime, 2],
     m: MeshImFreq,
     km: [[ndarray[complex, 3]]])
  -> Block2Gf[MeshImFreq, 2]

[157] (g: Gf[MeshImFreq, 2], m: MeshImTime, km: ndarray[complex, 3])
  -> Gf[MeshImTime, 2]

[158] (g: BlockGf[MeshImFreq, 2], m: MeshImTime, km: [ndarray[complex, 3]])
  -> BlockGf[MeshImTime, 2]

[159] (g: Block2Gf[MeshImFreq, 2],
     m: MeshImTime,
     km: [[ndarray[complex, 3]]])
  -> Block2Gf[MeshImTime, 2]

[160] (g: Gf[MeshReTime, 2], m: MeshReFreq, km: ndarray[complex, 3])
  -> Gf[MeshReFreq, 2]

[161] (g: Gf[MeshReTime, 2], m: MeshReFreq, km: ndarray[complex, 3])
  -> Gf[MeshReFreq, 2]

[162] (g: BlockGf[MeshReTime, 2], m: MeshReFreq, km: [ndarray[complex, 3]])
  -> BlockGf[MeshReFreq, 2]

[163] (g: BlockGf[MeshReTime, 2], m: MeshReFreq, km: [ndarray[complex, 3]])
  -> BlockGf[MeshReFreq, 2]

[164] (g: Block2Gf[MeshReTime, 2],
     m: MeshReFreq,
     km: [[ndarray[complex, 3]]])
  -> Block2Gf[MeshReFreq, 2]

[165] (g: Block2Gf[MeshReTime, 2],
     m: MeshReFreq,
     km: [[ndarray[complex, 3]]])
  -> Block2Gf[MeshReFreq, 2]

[166] (g: Gf[MeshReFreq, 2], m: MeshReTime, km: ndarray[complex, 3])
  -> Gf[MeshReTime, 2]

[167] (g: BlockGf[MeshReFreq, 2], m: MeshReTime, km: [ndarray[complex, 3]])
  -> BlockGf[MeshReTime, 2]

[168] (g: Block2Gf[MeshReFreq, 2],
     m: MeshReTime,
     km: [[ndarray[complex, 3]]])
  -> Block2Gf[MeshReTime, 2]

[169] (g: Gf[MeshBrZone, 2])
  -> Gf[MeshCycLat, 2]

[170] (g: BlockGf[MeshBrZone, 2])
  -> BlockGf[MeshCycLat, 2]

[171] (g: Block2Gf[MeshBrZone, 2])
  -> Block2Gf[MeshCycLat, 2]

[172] (g: Gf[MeshCycLat, 2])
  -> Gf[MeshBrZone, 2]

[173] (g: BlockGf[MeshCycLat, 2])
  -> BlockGf[MeshBrZone, 2]

[174] (g: Block2Gf[MeshCycLat, 2])
  -> Block2Gf[MeshBrZone, 2]

[175] (g: BlockGf[MeshImTime, 3])
  -> BlockGf[MeshImFreq, 3]

[176] (g: BlockGf[MeshImTime, 3])
  -> BlockGf[MeshImFreq, 3]

[177] (g: BlockGf[MeshImTime, 3], x: int)
  -> BlockGf[MeshImFreq, 3]

[178] (g: BlockGf[MeshImTime, 3], x: int)
  -> BlockGf[MeshImFreq, 3]

[179] (g: Block2Gf[MeshImTime, 3])
  -> Block2Gf[MeshImFreq, 3]

[180] (g: Block2Gf[MeshImTime, 3])
  -> Block2Gf[MeshImFreq, 3]

[181] (g: Block2Gf[MeshImTime, 3], x: int)
  -> Block2Gf[MeshImFreq, 3]

[182] (g: Block2Gf[MeshImTime, 3], x: int)
  -> Block2Gf[MeshImFreq, 3]

[183] (g: BlockGf[MeshImFreq, 3])
  -> BlockGf[MeshImTime, 3]

[184] (g: BlockGf[MeshImFreq, 3], x: int)
  -> BlockGf[MeshImTime, 3]

[185] (g: Block2Gf[MeshImFreq, 3])
  -> Block2Gf[MeshImTime, 3]

[186] (g: Block2Gf[MeshImFreq, 3], x: int)
  -> Block2Gf[MeshImTime, 3]

[187] (g: BlockGf[MeshReTime, 3])
  -> BlockGf[MeshReFreq, 3]

[188] (g: BlockGf[MeshReTime, 3])
  -> BlockGf[MeshReFreq, 3]

[189] (g: BlockGf[MeshReTime, 3], x: bool)
  -> BlockGf[MeshReFreq, 3]

[190] (g: BlockGf[MeshReTime, 3], x: bool)
  -> BlockGf[MeshReFreq, 3]

[191] (g: Block2Gf[MeshReTime, 3])
  -> Block2Gf[MeshReFreq, 3]

[192] (g: Block2Gf[MeshReTime, 3])
  -> Block2Gf[MeshReFreq, 3]

[193] (g: Block2Gf[MeshReTime, 3], x: bool)
  -> Block2Gf[MeshReFreq, 3]

[194] (g: Block2Gf[MeshReTime, 3], x: bool)
  -> Block2Gf[MeshReFreq, 3]

[195] (g: BlockGf[MeshReFreq, 3])
  -> BlockGf[MeshReTime, 3]

[196] (g: BlockGf[MeshReFreq, 3], x: bool)
  -> BlockGf[MeshReTime, 3]

[197] (g: Block2Gf[MeshReFreq, 3])
  -> Block2Gf[MeshReTime, 3]

[198] (g: Block2Gf[MeshReFreq, 3], x: bool)
  -> Block2Gf[MeshReTime, 3]

[199] (g: Gf[MeshImTime, 3], m: MeshImFreq, km: ndarray[complex, 4])
  -> Gf[MeshImFreq, 3]

[200] (g: Gf[MeshImTime, 3], m: MeshImFreq, km: ndarray[complex, 4])
  -> Gf[MeshImFreq, 3]

[201] (g: BlockGf[MeshImTime, 3], m: MeshImFreq, km: [ndarray[complex, 4]])
  -> BlockGf[MeshImFreq, 3]

[202] (g: BlockGf[MeshImTime, 3], m: MeshImFreq, km: [ndarray[complex, 4]])
  -> BlockGf[MeshImFreq, 3]

[203] (g: Block2Gf[MeshImTime, 3],
     m: MeshImFreq,
     km: [[ndarray[complex, 4]]])
  -> Block2Gf[MeshImFreq, 3]

[204] (g: Block2Gf[MeshImTime, 3],
     m: MeshImFreq,
     km: [[ndarray[complex, 4]]])
  -> Block2Gf[MeshImFreq, 3]

[205] (g: Gf[MeshImFreq, 3], m: MeshImTime, km: ndarray[complex, 4])
  -> Gf[MeshImTime, 3]

[206] (g: BlockGf[MeshImFreq, 3], m: MeshImTime, km: [ndarray[complex, 4]])
  -> BlockGf[MeshImTime, 3]

[207] (g: Block2Gf[MeshImFreq, 3],
     m: MeshImTime,
     km: [[ndarray[complex, 4]]])
  -> Block2Gf[MeshImTime, 3]

[208] (g: Gf[MeshReTime, 3], m: MeshReFreq, km: ndarray[complex, 4])
  -> Gf[MeshReFreq, 3]

[209] (g: Gf[MeshReTime, 3], m: MeshReFreq, km: ndarray[complex, 4])
  -> Gf[MeshReFreq, 3]

[210] (g: BlockGf[MeshReTime, 3], m: MeshReFreq, km: [ndarray[complex, 4]])
  -> BlockGf[MeshReFreq, 3]

[211] (g: BlockGf[MeshReTime, 3], m: MeshReFreq, km: [ndarray[complex, 4]])
  -> BlockGf[MeshReFreq, 3]

[212] (g: Block2Gf[MeshReTime, 3],
     m: MeshReFreq,
     km: [[ndarray[complex, 4]]])
  -> Block2Gf[MeshReFreq, 3]

[213] (g: Block2Gf[MeshReTime, 3],
     m: MeshReFreq,
     km: [[ndarray[complex, 4]]])
  -> Block2Gf[MeshReFreq, 3]

[214] (g: Gf[MeshReFreq, 3], m: MeshReTime, km: ndarray[complex, 4])
  -> Gf[MeshReTime, 3]

[215] (g: BlockGf[MeshReFreq, 3], m: MeshReTime, km: [ndarray[complex, 4]])
  -> BlockGf[MeshReTime, 3]

[216] (g: Block2Gf[MeshReFreq, 3],
     m: MeshReTime,
     km: [[ndarray[complex, 4]]])
  -> Block2Gf[MeshReTime, 3]

[217] (g: Gf[MeshBrZone, 3])
  -> Gf[MeshCycLat, 3]

[218] (g: BlockGf[MeshBrZone, 3])
  -> BlockGf[MeshCycLat, 3]

[219] (g: Block2Gf[MeshBrZone, 3])
  -> Block2Gf[MeshCycLat, 3]

[220] (g: Gf[MeshCycLat, 3])
  -> Gf[MeshBrZone, 3]

[221] (g: BlockGf[MeshCycLat, 3])
  -> BlockGf[MeshBrZone, 3]

[222] (g: Block2Gf[MeshCycLat, 3])
  -> Block2Gf[MeshBrZone, 3]

[223] (g: BlockGf[MeshImTime, 4])
  -> BlockGf[MeshImFreq, 4]

[224] (g: BlockGf[MeshImTime, 4])
  -> BlockGf[MeshImFreq, 4]

[225] (g: BlockGf[MeshImTime, 4], x: int)
  -> BlockGf[MeshImFreq, 4]

[226] (g: BlockGf[MeshImTime, 4], x: int)
  -> BlockGf[MeshImFreq, 4]

[227] (g: Block2Gf[MeshImTime, 4])
  -> Block2Gf[MeshImFreq, 4]

[228] (g: Block2Gf[MeshImTime, 4])
  -> Block2Gf[MeshImFreq, 4]

[229] (g: Block2Gf[MeshImTime, 4], x: int)
  -> Block2Gf[MeshImFreq, 4]

[230] (g: Block2Gf[MeshImTime, 4], x: int)
  -> Block2Gf[MeshImFreq, 4]

[231] (g: BlockGf[MeshImFreq, 4])
  -> BlockGf[MeshImTime, 4]

[232] (g: BlockGf[MeshImFreq, 4], x: int)
  -> BlockGf[MeshImTime, 4]

[233] (g: Block2Gf[MeshImFreq, 4])
  -> Block2Gf[MeshImTime, 4]

[234] (g: Block2Gf[MeshImFreq, 4], x: int)
  -> Block2Gf[MeshImTime, 4]

[235] (g: BlockGf[MeshReTime, 4])
  -> BlockGf[MeshReFreq, 4]

[236] (g: BlockGf[MeshReTime, 4])
  -> BlockGf[MeshReFreq, 4]

[237] (g: BlockGf[MeshReTime, 4], x: bool)
  -> BlockGf[MeshReFreq, 4]

[238] (g: BlockGf[MeshReTime, 4], x: bool)
  -> BlockGf[MeshReFreq, 4]

[239] (g: Block2Gf[MeshReTime, 4])
  -> Block2Gf[MeshReFreq, 4]

[240] (g: Block2Gf[MeshReTime, 4])
  -> Block2Gf[MeshReFreq, 4]

[241] (g: Block2Gf[MeshReTime, 4], x: bool)
  -> Block2Gf[MeshReFreq, 4]

[242] (g: Block2Gf[MeshReTime, 4], x: bool)
  -> Block2Gf[MeshReFreq, 4]

[243] (g: BlockGf[MeshReFreq, 4])
  -> BlockGf[MeshReTime, 4]

[244] (g: BlockGf[MeshReFreq, 4], x: bool)
  -> BlockGf[MeshReTime, 4]

[245] (g: Block2Gf[MeshReFreq, 4])
  -> Block2Gf[MeshReTime, 4]

[246] (g: Block2Gf[MeshReFreq, 4], x: bool)
  -> Block2Gf[MeshReTime, 4]

[247] (g: Gf[MeshImTime, 4], m: MeshImFreq, km: ndarray[complex, 5])
  -> Gf[MeshImFreq, 4]

[248] (g: Gf[MeshImTime, 4], m: MeshImFreq, km: ndarray[complex, 5])
  -> Gf[MeshImFreq, 4]

[249] (g: BlockGf[MeshImTime, 4], m: MeshImFreq, km: [ndarray[complex, 5]])
  -> BlockGf[MeshImFreq, 4]

[250] (g: BlockGf[MeshImTime, 4], m: MeshImFreq, km: [ndarray[complex, 5]])
  -> BlockGf[MeshImFreq, 4]

[251] (g: Block2Gf[MeshImTime, 4],
     m: MeshImFreq,
     km: [[ndarray[complex, 5]]])
  -> Block2Gf[MeshImFreq, 4]

[252] (g: Block2Gf[MeshImTime, 4],
     m: MeshImFreq,
     km: [[ndarray[complex, 5]]])
  -> Block2Gf[MeshImFreq, 4]

[253] (g: Gf[MeshImFreq, 4], m: MeshImTime, km: ndarray[complex, 5])
  -> Gf[MeshImTime, 4]

[254] (g: BlockGf[MeshImFreq, 4], m: MeshImTime, km: [ndarray[complex, 5]])
  -> BlockGf[MeshImTime, 4]

[255] (g: Block2Gf[MeshImFreq, 4],
     m: MeshImTime,
     km: [[ndarray[complex, 5]]])
  -> Block2Gf[MeshImTime, 4]

[256] (g: Gf[MeshReTime, 4], m: MeshReFreq, km: ndarray[complex, 5])
  -> Gf[MeshReFreq, 4]

[257] (g: Gf[MeshReTime, 4], m: MeshReFreq, km: ndarray[complex, 5])
  -> Gf[MeshReFreq, 4]

[258] (g: BlockGf[MeshReTime, 4], m: MeshReFreq, km: [ndarray[complex, 5]])
  -> BlockGf[MeshReFreq, 4]

[259] (g: BlockGf[MeshReTime, 4], m: MeshReFreq, km: [ndarray[complex, 5]])
  -> BlockGf[MeshReFreq, 4]

[260] (g: Block2Gf[MeshReTime, 4],
     m: MeshReFreq,
     km: [[ndarray[complex, 5]]])
  -> Block2Gf[MeshReFreq, 4]

[261] (g: Block2Gf[MeshReTime, 4],
     m: MeshReFreq,
     km: [[ndarray[complex, 5]]])
  -> Block2Gf[MeshReFreq, 4]

[262] (g: Gf[MeshReFreq, 4], m: MeshReTime, km: ndarray[complex, 5])
  -> Gf[MeshReTime, 4]

[263] (g: BlockGf[MeshReFreq, 4], m: MeshReTime, km: [ndarray[complex, 5]])
  -> BlockGf[MeshReTime, 4]

[264] (g: Block2Gf[MeshReFreq, 4],
     m: MeshReTime,
     km: [[ndarray[complex, 5]]])
  -> Block2Gf[MeshReTime, 4]

[265] (g: Gf[MeshBrZone, 4])
  -> Gf[MeshCycLat, 4]

[266] (g: BlockGf[MeshBrZone, 4])
  -> BlockGf[MeshCycLat, 4]

[267] (g: Block2Gf[MeshBrZone, 4])
  -> Block2Gf[MeshCycLat, 4]

[268] (g: Gf[MeshCycLat, 4])
  -> Gf[MeshBrZone, 4]

[269] (g: BlockGf[MeshCycLat, 4])
  -> BlockGf[MeshBrZone, 4]

[270] (g: Block2Gf[MeshCycLat, 4])
  -> Block2Gf[MeshBrZone, 4]

[271] (g_in: Gf[MeshProduct[MeshBrZone, MeshDLRImFreq], 0])
  -> Gf[MeshProduct[MeshCycLat, MeshDLRImTime], 0]

[272] (g_in: BlockGf[MeshProduct[MeshBrZone, MeshDLRImFreq], 0])
  -> BlockGf[MeshProduct[MeshCycLat, MeshDLRImTime], 0]

[273] (g_in: Gf[MeshProduct[MeshCycLat, MeshDLRImTime], 0])
  -> Gf[MeshProduct[MeshBrZone, MeshDLRImFreq], 0]

[274] (g_in: BlockGf[MeshProduct[MeshCycLat, MeshDLRImTime], 0])
  -> BlockGf[MeshProduct[MeshBrZone, MeshDLRImFreq], 0]

[275] (g_in: Gf[MeshProduct[MeshBrZone, MeshDLRImFreq], 2])
  -> Gf[MeshProduct[MeshCycLat, MeshDLRImTime], 2]

[276] (g_in: BlockGf[MeshProduct[MeshBrZone, MeshDLRImFreq], 2])
  -> BlockGf[MeshProduct[MeshCycLat, MeshDLRImTime], 2]

[277] (g_in: Gf[MeshProduct[MeshCycLat, MeshDLRImTime], 2])
  -> Gf[MeshProduct[MeshBrZone, MeshDLRImFreq], 2]

[278] (g_in: BlockGf[MeshProduct[MeshCycLat, MeshDLRImTime], 2])
  -> BlockGf[MeshProduct[MeshBrZone, MeshDLRImFreq], 2]

[1, 2, 3, 4, 5] Fourier transform a Matsubara-frequency Green’s function to imaginary time (n_tau time points, -1 for the default).

---

[6, 7, 8, 9, 10, 11, 12, 13, 14, 15] Fourier transform an imaginary-time Green’s function to Matsubara frequencies (n_iw positive frequencies, -1 for the default).

---

[16, 17, 18, 19, 20] Fourier transform a real-frequency Green’s function to real time (set shift_half_bin to shift the time mesh by half a bin).

---

[21, 22, 23, 24, 25, 26, 27, 28, 29, 30] Fourier transform a real-time Green’s function to real frequencies (set shift_half_bin to shift the frequency mesh by half a bin).

---

[31] Build a Green’s function on the conjugate mesh by Fourier transform.

Applies to every overload. The supported conjugate mesh pairs are imaginary time and Matsubara frequencies, real time and real frequency, cyclic lattice and Brillouin zone, and DLR imaginary time and DLR Matsubara frequencies. Product meshes pairing one of these Fourier axes with a lattice axis, as well as block and block-of-block Green’s function containers, are transformed block- and component-wise. All target ranks (scalar, vector, matrix, rank-3, rank-4) are supported.

Beyond the input Green’s function, the following optional positional arguments may be passed; which one applies depends on the input mesh.

• n_iw: the number of positive Matsubara frequencies in the output mesh, when the input lives on imaginary time (default is -1, which selects the default size from the input).

• n_tau: the number of imaginary-time points in the output mesh, when the input lives on Matsubara frequencies (default is -1, which selects the default size from the input).

• shift_half_bin: a half-bin shift flag for the output mesh, for the real-time and real-frequency pair (default is false).

• mesh and known_moments: an explicit output mesh together with an array of high-frequency moments, for the imaginary-time and Matsubara and the real-time and real-frequency pairs. The known-moment tail correction improves accuracy at high frequency.

---

Parameters:

gBlockGf[MeshImTime, 0]

The input Green’s function.

Returns:

BlockGf[MeshImFreq, 0]

A new Green’s function on the conjugate mesh.