Module Expr Str ImportFrom alias alias Assign NameStore ListLoad Str Import alias Import alias identifier ImportFrom alias Assign NameStore ListLoad Num Num Num Num Num Num Num Num Num Num Num FunctionDef arguments args NameParam defaults body Expr Str If CompareLt NameLoad Call NameLoad NameLoad body Return SubscriptLoad NameLoad Index NameLoad orelse ImportFrom alias Return Call NameLoad Call AttributeLoad NameLoad attr NameLoad decorator_list FunctionDef arguments args NameParam defaults body Expr Str Assign NameStore BinOpSub Call NameLoad NameLoad Num For NameStore ListLoad Num Num Num Num Num Num body AugAssignBitOr NameStore BinOpRShift NameLoad NameLoad Return BinOpAdd NameLoad Num decorator_list FunctionDef arguments args NameParam NameParam NameParam NameParam defaults NameLoad Num body Expr Str Assign TupleStore NameStore NameStore Call NameLoad AttributeLoad NameLoad attr Call AttributeLoad NameLoad attr NameLoad NameLoad If CompareIs NameLoad NameLoad body Assign NameStore Call NameLoad BinOpAdd BinOpAdd Call AttributeLoad NameLoad attr NameLoad BinOpMult Num NameLoad Num Assign NameStore Call AttributeLoad NameLoad attr NameLoad keyword AttributeLoad NameLoad attr Assign NameStore CompareEq BinOpMod NameLoad Num Num Expr Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad Call AttributeLoad SubscriptLoad NameLoad Index NameLoad attr NameLoad SubscriptLoad NameLoad Index NameLoad Assign TupleStore NameStore NameStore TupleLoad SubscriptLoad NameLoad Index UnaryOpInvert NameLoad SubscriptLoad NameLoad Index UnaryOpInvert NameLoad Assign NameStore Call AttributeLoad NameLoad attr Call AttributeLoad BinOpSub NameLoad BinOpFloorDiv NameLoad Num attr NameLoad Num BinOpSub NameLoad NameLoad Assign NameStore BinOpMult NameLoad Call AttributeLoad NameLoad attr BinOpSub BinOpSub NameLoad NameLoad SubscriptLoad Call AttributeLoad NameLoad attr NameLoad ExtSlice Slice Index AttributeLoad NameLoad attr Num Assign NameStore Call NameLoad BinOpSub NameLoad Num For NameStore Call NameLoad NameLoad body If CompareGt NameLoad Num body AugAssignMult NameStore BinOpDiv NameLoad BinOpSub NameLoad NameLoad Assign NameStore BinOpAdd NameLoad BinOpSub BinOpSub NameLoad Num NameLoad Expr Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad NameLoad BinOpDiv NameLoad BinOpMult NameLoad BinOpSub NameLoad NameLoad Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam NameParam NameParam NameParam NameParam NameParam NameParam defaults Num Num Num NameLoad Num body Expr Str AugAssignMult NameStore NameLoad AugAssignMult NameStore NameLoad Assert CompareGt NameLoad Num Assign TupleStore NameStore NameStore Call NameLoad AttributeLoad NameLoad attr Call AttributeLoad NameLoad attr NameLoad NameLoad If NameLoad body Assign NameStore Call NameLoad NameLoad Assert CompareGt NameLoad Num Assign NameStore Call NameLoad BinOpMult NameLoad NameLoad Assign NameStore Call AttributeLoad NameLoad attr If CompareGt NameLoad Num body Assign NameStore BinOpMult NameLoad Call AttributeLoad NameLoad attr BinOpMult BinOpMult BinOpMult Num AttributeLoad NameLoad attr NameLoad BinOpSub NameLoad NameLoad Assign NameStore BinOpMod BinOpMult BinOpMult BinOpSub NameLoad NameLoad NameLoad NameLoad NameLoad Assign NameStore Call NameLoad NameLoad NameLoad NameLoad NameLoad Assign NameStore Call AttributeLoad AttributeLoad NameLoad attr attr NameLoad If CompareNotEq NameLoad Num body Assign NameStore BinOpAdd NameLoad BinOpMult NameLoad Call AttributeLoad NameLoad attr NameLoad AugAssignMult NameStore Call AttributeLoad NameLoad attr BinOpMult BinOpMult BinOpMult Num AttributeLoad NameLoad attr NameLoad NameLoad Assign NameStore SubscriptLoad NameLoad Slice NameLoad Assign NameStore BinOpMult NameLoad AttributeLoad NameLoad attr Assign NameStore BinOpMult NameLoad AttributeLoad NameLoad attr orelse Assign NameStore BinOpAdd NameLoad BinOpMult NameLoad Call AttributeLoad NameLoad attr NameLoad Assign NameStore Call AttributeLoad NameLoad attr NameLoad Call AttributeLoad NameLoad attr BinOpMult BinOpMult BinOpMult Num AttributeLoad NameLoad attr NameLoad SubscriptLoad NameLoad ExtSlice Slice Index AttributeLoad NameLoad attr Assign NameStore Call AttributeLoad NameLoad attr NameLoad Call AttributeLoad NameLoad attr BinOpMult BinOpMult BinOpMult Num AttributeLoad NameLoad attr NameLoad SubscriptLoad NameLoad ExtSlice Slice Index AttributeLoad NameLoad attr Return TupleLoad NameLoad NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam NameParam NameParam NameParam NameParam NameParam NameParam NameParam NameParam NameParam defaults Num Num NameLoad NameLoad NameLoad NameLoad NameLoad Num Num NameLoad body Expr Str Assign TupleStore NameStore NameStore NameStore Call NameLoad AttributeLoad NameLoad attr Call AttributeLoad NameLoad attr NameLoad NameLoad NameLoad Assign NameStore BinOpDiv Num BinOpPow NameLoad Num AugAssignDiv NameStore Call AttributeLoad NameLoad attr If CompareIs NameLoad NameLoad body Assign NameStore BinOpDiv Num BinOpSub Call AttributeLoad NameLoad attr Call AttributeLoad NameLoad attr Assign NameStore BinOpDiv NameLoad NameLoad If CompareIs NameLoad NameLoad body Assign NameStore BinOpDiv BinOpMult Num Call NameLoad NameLoad BinOpSub Call AttributeLoad NameLoad attr Call AttributeLoad NameLoad attr Assign NameStore Call NameLoad Num BinOpDiv BinOpSub BinOpMult NameLoad NameLoad NameLoad NameLoad Assign NameStore Call NameLoad NameLoad Assert CompareGt NameLoad Num Assert CompareGt NameLoad Num Assign NameStore BinOpAdd NameLoad BinOpMult NameLoad Call AttributeLoad NameLoad attr NameLoad If BoolOpOr NameLoad NameLoad body Assign NameStore BinOpSub NameLoad Call AttributeLoad NameLoad attr NameLoad NameLoad Assign NameStore Call AttributeLoad NameLoad attr BoolOpOr NameLoad Dict Expr Call AttributeLoad NameLoad attr keyword NameLoad keyword NameLoad keyword NameLoad keyword NameLoad Assign TupleStore NameStore NameStore Call NameLoad NameLoad BinOpMult NameLoad NameLoad NameLoad Assign TupleStore NameStore NameStore Call NameLoad NameLoad NameLoad keyword Num NameLoad If NameLoad body Assign TupleStore NameStore NameStore Call NameLoad NameLoad NameLoad NameLoad With Call AttributeLoad NameLoad attr body If CompareEq NameLoad Num body Expr Call AttributeLoad NameLoad attr Str Assign NameStore BinOpDiv BinOpSub NameLoad BinOpMult BinOpMult Num NameLoad NameLoad BinOpSub NameLoad BinOpSub BinOpMult NameLoad NameLoad BinOpMult NameLoad NameLoad If Call AttributeLoad NameLoad attr SubscriptLoad NameLoad Index Num body Assign SubscriptStore NameLoad Index Num Num orelse Assign NameStore BinOpDiv NameLoad NameLoad Assign NameStore BinOpDiv NameLoad Call AttributeLoad NameLoad attr BinOpAdd Num BinOpMult NameLoad NameLoad Assign NameStore BinOpDiv Num Call AttributeLoad NameLoad attr BinOpAdd Num BinOpMult NameLoad NameLoad Assign NameStore BinOpMult Call AttributeLoad NameLoad attr Num Call AttributeLoad NameLoad attr BinOpAdd Num NameLoad Assign NameStore BinOpMult BinOpMult Call AttributeLoad NameLoad attr Num Call AttributeLoad NameLoad attr NameLoad Call AttributeLoad NameLoad attr BinOpSub Num NameLoad Assign NameStore Call AttributeLoad NameLoad attr NameLoad BinOpPow NameLoad Num Assign NameStore BinOpAdd BinOpMult NameLoad NameLoad BinOpMult NameLoad NameLoad Assign NameStore BinOpSub BinOpMult NameLoad NameLoad BinOpMult NameLoad NameLoad Assign NameStore BinOpMult Num BinOpAdd BinOpAdd Num BinOpMult NameLoad NameLoad BinOpMult NameLoad NameLoad Assign NameStore BinOpMult Num BinOpSub BinOpSub Num BinOpMult NameLoad NameLoad BinOpMult NameLoad NameLoad If NameLoad body AugAssignSub NameStore BinOpPow BinOpAdd BinOpMult NameLoad NameLoad BinOpMult NameLoad NameLoad Num AugAssignSub NameStore BinOpPow BinOpSub BinOpMult NameLoad NameLoad BinOpMult NameLoad NameLoad Num With Call AttributeLoad NameLoad attr body If BoolOpAnd NameLoad CompareEq NameLoad Num body Expr Call AttributeLoad NameLoad attr Str Assign NameStore BinOpDiv BinOpAdd BinOpDiv BinOpMult NameLoad NameLoad NameLoad BinOpDiv BinOpMult NameLoad NameLoad NameLoad NameLoad If BoolOpOr Call AttributeLoad NameLoad attr SubscriptLoad NameLoad Index Num Call AttributeLoad NameLoad attr SubscriptLoad NameLoad Index Num body Assign SubscriptStore NameLoad Index Num Num Return TupleLoad NameLoad NameLoad decorator_list ClassDef bases NameLoad body Expr Str FunctionDef arguments args NameParam NameParam NameParam NameParam NameParam NameParam NameParam NameParam NameParam NameParam defaults NameLoad NameLoad NameLoad NameLoad NameLoad Num NameLoad NameLoad NameLoad body Assign AttributeStore NameLoad attr NameLoad Assign AttributeStore NameLoad attr NameLoad Assign AttributeStore NameLoad attr NameLoad If CompareNotEq NameLoad Num body Raise Call NameLoad Str Expr Call AttributeLoad NameLoad attr NameLoad keyword NameLoad keyword NameLoad keyword NameLoad keyword Num keyword NameLoad keyword NameLoad keyword NameLoad decorator_list FunctionDef arguments args NameParam NameParam NameParam NameParam defaults body If BoolOpAnd UnaryOpNot AttributeLoad NameLoad attr CompareLt AttributeLoad AttributeLoad NameLoad attr attr Num body Expr Call AttributeLoad NameLoad attr Str Assign TupleStore NameStore NameStore Call NameLoad AttributeLoad NameLoad attr AttributeLoad NameLoad attr AttributeLoad NameLoad attr keyword NameLoad keyword NameLoad keyword NameLoad keyword AttributeLoad NameLoad attr keyword AttributeLoad NameLoad attr keyword AttributeLoad NameLoad attr BoolOpOr AttributeLoad NameLoad attr Dict Return NameLoad decorator_list FunctionDef arguments args NameParam NameParam defaults body If UnaryOpNot AttributeLoad NameLoad attr body Expr Call AttributeLoad NameLoad attr Str Return Call AttributeLoad NameLoad attr NameLoad NameLoad decorator_list decorator_list
N/A N/A 
Fast Lomb-Scargle Algorithm, following Press & Rybicki 1989
 __future__ print_function division N/A __all__ N/A LombScargleFast N/A warnings N/A numpy np lomb_scargle LombScargle N/A FACTORIALS N/A 1 1 2 6 24 120 720 5040 40320 362880 3628800 factorial N/A N/A N N/A N/A N/A Compute the factorial of N.
    If N <= 10, use a fast lookup table; otherwise use scipy.special.factorial
     N/A N/A N N/A len FACTORIALS N/A N/A N/A FACTORIALS N/A N N/A scipy special N/A N/A int N/A N/A special factorial N N/A bitceil N/A N/A N N/A N/A N/A 
    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)))
     N/A N N/A N/A int N 1 N/A i N/A 1 2 4 8 16 32 N/A N/A N N/A N i N/A N/A N 1 N/A extirpolate N/A N/A x y N M N/A None 4 N/A N/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)

    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).
     N/A N/A x y N/A map N/A np ravel N/A N/A np broadcast_arrays x y N/A N/A N None N/A N/A N N/A int N/A N/A N/A N/A np max x N/A 0.5 M 1 N/A result N/A N/A np zeros N dtype N/A y dtype N/A integers N/A N/A x 1 0 N/A N/A N/A N/A np add at result N/A N/A N/A x N/A integers astype int N/A y N/A integers N/A N/A x y N/A N/A x N/A N/A integers N/A y N/A N/A integers N/A ilo N/A N/A np clip N/A N/A N/A x N/A M 2 astype int 0 N/A N M N/A numerator N/A y N/A N/A np prod N/A N/A x ilo N/A N/A N/A np arange M N/A N/A N/A N/A np newaxis 0 N/A denominator N/A factorial N/A M 1 N/A j N/A range M N/A N/A N/A j 0 N/A N/A denominator N/A j N/A j M N/A ind N/A ilo N/A N/A M 1 j N/A N/A N/A N/A np add at result ind N/A numerator N/A denominator N/A x ind N/A result N/A trig_sum N/A N/A t h df N f0 freq_factor oversampling use_fft Mfft N/A 0 1 5 True 4 N/A N/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, 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; roughtly 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)
     N/A df freq_factor N/A f0 freq_factor N/A N/A df 0 N/A N/A t h N/A map N/A np ravel N/A N/A np broadcast_arrays t h N/A use_fft N/A N/A Mfft N/A int Mfft N/A N/A Mfft 0 N/A Nfft N/A bitceil N/A N oversampling N/A t0 N/A N/A t min N/A N/A f0 0 N/A N/A h N/A h N/A N/A np exp N/A N/A N/A 2j N/A np pi f0 N/A t t0 N/A tnorm N/A N/A N/A N/A t t0 Nfft df Nfft N/A grid N/A extirpolate tnorm h Nfft Mfft N/A fftgrid N/A N/A N/A np fft ifft grid N/A N/A t0 0 N/A N/A f N/A f0 N/A df N/A N/A np arange Nfft N/A fftgrid N/A N/A np exp N/A N/A N/A 2j N/A np pi t0 f N/A fftgrid N/A fftgrid N/A N N/A C N/A Nfft N/A fftgrid real N/A S N/A Nfft N/A fftgrid imag N/A N/A f N/A f0 N/A df N/A N/A np arange N N/A C N/A N/A np dot h N/A N/A np cos N/A N/A N/A 2 N/A np pi f N/A t N/A N/A N/A N/A np newaxis N/A S N/A N/A np dot h N/A N/A np sin N/A N/A N/A 2 N/A np pi f N/A t N/A N/A N/A N/A np newaxis N/A N/A S C N/A lomb_scargle_fast N/A N/A t y dy f0 df Nf center_data fit_offset use_fft freq_oversampling nyquist_factor trig_sum_kwds N/A 1 0 None None True True True 5 2 None N/A N/A Compute a lomb-scargle periodogram for the given data

    This implements both an O[N^2] method if use_fft==False, or an
    O[NlogN] method if use_fft==True.

    Parameters
    ----------
    t, y, dy : array_like
        times, values, and errors of the data points. These should be
        broadcastable to the same shape. If dy is not specified, a
        constant error will be used.
    f0, df, Nf : (float, float, int)
        parameters describing the frequency grid, f = f0 + df * arange(Nf).
        Defaults, with T = t.max() - t.min():
        - f0 = 0
        - df is set such that there are ``freq_oversampling`` points per
          peak width. ``freq_oversampling`` defaults to 5.
        - Nf is set such that the highest frequency is ``nyquist_factor``
          times the so-called "average Nyquist frequency".
          ``nyquist_factor`` defaults to 2.
        Note that for unevenly-spaced data, the periodogram can be sensitive
        to frequencies far higher than the average Nyquist frequency.
    center_data : bool (default=True)
        Specify whether to subtract the mean of the data before the fit
    fit_offset : bool (default=True)
        If True, then compute the floating-mean periodogram; i.e. let the mean
        vary with the fit.
    use_fft : bool (default=True)
        If True, then use the Press & Rybicki O[NlogN] algorithm to compute
        the result. Otherwise, use a slower O[N^2] algorithm

    Other Parameters
    ----------------
    freq_oversampling : float (default=5)
        Oversampling factor for the frequency bins. Only referenced if
        ``df`` is not specified
    nyquist_factor : float (default=2)
        Parameter controlling the highest probed frequency. Only referenced
        if ``Nf`` is not specified.
    trig_sum_kwds : dict or None (optional)
        extra keyword arguments to pass to the ``trig_sum`` utility.
        Options are ``oversampling`` and ``Mfft``. See documentation
        of ``trig_sum`` for details.

    Notes
    -----
    Note that the ``use_fft=True`` algorithm is an approximation to the true
    Lomb-Scargle periodogram, and as the number of points grows this
    approximation improves. On the other hand, for very small datasets
    (<~50 points or so) this approximation may not be useful.

    References
    ----------
    .. [1] Press W.H. and Rybicki, G.B, "Fast algorithm for spectral analysis
        of unevenly sampled data". ApJ 1:338, p277, 1989
    .. [2] M. Zechmeister and M. Kurster, A&A 496, 577-584 (2009)
    .. [3] W. Press et al, Numerical Recipies in C (2002)
     N/A N/A t y dy N/A map N/A np ravel N/A N/A np broadcast_arrays t y dy N/A w N/A 1.0 N/A dy 2 N/A w N/A N/A w sum N/A N/A df None N/A N/A peak_width N/A 1.0 N/A N/A N/A t max N/A N/A t min N/A df N/A peak_width freq_oversampling N/A N/A Nf None N/A N/A avg_Nyquist N/A N/A 0.5 N/A len t N/A N/A N/A t max N/A N/A t min N/A Nf N/A max 16 N/A N/A N/A nyquist_factor avg_Nyquist f0 df N/A Nf N/A int Nf N/A N/A df 0 N/A N/A Nf 0 N/A freq N/A f0 N/A df N/A N/A np arange Nf N/A N/A center_data fit_offset N/A N/A y N/A y N/A N/A np dot w y N/A kwargs N/A N/A dict copy N/A trig_sum_kwds N/A N/A N/A N/A kwargs update f0 f0 df df use_fft use_fft N Nf N/A N/A Sh Ch N/A trig_sum t N/A w y kwargs N/A N/A S2 C2 N/A trig_sum t w freq_factor 2 kwargs N/A fit_offset N/A N/A N/A S C N/A trig_sum t w kwargs N/A N/A N/A warnings catch_warnings N/A N/A N/A f0 0 N/A N/A N/A N/A warnings simplefilter ignore N/A tan_2omega_tau N/A N/A S2 N/A N/A 2 S C N/A C2 N/A N/A C C N/A S S N/A N/A N/A np isnan N/A tan_2omega_tau N/A 0 N/A N/A N/A tan_2omega_tau N/A 0 0 N/A N/A tan_2omega_tau N/A S2 C2 N/A S2w N/A tan_2omega_tau N/A N/A np sqrt N/A 1 N/A tan_2omega_tau tan_2omega_tau N/A C2w N/A 1 N/A N/A np sqrt N/A 1 N/A tan_2omega_tau tan_2omega_tau N/A Cw N/A N/A N/A np sqrt 0.5 N/A N/A np sqrt N/A 1 C2w N/A Sw N/A N/A N/A N/A np sqrt 0.5 N/A N/A np sign S2w N/A N/A np sqrt N/A 1 C2w N/A YY N/A N/A np dot w N/A y 2 N/A YC N/A N/A Ch Cw N/A Sh Sw N/A YS N/A N/A Sh Cw N/A Ch Sw N/A CC N/A 0.5 N/A N/A 1 N/A C2 C2w N/A S2 S2w N/A SS N/A 0.5 N/A N/A 1 N/A C2 C2w N/A S2 S2w N/A fit_offset N/A N/A CC N/A N/A N/A C Cw N/A S Sw 2 N/A SS N/A N/A N/A S Cw N/A C Sw 2 N/A N/A N/A warnings catch_warnings N/A N/A N/A fit_offset N/A f0 0 N/A N/A N/A N/A warnings simplefilter ignore N/A power N/A N/A N/A N/A YC YC CC N/A N/A YS YS SS YY N/A N/A N/A N/A np isnan N/A power N/A 0 N/A N/A np isinf N/A power N/A 0 N/A N/A N/A power N/A 0 0 N/A N/A freq power N/A LombScargleFast N/A LombScargle N/A N/A Fast FFT-based Lomb-Scargle Periodogram Implementation

    This implements the O[N log N] lomb-scargle periodogram, described in
    Press & Rybicki (1989) [1].
    To compute the periodogram via the fast algorithm, use the
    ``score_frequency_grid()`` method. The ``score()`` method and
    ``periodogram()`` method will default to the slower algorithm.
    See Notes below for more information about the algorithm.

    Parameters
    ----------
    optimizer : PeriodicOptimizer instance
        Optimizer to use to find the best period. If not specified, the
        LinearScanOptimizer will be used.
    center_data : boolean (default = True)
        If True, then compute the weighted mean of the input data and subtract
        before fitting the model.
    fit_offset : boolean (default = True)
        If True, then fit a floating-mean sinusoid model.
    use_fft : boolean (default = True)
        Specify whether to use the Press & Rybicki FFT algorithm to compute
        the result
    ls_kwds : dict
        Dictionary of keywords to pass to the ``lomb_scargle_fast`` routine.
    fit_period : bool (optional)
        If True, then fit for the best period when fit() method is called.
    optimizer_kwds : dict (optional)
        Dictionary of keyword arguments for constructing the optimizer. For
        example, silence optimizer output with `optimizer_kwds={"quiet": True}`.
    silence_warnings : bool (default=False)
        If False, then warn the user when doing silly things, like calling
        ``score()`` rather than ``score_frequency_grid()`` or fitting this to
        small datasets (fewer than 50 points).

    Examples
    --------
    >>> rng = np.random.RandomState(0)
    >>> t = 100 * rng.rand(100)
    >>> dy = 0.1
    >>> omega = 10
    >>> y = np.sin(omega * t) + dy * rng.randn(100)
    >>> ls = LombScargleFast().fit(t, y, dy)
    >>> ls.optimizer.period_range = (0.2, 1.2)
    >>> ls.best_period
    Finding optimal frequency:
     - Estimated peak width = 0.0639
     - Using 5 steps per peak; omega_step = 0.0128
     - User-specified period range:  0.2 to 1.2
     - Computing periods at 2051 steps
    Zooming-in on 5 candidate peaks:
     - Computing periods at 1000 steps
    0.62826265739259146
    >>> ls.predict([0, 0.5])
    array([-0.02019474, -0.92910567])

    Notes
    -----
    Currently, a NotImplementedError will be raised if both center_data
    and fit_offset are False.

    Note also that the fast algorithm is only an approximation to the true
    Lomb-Scargle periodogram, and as the number of points grows this
    approximation improves. On the other hand, for very small datasets
    (<~50 points or so) this approximation may produce incorrect results
    for some datasets.

    See Also
    --------
    LombScargle
    LombScargleAstroML

    References
    ----------
    .. [1] Press W.H. and Rybicki, G.B, "Fast algorithm for spectral analysis
           of unevenly sampled data". ApJ 1:338, p277, 1989
     __init__ N/A N/A self optimizer center_data fit_offset use_fft ls_kwds Nterms fit_period optimizer_kwds silence_warnings N/A None True True True None 1 False None False N/A N/A N/A self use_fft use_fft N/A N/A self ls_kwds ls_kwds N/A N/A self silence_warnings silence_warnings N/A N/A Nterms 1 N/A N/A N/A ValueError LombScargleFast supports only Nterms = 1 N/A N/A N/A LombScargle __init__ self optimizer optimizer center_data center_data fit_offset fit_offset Nterms 1 regularization None fit_period fit_period optimizer_kwds optimizer_kwds N/A _score_frequency_grid N/A N/A self f0 df N N/A N/A N/A N/A N/A N/A self silence_warnings N/A N/A N/A self t size 50 N/A N/A N/A N/A warnings warn For smaller datasets, the approximation used by LombScargleFast may not be suitable.
It is recommended to use LombScargle instead.
To silence this warning, set ``silence_warnings=True`` N/A N/A freq P N/A lomb_scargle_fast N/A self t N/A self y N/A self dy f0 f0 df df Nf N center_data N/A self center_data fit_offset N/A self fit_offset use_fft N/A self use_fft N/A N/A self ls_kwds N/A N/A P N/A _score N/A N/A self periods N/A N/A N/A N/A N/A self silence_warnings N/A N/A N/A N/A warnings warn The score() method defaults to a slower O[N^2] algorithm.
Use the score_frequency_grid() method to access the fast FFT-based algorithm.
To silence this warning, set ``silence_warnings=True`` N/A N/A N/A LombScargle _score self periods N/A N/A