U d»{j‰ã@s4ddlmZddlZdd„Zd dd„Zdd d „ZdS)é)Ú factorialNcCsdt|dƒ ¡>S)z· Find the bit (i.e. power of 2) immediately greater than or equal to N Note: this works for numbers up to 2 ** 64. Roughly equivalent to int(2 ** np.ceil(np.log2(N))) é)ÚintÚ bit_length)ÚN©rú€/var/www/html/bwave/python/venv/lib/python3.8/site-packages/astropy/timeseries/periodograms/lombscargle/implementations/utils.pyÚbitceilsr éc Cs:ttjt ||¡ƒ\}}|dkr:tt |¡d|dƒ}tj||jd}|ddk}tj  |||  t¡||¡||||}}t  ||d  t¡d||¡}|t  ||t  |¡dd…tjfd¡}t|dƒ}t|ƒD]J} | dkr|| | |9}||d| } tj  || |||| ¡qê|S)aö Extirpolate the values (x, y) onto an integer grid range(N), using lagrange polynomial weights on the M nearest points. Parameters ---------- x : array-like array of abscissas y : array-like array of ordinates N : int number of integer bins to use. For best performance, N should be larger than the maximum of x M : int number of adjoining points on which to extirpolate. Returns ------- yN : ndarray N extirpolated values associated with range(N) Examples -------- >>> rng = np.random.default_rng(0) >>> x = 100 * rng.random(20) >>> y = np.sin(x) >>> y_hat = extirpolate(x, y) >>> x_hat = np.arange(len(y_hat)) >>> f = lambda x: np.sin(x / 10) >>> np.allclose(np.sum(y * f(x)), np.sum(y_hat * f(x_hat))) True Notes ----- This code is based on the C implementation of spread() presented in Numerical Recipes in C, Second Edition (Press et al. 1989; p.583). Ngà?r)Údtyperé)ÚmapÚnpÚravelÚbroadcast_arraysrÚmaxZzerosr ÚaddÚatZastypeZclipÚprodÚarangeÚnewaxisrÚrange) ÚxÚyrÚMÚresultZintegersZiloÚ numeratorÚ denominatorÚjÚindrrrÚ extirpolates &  ,   r réTc  CsŠ||9}||9}|dkr tdƒ‚ttjt ||¡ƒ\}}|rt|ƒ}|dkrVtdƒ‚t||ƒ} | ¡} |dkr’|t dtj ||| ¡}|| | || } t | || |ƒ} tj   | ¡d|…} | dkrþ||t  |¡}| t dtj | |¡9} | | j}| | j}nn||t  |¡}t |t dtj ||dd…tjf¡¡}t |t dtj ||dd…tjf¡¡}||fS)aÓCompute (approximate) trigonometric sums for a number of frequencies This routine computes weighted sine and cosine sums:: S_j = sum_i { h_i * sin(2 pi * f_j * t_i) } C_j = sum_i { h_i * cos(2 pi * f_j * t_i) } Where f_j = freq_factor * (f0 + j * df) for the values j in 1 ... N. The sums can be computed either by a brute force O[N^2] method, or by an FFT-based O[Nlog(N)] method. Parameters ---------- t : array-like array of input times h : array-like array weights for the sum df : float frequency spacing N : int number of frequency bins to return f0 : float, optional The low frequency to use freq_factor : float, optional Factor which multiplies the frequency use_fft : bool if True, use the approximate FFT algorithm to compute the result. This uses the FFT with Press & Rybicki's Lagrangian extirpolation. oversampling : int (default = 5) oversampling freq_factor for the approximation; roughly the number of time samples across the highest-frequency sinusoid. This parameter contains the trade-off between accuracy and speed. Not referenced if use_fft is False. Mfft : int The number of adjacent points to use in the FFT approximation. Not referenced if use_fft is False. Returns ------- S, C : ndarray summation arrays for frequencies f = df * np.arange(1, N + 1) rzdf must be positivezMfft must be positivey@Nr )Ú ValueErrorr rrrrr ÚminÚexpÚpir ZfftZifftrÚrealÚimagÚdotÚcosrÚsin)ÚtÚhZdfrZf0Z freq_factorZ oversamplingZuse_fftZMfftZNfftÚt0ZtnormÚgridZfftgridÚfÚCÚSrrrÚtrig_sumRs2*    ..r2)Nr )rrr!Tr )ÚmathrÚnumpyrr r r2rrrrÚs  C