Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/scipy/fft/_pocketfft/basic.py: 29%

1""" 

2Discrete Fourier Transforms - basic.py 

3""" 

4import numpy as np 

5import functools 

6from . import pypocketfft as pfft 

7from .helper import (_asfarray, _init_nd_shape_and_axes, _datacopied, 

8 _fix_shape, _fix_shape_1d, _normalization, 

9 _workers) 

10 

11def c2c(forward, x, n=None, axis=-1, norm=None, overwrite_x=False, 

12 workers=None, *, plan=None): 

13 """ Return discrete Fourier transform of real or complex sequence. """ 

14 if plan is not None: 

15 raise NotImplementedError('Passing a precomputed plan is not yet ' 

16 'supported by scipy.fft functions') 

17 tmp = _asfarray(x) 

18 overwrite_x = overwrite_x or _datacopied(tmp, x) 

19 norm = _normalization(norm, forward) 

20 workers = _workers(workers) 

21 

22 if n is not None: 

23 tmp, copied = _fix_shape_1d(tmp, n, axis) 

24 overwrite_x = overwrite_x or copied 

25 elif tmp.shape[axis] < 1: 

26 raise ValueError("invalid number of data points ({0}) specified" 

27 .format(tmp.shape[axis])) 

28 

29 out = (tmp if overwrite_x and tmp.dtype.kind == 'c' else None) 

30 

31 return pfft.c2c(tmp, (axis,), forward, norm, out, workers) 

32 

33 

34fft = functools.partial(c2c, True) 

35fft.__name__ = 'fft' 

36ifft = functools.partial(c2c, False) 

37ifft.__name__ = 'ifft' 

38 

39 

40def r2c(forward, x, n=None, axis=-1, norm=None, overwrite_x=False, 

41 workers=None, *, plan=None): 

42 """ 

43 Discrete Fourier transform of a real sequence. 

44 """ 

45 if plan is not None: 

46 raise NotImplementedError('Passing a precomputed plan is not yet ' 

47 'supported by scipy.fft functions') 

48 tmp = _asfarray(x) 

49 norm = _normalization(norm, forward) 

50 workers = _workers(workers) 

51 

52 if not np.isrealobj(tmp): 

53 raise TypeError("x must be a real sequence") 

54 

55 if n is not None: 

56 tmp, _ = _fix_shape_1d(tmp, n, axis) 

57 elif tmp.shape[axis] < 1: 

58 raise ValueError("invalid number of data points ({0}) specified" 

59 .format(tmp.shape[axis])) 

60 

61 # Note: overwrite_x is not utilised 

62 return pfft.r2c(tmp, (axis,), forward, norm, None, workers) 

63 

64 

65rfft = functools.partial(r2c, True) 

66rfft.__name__ = 'rfft' 

67ihfft = functools.partial(r2c, False) 

68ihfft.__name__ = 'ihfft' 

69 

70 

71def c2r(forward, x, n=None, axis=-1, norm=None, overwrite_x=False, 

72 workers=None, *, plan=None): 

73 """ 

74 Return inverse discrete Fourier transform of real sequence x. 

75 """ 

76 if plan is not None: 

77 raise NotImplementedError('Passing a precomputed plan is not yet ' 

78 'supported by scipy.fft functions') 

79 tmp = _asfarray(x) 

80 norm = _normalization(norm, forward) 

81 workers = _workers(workers) 

82 

83 # TODO: Optimize for hermitian and real? 

84 if np.isrealobj(tmp): 

85 tmp = tmp + 0.j 

86 

87 # Last axis utilizes hermitian symmetry 

88 if n is None: 

89 n = (tmp.shape[axis] - 1) * 2 

90 if n < 1: 

91 raise ValueError("Invalid number of data points ({0}) specified" 

92 .format(n)) 

93 else: 

