ó šßÈ[c@ s‘ddlmZmZddlZddlmZddlZddlm Z m Z d„Z d„Z ddd„Zd d d edd „ZdS( iÿÿÿÿ(tprint_functiontdivisionN(t factoriali(trangetmapcC s¢ttjdƒr(tjj|||ƒStjdƒtj|ƒ}tj||ƒ\}}tj |ƒ}||cg|D]}|||kj ƒ^q|7St|ƒd}x.ddddddgD]}|||?O}qPW|dSdS( s· 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))) t bit_lengthiiiiii N(RtintR(tNR((sNlib/python2.7/site-packages/astropy/stats/lombscargle/implementations/utils.pytbitceils c C s’ttjtj||ƒƒ\}}|dkrTttj|ƒd|dƒ}ntj|d|jƒ}|ddk}t |||j tƒ||ƒ||||}}tj ||dj tƒd||ƒ}|tj ||tj |ƒdd…tjfdƒ}t|dƒ}xct|ƒD]U} | dkr\|| | |9}n||d| } t || |||| ƒq5W|S(sò 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) Example ------- >>> rng = np.random.RandomState(0) >>> x = 100 * rng.rand(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). gà?itdtypeiiN(RRtravelR tNoneRtmaxtzerosRRtastypetcliptprodtarangetnewaxisRR( txtyRtMtresulttintegerstilot numeratort denominatortjR((sNlib/python2.7/site-packages/astropy/stats/lombscargle/implementations/utils.pyt extirpolate*s %$ $!*:  iiic C s||9}||9}|dkr/tdƒ‚nttjtj||ƒƒ\}}|rwt|ƒ}|dkr€tdƒ‚nt||ƒ} |jƒ} |dkrÑ|tjdtj ||| ƒ}n|| | || } t | || |ƒ} tj j | ƒ| } | dkrZ||tj |ƒ}| tjdtj | |ƒ9} n| | j}| | j}n‘||tj |ƒ}tj|tjdtj ||dd…tjfƒƒ}tj|tjdtj ||dd…tjfƒƒ}||fS(sè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, default=0) The low frequency to use freq_factor : float (optional, default=1) 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 tradeoff 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 : ndarrays summation arrays for frequencies f = df * np.arange(1, N + 1) isdf must be positivesMfft must be positivey@iN(t ValueErrorRRRR RRtmintexptpiR-tffttifftR"trealtimagtdottcosR#tsin(ttthtdfRtf0t freq_factort oversamplingtuse_ffttMffttNffttt0ttnormtgridtfftgridtftCtS((sNlib/python2.7/site-packages/astropy/stats/lombscargle/implementations/utils.pyttrig_sumls2)   $    ) % ==(t __future__RRR tmathRtnumpyRtextern.six.movesRRRRRR-tTrueRI(((sNlib/python2.7/site-packages/astropy/stats/lombscargle/implementations/utils.pyts    B