94 tmp, _ = _fix_shape_1d(tmp, (n//2) + 1, axis) 

95 

96 # Note: overwrite_x is not utilized 

97 return pfft.c2r(tmp, (axis,), n, forward, norm, None, workers) 

98 

99 

100hfft = functools.partial(c2r, True) 

101hfft.__name__ = 'hfft' 

102irfft = functools.partial(c2r, False) 

103irfft.__name__ = 'irfft' 

104 

105 

106def fft2(x, s=None, axes=(-2,-1), norm=None, overwrite_x=False, workers=None, 

107 *, plan=None): 

108 """ 

109 2-D discrete Fourier transform. 

110 """ 

111 if plan is not None: 

112 raise NotImplementedError('Passing a precomputed plan is not yet ' 

113 'supported by scipy.fft functions') 

114 return fftn(x, s, axes, norm, overwrite_x, workers) 

115 

116 

117def ifft2(x, s=None, axes=(-2,-1), norm=None, overwrite_x=False, workers=None, 

118 *, plan=None): 

119 """ 

120 2-D discrete inverse Fourier transform of real or complex sequence. 

121 """ 

122 if plan is not None: 

123 raise NotImplementedError('Passing a precomputed plan is not yet ' 

124 'supported by scipy.fft functions') 

125 return ifftn(x, s, axes, norm, overwrite_x, workers) 

126 

127 

128def rfft2(x, s=None, axes=(-2,-1), norm=None, overwrite_x=False, workers=None, 

129 *, plan=None): 

130 """ 

131 2-D discrete Fourier transform of a real sequence 

132 """ 

133 if plan is not None: 

134 raise NotImplementedError('Passing a precomputed plan is not yet ' 

135 'supported by scipy.fft functions') 

136 return rfftn(x, s, axes, norm, overwrite_x, workers) 

137 

138 

139def irfft2(x, s=None, axes=(-2,-1), norm=None, overwrite_x=False, workers=None, 

140 *, plan=None): 

141 """ 

142 2-D discrete inverse Fourier transform of a real sequence 

143 """ 

144 if plan is not None: 

145 raise NotImplementedError('Passing a precomputed plan is not yet ' 

146 'supported by scipy.fft functions') 

147 return irfftn(x, s, axes, norm, overwrite_x, workers) 

148 

149 

150def hfft2(x, s=None, axes=(-2,-1), norm=None, overwrite_x=False, workers=None, 

151 *, plan=None): 

152 """ 

153 2-D discrete Fourier transform of a Hermitian sequence 

154 """ 

155 if plan is not None: 

156 raise NotImplementedError('Passing a precomputed plan is not yet ' 

157 'supported by scipy.fft functions') 

158 return hfftn(x, s, axes, norm, overwrite_x, workers) 

159 

160 

161def ihfft2(x, s=None, axes=(-2,-1), norm=None, overwrite_x=False, workers=None, 

162 *, plan=None): 

163 """ 

164 2-D discrete inverse Fourier transform of a Hermitian sequence 

165 """ 

166 if plan is not None: 

167 raise NotImplementedError('Passing a precomputed plan is not yet ' 

168 'supported by scipy.fft functions') 

169 return ihfftn(x, s, axes, norm, overwrite_x, workers) 

170 

171 

172def c2cn(forward, x, s=None, axes=None, norm=None, overwrite_x=False, 

173 workers=None, *, plan=None): 

174 """ 

175 Return multidimensional discrete Fourier transform. 

176 """ 

177 if plan is not None: 

178 raise NotImplementedError('Passing a precomputed plan is not yet ' 

179 'supported by scipy.fft functions') 

180 tmp = _asfarray(x) 

181 

182 shape, axes = _init_nd_shape_and_axes(tmp, s, axes) 

183 overwrite_x = overwrite_x or _datacopied(tmp, x) 

184 workers = _workers(workers) 

185 

186 if len(axes) == 0: 

187 return x 

188 

189 tmp, copied = _fix_shape(tmp, shape, axes) 

190 overwrite_x = overwrite_x or copied 

191 

192 norm = _normalization(norm, forward) 

193 out = (tmp if overwrite_x and tmp.dtype.kind == 'c' else None) 

194 

195 return pfft.c2c(tmp, axes, forward, norm, out, workers) 

196 

197 

198fftn = functools.partial(c2cn, True) 

199fftn.__name__ = 'fftn' 

200ifftn = functools.partial(c2cn, False) 

201ifftn.__name__ = 'ifftn' 

202 

203def r2cn(forward, x, s=None, axes=None, norm=None, overwrite_x=False, 

204 workers=None, *, plan=None): 

205 """Return multidimensional discrete Fourier transform of real input""" 

206 if plan is not None: 

207 raise NotImplementedError('Passing a precomputed plan is not yet ' 

208 'supported by scipy.fft functions') 

209 tmp = _asfarray(x) 

210 

211 if not np.isrealobj(tmp): 

212 raise TypeError("x must be a real sequence") 

213 

214 shape, axes = _init_nd_shape_and_axes(tmp, s, axes) 

215 tmp, _ = _fix_shape(tmp, shape, axes) 

216 norm = _normalization(norm, forward) 

217 workers = _workers(workers) 

218 

219 if len(axes) == 0: 

220 raise ValueError("at least 1 axis must be transformed") 

221 

222 # Note: overwrite_x is not utilized 

223 return pfft.r2c(tmp, axes, forward, norm, None, workers) 

224 

225 

226rfftn = functools.partial(r2cn, True) 

227rfftn.__name__ = 'rfftn' 

228ihfftn = functools.partial(r2cn, False) 

229ihfftn.__name__ = 'ihfftn' 

230 

231 

232def c2rn(forward, x, s=None, axes=None, norm=None, overwrite_x=False, 

233 workers=None, *, plan=None): 

234 """Multidimensional inverse discrete fourier transform with real output""" 

235 if plan is not None: 

236 raise NotImplementedError('Passing a precomputed plan is not yet ' 

237 'supported by scipy.fft functions') 

238 tmp = _asfarray(x) 

239 

240 # TODO: Optimize for hermitian and real? 

241 if np.isrealobj(tmp): 

242 tmp = tmp + 0.j 

243 

244 noshape = s is None 

245 shape, axes = _init_nd_shape_and_axes(tmp, s, axes) 

246 

247 if len(axes) == 0: 

248 raise ValueError("at least 1 axis must be transformed") 

249 

250 if noshape: 

251 shape[-1] = (x.shape[axes[-1]] - 1) * 2 

252 

253 norm = _normalization(norm, forward) 

254 workers = _workers(workers) 

255 

256 # Last axis utilizes hermitian symmetry 

257 lastsize = shape[-1] 

258 shape[-1] = (shape[-1] // 2) + 1 

259 

260 tmp, _ = _fix_shape(tmp, shape, axes) 

261 

262 # Note: overwrite_x is not utilized 

263 return pfft.c2r(tmp, axes, lastsize, forward, norm, None, workers) 

264 

265 

266hfftn = functools.partial(c2rn, True) 

267hfftn.__name__ = 'hfftn' 

268irfftn = functools.partial(c2rn, False) 

269irfftn.__name__ = 'irfftn' 

270 

271 

272def r2r_fftpack(forward, x, n=None, axis=-1, norm=None, overwrite_x=False): 

273 """FFT of a real sequence, returning fftpack half complex format""" 

274 tmp = _asfarray(x) 

275 overwrite_x = overwrite_x or _datacopied(tmp, x) 

276 norm = _normalization(norm, forward) 

277 workers = _workers(None) 

278 

279 if tmp.dtype.kind == 'c': 

280 raise TypeError('x must be a real sequence') 

281 

282 if n is not None: 

283 tmp, copied = _fix_shape_1d(tmp, n, axis) 

284 overwrite_x = overwrite_x or copied 

285 elif tmp.shape[axis] < 1: 

286 raise ValueError("invalid number of data points ({0}) specified" 

287 .format(tmp.shape[axis])) 

288 

289 out = (tmp if overwrite_x else None) 

290 

291 return pfft.r2r_fftpack(tmp, (axis,), forward, forward, norm, out, workers) 

292 

293 

294rfft_fftpack = functools.partial(r2r_fftpack, True) 

295rfft_fftpack.__name__ = 'rfft_fftpack' 

296irfft_fftpack = functools.partial(r2r_fftpack, False) 

297irfft_fftpack.__name__ = 'irfft_fftpack'