Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/scipy/signal/__init__.py

@@ -0,0 +1,346 @@
+"""
+=======================================
+Signal processing (:mod:`scipy.signal`)
+=======================================
+
+Convolution
+===========
+
+.. autosummary::
+   :toctree: generated/
+
+   convolve           -- N-D convolution.
+   correlate          -- N-D correlation.
+   fftconvolve        -- N-D convolution using the FFT.
+   oaconvolve         -- N-D convolution using the overlap-add method.
+   convolve2d         -- 2-D convolution (more options).
+   correlate2d        -- 2-D correlation (more options).
+   sepfir2d           -- Convolve with a 2-D separable FIR filter.
+   choose_conv_method -- Chooses faster of FFT and direct convolution methods.
+   correlation_lags   -- Determines lag indices for 1D cross-correlation.
+
+B-splines
+=========
+
+.. autosummary::
+   :toctree: generated/
+
+   gauss_spline   -- Gaussian approximation to the B-spline basis function.
+   cspline1d      -- Coefficients for 1-D cubic (3rd order) B-spline.
+   qspline1d      -- Coefficients for 1-D quadratic (2nd order) B-spline.
+   cspline2d      -- Coefficients for 2-D cubic (3rd order) B-spline.
+   qspline2d      -- Coefficients for 2-D quadratic (2nd order) B-spline.
+   cspline1d_eval -- Evaluate a cubic spline at the given points.
+   qspline1d_eval -- Evaluate a quadratic spline at the given points.
+   spline_filter  -- Smoothing spline (cubic) filtering of a rank-2 array.
+
+Filtering
+=========
+
+.. autosummary::
+   :toctree: generated/
+
+   order_filter  -- N-D order filter.
+   medfilt       -- N-D median filter.
+   medfilt2d     -- 2-D median filter (faster).
+   wiener        -- N-D Wiener filter.
+
+   symiirorder1  -- 2nd-order IIR filter (cascade of first-order systems).
+   symiirorder2  -- 4th-order IIR filter (cascade of second-order systems).
+   lfilter       -- 1-D FIR and IIR digital linear filtering.
+   lfiltic       -- Construct initial conditions for `lfilter`.
+   lfilter_zi    -- Compute an initial state zi for the lfilter function that
+                 -- corresponds to the steady state of the step response.
+   filtfilt      -- A forward-backward filter.
+   savgol_filter -- Filter a signal using the Savitzky-Golay filter.
+
+   deconvolve    -- 1-D deconvolution using lfilter.
+
+   sosfilt       -- 1-D IIR digital linear filtering using
+                 -- a second-order sections filter representation.
+   sosfilt_zi    -- Compute an initial state zi for the sosfilt function that
+                 -- corresponds to the steady state of the step response.
+   sosfiltfilt   -- A forward-backward filter for second-order sections.
+   hilbert       -- Compute 1-D analytic signal, using the Hilbert transform.
+   hilbert2      -- Compute 2-D analytic signal, using the Hilbert transform.
+
+   decimate      -- Downsample a signal.
+   detrend       -- Remove linear and/or constant trends from data.
+   resample      -- Resample using Fourier method.
+   resample_poly -- Resample using polyphase filtering method.
+   upfirdn       -- Upsample, apply FIR filter, downsample.
+
+Filter design
+=============
+
+.. autosummary::
+   :toctree: generated/
+
+   bilinear      -- Digital filter from an analog filter using
+                    -- the bilinear transform.
+   bilinear_zpk  -- Digital filter from an analog filter using
+                    -- the bilinear transform.
+   findfreqs     -- Find array of frequencies for computing filter response.
+   firls         -- FIR filter design using least-squares error minimization.
+   firwin        -- Windowed FIR filter design, with frequency response
+                    -- defined as pass and stop bands.
+   firwin2       -- Windowed FIR filter design, with arbitrary frequency
+                    -- response.
+   freqs         -- Analog filter frequency response from TF coefficients.
+   freqs_zpk     -- Analog filter frequency response from ZPK coefficients.
+   freqz         -- Digital filter frequency response from TF coefficients.
+   freqz_zpk     -- Digital filter frequency response from ZPK coefficients.
+   sosfreqz      -- Digital filter frequency response for SOS format filter.
+   gammatone     -- FIR and IIR gammatone filter design.
+   group_delay   -- Digital filter group delay.
+   iirdesign     -- IIR filter design given bands and gains.
+   iirfilter     -- IIR filter design given order and critical frequencies.
+   kaiser_atten  -- Compute the attenuation of a Kaiser FIR filter, given
+                    -- the number of taps and the transition width at
+                    -- discontinuities in the frequency response.
+   kaiser_beta   -- Compute the Kaiser parameter beta, given the desired
+                    -- FIR filter attenuation.
+   kaiserord     -- Design a Kaiser window to limit ripple and width of
+                    -- transition region.
+   minimum_phase -- Convert a linear phase FIR filter to minimum phase.
+   savgol_coeffs -- Compute the FIR filter coefficients for a Savitzky-Golay
+                    -- filter.
+   remez         -- Optimal FIR filter design.
+
+   unique_roots  -- Unique roots and their multiplicities.
+   residue       -- Partial fraction expansion of b(s) / a(s).
+   residuez      -- Partial fraction expansion of b(z) / a(z).
+   invres        -- Inverse partial fraction expansion for analog filter.
+   invresz       -- Inverse partial fraction expansion for digital filter.
+   BadCoefficients  -- Warning on badly conditioned filter coefficients.
+
+Lower-level filter design functions:
+
+.. autosummary::
+   :toctree: generated/
+
+   abcd_normalize -- Check state-space matrices and ensure they are rank-2.
+   band_stop_obj  -- Band Stop Objective Function for order minimization.
+   besselap       -- Return (z,p,k) for analog prototype of Bessel filter.
+   buttap         -- Return (z,p,k) for analog prototype of Butterworth filter.
+   cheb1ap        -- Return (z,p,k) for type I Chebyshev filter.
+   cheb2ap        -- Return (z,p,k) for type II Chebyshev filter.
+   cmplx_sort     -- Sort roots based on magnitude.
+   ellipap        -- Return (z,p,k) for analog prototype of elliptic filter.
+   lp2bp          -- Transform a lowpass filter prototype to a bandpass filter.
+   lp2bp_zpk      -- Transform a lowpass filter prototype to a bandpass filter.
+   lp2bs          -- Transform a lowpass filter prototype to a bandstop filter.
+   lp2bs_zpk      -- Transform a lowpass filter prototype to a bandstop filter.
+   lp2hp          -- Transform a lowpass filter prototype to a highpass filter.
+   lp2hp_zpk      -- Transform a lowpass filter prototype to a highpass filter.
+   lp2lp          -- Transform a lowpass filter prototype to a lowpass filter.
+   lp2lp_zpk      -- Transform a lowpass filter prototype to a lowpass filter.
+   normalize      -- Normalize polynomial representation of a transfer function.
+
+
+
+Matlab-style IIR filter design
+==============================
+
+.. autosummary::
+   :toctree: generated/
+
+   butter -- Butterworth
+   buttord
+   cheby1 -- Chebyshev Type I
+   cheb1ord
+   cheby2 -- Chebyshev Type II
+   cheb2ord
+   ellip -- Elliptic (Cauer)
+   ellipord
+   bessel -- Bessel (no order selection available -- try butterod)
+   iirnotch      -- Design second-order IIR notch digital filter.
+   iirpeak       -- Design second-order IIR peak (resonant) digital filter.
+   iircomb       -- Design IIR comb filter.
+
+Continuous-time linear systems
+==============================
+
+.. autosummary::
+   :toctree: generated/
+
+   lti              -- Continuous-time linear time invariant system base class.
+   StateSpace       -- Linear time invariant system in state space form.
+   TransferFunction -- Linear time invariant system in transfer function form.
+   ZerosPolesGain   -- Linear time invariant system in zeros, poles, gain form.
+   lsim             -- Continuous-time simulation of output to linear system.
+   impulse          -- Impulse response of linear, time-invariant (LTI) system.
+   step             -- Step response of continuous-time LTI system.
+   freqresp         -- Frequency response of a continuous-time LTI system.
+   bode             -- Bode magnitude and phase data (continuous-time LTI).
+
+Discrete-time linear systems
+============================
+
+.. autosummary::
+   :toctree: generated/
+
+   dlti             -- Discrete-time linear time invariant system base class.
+   StateSpace       -- Linear time invariant system in state space form.
+   TransferFunction -- Linear time invariant system in transfer function form.
+   ZerosPolesGain   -- Linear time invariant system in zeros, poles, gain form.
+   dlsim            -- Simulation of output to a discrete-time linear system.
+   dimpulse         -- Impulse response of a discrete-time LTI system.
+   dstep            -- Step response of a discrete-time LTI system.
+   dfreqresp        -- Frequency response of a discrete-time LTI system.
+   dbode            -- Bode magnitude and phase data (discrete-time LTI).
+
+LTI representations
+===================
+
+.. autosummary::
+   :toctree: generated/
+
+   tf2zpk        -- Transfer function to zero-pole-gain.
+   tf2sos        -- Transfer function to second-order sections.
+   tf2ss         -- Transfer function to state-space.
+   zpk2tf        -- Zero-pole-gain to transfer function.
+   zpk2sos       -- Zero-pole-gain to second-order sections.
+   zpk2ss        -- Zero-pole-gain to state-space.
+   ss2tf         -- State-pace to transfer function.
+   ss2zpk        -- State-space to pole-zero-gain.
+   sos2zpk       -- Second-order sections to zero-pole-gain.
+   sos2tf        -- Second-order sections to transfer function.
+   cont2discrete -- Continuous-time to discrete-time LTI conversion.
+   place_poles   -- Pole placement.
+
+Waveforms
+=========
+
+.. autosummary::
+   :toctree: generated/
+
+   chirp        -- Frequency swept cosine signal, with several freq functions.
+   gausspulse   -- Gaussian modulated sinusoid.
+   max_len_seq  -- Maximum length sequence.
+   sawtooth     -- Periodic sawtooth.
+   square       -- Square wave.
+   sweep_poly   -- Frequency swept cosine signal; freq is arbitrary polynomial.
+   unit_impulse -- Discrete unit impulse.
+
+Window functions
+================
+
+For window functions, see the `scipy.signal.windows` namespace.
+
+In the `scipy.signal` namespace, there is a convenience function to
+obtain these windows by name:
+
+.. autosummary::
+   :toctree: generated/
+
+   get_window -- Return a window of a given length and type.
+
+Wavelets
+========
+
+.. autosummary::
+   :toctree: generated/
+
+   cascade      -- Compute scaling function and wavelet from coefficients.
+   daub         -- Return low-pass.
+   morlet       -- Complex Morlet wavelet.
+   qmf          -- Return quadrature mirror filter from low-pass.
+   ricker       -- Return ricker wavelet.
+   morlet2      -- Return Morlet wavelet, compatible with cwt.
+   cwt          -- Perform continuous wavelet transform.
+
+Peak finding
+============
+
+.. autosummary::
+   :toctree: generated/
+
+   argrelmin        -- Calculate the relative minima of data.
+   argrelmax        -- Calculate the relative maxima of data.
+   argrelextrema    -- Calculate the relative extrema of data.
+   find_peaks       -- Find a subset of peaks inside a signal.
+   find_peaks_cwt   -- Find peaks in a 1-D array with wavelet transformation.
+   peak_prominences -- Calculate the prominence of each peak in a signal.
+   peak_widths      -- Calculate the width of each peak in a signal.
+
+Spectral analysis
+=================
+
+.. autosummary::
+   :toctree: generated/
+
+   periodogram    -- Compute a (modified) periodogram.
+   welch          -- Compute a periodogram using Welch's method.
+   csd            -- Compute the cross spectral density, using Welch's method.
+   coherence      -- Compute the magnitude squared coherence, using Welch's method.
+   spectrogram    -- Compute the spectrogram (legacy).
+   lombscargle    -- Computes the Lomb-Scargle periodogram.
+   vectorstrength -- Computes the vector strength.
+   ShortTimeFFT   -- Interface for calculating the \
+                     :ref:`Short Time Fourier Transform <tutorial_stft>` and \
+                     its inverse.
+   stft           -- Compute the Short Time Fourier Transform (legacy).
+   istft          -- Compute the Inverse Short Time Fourier Transform (legacy).
+   check_COLA     -- Check the COLA constraint for iSTFT reconstruction.
+   check_NOLA     -- Check the NOLA constraint for iSTFT reconstruction.
+
+Chirp Z-transform and Zoom FFT
+============================================
+
+.. autosummary::
+   :toctree: generated/
+
+   czt - Chirp z-transform convenience function
+   zoom_fft - Zoom FFT convenience function
+   CZT - Chirp z-transform function generator
+   ZoomFFT - Zoom FFT function generator
+   czt_points - Output the z-plane points sampled by a chirp z-transform
+
+The functions are simpler to use than the classes, but are less efficient when
+using the same transform on many arrays of the same length, since they
+repeatedly generate the same chirp signal with every call.  In these cases,
+use the classes to create a reusable function instead.
+
+"""
+
+from . import _sigtools, windows
+from ._waveforms import *
+from ._max_len_seq import max_len_seq
+from ._upfirdn import upfirdn
+
+from ._spline import (
+    cspline2d,
+    qspline2d,
+    sepfir2d,
+    symiirorder1,
+    symiirorder2,
+)
+
+from ._bsplines import *
+from ._filter_design import *
+from ._fir_filter_design import *
+from ._ltisys import *
+from ._lti_conversion import *
+from ._signaltools import *
+from ._savitzky_golay import savgol_coeffs, savgol_filter
+from ._spectral_py import *
+from ._short_time_fft import *
+from ._wavelets import *
+from ._peak_finding import *
+from ._czt import *
+from .windows import get_window  # keep this one in signal namespace
+
+# Deprecated namespaces, to be removed in v2.0.0
+from . import (
+    bsplines, filter_design, fir_filter_design, lti_conversion, ltisys,
+    spectral, signaltools, waveforms, wavelets, spline
+)
+
+__all__ = [
+    s for s in dir() if not s.startswith("_")
+]
+
+from scipy._lib._testutils import PytestTester
+test = PytestTester(__name__)
+del PytestTester

env-llmeval/lib/python3.10/site-packages/scipy/signal/_arraytools.py

@@ -0,0 +1,264 @@
+"""
+Functions for acting on a axis of an array.
+"""
+import numpy as np
+
+
+def axis_slice(a, start=None, stop=None, step=None, axis=-1):
+    """Take a slice along axis 'axis' from 'a'.
+
+    Parameters
+    ----------
+    a : numpy.ndarray
+        The array to be sliced.
+    start, stop, step : int or None
+        The slice parameters.
+    axis : int, optional
+        The axis of `a` to be sliced.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.signal._arraytools import axis_slice
+    >>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    >>> axis_slice(a, start=0, stop=1, axis=1)
+    array([[1],
+           [4],
+           [7]])
+    >>> axis_slice(a, start=1, axis=0)
+    array([[4, 5, 6],
+           [7, 8, 9]])
+
+    Notes
+    -----
+    The keyword arguments start, stop and step are used by calling
+    slice(start, stop, step). This implies axis_slice() does not
+    handle its arguments the exactly the same as indexing. To select
+    a single index k, for example, use
+        axis_slice(a, start=k, stop=k+1)
+    In this case, the length of the axis 'axis' in the result will
+    be 1; the trivial dimension is not removed. (Use numpy.squeeze()
+    to remove trivial axes.)
+    """
+    a_slice = [slice(None)] * a.ndim
+    a_slice[axis] = slice(start, stop, step)
+    b = a[tuple(a_slice)]
+    return b
+
+
+def axis_reverse(a, axis=-1):
+    """Reverse the 1-D slices of `a` along axis `axis`.
+
+    Returns axis_slice(a, step=-1, axis=axis).
+    """
+    return axis_slice(a, step=-1, axis=axis)
+
+
+def odd_ext(x, n, axis=-1):
+    """
+    Odd extension at the boundaries of an array
+
+    Generate a new ndarray by making an odd extension of `x` along an axis.
+
+    Parameters
+    ----------
+    x : ndarray
+        The array to be extended.
+    n : int
+        The number of elements by which to extend `x` at each end of the axis.
+    axis : int, optional
+        The axis along which to extend `x`. Default is -1.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.signal._arraytools import odd_ext
+    >>> a = np.array([[1, 2, 3, 4, 5], [0, 1, 4, 9, 16]])
+    >>> odd_ext(a, 2)
+    array([[-1,  0,  1,  2,  3,  4,  5,  6,  7],
+           [-4, -1,  0,  1,  4,  9, 16, 23, 28]])
+
+    Odd extension is a "180 degree rotation" at the endpoints of the original
+    array:
+
+    >>> t = np.linspace(0, 1.5, 100)
+    >>> a = 0.9 * np.sin(2 * np.pi * t**2)
+    >>> b = odd_ext(a, 40)
+    >>> import matplotlib.pyplot as plt
+    >>> plt.plot(np.arange(-40, 140), b, 'b', lw=1, label='odd extension')
+    >>> plt.plot(np.arange(100), a, 'r', lw=2, label='original')
+    >>> plt.legend(loc='best')
+    >>> plt.show()
+    """
+    if n < 1:
+        return x
+    if n > x.shape[axis] - 1:
+        raise ValueError(("The extension length n (%d) is too big. " +
+                         "It must not exceed x.shape[axis]-1, which is %d.")
+                         % (n, x.shape[axis] - 1))
+    left_end = axis_slice(x, start=0, stop=1, axis=axis)
+    left_ext = axis_slice(x, start=n, stop=0, step=-1, axis=axis)
+    right_end = axis_slice(x, start=-1, axis=axis)
+    right_ext = axis_slice(x, start=-2, stop=-(n + 2), step=-1, axis=axis)
+    ext = np.concatenate((2 * left_end - left_ext,
+                          x,
+                          2 * right_end - right_ext),
+                         axis=axis)
+    return ext
+
+
+def even_ext(x, n, axis=-1):
+    """
+    Even extension at the boundaries of an array
+
+    Generate a new ndarray by making an even extension of `x` along an axis.
+
+    Parameters
+    ----------
+    x : ndarray
+        The array to be extended.
+    n : int
+        The number of elements by which to extend `x` at each end of the axis.
+    axis : int, optional
+        The axis along which to extend `x`. Default is -1.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.signal._arraytools import even_ext
+    >>> a = np.array([[1, 2, 3, 4, 5], [0, 1, 4, 9, 16]])
+    >>> even_ext(a, 2)
+    array([[ 3,  2,  1,  2,  3,  4,  5,  4,  3],
+           [ 4,  1,  0,  1,  4,  9, 16,  9,  4]])
+
+    Even extension is a "mirror image" at the boundaries of the original array:
+
+    >>> t = np.linspace(0, 1.5, 100)
+    >>> a = 0.9 * np.sin(2 * np.pi * t**2)
+    >>> b = even_ext(a, 40)
+    >>> import matplotlib.pyplot as plt
+    >>> plt.plot(np.arange(-40, 140), b, 'b', lw=1, label='even extension')
+    >>> plt.plot(np.arange(100), a, 'r', lw=2, label='original')
+    >>> plt.legend(loc='best')
+    >>> plt.show()
+    """
+    if n < 1:
+        return x
+    if n > x.shape[axis] - 1:
+        raise ValueError(("The extension length n (%d) is too big. " +
+                         "It must not exceed x.shape[axis]-1, which is %d.")
+                         % (n, x.shape[axis] - 1))
+    left_ext = axis_slice(x, start=n, stop=0, step=-1, axis=axis)
+    right_ext = axis_slice(x, start=-2, stop=-(n + 2), step=-1, axis=axis)
+    ext = np.concatenate((left_ext,
+                          x,
+                          right_ext),
+                         axis=axis)
+    return ext
+
+
+def const_ext(x, n, axis=-1):
+    """
+    Constant extension at the boundaries of an array
+
+    Generate a new ndarray that is a constant extension of `x` along an axis.
+
+    The extension repeats the values at the first and last element of
+    the axis.
+
+    Parameters
+    ----------
+    x : ndarray
+        The array to be extended.
+    n : int
+        The number of elements by which to extend `x` at each end of the axis.
+    axis : int, optional
+        The axis along which to extend `x`. Default is -1.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.signal._arraytools import const_ext
+    >>> a = np.array([[1, 2, 3, 4, 5], [0, 1, 4, 9, 16]])
+    >>> const_ext(a, 2)
+    array([[ 1,  1,  1,  2,  3,  4,  5,  5,  5],
+           [ 0,  0,  0,  1,  4,  9, 16, 16, 16]])
+
+    Constant extension continues with the same values as the endpoints of the
+    array:
+
+    >>> t = np.linspace(0, 1.5, 100)
+    >>> a = 0.9 * np.sin(2 * np.pi * t**2)
+    >>> b = const_ext(a, 40)
+    >>> import matplotlib.pyplot as plt
+    >>> plt.plot(np.arange(-40, 140), b, 'b', lw=1, label='constant extension')
+    >>> plt.plot(np.arange(100), a, 'r', lw=2, label='original')
+    >>> plt.legend(loc='best')
+    >>> plt.show()
+    """
+    if n < 1:
+        return x
+    left_end = axis_slice(x, start=0, stop=1, axis=axis)
+    ones_shape = [1] * x.ndim
+    ones_shape[axis] = n
+    ones = np.ones(ones_shape, dtype=x.dtype)
+    left_ext = ones * left_end
+    right_end = axis_slice(x, start=-1, axis=axis)
+    right_ext = ones * right_end
+    ext = np.concatenate((left_ext,
+                          x,
+                          right_ext),
+                         axis=axis)
+    return ext
+
+
+def zero_ext(x, n, axis=-1):
+    """
+    Zero padding at the boundaries of an array
+
+    Generate a new ndarray that is a zero-padded extension of `x` along
+    an axis.
+
+    Parameters
+    ----------
+    x : ndarray
+        The array to be extended.
+    n : int
+        The number of elements by which to extend `x` at each end of the
+        axis.
+    axis : int, optional
+        The axis along which to extend `x`. Default is -1.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.signal._arraytools import zero_ext
+    >>> a = np.array([[1, 2, 3, 4, 5], [0, 1, 4, 9, 16]])
+    >>> zero_ext(a, 2)
+    array([[ 0,  0,  1,  2,  3,  4,  5,  0,  0],
+           [ 0,  0,  0,  1,  4,  9, 16,  0,  0]])
+    """
+    if n < 1:
+        return x
+    zeros_shape = list(x.shape)
+    zeros_shape[axis] = n
+    zeros = np.zeros(zeros_shape, dtype=x.dtype)
+    ext = np.concatenate((zeros, x, zeros), axis=axis)
+    return ext
+
+
+def _validate_fs(fs, allow_none=True):
+    """
+    Check if the given sampling frequency is a scalar and raises an exception
+    otherwise. If allow_none is False, also raises an exception for none
+    sampling rates. Returns the sampling frequency as float or none if the
+    input is none.
+    """
+    if fs is None:
+        if not allow_none:
+            raise ValueError("Sampling frequency can not be none.")
+    else:  # should be float
+        if not np.isscalar(fs):
+            raise ValueError("Sampling frequency fs must be a single scalar.")
+        fs = float(fs)
+    return fs

env-llmeval/lib/python3.10/site-packages/scipy/signal/_bsplines.py

@@ -0,0 +1,519 @@
+from numpy import (asarray, pi, zeros_like,
+                   array, arctan2, tan, ones, arange, floor,
+                   r_, atleast_1d, sqrt, exp, greater, cos, add, sin)
+
+# From splinemodule.c
+from ._spline import cspline2d, sepfir2d
+from ._signaltools import lfilter, sosfilt, lfiltic
+
+from scipy.interpolate import BSpline
+
+__all__ = ['spline_filter', 'gauss_spline',
+           'cspline1d', 'qspline1d', 'cspline1d_eval', 'qspline1d_eval']
+
+
+def spline_filter(Iin, lmbda=5.0):
+    """Smoothing spline (cubic) filtering of a rank-2 array.
+
+    Filter an input data set, `Iin`, using a (cubic) smoothing spline of
+    fall-off `lmbda`.
+
+    Parameters
+    ----------
+    Iin : array_like
+        input data set
+    lmbda : float, optional
+        spline smooghing fall-off value, default is `5.0`.
+
+    Returns
+    -------
+    res : ndarray
+        filtered input data
+
+    Examples
+    --------
+    We can filter an multi dimensional signal (ex: 2D image) using cubic
+    B-spline filter:
+
+    >>> import numpy as np
+    >>> from scipy.signal import spline_filter
+    >>> import matplotlib.pyplot as plt
+    >>> orig_img = np.eye(20)  # create an image
+    >>> orig_img[10, :] = 1.0
+    >>> sp_filter = spline_filter(orig_img, lmbda=0.1)
+    >>> f, ax = plt.subplots(1, 2, sharex=True)
+    >>> for ind, data in enumerate([[orig_img, "original image"],
+    ...                             [sp_filter, "spline filter"]]):
+    ...     ax[ind].imshow(data[0], cmap='gray_r')
+    ...     ax[ind].set_title(data[1])
+    >>> plt.tight_layout()
+    >>> plt.show()
+
+    """
+    intype = Iin.dtype.char
+    hcol = array([1.0, 4.0, 1.0], 'f') / 6.0
+    if intype in ['F', 'D']:
+        Iin = Iin.astype('F')
+        ckr = cspline2d(Iin.real, lmbda)
+        cki = cspline2d(Iin.imag, lmbda)
+        outr = sepfir2d(ckr, hcol, hcol)
+        outi = sepfir2d(cki, hcol, hcol)
+        out = (outr + 1j * outi).astype(intype)
+    elif intype in ['f', 'd']:
+        ckr = cspline2d(Iin, lmbda)
+        out = sepfir2d(ckr, hcol, hcol)
+        out = out.astype(intype)
+    else:
+        raise TypeError("Invalid data type for Iin")
+    return out
+
+
+_splinefunc_cache = {}
+
+
+def gauss_spline(x, n):
+    r"""Gaussian approximation to B-spline basis function of order n.
+
+    Parameters
+    ----------
+    x : array_like
+        a knot vector
+    n : int
+        The order of the spline. Must be non-negative, i.e., n >= 0
+
+    Returns
+    -------
+    res : ndarray
+        B-spline basis function values approximated by a zero-mean Gaussian
+        function.
+
+    Notes
+    -----
+    The B-spline basis function can be approximated well by a zero-mean
+    Gaussian function with standard-deviation equal to :math:`\sigma=(n+1)/12`
+    for large `n` :
+
+    .. math::  \frac{1}{\sqrt {2\pi\sigma^2}}exp(-\frac{x^2}{2\sigma})
+
+    References
+    ----------
+    .. [1] Bouma H., Vilanova A., Bescos J.O., ter Haar Romeny B.M., Gerritsen
+       F.A. (2007) Fast and Accurate Gaussian Derivatives Based on B-Splines. In:
+       Sgallari F., Murli A., Paragios N. (eds) Scale Space and Variational
+       Methods in Computer Vision. SSVM 2007. Lecture Notes in Computer
+       Science, vol 4485. Springer, Berlin, Heidelberg
+    .. [2] http://folk.uio.no/inf3330/scripting/doc/python/SciPy/tutorial/old/node24.html
+
+    Examples
+    --------
+    We can calculate B-Spline basis functions approximated by a gaussian
+    distribution:
+
+    >>> import numpy as np
+    >>> from scipy.signal import gauss_spline
+    >>> knots = np.array([-1.0, 0.0, -1.0])
+    >>> gauss_spline(knots, 3)
+    array([0.15418033, 0.6909883, 0.15418033])  # may vary
+
+    """
+    x = asarray(x)
+    signsq = (n + 1) / 12.0
+    return 1 / sqrt(2 * pi * signsq) * exp(-x ** 2 / 2 / signsq)
+
+
+def _cubic(x):
+    x = asarray(x, dtype=float)
+    b = BSpline.basis_element([-2, -1, 0, 1, 2], extrapolate=False)
+    out = b(x)
+    out[(x < -2) | (x > 2)] = 0
+    return out
+
+
+def _quadratic(x):
+    x = abs(asarray(x, dtype=float))
+    b = BSpline.basis_element([-1.5, -0.5, 0.5, 1.5], extrapolate=False)
+    out = b(x)
+    out[(x < -1.5) | (x > 1.5)] = 0
+    return out
+
+
+def _coeff_smooth(lam):
+    xi = 1 - 96 * lam + 24 * lam * sqrt(3 + 144 * lam)
+    omeg = arctan2(sqrt(144 * lam - 1), sqrt(xi))
+    rho = (24 * lam - 1 - sqrt(xi)) / (24 * lam)
+    rho = rho * sqrt((48 * lam + 24 * lam * sqrt(3 + 144 * lam)) / xi)
+    return rho, omeg
+
+
+def _hc(k, cs, rho, omega):
+    return (cs / sin(omega) * (rho ** k) * sin(omega * (k + 1)) *
+            greater(k, -1))
+
+
+def _hs(k, cs, rho, omega):
+    c0 = (cs * cs * (1 + rho * rho) / (1 - rho * rho) /
+          (1 - 2 * rho * rho * cos(2 * omega) + rho ** 4))
+    gamma = (1 - rho * rho) / (1 + rho * rho) / tan(omega)
+    ak = abs(k)
+    return c0 * rho ** ak * (cos(omega * ak) + gamma * sin(omega * ak))
+
+
+def _cubic_smooth_coeff(signal, lamb):
+    rho, omega = _coeff_smooth(lamb)
+    cs = 1 - 2 * rho * cos(omega) + rho * rho
+    K = len(signal)
+    k = arange(K)
+
+    zi_2 = (_hc(0, cs, rho, omega) * signal[0] +
+            add.reduce(_hc(k + 1, cs, rho, omega) * signal))
+    zi_1 = (_hc(0, cs, rho, omega) * signal[0] +
+            _hc(1, cs, rho, omega) * signal[1] +
+            add.reduce(_hc(k + 2, cs, rho, omega) * signal))
+
+    # Forward filter:
+    # for n in range(2, K):
+    #     yp[n] = (cs * signal[n] + 2 * rho * cos(omega) * yp[n - 1] -
+    #              rho * rho * yp[n - 2])
+    zi = lfiltic(cs, r_[1, -2 * rho * cos(omega), rho * rho], r_[zi_1, zi_2])
+    zi = zi.reshape(1, -1)
+
+    sos = r_[cs, 0, 0, 1, -2 * rho * cos(omega), rho * rho]
+    sos = sos.reshape(1, -1)
+
+    yp, _ = sosfilt(sos, signal[2:], zi=zi)
+    yp = r_[zi_2, zi_1, yp]
+
+    # Reverse filter:
+    # for n in range(K - 3, -1, -1):
+    #     y[n] = (cs * yp[n] + 2 * rho * cos(omega) * y[n + 1] -
+    #             rho * rho * y[n + 2])
+
+    zi_2 = add.reduce((_hs(k, cs, rho, omega) +
+                       _hs(k + 1, cs, rho, omega)) * signal[::-1])
+    zi_1 = add.reduce((_hs(k - 1, cs, rho, omega) +
+                       _hs(k + 2, cs, rho, omega)) * signal[::-1])
+
+    zi = lfiltic(cs, r_[1, -2 * rho * cos(omega), rho * rho], r_[zi_1, zi_2])
+    zi = zi.reshape(1, -1)
+    y, _ = sosfilt(sos, yp[-3::-1], zi=zi)
+    y = r_[y[::-1], zi_1, zi_2]
+    return y
+
+
+def _cubic_coeff(signal):
+    zi = -2 + sqrt(3)
+    K = len(signal)
+    powers = zi ** arange(K)
+
+    if K == 1:
+        yplus = signal[0] + zi * add.reduce(powers * signal)
+        output = zi / (zi - 1) * yplus
+        return atleast_1d(output)
+
+    # Forward filter:
+    # yplus[0] = signal[0] + zi * add.reduce(powers * signal)
+    # for k in range(1, K):
+    #     yplus[k] = signal[k] + zi * yplus[k - 1]
+
+    state = lfiltic(1, r_[1, -zi], atleast_1d(add.reduce(powers * signal)))
+
+    b = ones(1)
+    a = r_[1, -zi]
+    yplus, _ = lfilter(b, a, signal, zi=state)
+
+    # Reverse filter:
+    # output[K - 1] = zi / (zi - 1) * yplus[K - 1]
+    # for k in range(K - 2, -1, -1):
+    #     output[k] = zi * (output[k + 1] - yplus[k])
+    out_last = zi / (zi - 1) * yplus[K - 1]
+    state = lfiltic(-zi, r_[1, -zi], atleast_1d(out_last))
+
+    b = asarray([-zi])
+    output, _ = lfilter(b, a, yplus[-2::-1], zi=state)
+    output = r_[output[::-1], out_last]
+    return output * 6.0
+
+
+def _quadratic_coeff(signal):
+    zi = -3 + 2 * sqrt(2.0)
+    K = len(signal)
+    powers = zi ** arange(K)
+
+    if K == 1:
+        yplus = signal[0] + zi * add.reduce(powers * signal)
+        output = zi / (zi - 1) * yplus
+        return atleast_1d(output)
+
+    # Forward filter:
+    # yplus[0] = signal[0] + zi * add.reduce(powers * signal)
+    # for k in range(1, K):
+    #     yplus[k] = signal[k] + zi * yplus[k - 1]
+
+    state = lfiltic(1, r_[1, -zi], atleast_1d(add.reduce(powers * signal)))
+
+    b = ones(1)
+    a = r_[1, -zi]
+    yplus, _ = lfilter(b, a, signal, zi=state)
+
+    # Reverse filter:
+    # output[K - 1] = zi / (zi - 1) * yplus[K - 1]
+    # for k in range(K - 2, -1, -1):
+    #     output[k] = zi * (output[k + 1] - yplus[k])
+    out_last = zi / (zi - 1) * yplus[K - 1]
+    state = lfiltic(-zi, r_[1, -zi], atleast_1d(out_last))
+
+    b = asarray([-zi])
+    output, _ = lfilter(b, a, yplus[-2::-1], zi=state)
+    output = r_[output[::-1], out_last]
+    return output * 8.0
+
+
+def cspline1d(signal, lamb=0.0):
+    """
+    Compute cubic spline coefficients for rank-1 array.
+
+    Find the cubic spline coefficients for a 1-D signal assuming
+    mirror-symmetric boundary conditions. To obtain the signal back from the
+    spline representation mirror-symmetric-convolve these coefficients with a
+    length 3 FIR window [1.0, 4.0, 1.0]/ 6.0 .
+
+    Parameters
+    ----------
+    signal : ndarray
+        A rank-1 array representing samples of a signal.
+    lamb : float, optional
+        Smoothing coefficient, default is 0.0.
+
+    Returns
+    -------
+    c : ndarray
+        Cubic spline coefficients.
+
+    See Also
+    --------
+    cspline1d_eval : Evaluate a cubic spline at the new set of points.
+
+    Examples
+    --------
+    We can filter a signal to reduce and smooth out high-frequency noise with
+    a cubic spline:
+
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> from scipy.signal import cspline1d, cspline1d_eval
+    >>> rng = np.random.default_rng()
+    >>> sig = np.repeat([0., 1., 0.], 100)
+    >>> sig += rng.standard_normal(len(sig))*0.05  # add noise
+    >>> time = np.linspace(0, len(sig))
+    >>> filtered = cspline1d_eval(cspline1d(sig), time)
+    >>> plt.plot(sig, label="signal")
+    >>> plt.plot(time, filtered, label="filtered")
+    >>> plt.legend()
+    >>> plt.show()
+
+    """
+    if lamb != 0.0:
+        return _cubic_smooth_coeff(signal, lamb)
+    else:
+        return _cubic_coeff(signal)
+
+
+def qspline1d(signal, lamb=0.0):
+    """Compute quadratic spline coefficients for rank-1 array.
+
+    Parameters
+    ----------
+    signal : ndarray
+        A rank-1 array representing samples of a signal.
+    lamb : float, optional
+        Smoothing coefficient (must be zero for now).
+
+    Returns
+    -------
+    c : ndarray
+        Quadratic spline coefficients.
+
+    See Also
+    --------
+    qspline1d_eval : Evaluate a quadratic spline at the new set of points.
+
+    Notes
+    -----
+    Find the quadratic spline coefficients for a 1-D signal assuming
+    mirror-symmetric boundary conditions. To obtain the signal back from the
+    spline representation mirror-symmetric-convolve these coefficients with a
+    length 3 FIR window [1.0, 6.0, 1.0]/ 8.0 .
+
+    Examples
+    --------
+    We can filter a signal to reduce and smooth out high-frequency noise with
+    a quadratic spline:
+
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> from scipy.signal import qspline1d, qspline1d_eval
+    >>> rng = np.random.default_rng()
+    >>> sig = np.repeat([0., 1., 0.], 100)
+    >>> sig += rng.standard_normal(len(sig))*0.05  # add noise
+    >>> time = np.linspace(0, len(sig))
+    >>> filtered = qspline1d_eval(qspline1d(sig), time)
+    >>> plt.plot(sig, label="signal")
+    >>> plt.plot(time, filtered, label="filtered")
+    >>> plt.legend()
+    >>> plt.show()
+
+    """
+    if lamb != 0.0:
+        raise ValueError("Smoothing quadratic splines not supported yet.")
+    else:
+        return _quadratic_coeff(signal)
+
+
+def cspline1d_eval(cj, newx, dx=1.0, x0=0):
+    """Evaluate a cubic spline at the new set of points.
+
+    `dx` is the old sample-spacing while `x0` was the old origin. In
+    other-words the old-sample points (knot-points) for which the `cj`
+    represent spline coefficients were at equally-spaced points of:
+
+      oldx = x0 + j*dx  j=0...N-1, with N=len(cj)
+
+    Edges are handled using mirror-symmetric boundary conditions.
+
+    Parameters
+    ----------
+    cj : ndarray
+        cublic spline coefficients
+    newx : ndarray
+        New set of points.
+    dx : float, optional
+        Old sample-spacing, the default value is 1.0.
+    x0 : int, optional
+        Old origin, the default value is 0.
+
+    Returns
+    -------
+    res : ndarray
+        Evaluated a cubic spline points.
+
+    See Also
+    --------
+    cspline1d : Compute cubic spline coefficients for rank-1 array.
+
+    Examples
+    --------
+    We can filter a signal to reduce and smooth out high-frequency noise with
+    a cubic spline:
+
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> from scipy.signal import cspline1d, cspline1d_eval
+    >>> rng = np.random.default_rng()
+    >>> sig = np.repeat([0., 1., 0.], 100)
+    >>> sig += rng.standard_normal(len(sig))*0.05  # add noise
+    >>> time = np.linspace(0, len(sig))
+    >>> filtered = cspline1d_eval(cspline1d(sig), time)
+    >>> plt.plot(sig, label="signal")
+    >>> plt.plot(time, filtered, label="filtered")
+    >>> plt.legend()
+    >>> plt.show()
+
+    """
+    newx = (asarray(newx) - x0) / float(dx)
+    res = zeros_like(newx, dtype=cj.dtype)
+    if res.size == 0:
+        return res
+    N = len(cj)
+    cond1 = newx < 0
+    cond2 = newx > (N - 1)
+    cond3 = ~(cond1 | cond2)
+    # handle general mirror-symmetry
+    res[cond1] = cspline1d_eval(cj, -newx[cond1])
+    res[cond2] = cspline1d_eval(cj, 2 * (N - 1) - newx[cond2])
+    newx = newx[cond3]
+    if newx.size == 0:
+        return res
+    result = zeros_like(newx, dtype=cj.dtype)
+    jlower = floor(newx - 2).astype(int) + 1
+    for i in range(4):
+        thisj = jlower + i
+        indj = thisj.clip(0, N - 1)  # handle edge cases
+        result += cj[indj] * _cubic(newx - thisj)
+    res[cond3] = result
+    return res
+
+
+def qspline1d_eval(cj, newx, dx=1.0, x0=0):
+    """Evaluate a quadratic spline at the new set of points.
+
+    Parameters
+    ----------
+    cj : ndarray
+        Quadratic spline coefficients
+    newx : ndarray
+        New set of points.
+    dx : float, optional
+        Old sample-spacing, the default value is 1.0.
+    x0 : int, optional
+        Old origin, the default value is 0.
+
+    Returns
+    -------
+    res : ndarray
+        Evaluated a quadratic spline points.
+
+    See Also
+    --------
+    qspline1d : Compute quadratic spline coefficients for rank-1 array.
+
+    Notes
+    -----
+    `dx` is the old sample-spacing while `x0` was the old origin. In
+    other-words the old-sample points (knot-points) for which the `cj`
+    represent spline coefficients were at equally-spaced points of::
+
+      oldx = x0 + j*dx  j=0...N-1, with N=len(cj)
+
+    Edges are handled using mirror-symmetric boundary conditions.
+
+    Examples
+    --------
+    We can filter a signal to reduce and smooth out high-frequency noise with
+    a quadratic spline:
+
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> from scipy.signal import qspline1d, qspline1d_eval
+    >>> rng = np.random.default_rng()
+    >>> sig = np.repeat([0., 1., 0.], 100)
+    >>> sig += rng.standard_normal(len(sig))*0.05  # add noise
+    >>> time = np.linspace(0, len(sig))
+    >>> filtered = qspline1d_eval(qspline1d(sig), time)
+    >>> plt.plot(sig, label="signal")
+    >>> plt.plot(time, filtered, label="filtered")
+    >>> plt.legend()
+    >>> plt.show()
+
+    """
+    newx = (asarray(newx) - x0) / dx
+    res = zeros_like(newx)
+    if res.size == 0:
+        return res
+    N = len(cj)
+    cond1 = newx < 0
+    cond2 = newx > (N - 1)
+    cond3 = ~(cond1 | cond2)
+    # handle general mirror-symmetry
+    res[cond1] = qspline1d_eval(cj, -newx[cond1])
+    res[cond2] = qspline1d_eval(cj, 2 * (N - 1) - newx[cond2])
+    newx = newx[cond3]
+    if newx.size == 0:
+        return res
+    result = zeros_like(newx)
+    jlower = floor(newx - 1.5).astype(int) + 1
+    for i in range(3):
+        thisj = jlower + i
+        indj = thisj.clip(0, N - 1)  # handle edge cases
+        result += cj[indj] * _quadratic(newx - thisj)
+    res[cond3] = result
+    return res

env-llmeval/lib/python3.10/site-packages/scipy/signal/_max_len_seq.py

@@ -0,0 +1,139 @@
+# Author: Eric Larson
+# 2014
+
+"""Tools for MLS generation"""
+
+import numpy as np
+
+from ._max_len_seq_inner import _max_len_seq_inner
+
+__all__ = ['max_len_seq']
+
+
+# These are definitions of linear shift register taps for use in max_len_seq()
+_mls_taps = {2: [1], 3: [2], 4: [3], 5: [3], 6: [5], 7: [6], 8: [7, 6, 1],
+             9: [5], 10: [7], 11: [9], 12: [11, 10, 4], 13: [12, 11, 8],
+             14: [13, 12, 2], 15: [14], 16: [15, 13, 4], 17: [14],
+             18: [11], 19: [18, 17, 14], 20: [17], 21: [19], 22: [21],
+             23: [18], 24: [23, 22, 17], 25: [22], 26: [25, 24, 20],
+             27: [26, 25, 22], 28: [25], 29: [27], 30: [29, 28, 7],
+             31: [28], 32: [31, 30, 10]}
+
+def max_len_seq(nbits, state=None, length=None, taps=None):
+    """
+    Maximum length sequence (MLS) generator.
+
+    Parameters
+    ----------
+    nbits : int
+        Number of bits to use. Length of the resulting sequence will
+        be ``(2**nbits) - 1``. Note that generating long sequences
+        (e.g., greater than ``nbits == 16``) can take a long time.
+    state : array_like, optional
+        If array, must be of length ``nbits``, and will be cast to binary
+        (bool) representation. If None, a seed of ones will be used,
+        producing a repeatable representation. If ``state`` is all
+        zeros, an error is raised as this is invalid. Default: None.
+    length : int, optional
+        Number of samples to compute. If None, the entire length
+        ``(2**nbits) - 1`` is computed.
+    taps : array_like, optional
+        Polynomial taps to use (e.g., ``[7, 6, 1]`` for an 8-bit sequence).
+        If None, taps will be automatically selected (for up to
+        ``nbits == 32``).
+
+    Returns
+    -------
+    seq : array
+        Resulting MLS sequence of 0's and 1's.
+    state : array
+        The final state of the shift register.
+
+    Notes
+    -----
+    The algorithm for MLS generation is generically described in:
+
+        https://en.wikipedia.org/wiki/Maximum_length_sequence
+
+    The default values for taps are specifically taken from the first
+    option listed for each value of ``nbits`` in:
+
+        https://web.archive.org/web/20181001062252/http://www.newwaveinstruments.com/resources/articles/m_sequence_linear_feedback_shift_register_lfsr.htm
+
+    .. versionadded:: 0.15.0
+
+    Examples
+    --------
+    MLS uses binary convention:
+
+    >>> from scipy.signal import max_len_seq
+    >>> max_len_seq(4)[0]
+    array([1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0], dtype=int8)
+
+    MLS has a white spectrum (except for DC):
+
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> from numpy.fft import fft, ifft, fftshift, fftfreq
+    >>> seq = max_len_seq(6)[0]*2-1  # +1 and -1
+    >>> spec = fft(seq)
+    >>> N = len(seq)
+    >>> plt.plot(fftshift(fftfreq(N)), fftshift(np.abs(spec)), '.-')
+    >>> plt.margins(0.1, 0.1)
+    >>> plt.grid(True)
+    >>> plt.show()
+
+    Circular autocorrelation of MLS is an impulse:
+
+    >>> acorrcirc = ifft(spec * np.conj(spec)).real
+    >>> plt.figure()
+    >>> plt.plot(np.arange(-N/2+1, N/2+1), fftshift(acorrcirc), '.-')
+    >>> plt.margins(0.1, 0.1)
+    >>> plt.grid(True)
+    >>> plt.show()
+
+    Linear autocorrelation of MLS is approximately an impulse:
+
+    >>> acorr = np.correlate(seq, seq, 'full')
+    >>> plt.figure()
+    >>> plt.plot(np.arange(-N+1, N), acorr, '.-')
+    >>> plt.margins(0.1, 0.1)
+    >>> plt.grid(True)
+    >>> plt.show()
+
+    """
+    taps_dtype = np.int32 if np.intp().itemsize == 4 else np.int64
+    if taps is None:
+        if nbits not in _mls_taps:
+            known_taps = np.array(list(_mls_taps.keys()))
+            raise ValueError(f'nbits must be between {known_taps.min()} and '
+                             f'{known_taps.max()} if taps is None')
+        taps = np.array(_mls_taps[nbits], taps_dtype)
+    else:
+        taps = np.unique(np.array(taps, taps_dtype))[::-1]
+        if np.any(taps < 0) or np.any(taps > nbits) or taps.size < 1:
+            raise ValueError('taps must be non-empty with values between '
+                             'zero and nbits (inclusive)')
+        taps = np.array(taps)  # needed for Cython and Pythran
+    n_max = (2**nbits) - 1
+    if length is None:
+        length = n_max
+    else:
+        length = int(length)
+        if length < 0:
+            raise ValueError('length must be greater than or equal to 0')
+    # We use int8 instead of bool here because NumPy arrays of bools
+    # don't seem to work nicely with Cython
+    if state is None:
+        state = np.ones(nbits, dtype=np.int8, order='c')
+    else:
+        # makes a copy if need be, ensuring it's 0's and 1's
+        state = np.array(state, dtype=bool, order='c').astype(np.int8)
+    if state.ndim != 1 or state.size != nbits:
+        raise ValueError('state must be a 1-D array of size nbits')
+    if np.all(state == 0):
+        raise ValueError('state must not be all zeros')
+
+    seq = np.empty(length, dtype=np.int8, order='c')
+    state = _max_len_seq_inner(taps, state, nbits, length, seq)
+    return seq, state

env-llmeval/lib/python3.10/site-packages/scipy/signal/_short_time_fft.py

@@ -0,0 +1,1676 @@
+"""Implementation of an FFT-based Short-time Fourier Transform. """
+
+# Implementation Notes for this file (as of 2023-07)
+# --------------------------------------------------
+# * MyPy version 1.1.1 does not seem to support decorated property methods
+#   properly. Hence, applying ``@property`` to methods decorated with `@cache``
+#   (as tried with the ``lower_border_end`` method) causes a mypy error when
+#   accessing it as an index (e.g., ``SFT.lower_border_end[0]``).
+# * Since the method `stft` and `istft` have identical names as the legacy
+#   functions in the signal module, referencing them as HTML link in the
+#   docstrings has to be done by an explicit `~ShortTimeFFT.stft` instead of an
+#   ambiguous `stft` (The ``~`` hides the class / module name).
+# * The HTML documentation currently renders each method/property on a separate
+#   page without reference to the parent class. Thus, a link to `ShortTimeFFT`
+#   was added to the "See Also" section of each method/property. These links
+#   can be removed, when SciPy updates ``pydata-sphinx-theme`` to >= 0.13.3
+#   (currently 0.9). Consult Issue 18512 and PR 16660 for further details.
+#
+
+# Provides typing union operator ``|`` in Python 3.9:
+from __future__ import annotations
+# Linter does not allow to import ``Generator`` from ``typing`` module:
+from collections.abc import Generator
+from functools import cache, lru_cache, partial
+from typing import Callable, get_args, Literal
+
+import numpy as np
+
+import scipy.fft as fft_lib
+from scipy.signal import detrend
+from scipy.signal.windows import get_window
+
+__all__ = ['ShortTimeFFT']
+
+
+#: Allowed values for parameter `padding` of method `ShortTimeFFT.stft()`:
+PAD_TYPE = Literal['zeros', 'edge', 'even', 'odd']
+
+#: Allowed values for property `ShortTimeFFT.fft_mode`:
+FFT_MODE_TYPE = Literal['twosided', 'centered', 'onesided', 'onesided2X']
+
+
+def _calc_dual_canonical_window(win: np.ndarray, hop: int) -> np.ndarray:
+    """Calculate canonical dual window for 1d window `win` and a time step
+    of `hop` samples.
+
+    A ``ValueError`` is raised, if the inversion fails.
+
+    This is a separate function not a method, since it is also used in the
+    class method ``ShortTimeFFT.from_dual()``.
+    """
+    if hop > len(win):
+        raise ValueError(f"{hop=} is larger than window length of {len(win)}" +
+                         " => STFT not invertible!")
+    if issubclass(win.dtype.type, np.integer):
+        raise ValueError("Parameter 'win' cannot be of integer type, but " +
+                         f"{win.dtype=} => STFT not invertible!")
+        # The calculation of `relative_resolution` does not work for ints.
+        # Furthermore, `win / DD` casts the integers away, thus an implicit
+        # cast is avoided, which can always cause confusion when using 32-Bit
+        # floats.
+
+    w2 = win.real**2 + win.imag**2  # win*win.conj() does not ensure w2 is real
+    DD = w2.copy()
+    for k_ in range(hop, len(win), hop):
+        DD[k_:] += w2[:-k_]
+        DD[:-k_] += w2[k_:]
+
+    # check DD > 0:
+    relative_resolution = np.finfo(win.dtype).resolution * max(DD)
+    if not np.all(DD >= relative_resolution):
+        raise ValueError("Short-time Fourier Transform not invertible!")
+
+    return win / DD
+
+
+# noinspection PyShadowingNames
+class ShortTimeFFT:
+    r"""Provide a parametrized discrete Short-time Fourier transform (stft)
+    and its inverse (istft).
+
+    .. currentmodule:: scipy.signal.ShortTimeFFT
+
+    The `~ShortTimeFFT.stft` calculates sequential FFTs by sliding a
+    window (`win`) over an input signal by `hop` increments. It can be used to
+    quantify the change of the spectrum over time.
+
+    The `~ShortTimeFFT.stft` is represented by a complex-valued matrix S[q,p]
+    where the p-th column represents an FFT with the window centered at the
+    time t[p] = p * `delta_t` = p * `hop` * `T` where `T` is  the sampling
+    interval of the input signal. The q-th row represents the values at the
+    frequency f[q] = q * `delta_f` with `delta_f` = 1 / (`mfft` * `T`) being
+    the bin width of the FFT.
+
+    The inverse STFT `~ShortTimeFFT.istft` is calculated by reversing the steps
+    of the STFT: Take the IFFT of the p-th slice of S[q,p] and multiply the
+    result with the so-called dual window (see `dual_win`). Shift the result by
+    p * `delta_t` and add the result to previous shifted results to reconstruct
+    the signal. If only the dual window is known and the STFT is invertible,
+    `from_dual` can be used to instantiate this class.
+
+    Due to the convention of time t = 0 being at the first sample of the input
+    signal, the STFT values typically have negative time slots. Hence,
+    negative indexes like `p_min` or `k_min` do not indicate counting
+    backwards from an array's end like in standard Python indexing but being
+    left of t = 0.
+
+    More detailed information can be found in the :ref:`tutorial_stft` section
+    of the :ref:`user_guide`.
+
+    Note that all parameters of the initializer, except `scale_to` (which uses
+    `scaling`) have identical named attributes.
+
+    Parameters
+    ----------
+    win : np.ndarray
+        The window must be a real- or complex-valued 1d array.
+    hop : int
+        The increment in samples, by which the window is shifted in each step.
+    fs : float
+        Sampling frequency of input signal and window. Its relation to the
+        sampling interval `T` is ``T = 1 / fs``.
+    fft_mode : 'twosided', 'centered', 'onesided', 'onesided2X'
+        Mode of FFT to be used (default 'onesided').
+        See property `fft_mode` for details.
+    mfft: int | None
+        Length of the FFT used, if a zero padded FFT is desired.
+        If ``None`` (default), the length of the window `win` is used.
+    dual_win : np.ndarray | None
+        The dual window of `win`. If set to ``None``, it is calculated if
+        needed.
+    scale_to : 'magnitude', 'psd' | None
+        If not ``None`` (default) the window function is scaled, so each STFT
+        column represents  either a 'magnitude' or a power spectral density
+        ('psd') spectrum. This parameter sets the property `scaling` to the
+        same value. See method `scale_to` for details.
+    phase_shift : int | None
+        If set, add a linear phase `phase_shift` / `mfft` * `f` to each
+        frequency `f`. The default value 0 ensures that there is no phase shift
+        on the zeroth slice (in which t=0 is centered). See property
+        `phase_shift` for more details.
+
+    Examples
+    --------
+    The following example shows the magnitude of the STFT of a sine with
+    varying frequency :math:`f_i(t)` (marked by a red dashed line in the plot):
+
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> from scipy.signal import ShortTimeFFT
+    >>> from scipy.signal.windows import gaussian
+    ...
+    >>> T_x, N = 1 / 20, 1000  # 20 Hz sampling rate for 50 s signal
+    >>> t_x = np.arange(N) * T_x  # time indexes for signal
+    >>> f_i = 1 * np.arctan((t_x - t_x[N // 2]) / 2) + 5  # varying frequency
+    >>> x = np.sin(2*np.pi*np.cumsum(f_i)*T_x) # the signal
+
+    The utilized Gaussian window is 50 samples or 2.5 s long. The parameter
+    ``mfft=200`` in `ShortTimeFFT` causes the spectrum to be oversampled
+    by a factor of 4:
+
+    >>> g_std = 8  # standard deviation for Gaussian window in samples
+    >>> w = gaussian(50, std=g_std, sym=True)  # symmetric Gaussian window
+    >>> SFT = ShortTimeFFT(w, hop=10, fs=1/T_x, mfft=200, scale_to='magnitude')
+    >>> Sx = SFT.stft(x)  # perform the STFT
+
+    In the plot, the time extent of the signal `x` is marked by vertical dashed
+    lines. Note that the SFT produces values outside the time range of `x`. The
+    shaded areas on the left and the right indicate border effects caused
+    by  the window slices in that area not fully being inside time range of
+    `x`:
+
+    >>> fig1, ax1 = plt.subplots(figsize=(6., 4.))  # enlarge plot a bit
+    >>> t_lo, t_hi = SFT.extent(N)[:2]  # time range of plot
+    >>> ax1.set_title(rf"STFT ({SFT.m_num*SFT.T:g}$\,s$ Gaussian window, " +
+    ...               rf"$\sigma_t={g_std*SFT.T}\,$s)")
+    >>> ax1.set(xlabel=f"Time $t$ in seconds ({SFT.p_num(N)} slices, " +
+    ...                rf"$\Delta t = {SFT.delta_t:g}\,$s)",
+    ...         ylabel=f"Freq. $f$ in Hz ({SFT.f_pts} bins, " +
+    ...                rf"$\Delta f = {SFT.delta_f:g}\,$Hz)",
+    ...         xlim=(t_lo, t_hi))
+    ...
+    >>> im1 = ax1.imshow(abs(Sx), origin='lower', aspect='auto',
+    ...                  extent=SFT.extent(N), cmap='viridis')
+    >>> ax1.plot(t_x, f_i, 'r--', alpha=.5, label='$f_i(t)$')
+    >>> fig1.colorbar(im1, label="Magnitude $|S_x(t, f)|$")
+    ...
+    >>> # Shade areas where window slices stick out to the side:
+    >>> for t0_, t1_ in [(t_lo, SFT.lower_border_end[0] * SFT.T),
+    ...                  (SFT.upper_border_begin(N)[0] * SFT.T, t_hi)]:
+    ...     ax1.axvspan(t0_, t1_, color='w', linewidth=0, alpha=.2)
+    >>> for t_ in [0, N * SFT.T]:  # mark signal borders with vertical line:
+    ...     ax1.axvline(t_, color='y', linestyle='--', alpha=0.5)
+    >>> ax1.legend()
+    >>> fig1.tight_layout()
+    >>> plt.show()
+
+    Reconstructing the signal with the `~ShortTimeFFT.istft` is
+    straightforward, but note that the length of `x1` should be specified,
+    since the SFT length increases in `hop` steps:
+
+    >>> SFT.invertible  # check if invertible
+    True
+    >>> x1 = SFT.istft(Sx, k1=N)
+    >>> np.allclose(x, x1)
+    True
+
+    It is possible to calculate the SFT of signal parts:
+
+    >>> p_q = SFT.nearest_k_p(N // 2)
+    >>> Sx0 = SFT.stft(x[:p_q])
+    >>> Sx1 = SFT.stft(x[p_q:])
+
+    When assembling sequential STFT parts together, the overlap needs to be
+    considered:
+
+    >>> p0_ub = SFT.upper_border_begin(p_q)[1] - SFT.p_min
+    >>> p1_le = SFT.lower_border_end[1] - SFT.p_min
+    >>> Sx01 = np.hstack((Sx0[:, :p0_ub],
+    ...                   Sx0[:, p0_ub:] + Sx1[:, :p1_le],
+    ...                   Sx1[:, p1_le:]))
+    >>> np.allclose(Sx01, Sx)  # Compare with SFT of complete signal
+    True
+
+    It is also possible to calculate the `itsft` for signal parts:
+
+    >>> y_p = SFT.istft(Sx, N//3, N//2)
+    >>> np.allclose(y_p, x[N//3:N//2])
+    True
+
+    """
+    # immutable attributes (only have getters but no setters):
+    _win: np.ndarray  # window
+    _dual_win: np.ndarray | None = None  # canonical dual window
+    _hop: int  # Step of STFT in number of samples
+
+    # mutable attributes:
+    _fs: float  # sampling frequency of input signal and window
+    _fft_mode: FFT_MODE_TYPE = 'onesided'  # Mode of FFT to use
+    _mfft: int  # length of FFT used - defaults to len(win)
+    _scaling: Literal['magnitude', 'psd'] | None = None  # Scaling of _win
+    _phase_shift: int | None  # amount to shift phase of FFT in samples
+
+    # attributes for caching calculated values:
+    _fac_mag: float | None = None
+    _fac_psd: float | None = None
+    _lower_border_end: tuple[int, int] | None = None
+
+    def __init__(self, win: np.ndarray, hop: int, fs: float, *,
+                 fft_mode: FFT_MODE_TYPE = 'onesided',
+                 mfft: int | None = None,
+                 dual_win: np.ndarray | None = None,
+                 scale_to: Literal['magnitude', 'psd'] | None = None,
+                 phase_shift: int | None = 0):
+        if not (win.ndim == 1 and win.size > 0):
+            raise ValueError(f"Parameter win must be 1d, but {win.shape=}!")
+        if not all(np.isfinite(win)):
+            raise ValueError("Parameter win must have finite entries!")
+        if not (hop >= 1 and isinstance(hop, int)):
+            raise ValueError(f"Parameter {hop=} is not an integer >= 1!")
+        self._win, self._hop, self.fs = win, hop, fs
+
+        self.mfft = len(win) if mfft is None else mfft
+
+        if dual_win is not None:
+            if dual_win.shape != win.shape:
+                raise ValueError(f"{dual_win.shape=} must equal {win.shape=}!")
+            if not all(np.isfinite(dual_win)):
+                raise ValueError("Parameter dual_win must be a finite array!")
+        self._dual_win = dual_win  # needs to be set before scaling
+
+        if scale_to is not None:  # needs to be set before fft_mode
+            self.scale_to(scale_to)
+
+        self.fft_mode, self.phase_shift = fft_mode, phase_shift
+
+    @classmethod
+    def from_dual(cls, dual_win: np.ndarray, hop: int, fs: float, *,
+                  fft_mode: FFT_MODE_TYPE = 'onesided',
+                  mfft: int | None = None,
+                  scale_to: Literal['magnitude', 'psd'] | None = None,
+                  phase_shift: int | None = 0):
+        r"""Instantiate a `ShortTimeFFT` by only providing a dual window.
+
+        If an STFT is invertible, it is possible to calculate the window `win`
+        from a given dual window `dual_win`. All other parameters have the
+        same meaning as in the initializer of `ShortTimeFFT`.
+
+        As explained in the :ref:`tutorial_stft` section of the
+        :ref:`user_guide`, an invertible STFT can be interpreted as series
+        expansion of time-shifted and frequency modulated dual windows. E.g.,
+        the series coefficient S[q,p] belongs to the term, which shifted
+        `dual_win` by p * `delta_t` and multiplied it by
+        exp( 2 * j * pi * t * q * `delta_f`).
+
+
+        Examples
+        --------
+        The following example discusses decomposing a signal into time- and
+        frequency-shifted Gaussians. A Gaussian with standard deviation of
+        one made up of 51 samples will be used:
+
+        >>> import numpy as np
+        >>> import matplotlib.pyplot as plt
+        >>> from scipy.signal import ShortTimeFFT
+        >>> from scipy.signal.windows import gaussian
+        ...
+        >>> T, N = 0.1, 51
+        >>> d_win = gaussian(N, std=1/T, sym=True)  # symmetric Gaussian window
+        >>> t = T * (np.arange(N) - N//2)
+        ...
+        >>> fg1, ax1 = plt.subplots()
+        >>> ax1.set_title(r"Dual Window: Gaussian with $\sigma_t=1$")
+        >>> ax1.set(xlabel=f"Time $t$ in seconds ({N} samples, $T={T}$ s)",
+        ...        xlim=(t[0], t[-1]), ylim=(0, 1.1*max(d_win)))
+        >>> ax1.plot(t, d_win, 'C0-')
+
+        The following plot with the overlap of 41, 11 and 2 samples show how
+        the `hop` interval affects the shape of the window `win`:
+
+        >>> fig2, axx = plt.subplots(3, 1, sharex='all')
+        ...
+        >>> axx[0].set_title(r"Windows for hop$\in\{10, 40, 49\}$")
+        >>> for c_, h_ in enumerate([10, 40, 49]):
+        ...     SFT = ShortTimeFFT.from_dual(d_win, h_, 1/T)
+        ...     axx[c_].plot(t + h_ * T, SFT.win, 'k--', alpha=.3, label=None)
+        ...     axx[c_].plot(t - h_ * T, SFT.win, 'k:', alpha=.3, label=None)
+        ...     axx[c_].plot(t, SFT.win, f'C{c_+1}',
+        ...                     label=r"$\Delta t=%0.1f\,$s" % SFT.delta_t)
+        ...     axx[c_].set_ylim(0, 1.1*max(SFT.win))
+        ...     axx[c_].legend(loc='center')
+        >>> axx[-1].set(xlabel=f"Time $t$ in seconds ({N} samples, $T={T}$ s)",
+        ...             xlim=(t[0], t[-1]))
+        >>> plt.show()
+
+        Beside the window `win` centered at t = 0 the previous (t = -`delta_t`)
+        and following window (t = `delta_t`) are depicted. It can be seen that
+        for small `hop` intervals, the window is compact and smooth, having a
+        good time-frequency concentration in the STFT. For the large `hop`
+        interval of 4.9 s, the window has small values around t = 0, which are
+        not covered by the overlap of the adjacent windows, which could lead to
+        numeric inaccuracies. Furthermore, the peaky shape at the beginning and
+        the end of the window points to a higher bandwidth, resulting in a
+        poorer time-frequency resolution of the STFT.
+        Hence, the choice of the `hop` interval will be a compromise between
+        a time-frequency resolution and memory requirements demanded by small
+        `hop` sizes.
+
+        See Also
+        --------
+        from_window: Create instance by wrapping `get_window`.
+        ShortTimeFFT: Create instance using standard initializer.
+        """
+        win = _calc_dual_canonical_window(dual_win, hop)
+        return cls(win=win, hop=hop, fs=fs, fft_mode=fft_mode, mfft=mfft,
+                   dual_win=dual_win, scale_to=scale_to,
+                   phase_shift=phase_shift)
+
+    @classmethod
+    def from_window(cls, win_param: str | tuple | float,
+                    fs: float, nperseg: int, noverlap: int, *,
+                    symmetric_win: bool = False,
+                    fft_mode: FFT_MODE_TYPE = 'onesided',
+                    mfft: int | None = None,
+                    scale_to: Literal['magnitude', 'psd'] | None = None,
+                    phase_shift: int | None = 0):
+        """Instantiate `ShortTimeFFT` by using `get_window`.
+
+        The method `get_window` is used to create a window of length
+        `nperseg`. The parameter names `noverlap`, and `nperseg` are used here,
+        since they more inline with other classical STFT libraries.
+
+        Parameters
+        ----------
+        win_param: Union[str, tuple, float],
+            Parameters passed to `get_window`. For windows with no parameters,
+            it may be a string (e.g., ``'hann'``), for parametrized windows a
+            tuple, (e.g., ``('gaussian', 2.)``) or a single float specifying
+            the shape parameter of a kaiser window (i.e. ``4.``  and
+            ``('kaiser', 4.)`` are equal. See `get_window` for more details.
+        fs : float
+            Sampling frequency of input signal. Its relation to the
+            sampling interval `T` is ``T = 1 / fs``.
+        nperseg: int
+            Window length in samples, which corresponds to the `m_num`.
+        noverlap: int
+            Window overlap in samples. It relates to the `hop` increment by
+            ``hop = npsereg - noverlap``.
+        symmetric_win: bool
+            If ``True`` then a symmetric window is generated, else a periodic
+            window is generated (default). Though symmetric windows seem for
+            most applications to be more sensible, the default of a periodic
+            windows was chosen to correspond to the default of `get_window`.
+        fft_mode : 'twosided', 'centered', 'onesided', 'onesided2X'
+            Mode of FFT to be used (default 'onesided').
+            See property `fft_mode` for details.
+        mfft: int | None
+            Length of the FFT used, if a zero padded FFT is desired.
+            If ``None`` (default), the length of the window `win` is used.
+        scale_to : 'magnitude', 'psd' | None
+            If not ``None`` (default) the window function is scaled, so each
+            STFT column represents  either a 'magnitude' or a power spectral
+            density ('psd') spectrum. This parameter sets the property
+            `scaling` to the same value. See method `scale_to` for details.
+        phase_shift : int | None
+            If set, add a linear phase `phase_shift` / `mfft` * `f` to each
+            frequency `f`. The default value 0 ensures that there is no phase
+            shift on the zeroth slice (in which t=0 is centered). See property
+            `phase_shift` for more details.
+
+        Examples
+        --------
+        The following instances ``SFT0`` and ``SFT1`` are equivalent:
+
+        >>> from scipy.signal import ShortTimeFFT, get_window
+        >>> nperseg = 9  # window length
+        >>> w = get_window(('gaussian', 2.), nperseg)
+        >>> fs = 128  # sampling frequency
+        >>> hop = 3  # increment of STFT time slice
+        >>> SFT0 = ShortTimeFFT(w, hop, fs=fs)
+        >>> SFT1 = ShortTimeFFT.from_window(('gaussian', 2.), fs, nperseg,
+        ...                                 noverlap=nperseg-hop)
+
+        See Also
+        --------
+        scipy.signal.get_window: Return a window of a given length and type.
+        from_dual: Create instance using dual window.
+        ShortTimeFFT: Create instance using standard initializer.
+        """
+        win = get_window(win_param, nperseg, fftbins=not symmetric_win)
+        return cls(win, hop=nperseg-noverlap, fs=fs, fft_mode=fft_mode,
+                   mfft=mfft, scale_to=scale_to, phase_shift=phase_shift)
+
+    @property
+    def win(self) -> np.ndarray:
+        """Window function as real- or complex-valued 1d array.
+
+        This attribute is read only, since `dual_win` depends on it.
+
+        See Also
+        --------
+        dual_win: Canonical dual window.
+        m_num: Number of samples in window `win`.
+        m_num_mid: Center index of window `win`.
+        mfft: Length of input for the FFT used - may be larger than `m_num`.
+        hop: ime increment in signal samples for sliding window.
+        win: Window function as real- or complex-valued 1d array.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        return self._win
+
+    @property
+    def hop(self) -> int:
+        """Time increment in signal samples for sliding window.
+
+        This attribute is read only, since `dual_win` depends on it.
+
+        See Also
+        --------
+        delta_t: Time increment of STFT (``hop*T``)
+        m_num: Number of samples in window `win`.
+        m_num_mid: Center index of window `win`.
+        mfft: Length of input for the FFT used - may be larger than `m_num`.
+        T: Sampling interval of input signal and of the window.
+        win: Window function as real- or complex-valued 1d array.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        return self._hop
+
+    @property
+    def T(self) -> float:
+        """Sampling interval of input signal and of the window.
+
+        A ``ValueError`` is raised if it is set to a non-positive value.
+
+        See Also
+        --------
+        delta_t: Time increment of STFT (``hop*T``)
+        hop: Time increment in signal samples for sliding window.
+        fs: Sampling frequency (being ``1/T``)
+        t: Times of STFT for an input signal with `n` samples.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        return 1 / self._fs
+
+    @T.setter
+    def T(self, v: float):
+        """Sampling interval of input signal and of the window.
+
+        A ``ValueError`` is raised if it is set to a non-positive value.
+        """
+        if not (v > 0):
+            raise ValueError(f"Sampling interval T={v} must be positive!")
+        self._fs = 1 / v
+
+    @property
+    def fs(self) -> float:
+        """Sampling frequency of input signal and of the window.
+
+        The sampling frequency is the inverse of the sampling interval `T`.
+        A ``ValueError`` is raised if it is set to a non-positive value.
+
+        See Also
+        --------
+        delta_t: Time increment of STFT (``hop*T``)
+        hop: Time increment in signal samples for sliding window.
+        T: Sampling interval of input signal and of the window (``1/fs``).
+        ShortTimeFFT: Class this property belongs to.
+        """
+        return self._fs
+
+    @fs.setter
+    def fs(self, v: float):
+        """Sampling frequency of input signal and of the window.
+
+        The sampling frequency is the inverse of the sampling interval `T`.
+        A ``ValueError`` is raised if it is set to a non-positive value.
+        """
+        if not (v > 0):
+            raise ValueError(f"Sampling frequency fs={v} must be positive!")
+        self._fs = v
+
+    @property
+    def fft_mode(self) -> FFT_MODE_TYPE:
+        """Mode of utilized FFT ('twosided', 'centered', 'onesided' or
+        'onesided2X').
+
+        It can have the following values:
+
+        'twosided':
+            Two-sided FFT, where values for the negative frequencies are in
+            upper half of the array. Corresponds to :func:`~scipy.fft.fft()`.
+        'centered':
+            Two-sided FFT with the values being ordered along monotonically
+            increasing frequencies. Corresponds to applying
+            :func:`~scipy.fft.fftshift()` to :func:`~scipy.fft.fft()`.
+        'onesided':
+            Calculates only values for non-negative frequency values.
+            Corresponds to :func:`~scipy.fft.rfft()`.
+        'onesided2X':
+            Like `onesided`, but the non-zero frequencies are doubled if
+            `scaling` is set to 'magnitude' or multiplied by ``sqrt(2)`` if
+            set to 'psd'. If `scaling` is ``None``, setting `fft_mode` to
+            `onesided2X` is not allowed.
+            If the FFT length `mfft` is even, the last FFT value is not paired,
+            and thus it is not scaled.
+
+        Note that `onesided` and `onesided2X` do not work for complex-valued signals or
+        complex-valued windows. Furthermore, the frequency values can be obtained by
+        reading the `f` property, and the number of samples by accessing the `f_pts`
+        property.
+
+        See Also
+        --------
+        delta_f: Width of the frequency bins of the STFT.
+        f: Frequencies values of the STFT.
+        f_pts: Width of the frequency bins of the STFT.
+        onesided_fft: True if a one-sided FFT is used.
+        scaling: Normalization applied to the window function
+        ShortTimeFFT: Class this property belongs to.
+        """
+        return self._fft_mode
+
+    @fft_mode.setter
+    def fft_mode(self, t: FFT_MODE_TYPE):
+        """Set mode of FFT.
+
+        Allowed values are 'twosided', 'centered', 'onesided', 'onesided2X'.
+        See the property `fft_mode` for more details.
+        """
+        if t not in (fft_mode_types := get_args(FFT_MODE_TYPE)):
+            raise ValueError(f"fft_mode='{t}' not in {fft_mode_types}!")
+
+        if t in {'onesided', 'onesided2X'} and np.iscomplexobj(self.win):
+            raise ValueError(f"One-sided spectra, i.e., fft_mode='{t}', " +
+                             "are not allowed for complex-valued windows!")
+
+        if t == 'onesided2X' and self.scaling is None:
+            raise ValueError(f"For scaling is None, fft_mode='{t}' is invalid!"
+                             "Do scale_to('psd') or scale_to('magnitude')!")
+        self._fft_mode = t
+
+    @property
+    def mfft(self) -> int:
+        """Length of input for the FFT used - may be larger than window
+        length `m_num`.
+
+        If not set, `mfft` defaults to the window length `m_num`.
+
+        See Also
+        --------
+        f_pts: Number of points along the frequency axis.
+        f: Frequencies values of the STFT.
+        m_num: Number of samples in window `win`.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        return self._mfft
+
+    @mfft.setter
+    def mfft(self, n_: int):
+        """Setter for the length of FFT utilized.
+
+        See the property `mfft` for further details.
+        """
+        if not (n_ >= self.m_num):
+            raise ValueError(f"Attribute mfft={n_} needs to be at least the " +
+                             f"window length m_num={self.m_num}!")
+        self._mfft = n_
+
+    @property
+    def scaling(self) -> Literal['magnitude', 'psd'] | None:
+        """Normalization applied to the window function
+        ('magnitude', 'psd' or ``None``).
+
+        If not ``None``, the FFTs can be either interpreted as a magnitude or
+        a power spectral density spectrum.
+
+        The window function can be scaled by calling the `scale_to` method,
+        or it is set by the initializer parameter ``scale_to``.
+
+        See Also
+        --------
+        fac_magnitude: Scaling factor for to a magnitude spectrum.
+        fac_psd: Scaling factor for to  a power spectral density spectrum.
+        fft_mode: Mode of utilized FFT
+        scale_to: Scale window to obtain 'magnitude' or 'psd' scaling.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        return self._scaling
+
+    def scale_to(self, scaling: Literal['magnitude', 'psd']):
+        """Scale window to obtain 'magnitude' or 'psd' scaling for the STFT.
+
+        The window of a 'magnitude' spectrum has an integral of one, i.e., unit
+        area for non-negative windows. This ensures that absolute the values of
+        spectrum does not change if the length of the window changes (given
+        the input signal is stationary).
+
+        To represent the power spectral density ('psd') for varying length
+        windows the area of the absolute square of the window needs to be
+        unity.
+
+        The `scaling` property shows the current scaling. The properties
+        `fac_magnitude` and `fac_psd` show the scaling factors required to
+        scale the STFT values to a magnitude or a psd spectrum.
+
+        This method is called, if the initializer parameter `scale_to` is set.
+
+        See Also
+        --------
+        fac_magnitude: Scaling factor for to  a magnitude spectrum.
+        fac_psd: Scaling factor for to  a power spectral density spectrum.
+        fft_mode: Mode of utilized FFT
+        scaling: Normalization applied to the window function.
+        ShortTimeFFT: Class this method belongs to.
+        """
+        if scaling not in (scaling_values := {'magnitude', 'psd'}):
+            raise ValueError(f"{scaling=} not in {scaling_values}!")
+        if self._scaling == scaling:  # do nothing
+            return
+
+        s_fac = self.fac_psd if scaling == 'psd' else self.fac_magnitude
+        self._win = self._win * s_fac
+        if self._dual_win is not None:
+            self._dual_win = self._dual_win / s_fac
+        self._fac_mag, self._fac_psd = None, None  # reset scaling factors
+        self._scaling = scaling
+
+    @property
+    def phase_shift(self) -> int | None:
+        """If set, add linear phase `phase_shift` / `mfft` * `f` to each FFT
+        slice of frequency `f`.
+
+        Shifting (more precisely `rolling`) an `mfft`-point FFT input by
+        `phase_shift` samples results in a multiplication of the output by
+        ``np.exp(2j*np.pi*q*phase_shift/mfft)`` at the frequency q * `delta_f`.
+
+        The default value 0 ensures that there is no phase shift on the
+        zeroth slice (in which t=0 is centered).
+        No phase shift (``phase_shift is None``) is equivalent to
+        ``phase_shift = -mfft//2``. In this case slices are not shifted
+        before calculating the FFT.
+
+        The absolute value of `phase_shift` is limited to be less than `mfft`.
+
+        See Also
+        --------
+        delta_f: Width of the frequency bins of the STFT.
+        f: Frequencies values of the STFT.
+        mfft: Length of input for the FFT used
+        ShortTimeFFT: Class this property belongs to.
+        """
+        return self._phase_shift
+
+    @phase_shift.setter
+    def phase_shift(self, v: int | None):
+        """The absolute value of the phase shift needs to be less than mfft
+        samples.
+
+        See the `phase_shift` getter method for more details.
+        """
+        if v is None:
+            self._phase_shift = v
+            return
+        if not isinstance(v, int):
+            raise ValueError(f"phase_shift={v} has the unit samples. Hence " +
+                             "it needs to be an int or it may be None!")
+        if not (-self.mfft < v < self.mfft):
+            raise ValueError("-mfft < phase_shift < mfft does not hold " +
+                             f"for mfft={self.mfft}, phase_shift={v}!")
+        self._phase_shift = v
+
+    def _x_slices(self, x: np.ndarray, k_off: int, p0: int, p1: int,
+                  padding: PAD_TYPE) -> Generator[np.ndarray, None, None]:
+        """Generate signal slices along last axis of `x`.
+
+        This method is only used by `stft_detrend`. The parameters are
+        described in `~ShortTimeFFT.stft`.
+        """
+        if padding not in (padding_types := get_args(PAD_TYPE)):
+            raise ValueError(f"Parameter {padding=} not in {padding_types}!")
+        pad_kws: dict[str, dict] = {  # possible keywords to pass to np.pad:
+            'zeros': dict(mode='constant', constant_values=(0, 0)),
+            'edge': dict(mode='edge'),
+            'even': dict(mode='reflect', reflect_type='even'),
+            'odd': dict(mode='reflect', reflect_type='odd'),
+           }  # typing of pad_kws is needed to make mypy happy
+
+        n, n1 = x.shape[-1], (p1 - p0) * self.hop
+        k0 = p0 * self.hop - self.m_num_mid + k_off  # start sample
+        k1 = k0 + n1 + self.m_num  # end sample
+
+        i0, i1 = max(k0, 0), min(k1, n)  # indexes to shorten x
+        # dimensions for padding x:
+        pad_width = [(0, 0)] * (x.ndim-1) + [(-min(k0, 0), max(k1 - n, 0))]
+
+        x1 = np.pad(x[..., i0:i1], pad_width, **pad_kws[padding])
+        for k_ in range(0, n1, self.hop):
+            yield x1[..., k_:k_ + self.m_num]
+
+    def stft(self, x: np.ndarray, p0: int | None = None,
+             p1: int | None = None, *, k_offset: int = 0,
+             padding: PAD_TYPE = 'zeros', axis: int = -1) \
+            -> np.ndarray:
+        """Perform the short-time Fourier transform.
+
+        A two-dimensional matrix with ``p1-p0`` columns is calculated.
+        The `f_pts` rows represent value at the frequencies `f`. The q-th
+        column of the windowed FFT with the window `win` is centered at t[q].
+        The columns represent the values at the frequencies `f`.
+
+        Parameters
+        ----------
+        x
+            The input signal as real or complex valued array. For complex values, the
+            property `fft_mode` must be set to 'twosided' or 'centered'.
+        p0
+            The first element of the range of slices to calculate. If ``None``
+            then it is set to :attr:`p_min`, which is the smallest possible
+            slice.
+        p1
+            The end of the array. If ``None`` then `p_max(n)` is used.
+        k_offset
+            Index of first sample (t = 0) in `x`.
+        padding
+            Kind of values which are added, when the sliding window sticks out
+            on either the lower or upper end of the input `x`. Zeros are added
+            if the default 'zeros' is set. For 'edge' either the first or the
+            last value of `x` is used. 'even' pads by reflecting the
+            signal on the first or last sample and 'odd' additionally
+            multiplies it with -1.
+        axis
+            The axis of `x` over which to compute the STFT.
+            If not given, the last axis is used.
+
+        Returns
+        -------
+        S
+            A complex array is returned with the dimension always being larger
+            by one than of `x`. The last axis always represent the time slices
+            of the STFT. `axis` defines the frequency axis (default second to
+            last). E.g., for a one-dimensional `x`, a complex 2d array is
+            returned, with axis 0 representing frequency and axis 1 the time
+            slices.
+
+        See Also
+        --------
+        delta_f: Width of the frequency bins of the STFT.
+        delta_t: Time increment of STFT
+        f: Frequencies values of the STFT.
+        invertible: Check if STFT is invertible.
+        :meth:`~ShortTimeFFT.istft`: Inverse short-time Fourier transform.
+        p_range: Determine and validate slice index range.
+        stft_detrend: STFT with detrended segments.
+        t: Times of STFT for an input signal with `n` samples.
+        :class:`scipy.signal.ShortTimeFFT`: Class this method belongs to.
+        """
+        return self.stft_detrend(x, None, p0, p1, k_offset=k_offset,
+                                 padding=padding, axis=axis)
+
+    def stft_detrend(self, x: np.ndarray,
+                     detr: Callable[[np.ndarray], np.ndarray] | Literal['linear', 'constant'] | None,  # noqa: E501
+                     p0: int | None = None, p1: int | None = None, *,
+                     k_offset: int = 0, padding: PAD_TYPE = 'zeros',
+                     axis: int = -1) \
+            -> np.ndarray:
+        """Short-time Fourier transform with a trend being subtracted from each
+        segment beforehand.
+
+        If `detr` is set to 'constant', the mean is subtracted, if set to
+        "linear", the linear trend is removed. This is achieved by calling
+        :func:`scipy.signal.detrend`. If `detr` is a function, `detr` is
+        applied to each segment.
+        All other parameters have the same meaning as in `~ShortTimeFFT.stft`.
+
+        Note that due to the detrending, the original signal cannot be
+        reconstructed by the `~ShortTimeFFT.istft`.
+
+        See Also
+        --------
+        invertible: Check if STFT is invertible.
+        :meth:`~ShortTimeFFT.istft`: Inverse short-time Fourier transform.
+        :meth:`~ShortTimeFFT.stft`: Short-time Fourier transform
+                                   (without detrending).
+        :class:`scipy.signal.ShortTimeFFT`: Class this method belongs to.
+        """
+        if self.onesided_fft and np.iscomplexobj(x):
+            raise ValueError(f"Complex-valued `x` not allowed for {self.fft_mode=}'! "
+                             "Set property `fft_mode` to 'twosided' or 'centered'.")
+        if isinstance(detr, str):
+            detr = partial(detrend, type=detr)
+        elif not (detr is None or callable(detr)):
+            raise ValueError(f"Parameter {detr=} is not a str, function or " +
+                             "None!")
+        n = x.shape[axis]
+        if not (n >= (m2p := self.m_num-self.m_num_mid)):
+            e_str = f'{len(x)=}' if x.ndim == 1 else f'of {axis=} of {x.shape}'
+            raise ValueError(f"{e_str} must be >= ceil(m_num/2) = {m2p}!")
+
+        if x.ndim > 1:  # motivated by the NumPy broadcasting mechanisms:
+            x = np.moveaxis(x, axis, -1)
+        # determine slice index range:
+        p0, p1 = self.p_range(n, p0, p1)
+        S_shape_1d = (self.f_pts, p1 - p0)
+        S_shape = x.shape[:-1] + S_shape_1d if x.ndim > 1 else S_shape_1d
+        S = np.zeros(S_shape, dtype=complex)
+        for p_, x_ in enumerate(self._x_slices(x, k_offset, p0, p1, padding)):
+            if detr is not None:
+                x_ = detr(x_)
+            S[..., :, p_] = self._fft_func(x_ * self.win.conj())
+        if x.ndim > 1:
+            return np.moveaxis(S, -2, axis if axis >= 0 else axis-1)
+        return S
+
+    def spectrogram(self, x: np.ndarray, y: np.ndarray | None = None,
+                    detr: Callable[[np.ndarray], np.ndarray] | Literal['linear', 'constant'] | None = None,  # noqa: E501
+                    *,
+                    p0: int | None = None, p1: int | None = None,
+                    k_offset: int = 0, padding: PAD_TYPE = 'zeros',
+                    axis: int = -1) \
+            -> np.ndarray:
+        r"""Calculate spectrogram or cross-spectrogram.
+
+        The spectrogram is the absolute square of the STFT, i.e, it is
+        ``abs(S[q,p])**2`` for given ``S[q,p]``  and thus is always
+        non-negative.
+        For two STFTs ``Sx[q,p], Sy[q,p]``, the cross-spectrogram is defined
+        as ``Sx[q,p] * np.conj(Sx[q,p])`` and is complex-valued.
+        This is a convenience function for calling `~ShortTimeFFT.stft` /
+        `stft_detrend`, hence all parameters are discussed there. If `y` is not
+        ``None`` it needs to have the same shape as `x`.
+
+        Examples
+        --------
+        The following example shows the spectrogram of a square wave with
+        varying frequency :math:`f_i(t)` (marked by a green dashed line in the
+        plot) sampled with 20 Hz:
+
+        >>> import matplotlib.pyplot as plt
+        >>> import numpy as np
+        >>> from scipy.signal import square, ShortTimeFFT
+        >>> from scipy.signal.windows import gaussian
+        ...
+        >>> T_x, N = 1 / 20, 1000  # 20 Hz sampling rate for 50 s signal
+        >>> t_x = np.arange(N) * T_x  # time indexes for signal
+        >>> f_i = 5e-3*(t_x - t_x[N // 3])**2 + 1  # varying frequency
+        >>> x = square(2*np.pi*np.cumsum(f_i)*T_x)  # the signal
+
+        The utitlized Gaussian window is 50 samples or 2.5 s long. The
+        parameter ``mfft=800`` (oversampling factor 16) and the `hop` interval
+        of 2 in `ShortTimeFFT` was chosen to produce a sufficient number of
+        points:
+
+        >>> g_std = 12  # standard deviation for Gaussian window in samples
+        >>> win = gaussian(50, std=g_std, sym=True)  # symmetric Gaussian wind.
+        >>> SFT = ShortTimeFFT(win, hop=2, fs=1/T_x, mfft=800, scale_to='psd')
+        >>> Sx2 = SFT.spectrogram(x)  # calculate absolute square of STFT
+
+        The plot's colormap is logarithmically scaled as the power spectral
+        density is in dB. The time extent of the signal `x` is marked by
+        vertical dashed lines and the shaded areas mark the presence of border
+        effects:
+
+        >>> fig1, ax1 = plt.subplots(figsize=(6., 4.))  # enlarge plot a bit
+        >>> t_lo, t_hi = SFT.extent(N)[:2]  # time range of plot
+        >>> ax1.set_title(rf"Spectrogram ({SFT.m_num*SFT.T:g}$\,s$ Gaussian " +
+        ...               rf"window, $\sigma_t={g_std*SFT.T:g}\,$s)")
+        >>> ax1.set(xlabel=f"Time $t$ in seconds ({SFT.p_num(N)} slices, " +
+        ...                rf"$\Delta t = {SFT.delta_t:g}\,$s)",
+        ...         ylabel=f"Freq. $f$ in Hz ({SFT.f_pts} bins, " +
+        ...                rf"$\Delta f = {SFT.delta_f:g}\,$Hz)",
+        ...         xlim=(t_lo, t_hi))
+        >>> Sx_dB = 10 * np.log10(np.fmax(Sx2, 1e-4))  # limit range to -40 dB
+        >>> im1 = ax1.imshow(Sx_dB, origin='lower', aspect='auto',
+        ...                  extent=SFT.extent(N), cmap='magma')
+        >>> ax1.plot(t_x, f_i, 'g--', alpha=.5, label='$f_i(t)$')
+        >>> fig1.colorbar(im1, label='Power Spectral Density ' +
+        ...                          r"$20\,\log_{10}|S_x(t, f)|$ in dB")
+        ...
+        >>> # Shade areas where window slices stick out to the side:
+        >>> for t0_, t1_ in [(t_lo, SFT.lower_border_end[0] * SFT.T),
+        ...                  (SFT.upper_border_begin(N)[0] * SFT.T, t_hi)]:
+        ...     ax1.axvspan(t0_, t1_, color='w', linewidth=0, alpha=.3)
+        >>> for t_ in [0, N * SFT.T]:  # mark signal borders with vertical line
+        ...     ax1.axvline(t_, color='c', linestyle='--', alpha=0.5)
+        >>> ax1.legend()
+        >>> fig1.tight_layout()
+        >>> plt.show()
+
+        The logarithmic scaling reveals the odd harmonics of the square wave,
+        which are reflected at the Nyquist frequency of 10 Hz. This aliasing
+        is also the main source of the noise artifacts in the plot.
+
+
+        See Also
+        --------
+        :meth:`~ShortTimeFFT.stft`: Perform the short-time Fourier transform.
+        stft_detrend: STFT with a trend subtracted from each segment.
+        :class:`scipy.signal.ShortTimeFFT`: Class this method belongs to.
+        """
+        Sx = self.stft_detrend(x, detr, p0, p1, k_offset=k_offset,
+                               padding=padding, axis=axis)
+        if y is None or y is x:  # do spectrogram:
+            return Sx.real**2 + Sx.imag**2
+        # Cross-spectrogram:
+        Sy = self.stft_detrend(y, detr, p0, p1, k_offset=k_offset,
+                               padding=padding, axis=axis)
+        return Sx * Sy.conj()
+
+    @property
+    def dual_win(self) -> np.ndarray:
+        """Canonical dual window.
+
+        A STFT can be interpreted as the input signal being expressed as a
+        weighted sum of modulated and time-shifted dual windows. Note that for
+        a given window there exist many dual windows. The canonical window is
+        the one with the minimal energy (i.e., :math:`L_2` norm).
+
+        `dual_win` has same length as `win`, namely `m_num` samples.
+
+        If the dual window cannot be calculated a ``ValueError`` is raised.
+        This attribute is read only and calculated lazily.
+
+        See Also
+        --------
+        dual_win: Canonical dual window.
+        m_num: Number of samples in window `win`.
+        win: Window function as real- or complex-valued 1d array.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        if self._dual_win is None:
+            self._dual_win = _calc_dual_canonical_window(self.win, self.hop)
+        return self._dual_win
+
+    @property
+    def invertible(self) -> bool:
+        """Check if STFT is invertible.
+
+        This is achieved by trying to calculate the canonical dual window.
+
+        See Also
+        --------
+        :meth:`~ShortTimeFFT.istft`: Inverse short-time Fourier transform.
+        m_num: Number of samples in window `win` and `dual_win`.
+        dual_win: Canonical dual window.
+        win: Window for STFT.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        try:
+            return len(self.dual_win) > 0  # call self.dual_win()
+        except ValueError:
+            return False
+
+    def istft(self, S: np.ndarray, k0: int = 0, k1: int | None = None, *,
+              f_axis: int = -2, t_axis: int = -1) \
+            -> np.ndarray:
+        """Inverse short-time Fourier transform.
+
+        It returns an array of dimension ``S.ndim - 1``  which is real
+        if `onesided_fft` is set, else complex. If the STFT is not
+        `invertible`, or the parameters are out of bounds  a ``ValueError`` is
+        raised.
+
+        Parameters
+        ----------
+        S
+            A complex valued array where `f_axis` denotes the frequency
+            values and the `t-axis` dimension the temporal values of the
+            STFT values.
+        k0, k1
+            The start and the end index of the reconstructed signal. The
+            default (``k0 = 0``, ``k1 = None``) assumes that the maximum length
+            signal should be reconstructed.
+        f_axis, t_axis
+            The axes in `S` denoting the frequency and the time dimension.
+
+        Notes
+        -----
+        It is required that `S` has `f_pts` entries along the `f_axis`. For
+        the `t_axis` it is assumed that the first entry corresponds to
+        `p_min` * `delta_t` (being <= 0). The length of `t_axis` needs to be
+        compatible with `k1`. I.e., ``S.shape[t_axis] >= self.p_max(k1)`` must
+        hold, if `k1` is not ``None``. Else `k1` is set to `k_max` with::
+
+            q_max = S.shape[t_range] + self.p_min
+            k_max = (q_max - 1) * self.hop + self.m_num - self.m_num_mid
+
+        The :ref:`tutorial_stft` section of the :ref:`user_guide` discussed the
+        slicing behavior by means of an example.
+
+        See Also
+        --------
+        invertible: Check if STFT is invertible.
+        :meth:`~ShortTimeFFT.stft`: Perform Short-time Fourier transform.
+        :class:`scipy.signal.ShortTimeFFT`: Class this method belongs to.
+        """
+        if f_axis == t_axis:
+            raise ValueError(f"{f_axis=} may not be equal to {t_axis=}!")
+        if S.shape[f_axis] != self.f_pts:
+            raise ValueError(f"{S.shape[f_axis]=} must be equal to " +
+                             f"{self.f_pts=} ({S.shape=})!")
+        n_min = self.m_num-self.m_num_mid  # minimum signal length
+        if not (S.shape[t_axis] >= (q_num := self.p_num(n_min))):
+            raise ValueError(f"{S.shape[t_axis]=} needs to have at least " +
+                             f"{q_num} slices ({S.shape=})!")
+        if t_axis != S.ndim - 1 or f_axis != S.ndim - 2:
+            t_axis = S.ndim + t_axis if t_axis < 0 else t_axis
+            f_axis = S.ndim + f_axis if f_axis < 0 else f_axis
+            S = np.moveaxis(S, (f_axis, t_axis), (-2, -1))
+
+        q_max = S.shape[-1] + self.p_min
+        k_max = (q_max - 1) * self.hop + self.m_num - self.m_num_mid
+
+        k1 = k_max if k1 is None else k1
+        if not (self.k_min <= k0 < k1 <= k_max):
+            raise ValueError(f"({self.k_min=}) <= ({k0=}) < ({k1=}) <= " +
+                             f"({k_max=}) is false!")
+        if not (num_pts := k1 - k0) >= n_min:
+            raise ValueError(f"({k1=}) - ({k0=}) = {num_pts} has to be at " +
+                             f"least the half the window length {n_min}!")
+
+        q0 = (k0 // self.hop + self.p_min if k0 >= 0 else  # p_min always <= 0
+              k0 // self.hop)
+        q1 = min(self.p_max(k1), q_max)
+        k_q0, k_q1 = self.nearest_k_p(k0), self.nearest_k_p(k1, left=False)
+        n_pts = k_q1 - k_q0 + self.m_num - self.m_num_mid
+        x = np.zeros(S.shape[:-2] + (n_pts,),
+                     dtype=float if self.onesided_fft else complex)
+        for q_ in range(q0, q1):
+            xs = self._ifft_func(S[..., :, q_ - self.p_min]) * self.dual_win
+            i0 = q_ * self.hop - self.m_num_mid
+            i1 = min(i0 + self.m_num, n_pts+k0)
+            j0, j1 = 0, i1 - i0
+            if i0 < k0:  # xs sticks out to the left on x:
+                j0 += k0 - i0
+                i0 = k0
+            x[..., i0-k0:i1-k0] += xs[..., j0:j1]
+        x = x[..., :k1-k0]
+        if x.ndim > 1:
+            x = np.moveaxis(x, -1, f_axis if f_axis < x.ndim else t_axis)
+        return x
+
+    @property
+    def fac_magnitude(self) -> float:
+        """Factor to multiply the STFT values by to scale each frequency slice
+        to a magnitude spectrum.
+
+        It is 1 if attribute ``scaling == 'magnitude'``.
+        The window can be scaled to a magnitude spectrum by using the method
+        `scale_to`.
+
+        See Also
+        --------
+        fac_psd: Scaling factor for to a power spectral density spectrum.
+        scale_to: Scale window to obtain 'magnitude' or 'psd' scaling.
+        scaling: Normalization applied to the window function.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        if self.scaling == 'magnitude':
+            return 1
+        if self._fac_mag is None:
+            self._fac_mag = 1 / abs(sum(self.win))
+        return self._fac_mag
+
+    @property
+    def fac_psd(self) -> float:
+        """Factor to multiply the STFT values by to scale each frequency slice
+        to a power spectral density (PSD).
+
+        It is 1 if attribute ``scaling == 'psd'``.
+        The window can be scaled to a psd spectrum by using the method
+        `scale_to`.
+
+        See Also
+        --------
+        fac_magnitude: Scaling factor for to a magnitude spectrum.
+        scale_to: Scale window to obtain 'magnitude' or 'psd' scaling.
+        scaling: Normalization applied to the window function.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        if self.scaling == 'psd':
+            return 1
+        if self._fac_psd is None:
+            self._fac_psd = 1 / np.sqrt(
+                sum(self.win.real**2+self.win.imag**2) / self.T)
+        return self._fac_psd
+
+    @property
+    def m_num(self) -> int:
+        """Number of samples in window `win`.
+
+        Note that the FFT can be oversampled by zero-padding. This is achieved
+        by setting the `mfft` property.
+
+        See Also
+        --------
+        m_num_mid: Center index of window `win`.
+        mfft: Length of input for the FFT used - may be larger than `m_num`.
+        hop: Time increment in signal samples for sliding window.
+        win: Window function as real- or complex-valued 1d array.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        return len(self.win)
+
+    @property
+    def m_num_mid(self) -> int:
+        """Center index of window `win`.
+
+        For odd `m_num`, ``(m_num - 1) / 2`` is returned and
+        for even `m_num` (per definition) ``m_num / 2`` is returned.
+
+        See Also
+        --------
+        m_num: Number of samples in window `win`.
+        mfft: Length of input for the FFT used - may be larger than `m_num`.
+        hop: ime increment in signal samples for sliding window.
+        win: Window function as real- or complex-valued 1d array.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        return self.m_num // 2
+
+    @cache
+    def _pre_padding(self) -> tuple[int, int]:
+        """Smallest signal index and slice index due to padding.
+
+         Since, per convention, for time t=0, n,q is zero, the returned values
+         are negative or zero.
+         """
+        w2 = self.win.real**2 + self.win.imag**2
+        # move window to the left until the overlap with t >= 0 vanishes:
+        n0 = -self.m_num_mid
+        for q_, n_ in enumerate(range(n0, n0-self.m_num-1, -self.hop)):
+            n_next = n_ - self.hop
+            if n_next + self.m_num <= 0 or all(w2[n_next:] == 0):
+                return n_, -q_
+        raise RuntimeError("This is code line should not have been reached!")
+        # If this case is reached, it probably means the first slice should be
+        # returned, i.e.: return n0, 0
+
+    @property
+    def k_min(self) -> int:
+        """The smallest possible signal index of the STFT.
+
+        `k_min` is the index of the left-most non-zero value of the lowest
+        slice `p_min`. Since the zeroth slice is centered over the zeroth
+        sample of the input signal, `k_min` is never positive.
+        A detailed example is provided in the :ref:`tutorial_stft_sliding_win`
+        section of the :ref:`user_guide`.
+
+        See Also
+        --------
+        k_max: First sample index after signal end not touched by a time slice.
+        lower_border_end: Where pre-padding effects end.
+        p_min: The smallest possible slice index.
+        p_max: Index of first non-overlapping upper time slice.
+        p_num: Number of time slices, i.e., `p_max` - `p_min`.
+        p_range: Determine and validate slice index range.
+        upper_border_begin: Where post-padding effects start.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        return self._pre_padding()[0]
+
+    @property
+    def p_min(self) -> int:
+        """The smallest possible slice index.
+
+        `p_min` is the index of the left-most slice, where the window still
+        sticks into the signal, i.e., has non-zero part for t >= 0.
+        `k_min` is the smallest index where the window function of the slice
+        `p_min` is non-zero.
+
+        Since, per convention the zeroth slice is centered at t=0,
+        `p_min` <= 0 always holds.
+        A detailed example is provided in the :ref:`tutorial_stft_sliding_win`
+        section of the :ref:`user_guide`.
+
+        See Also
+        --------
+        k_min: The smallest possible signal index.
+        k_max: First sample index after signal end not touched by a time slice.
+        p_max: Index of first non-overlapping upper time slice.
+        p_num: Number of time slices, i.e., `p_max` - `p_min`.
+        p_range: Determine and validate slice index range.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        return self._pre_padding()[1]
+
+    @lru_cache(maxsize=256)
+    def _post_padding(self, n: int) -> tuple[int, int]:
+        """Largest signal index and slice index due to padding."""
+        w2 = self.win.real**2 + self.win.imag**2
+        # move window to the right until the overlap for t < t[n] vanishes:
+        q1 = n // self.hop   # last slice index with t[p1] <= t[n]
+        k1 = q1 * self.hop - self.m_num_mid
+        for q_, k_ in enumerate(range(k1, n+self.m_num, self.hop), start=q1):
+            n_next = k_ + self.hop
+            if n_next >= n or all(w2[:n-n_next] == 0):
+                return k_ + self.m_num, q_ + 1
+        raise RuntimeError("This is code line should not have been reached!")
+        # If this case is reached, it probably means the last slice should be
+        # returned, i.e.: return k1 + self.m_num - self.m_num_mid, q1 + 1
+
+    def k_max(self, n: int) -> int:
+        """First sample index after signal end not touched by a time slice.
+
+        `k_max` - 1 is the largest sample index of the slice `p_max` for a
+        given input signal of `n` samples.
+        A detailed example is provided in the :ref:`tutorial_stft_sliding_win`
+        section of the :ref:`user_guide`.
+
+        See Also
+        --------
+        k_min: The smallest possible signal index.
+        p_min: The smallest possible slice index.
+        p_max: Index of first non-overlapping upper time slice.
+        p_num: Number of time slices, i.e., `p_max` - `p_min`.
+        p_range: Determine and validate slice index range.
+        ShortTimeFFT: Class this method belongs to.
+        """
+        return self._post_padding(n)[0]
+
+    def p_max(self, n: int) -> int:
+        """Index of first non-overlapping upper time slice for `n` sample
+        input.
+
+        Note that center point t[p_max] = (p_max(n)-1) * `delta_t` is typically
+        larger than last time index t[n-1] == (`n`-1) * `T`. The upper border
+        of samples indexes covered by the window slices is given by `k_max`.
+        Furthermore, `p_max` does not denote the number of slices `p_num` since
+        `p_min` is typically less than zero.
+        A detailed example is provided in the :ref:`tutorial_stft_sliding_win`
+        section of the :ref:`user_guide`.
+
+        See Also
+        --------
+        k_min: The smallest possible signal index.
+        k_max: First sample index after signal end not touched by a time slice.
+        p_min: The smallest possible slice index.
+        p_num: Number of time slices, i.e., `p_max` - `p_min`.
+        p_range: Determine and validate slice index range.
+        ShortTimeFFT: Class this method belongs to.
+        """
+        return self._post_padding(n)[1]
+
+    def p_num(self, n: int) -> int:
+        """Number of time slices for an input signal with `n` samples.
+
+        It is given by `p_num` = `p_max` - `p_min` with `p_min` typically
+        being negative.
+        A detailed example is provided in the :ref:`tutorial_stft_sliding_win`
+        section of the :ref:`user_guide`.
+
+        See Also
+        --------
+        k_min: The smallest possible signal index.
+        k_max: First sample index after signal end not touched by a time slice.
+        lower_border_end: Where pre-padding effects end.
+        p_min: The smallest possible slice index.
+        p_max: Index of first non-overlapping upper time slice.
+        p_range: Determine and validate slice index range.
+        upper_border_begin: Where post-padding effects start.
+        ShortTimeFFT: Class this method belongs to.
+        """
+        return self.p_max(n) - self.p_min
+
+    @property
+    def lower_border_end(self) -> tuple[int, int]:
+        """First signal index and first slice index unaffected by pre-padding.
+
+        Describes the point where the window does not stick out to the left
+        of the signal domain.
+        A detailed example is provided in the :ref:`tutorial_stft_sliding_win`
+        section of the :ref:`user_guide`.
+
+        See Also
+        --------
+        k_min: The smallest possible signal index.
+        k_max: First sample index after signal end not touched by a time slice.
+        lower_border_end: Where pre-padding effects end.
+        p_min: The smallest possible slice index.
+        p_max: Index of first non-overlapping upper time slice.
+        p_num: Number of time slices, i.e., `p_max` - `p_min`.
+        p_range: Determine and validate slice index range.
+        upper_border_begin: Where post-padding effects start.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        # not using @cache decorator due to MyPy limitations
+        if self._lower_border_end is not None:
+            return self._lower_border_end
+
+        # first non-zero element in self.win:
+        m0 = np.flatnonzero(self.win.real**2 + self.win.imag**2)[0]
+
+        # move window to the right until does not stick out to the left:
+        k0 = -self.m_num_mid + m0
+        for q_, k_ in enumerate(range(k0, self.hop + 1, self.hop)):
+            if k_ + self.hop >= 0:  # next entry does not stick out anymore
+                self._lower_border_end = (k_ + self.m_num, q_ + 1)
+                return self._lower_border_end
+        self._lower_border_end = (0, max(self.p_min, 0))  # ends at first slice
+        return self._lower_border_end
+
+    @lru_cache(maxsize=256)
+    def upper_border_begin(self, n: int) -> tuple[int, int]:
+        """First signal index and first slice index affected by post-padding.
+
+        Describes the point where the window does begin stick out to the right
+        of the signal domain.
+        A detailed example is given :ref:`tutorial_stft_sliding_win` section
+        of the :ref:`user_guide`.
+
+        See Also
+        --------
+        k_min: The smallest possible signal index.
+        k_max: First sample index after signal end not touched by a time slice.
+        lower_border_end: Where pre-padding effects end.
+        p_min: The smallest possible slice index.
+        p_max: Index of first non-overlapping upper time slice.
+        p_num: Number of time slices, i.e., `p_max` - `p_min`.
+        p_range: Determine and validate slice index range.
+        ShortTimeFFT: Class this method belongs to.
+        """
+        w2 = self.win.real**2 + self.win.imag**2
+        q2 = n // self.hop + 1  # first t[q] >= t[n]
+        q1 = max((n-self.m_num) // self.hop - 1, -1)
+        # move window left until does not stick out to the right:
+        for q_ in range(q2, q1, -1):
+            k_ = q_ * self.hop + (self.m_num - self.m_num_mid)
+            if k_ < n or all(w2[n-k_:] == 0):
+                return (q_ + 1) * self.hop - self.m_num_mid, q_ + 1
+        return 0, 0  # border starts at first slice
+
+    @property
+    def delta_t(self) -> float:
+        """Time increment of STFT.
+
+        The time increment `delta_t` = `T` * `hop` represents the sample
+        increment `hop` converted to time based on the sampling interval `T`.
+
+        See Also
+        --------
+        delta_f: Width of the frequency bins of the STFT.
+        hop: Hop size in signal samples for sliding window.
+        t: Times of STFT for an input signal with `n` samples.
+        T: Sampling interval of input signal and window `win`.
+        ShortTimeFFT: Class this property belongs to
+        """
+        return self.T * self.hop
+
+    def p_range(self, n: int, p0: int | None = None,
+                p1: int | None = None) -> tuple[int, int]:
+        """Determine and validate slice index range.
+
+        Parameters
+        ----------
+        n : int
+            Number of samples of input signal, assuming t[0] = 0.
+        p0 : int | None
+            First slice index. If 0 then the first slice is centered at t = 0.
+            If ``None`` then `p_min` is used. Note that p0 may be < 0 if
+            slices are left of t = 0.
+        p1 : int | None
+            End of interval (last value is p1-1).
+            If ``None`` then `p_max(n)` is used.
+
+
+        Returns
+        -------
+        p0_ : int
+            The fist slice index
+        p1_ : int
+            End of interval (last value is p1-1).
+
+        Notes
+        -----
+        A ``ValueError`` is raised if ``p_min <= p0 < p1 <= p_max(n)`` does not
+        hold.
+
+        See Also
+        --------
+        k_min: The smallest possible signal index.
+        k_max: First sample index after signal end not touched by a time slice.
+        lower_border_end: Where pre-padding effects end.
+        p_min: The smallest possible slice index.
+        p_max: Index of first non-overlapping upper time slice.
+        p_num: Number of time slices, i.e., `p_max` - `p_min`.
+        upper_border_begin: Where post-padding effects start.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        p_max = self.p_max(n)  # shorthand
+        p0_ = self.p_min if p0 is None else p0
+        p1_ = p_max if p1 is None else p1
+        if not (self.p_min <= p0_ < p1_ <= p_max):
+            raise ValueError(f"Invalid Parameter {p0=}, {p1=}, i.e., " +
+                             f"{self.p_min=} <= p0 < p1 <= {p_max=} " +
+                             f"does not hold for signal length {n=}!")
+        return p0_, p1_
+
+    @lru_cache(maxsize=1)
+    def t(self, n: int, p0: int | None = None, p1: int | None = None,
+          k_offset: int = 0) -> np.ndarray:
+        """Times of STFT for an input signal with `n` samples.
+
+        Returns a 1d array with times of the `~ShortTimeFFT.stft` values with
+        the same  parametrization. Note that the slices are
+        ``delta_t = hop * T`` time units apart.
+
+         Parameters
+        ----------
+        n
+            Number of sample of the input signal.
+        p0
+            The first element of the range of slices to calculate. If ``None``
+            then it is set to :attr:`p_min`, which is the smallest possible
+            slice.
+        p1
+            The end of the array. If ``None`` then `p_max(n)` is used.
+        k_offset
+            Index of first sample (t = 0) in `x`.
+
+
+        See Also
+        --------
+        delta_t: Time increment of STFT (``hop*T``)
+        hop: Time increment in signal samples for sliding window.
+        nearest_k_p: Nearest sample index k_p for which t[k_p] == t[p] holds.
+        T: Sampling interval of input signal and of the window (``1/fs``).
+        fs: Sampling frequency (being ``1/T``)
+        ShortTimeFFT: Class this method belongs to.
+        """
+        p0, p1 = self.p_range(n, p0, p1)
+        return np.arange(p0, p1) * self.delta_t + k_offset * self.T
+
+    def nearest_k_p(self, k: int, left: bool = True) -> int:
+        """Return nearest sample index k_p for which t[k_p] == t[p] holds.
+
+        The nearest next smaller time sample p (where t[p] is the center
+        position of the window of the p-th slice) is p_k = k // `hop`.
+        If `hop` is a divisor of `k` than `k` is returned.
+        If `left` is set than p_k * `hop` is returned else (p_k+1) * `hop`.
+
+        This method can be used to slice an input signal into chunks for
+        calculating the STFT and iSTFT incrementally.
+
+        See Also
+        --------
+        delta_t: Time increment of STFT (``hop*T``)
+        hop: Time increment in signal samples for sliding window.
+        T: Sampling interval of input signal and of the window (``1/fs``).
+        fs: Sampling frequency (being ``1/T``)
+        t: Times of STFT for an input signal with `n` samples.
+        ShortTimeFFT: Class this method belongs to.
+        """
+        p_q, remainder = divmod(k, self.hop)
+        if remainder == 0:
+            return k
+        return p_q * self.hop if left else (p_q + 1) * self.hop
+
+    @property
+    def delta_f(self) -> float:
+        """Width of the frequency bins of the STFT.
+
+        Return the frequency interval `delta_f` = 1 / (`mfft` * `T`).
+
+        See Also
+        --------
+        delta_t: Time increment of STFT.
+        f_pts: Number of points along the frequency axis.
+        f: Frequencies values of the STFT.
+        mfft: Length of the input for FFT used.
+        T: Sampling interval.
+        t: Times of STFT for an input signal with `n` samples.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        return 1 / (self.mfft * self.T)
+
+    @property
+    def f_pts(self) -> int:
+        """Number of points along the frequency axis.
+
+        See Also
+        --------
+        delta_f: Width of the frequency bins of the STFT.
+        f: Frequencies values of the STFT.
+        mfft: Length of the input for FFT used.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        return self.mfft // 2 + 1 if self.onesided_fft else self.mfft
+
+    @property
+    def onesided_fft(self) -> bool:
+        """Return True if a one-sided FFT is used.
+
+        Returns ``True`` if `fft_mode` is either 'onesided' or 'onesided2X'.
+
+        See Also
+        --------
+        fft_mode: Utilized FFT ('twosided', 'centered', 'onesided' or
+                 'onesided2X')
+        ShortTimeFFT: Class this property belongs to.
+        """
+        return self.fft_mode in {'onesided', 'onesided2X'}
+
+    @property
+    def f(self) -> np.ndarray:
+        """Frequencies values of the STFT.
+
+        A 1d array of length `f_pts` with `delta_f` spaced entries is returned.
+
+        See Also
+        --------
+        delta_f: Width of the frequency bins of the STFT.
+        f_pts: Number of points along the frequency axis.
+        mfft: Length of the input for FFT used.
+        ShortTimeFFT: Class this property belongs to.
+        """
+        if self.fft_mode in {'onesided', 'onesided2X'}:
+            return fft_lib.rfftfreq(self.mfft, self.T)
+        elif self.fft_mode == 'twosided':
+            return fft_lib.fftfreq(self.mfft, self.T)
+        elif self.fft_mode == 'centered':
+            return fft_lib.fftshift(fft_lib.fftfreq(self.mfft, self.T))
+        # This should never happen but makes the Linters happy:
+        fft_modes = get_args(FFT_MODE_TYPE)
+        raise RuntimeError(f"{self.fft_mode=} not in {fft_modes}!")
+
+    def _fft_func(self, x: np.ndarray) -> np.ndarray:
+        """FFT based on the `fft_mode`, `mfft`, `scaling` and `phase_shift`
+        attributes.
+
+        For multidimensional arrays the transformation is carried out on the
+        last axis.
+        """
+        if self.phase_shift is not None:
+            if x.shape[-1] < self.mfft:  # zero pad if needed
+                z_shape = list(x.shape)
+                z_shape[-1] = self.mfft - x.shape[-1]
+                x = np.hstack((x, np.zeros(z_shape, dtype=x.dtype)))
+            p_s = (self.phase_shift + self.m_num_mid) % self.m_num
+            x = np.roll(x, -p_s, axis=-1)
+
+        if self.fft_mode == 'twosided':
+            return fft_lib.fft(x, n=self.mfft, axis=-1)
+        if self.fft_mode == 'centered':
+            return fft_lib.fftshift(fft_lib.fft(x, self.mfft, axis=-1), axes=-1)
+        if self.fft_mode == 'onesided':
+            return fft_lib.rfft(x, n=self.mfft, axis=-1)
+        if self.fft_mode == 'onesided2X':
+            X = fft_lib.rfft(x, n=self.mfft, axis=-1)
+            # Either squared magnitude (psd) or magnitude is doubled:
+            fac = np.sqrt(2) if self.scaling == 'psd' else 2
+            # For even input length, the last entry is unpaired:
+            X[..., 1: -1 if self.mfft % 2 == 0 else None] *= fac
+            return X
+        # This should never happen but makes the Linter happy:
+        fft_modes = get_args(FFT_MODE_TYPE)
+        raise RuntimeError(f"{self.fft_mode=} not in {fft_modes}!")
+
+    def _ifft_func(self, X: np.ndarray) -> np.ndarray:
+        """Inverse to `_fft_func`.
+
+        Returned is an array of length `m_num`. If the FFT is `onesided`
+        then a float array is returned else a complex array is returned.
+        For multidimensional arrays the transformation is carried out on the
+        last axis.
+        """
+        if self.fft_mode == 'twosided':
+            x = fft_lib.ifft(X, n=self.mfft, axis=-1)
+        elif self.fft_mode == 'centered':
+            x = fft_lib.ifft(fft_lib.ifftshift(X, axes=-1), n=self.mfft, axis=-1)
+        elif self.fft_mode == 'onesided':
+            x = fft_lib.irfft(X, n=self.mfft, axis=-1)
+        elif self.fft_mode == 'onesided2X':
+            Xc = X.copy()  # we do not want to modify function parameters
+            fac = np.sqrt(2) if self.scaling == 'psd' else 2
+            # For even length X the last value is not paired with a negative
+            # value on the two-sided FFT:
+            q1 = -1 if self.mfft % 2 == 0 else None
+            Xc[..., 1:q1] /= fac
+            x = fft_lib.irfft(Xc, n=self.mfft, axis=-1)
+        else:  # This should never happen but makes the Linter happy:
+            error_str = f"{self.fft_mode=} not in {get_args(FFT_MODE_TYPE)}!"
+            raise RuntimeError(error_str)
+
+        if self.phase_shift is None:
+            return x[:self.m_num]
+        p_s = (self.phase_shift + self.m_num_mid) % self.m_num
+        return np.roll(x, p_s, axis=-1)[:self.m_num]
+
+    def extent(self, n: int, axes_seq: Literal['tf', 'ft'] = 'tf',
+               center_bins: bool = False) -> tuple[float, float, float, float]:
+        """Return minimum and maximum values time-frequency values.
+
+        A tuple with four floats  ``(t0, t1, f0, f1)`` for 'tf' and
+        ``(f0, f1, t0, t1)`` for 'ft' is returned describing the corners
+        of the time-frequency domain of the `~ShortTimeFFT.stft`.
+        That tuple can be passed to `matplotlib.pyplot.imshow` as a parameter
+        with the same name.
+
+        Parameters
+        ----------
+        n : int
+            Number of samples in input signal.
+        axes_seq : {'tf', 'ft'}
+            Return time extent first and then frequency extent or vice-versa.
+        center_bins: bool
+            If set (default ``False``), the values of the time slots and
+            frequency bins are moved from the side the middle. This is useful,
+            when plotting the `~ShortTimeFFT.stft` values as step functions,
+            i.e., with no interpolation.
+
+        See Also
+        --------
+        :func:`matplotlib.pyplot.imshow`: Display data as an image.
+        :class:`scipy.signal.ShortTimeFFT`: Class this method belongs to.
+        """
+        if axes_seq not in ('tf', 'ft'):
+            raise ValueError(f"Parameter {axes_seq=} not in ['tf', 'ft']!")
+
+        if self.onesided_fft:
+            q0, q1 = 0, self.f_pts
+        elif self.fft_mode == 'centered':
+            q0 = -self.mfft // 2
+            q1 = self.mfft // 2 - 1 if self.mfft % 2 == 0 else self.mfft // 2
+        else:
+            raise ValueError(f"Attribute fft_mode={self.fft_mode} must be " +
+                             "in ['centered', 'onesided', 'onesided2X']")
+
+        p0, p1 = self.p_min, self.p_max(n)  # shorthand
+        if center_bins:
+            t0, t1 = self.delta_t * (p0 - 0.5), self.delta_t * (p1 - 0.5)
+            f0, f1 = self.delta_f * (q0 - 0.5), self.delta_f * (q1 - 0.5)
+        else:
+            t0, t1 = self.delta_t * p0, self.delta_t * p1
+            f0, f1 = self.delta_f * q0, self.delta_f * q1
+        return (t0, t1, f0, f1) if axes_seq == 'tf' else (f0, f1, t0, t1)

env-llmeval/lib/python3.10/site-packages/scipy/signal/_spectral_py.py

@@ -0,0 +1,2101 @@
+"""Tools for spectral analysis.
+"""
+import numpy as np
+from scipy import fft as sp_fft
+from . import _signaltools
+from .windows import get_window
+from ._spectral import _lombscargle
+from ._arraytools import const_ext, even_ext, odd_ext, zero_ext
+import warnings
+
+
+__all__ = ['periodogram', 'welch', 'lombscargle', 'csd', 'coherence',
+           'spectrogram', 'stft', 'istft', 'check_COLA', 'check_NOLA']
+
+
+def lombscargle(x,
+                y,
+                freqs,
+                precenter=False,
+                normalize=False):
+    """
+    lombscargle(x, y, freqs)
+
+    Computes the Lomb-Scargle periodogram.
+
+    The Lomb-Scargle periodogram was developed by Lomb [1]_ and further
+    extended by Scargle [2]_ to find, and test the significance of weak
+    periodic signals with uneven temporal sampling.
+
+    When *normalize* is False (default) the computed periodogram
+    is unnormalized, it takes the value ``(A**2) * N/4`` for a harmonic
+    signal with amplitude A for sufficiently large N.
+
+    When *normalize* is True the computed periodogram is normalized by
+    the residuals of the data around a constant reference model (at zero).
+
+    Input arrays should be 1-D and will be cast to float64.
+
+    Parameters
+    ----------
+    x : array_like
+        Sample times.
+    y : array_like
+        Measurement values.
+    freqs : array_like
+        Angular frequencies for output periodogram.
+    precenter : bool, optional
+        Pre-center measurement values by subtracting the mean.
+    normalize : bool, optional
+        Compute normalized periodogram.
+
+    Returns
+    -------
+    pgram : array_like
+        Lomb-Scargle periodogram.
+
+    Raises
+    ------
+    ValueError
+        If the input arrays `x` and `y` do not have the same shape.
+
+    See Also
+    --------
+    istft: Inverse Short Time Fourier Transform
+    check_COLA: Check whether the Constant OverLap Add (COLA) constraint is met
+    welch: Power spectral density by Welch's method
+    spectrogram: Spectrogram by Welch's method
+    csd: Cross spectral density by Welch's method
+
+    Notes
+    -----
+    This subroutine calculates the periodogram using a slightly
+    modified algorithm due to Townsend [3]_ which allows the
+    periodogram to be calculated using only a single pass through
+    the input arrays for each frequency.
+
+    The algorithm running time scales roughly as O(x * freqs) or O(N^2)
+    for a large number of samples and frequencies.
+
+    References
+    ----------
+    .. [1] N.R. Lomb "Least-squares frequency analysis of unequally spaced
+           data", Astrophysics and Space Science, vol 39, pp. 447-462, 1976
+
+    .. [2] J.D. Scargle "Studies in astronomical time series analysis. II -
+           Statistical aspects of spectral analysis of unevenly spaced data",
+           The Astrophysical Journal, vol 263, pp. 835-853, 1982
+
+    .. [3] R.H.D. Townsend, "Fast calculation of the Lomb-Scargle
+           periodogram using graphics processing units.", The Astrophysical
+           Journal Supplement Series, vol 191, pp. 247-253, 2010
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> rng = np.random.default_rng()
+
+    First define some input parameters for the signal:
+
+    >>> A = 2.
+    >>> w0 = 1.  # rad/sec
+    >>> nin = 150
+    >>> nout = 100000
+
+    Randomly generate sample times:
+
+    >>> x = rng.uniform(0, 10*np.pi, nin)
+
+    Plot a sine wave for the selected times:
+
+    >>> y = A * np.cos(w0*x)
+
+    Define the array of frequencies for which to compute the periodogram:
+
+    >>> w = np.linspace(0.01, 10, nout)
+
+    Calculate Lomb-Scargle periodogram:
+
+    >>> import scipy.signal as signal
+    >>> pgram = signal.lombscargle(x, y, w, normalize=True)
+
+    Now make a plot of the input data:
+
+    >>> fig, (ax_t, ax_w) = plt.subplots(2, 1, constrained_layout=True)
+    >>> ax_t.plot(x, y, 'b+')
+    >>> ax_t.set_xlabel('Time [s]')
+
+    Then plot the normalized periodogram:
+
+    >>> ax_w.plot(w, pgram)
+    >>> ax_w.set_xlabel('Angular frequency [rad/s]')
+    >>> ax_w.set_ylabel('Normalized amplitude')
+    >>> plt.show()
+
+    """
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    freqs = np.ascontiguousarray(freqs, dtype=np.float64)
+
+    assert x.ndim == 1
+    assert y.ndim == 1
+    assert freqs.ndim == 1
+
+    if precenter:
+        pgram = _lombscargle(x, y - y.mean(), freqs)
+    else:
+        pgram = _lombscargle(x, y, freqs)
+
+    if normalize:
+        pgram *= 2 / np.dot(y, y)
+
+    return pgram
+
+
+def periodogram(x, fs=1.0, window='boxcar', nfft=None, detrend='constant',
+                return_onesided=True, scaling='density', axis=-1):
+    """
+    Estimate power spectral density using a periodogram.
+
+    Parameters
+    ----------
+    x : array_like
+        Time series of measurement values
+    fs : float, optional
+        Sampling frequency of the `x` time series. Defaults to 1.0.
+    window : str or tuple or array_like, optional
+        Desired window to use. If `window` is a string or tuple, it is
+        passed to `get_window` to generate the window values, which are
+        DFT-even by default. See `get_window` for a list of windows and
+        required parameters. If `window` is array_like it will be used
+        directly as the window and its length must be equal to the length
+        of the axis over which the periodogram is computed. Defaults
+        to 'boxcar'.
+    nfft : int, optional
+        Length of the FFT used. If `None` the length of `x` will be
+        used.
+    detrend : str or function or `False`, optional
+        Specifies how to detrend each segment. If `detrend` is a
+        string, it is passed as the `type` argument to the `detrend`
+        function. If it is a function, it takes a segment and returns a
+        detrended segment. If `detrend` is `False`, no detrending is
+        done. Defaults to 'constant'.
+    return_onesided : bool, optional
+        If `True`, return a one-sided spectrum for real data. If
+        `False` return a two-sided spectrum. Defaults to `True`, but for
+        complex data, a two-sided spectrum is always returned.
+    scaling : { 'density', 'spectrum' }, optional
+        Selects between computing the power spectral density ('density')
+        where `Pxx` has units of V**2/Hz and computing the squared magnitude
+        spectrum ('spectrum') where `Pxx` has units of V**2, if `x`
+        is measured in V and `fs` is measured in Hz. Defaults to
+        'density'
+    axis : int, optional
+        Axis along which the periodogram is computed; the default is
+        over the last axis (i.e. ``axis=-1``).
+
+    Returns
+    -------
+    f : ndarray
+        Array of sample frequencies.
+    Pxx : ndarray
+        Power spectral density or power spectrum of `x`.
+
+    See Also
+    --------
+    welch: Estimate power spectral density using Welch's method
+    lombscargle: Lomb-Scargle periodogram for unevenly sampled data
+
+    Notes
+    -----
+    Consult the :ref:`tutorial_SpectralAnalysis` section of the :ref:`user_guide`
+    for a discussion of the scalings of the power spectral density and
+    the magnitude (squared) spectrum.
+
+    .. versionadded:: 0.12.0
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy import signal
+    >>> import matplotlib.pyplot as plt
+    >>> rng = np.random.default_rng()
+
+    Generate a test signal, a 2 Vrms sine wave at 1234 Hz, corrupted by
+    0.001 V**2/Hz of white noise sampled at 10 kHz.
+
+    >>> fs = 10e3
+    >>> N = 1e5
+    >>> amp = 2*np.sqrt(2)
+    >>> freq = 1234.0
+    >>> noise_power = 0.001 * fs / 2
+    >>> time = np.arange(N) / fs
+    >>> x = amp*np.sin(2*np.pi*freq*time)
+    >>> x += rng.normal(scale=np.sqrt(noise_power), size=time.shape)
+
+    Compute and plot the power spectral density.
+
+    >>> f, Pxx_den = signal.periodogram(x, fs)
+    >>> plt.semilogy(f, Pxx_den)
+    >>> plt.ylim([1e-7, 1e2])
+    >>> plt.xlabel('frequency [Hz]')
+    >>> plt.ylabel('PSD [V**2/Hz]')
+    >>> plt.show()
+
+    If we average the last half of the spectral density, to exclude the
+    peak, we can recover the noise power on the signal.
+
+    >>> np.mean(Pxx_den[25000:])
+    0.000985320699252543
+
+    Now compute and plot the power spectrum.
+
+    >>> f, Pxx_spec = signal.periodogram(x, fs, 'flattop', scaling='spectrum')
+    >>> plt.figure()
+    >>> plt.semilogy(f, np.sqrt(Pxx_spec))
+    >>> plt.ylim([1e-4, 1e1])
+    >>> plt.xlabel('frequency [Hz]')
+    >>> plt.ylabel('Linear spectrum [V RMS]')
+    >>> plt.show()
+
+    The peak height in the power spectrum is an estimate of the RMS
+    amplitude.
+
+    >>> np.sqrt(Pxx_spec.max())
+    2.0077340678640727
+
+    """
+    x = np.asarray(x)
+
+    if x.size == 0:
+        return np.empty(x.shape), np.empty(x.shape)
+
+    if window is None:
+        window = 'boxcar'
+
+    if nfft is None:
+        nperseg = x.shape[axis]
+    elif nfft == x.shape[axis]:
+        nperseg = nfft
+    elif nfft > x.shape[axis]:
+        nperseg = x.shape[axis]
+    elif nfft < x.shape[axis]:
+        s = [np.s_[:]]*len(x.shape)
+        s[axis] = np.s_[:nfft]
+        x = x[tuple(s)]
+        nperseg = nfft
+        nfft = None
+
+    if hasattr(window, 'size'):
+        if window.size != nperseg:
+            raise ValueError('the size of the window must be the same size '
+                             'of the input on the specified axis')
+
+    return welch(x, fs=fs, window=window, nperseg=nperseg, noverlap=0,
+                 nfft=nfft, detrend=detrend, return_onesided=return_onesided,
+                 scaling=scaling, axis=axis)
+
+
+def welch(x, fs=1.0, window='hann', nperseg=None, noverlap=None, nfft=None,
+          detrend='constant', return_onesided=True, scaling='density',
+          axis=-1, average='mean'):
+    r"""
+    Estimate power spectral density using Welch's method.
+
+    Welch's method [1]_ computes an estimate of the power spectral
+    density by dividing the data into overlapping segments, computing a
+    modified periodogram for each segment and averaging the
+    periodograms.
+
+    Parameters
+    ----------
+    x : array_like
+        Time series of measurement values
+    fs : float, optional
+        Sampling frequency of the `x` time series. Defaults to 1.0.
+    window : str or tuple or array_like, optional
+        Desired window to use. If `window` is a string or tuple, it is
+        passed to `get_window` to generate the window values, which are
+        DFT-even by default. See `get_window` for a list of windows and
+        required parameters. If `window` is array_like it will be used
+        directly as the window and its length must be nperseg. Defaults
+        to a Hann window.
+    nperseg : int, optional
+        Length of each segment. Defaults to None, but if window is str or
+        tuple, is set to 256, and if window is array_like, is set to the
+        length of the window.
+    noverlap : int, optional
+        Number of points to overlap between segments. If `None`,
+        ``noverlap = nperseg // 2``. Defaults to `None`.
+    nfft : int, optional
+        Length of the FFT used, if a zero padded FFT is desired. If
+        `None`, the FFT length is `nperseg`. Defaults to `None`.
+    detrend : str or function or `False`, optional
+        Specifies how to detrend each segment. If `detrend` is a
+        string, it is passed as the `type` argument to the `detrend`
+        function. If it is a function, it takes a segment and returns a
+        detrended segment. If `detrend` is `False`, no detrending is
+        done. Defaults to 'constant'.
+    return_onesided : bool, optional
+        If `True`, return a one-sided spectrum for real data. If
+        `False` return a two-sided spectrum. Defaults to `True`, but for
+        complex data, a two-sided spectrum is always returned.
+    scaling : { 'density', 'spectrum' }, optional
+        Selects between computing the power spectral density ('density')
+        where `Pxx` has units of V**2/Hz and computing the squared magnitude
+        spectrum ('spectrum') where `Pxx` has units of V**2, if `x`
+        is measured in V and `fs` is measured in Hz. Defaults to
+        'density'
+    axis : int, optional
+        Axis along which the periodogram is computed; the default is
+        over the last axis (i.e. ``axis=-1``).
+    average : { 'mean', 'median' }, optional
+        Method to use when averaging periodograms. Defaults to 'mean'.
+
+        .. versionadded:: 1.2.0
+
+    Returns
+    -------
+    f : ndarray
+        Array of sample frequencies.
+    Pxx : ndarray
+        Power spectral density or power spectrum of x.
+
+    See Also
+    --------
+    periodogram: Simple, optionally modified periodogram
+    lombscargle: Lomb-Scargle periodogram for unevenly sampled data
+
+    Notes
+    -----
+    An appropriate amount of overlap will depend on the choice of window
+    and on your requirements. For the default Hann window an overlap of
+    50% is a reasonable trade off between accurately estimating the
+    signal power, while not over counting any of the data. Narrower
+    windows may require a larger overlap.
+
+    If `noverlap` is 0, this method is equivalent to Bartlett's method
+    [2]_.
+
+    Consult the :ref:`tutorial_SpectralAnalysis` section of the :ref:`user_guide`
+    for a discussion of the scalings of the power spectral density and
+    the (squared) magnitude spectrum.
+
+    .. versionadded:: 0.12.0
+
+    References
+    ----------
+    .. [1] P. Welch, "The use of the fast Fourier transform for the
+           estimation of power spectra: A method based on time averaging
+           over short, modified periodograms", IEEE Trans. Audio
+           Electroacoust. vol. 15, pp. 70-73, 1967.
+    .. [2] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra",
+           Biometrika, vol. 37, pp. 1-16, 1950.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy import signal
+    >>> import matplotlib.pyplot as plt
+    >>> rng = np.random.default_rng()
+
+    Generate a test signal, a 2 Vrms sine wave at 1234 Hz, corrupted by
+    0.001 V**2/Hz of white noise sampled at 10 kHz.
+
+    >>> fs = 10e3
+    >>> N = 1e5
+    >>> amp = 2*np.sqrt(2)
+    >>> freq = 1234.0
+    >>> noise_power = 0.001 * fs / 2
+    >>> time = np.arange(N) / fs
+    >>> x = amp*np.sin(2*np.pi*freq*time)
+    >>> x += rng.normal(scale=np.sqrt(noise_power), size=time.shape)
+
+    Compute and plot the power spectral density.
+
+    >>> f, Pxx_den = signal.welch(x, fs, nperseg=1024)
+    >>> plt.semilogy(f, Pxx_den)
+    >>> plt.ylim([0.5e-3, 1])
+    >>> plt.xlabel('frequency [Hz]')
+    >>> plt.ylabel('PSD [V**2/Hz]')
+    >>> plt.show()
+
+    If we average the last half of the spectral density, to exclude the
+    peak, we can recover the noise power on the signal.
+
+    >>> np.mean(Pxx_den[256:])
+    0.0009924865443739191
+
+    Now compute and plot the power spectrum.
+
+    >>> f, Pxx_spec = signal.welch(x, fs, 'flattop', 1024, scaling='spectrum')
+    >>> plt.figure()
+    >>> plt.semilogy(f, np.sqrt(Pxx_spec))
+    >>> plt.xlabel('frequency [Hz]')
+    >>> plt.ylabel('Linear spectrum [V RMS]')
+    >>> plt.show()
+
+    The peak height in the power spectrum is an estimate of the RMS
+    amplitude.
+
+    >>> np.sqrt(Pxx_spec.max())
+    2.0077340678640727
+
+    If we now introduce a discontinuity in the signal, by increasing the
+    amplitude of a small portion of the signal by 50, we can see the
+    corruption of the mean average power spectral density, but using a
+    median average better estimates the normal behaviour.
+
+    >>> x[int(N//2):int(N//2)+10] *= 50.
+    >>> f, Pxx_den = signal.welch(x, fs, nperseg=1024)
+    >>> f_med, Pxx_den_med = signal.welch(x, fs, nperseg=1024, average='median')
+    >>> plt.semilogy(f, Pxx_den, label='mean')
+    >>> plt.semilogy(f_med, Pxx_den_med, label='median')
+    >>> plt.ylim([0.5e-3, 1])
+    >>> plt.xlabel('frequency [Hz]')
+    >>> plt.ylabel('PSD [V**2/Hz]')
+    >>> plt.legend()
+    >>> plt.show()
+
+    """
+    freqs, Pxx = csd(x, x, fs=fs, window=window, nperseg=nperseg,
+                     noverlap=noverlap, nfft=nfft, detrend=detrend,
+                     return_onesided=return_onesided, scaling=scaling,
+                     axis=axis, average=average)
+
+    return freqs, Pxx.real
+
+
+def csd(x, y, fs=1.0, window='hann', nperseg=None, noverlap=None, nfft=None,
+        detrend='constant', return_onesided=True, scaling='density',
+        axis=-1, average='mean'):
+    r"""
+    Estimate the cross power spectral density, Pxy, using Welch's method.
+
+    Parameters
+    ----------
+    x : array_like
+        Time series of measurement values
+    y : array_like
+        Time series of measurement values
+    fs : float, optional
+        Sampling frequency of the `x` and `y` time series. Defaults
+        to 1.0.
+    window : str or tuple or array_like, optional
+        Desired window to use. If `window` is a string or tuple, it is
+        passed to `get_window` to generate the window values, which are
+        DFT-even by default. See `get_window` for a list of windows and
+        required parameters. If `window` is array_like it will be used
+        directly as the window and its length must be nperseg. Defaults
+        to a Hann window.
+    nperseg : int, optional
+        Length of each segment. Defaults to None, but if window is str or
+        tuple, is set to 256, and if window is array_like, is set to the
+        length of the window.
+    noverlap: int, optional
+        Number of points to overlap between segments. If `None`,
+        ``noverlap = nperseg // 2``. Defaults to `None`.
+    nfft : int, optional
+        Length of the FFT used, if a zero padded FFT is desired. If
+        `None`, the FFT length is `nperseg`. Defaults to `None`.
+    detrend : str or function or `False`, optional
+        Specifies how to detrend each segment. If `detrend` is a
+        string, it is passed as the `type` argument to the `detrend`
+        function. If it is a function, it takes a segment and returns a
+        detrended segment. If `detrend` is `False`, no detrending is
+        done. Defaults to 'constant'.
+    return_onesided : bool, optional
+        If `True`, return a one-sided spectrum for real data. If
+        `False` return a two-sided spectrum. Defaults to `True`, but for
+        complex data, a two-sided spectrum is always returned.
+    scaling : { 'density', 'spectrum' }, optional
+        Selects between computing the cross spectral density ('density')
+        where `Pxy` has units of V**2/Hz and computing the cross spectrum
+        ('spectrum') where `Pxy` has units of V**2, if `x` and `y` are
+        measured in V and `fs` is measured in Hz. Defaults to 'density'
+    axis : int, optional
+        Axis along which the CSD is computed for both inputs; the
+        default is over the last axis (i.e. ``axis=-1``).
+    average : { 'mean', 'median' }, optional
+        Method to use when averaging periodograms. If the spectrum is
+        complex, the average is computed separately for the real and
+        imaginary parts. Defaults to 'mean'.
+
+        .. versionadded:: 1.2.0
+
+    Returns
+    -------
+    f : ndarray
+        Array of sample frequencies.
+    Pxy : ndarray
+        Cross spectral density or cross power spectrum of x,y.
+
+    See Also
+    --------
+    periodogram: Simple, optionally modified periodogram
+    lombscargle: Lomb-Scargle periodogram for unevenly sampled data
+    welch: Power spectral density by Welch's method. [Equivalent to
+           csd(x,x)]
+    coherence: Magnitude squared coherence by Welch's method.
+
+    Notes
+    -----
+    By convention, Pxy is computed with the conjugate FFT of X
+    multiplied by the FFT of Y.
+
+    If the input series differ in length, the shorter series will be
+    zero-padded to match.
+
+    An appropriate amount of overlap will depend on the choice of window
+    and on your requirements. For the default Hann window an overlap of
+    50% is a reasonable trade off between accurately estimating the
+    signal power, while not over counting any of the data. Narrower
+    windows may require a larger overlap.
+
+    Consult the :ref:`tutorial_SpectralAnalysis` section of the :ref:`user_guide`
+    for a discussion of the scalings of a spectral density and an (amplitude) spectrum.
+
+    .. versionadded:: 0.16.0
+
+    References
+    ----------
+    .. [1] P. Welch, "The use of the fast Fourier transform for the
+           estimation of power spectra: A method based on time averaging
+           over short, modified periodograms", IEEE Trans. Audio
+           Electroacoust. vol. 15, pp. 70-73, 1967.
+    .. [2] Rabiner, Lawrence R., and B. Gold. "Theory and Application of
+           Digital Signal Processing" Prentice-Hall, pp. 414-419, 1975
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy import signal
+    >>> import matplotlib.pyplot as plt
+    >>> rng = np.random.default_rng()
+
+    Generate two test signals with some common features.
+
+    >>> fs = 10e3
+    >>> N = 1e5
+    >>> amp = 20
+    >>> freq = 1234.0
+    >>> noise_power = 0.001 * fs / 2
+    >>> time = np.arange(N) / fs
+    >>> b, a = signal.butter(2, 0.25, 'low')
+    >>> x = rng.normal(scale=np.sqrt(noise_power), size=time.shape)
+    >>> y = signal.lfilter(b, a, x)
+    >>> x += amp*np.sin(2*np.pi*freq*time)
+    >>> y += rng.normal(scale=0.1*np.sqrt(noise_power), size=time.shape)
+
+    Compute and plot the magnitude of the cross spectral density.
+
+    >>> f, Pxy = signal.csd(x, y, fs, nperseg=1024)
+    >>> plt.semilogy(f, np.abs(Pxy))
+    >>> plt.xlabel('frequency [Hz]')
+    >>> plt.ylabel('CSD [V**2/Hz]')
+    >>> plt.show()
+
+    """
+    freqs, _, Pxy = _spectral_helper(x, y, fs, window, nperseg, noverlap,
+                                     nfft, detrend, return_onesided, scaling,
+                                     axis, mode='psd')
+
+    # Average over windows.
+    if len(Pxy.shape) >= 2 and Pxy.size > 0:
+        if Pxy.shape[-1] > 1:
+            if average == 'median':
+                # np.median must be passed real arrays for the desired result
+                bias = _median_bias(Pxy.shape[-1])
+                if np.iscomplexobj(Pxy):
+                    Pxy = (np.median(np.real(Pxy), axis=-1)
+                           + 1j * np.median(np.imag(Pxy), axis=-1))
+                else:
+                    Pxy = np.median(Pxy, axis=-1)
+                Pxy /= bias
+            elif average == 'mean':
+                Pxy = Pxy.mean(axis=-1)
+            else:
+                raise ValueError(f'average must be "median" or "mean", got {average}')
+        else:
+            Pxy = np.reshape(Pxy, Pxy.shape[:-1])
+
+    return freqs, Pxy
+
+
+def spectrogram(x, fs=1.0, window=('tukey', .25), nperseg=None, noverlap=None,
+                nfft=None, detrend='constant', return_onesided=True,
+                scaling='density', axis=-1, mode='psd'):
+    """Compute a spectrogram with consecutive Fourier transforms (legacy function).
+
+    Spectrograms can be used as a way of visualizing the change of a
+    nonstationary signal's frequency content over time.
+
+    .. legacy:: function
+
+        :class:`ShortTimeFFT` is a newer STFT / ISTFT implementation with more
+        features also including a :meth:`~ShortTimeFFT.spectrogram` method.
+        A :ref:`comparison <tutorial_stft_legacy_stft>` between the
+        implementations can be found in the :ref:`tutorial_stft` section of
+        the :ref:`user_guide`.
+
+    Parameters
+    ----------
+    x : array_like
+        Time series of measurement values
+    fs : float, optional
+        Sampling frequency of the `x` time series. Defaults to 1.0.
+    window : str or tuple or array_like, optional
+        Desired window to use. If `window` is a string or tuple, it is
+        passed to `get_window` to generate the window values, which are
+        DFT-even by default. See `get_window` for a list of windows and
+        required parameters. If `window` is array_like it will be used
+        directly as the window and its length must be nperseg.
+        Defaults to a Tukey window with shape parameter of 0.25.
+    nperseg : int, optional
+        Length of each segment. Defaults to None, but if window is str or
+        tuple, is set to 256, and if window is array_like, is set to the
+        length of the window.
+    noverlap : int, optional
+        Number of points to overlap between segments. If `None`,
+        ``noverlap = nperseg // 8``. Defaults to `None`.
+    nfft : int, optional
+        Length of the FFT used, if a zero padded FFT is desired. If
+        `None`, the FFT length is `nperseg`. Defaults to `None`.
+    detrend : str or function or `False`, optional
+        Specifies how to detrend each segment. If `detrend` is a
+        string, it is passed as the `type` argument to the `detrend`
+        function. If it is a function, it takes a segment and returns a
+        detrended segment. If `detrend` is `False`, no detrending is
+        done. Defaults to 'constant'.
+    return_onesided : bool, optional
+        If `True`, return a one-sided spectrum for real data. If
+        `False` return a two-sided spectrum. Defaults to `True`, but for
+        complex data, a two-sided spectrum is always returned.
+    scaling : { 'density', 'spectrum' }, optional
+        Selects between computing the power spectral density ('density')
+        where `Sxx` has units of V**2/Hz and computing the power
+        spectrum ('spectrum') where `Sxx` has units of V**2, if `x`
+        is measured in V and `fs` is measured in Hz. Defaults to
+        'density'.
+    axis : int, optional
+        Axis along which the spectrogram is computed; the default is over
+        the last axis (i.e. ``axis=-1``).
+    mode : str, optional
+        Defines what kind of return values are expected. Options are
+        ['psd', 'complex', 'magnitude', 'angle', 'phase']. 'complex' is
+        equivalent to the output of `stft` with no padding or boundary
+        extension. 'magnitude' returns the absolute magnitude of the
+        STFT. 'angle' and 'phase' return the complex angle of the STFT,
+        with and without unwrapping, respectively.
+
+    Returns
+    -------
+    f : ndarray
+        Array of sample frequencies.
+    t : ndarray
+        Array of segment times.
+    Sxx : ndarray
+        Spectrogram of x. By default, the last axis of Sxx corresponds
+        to the segment times.
+
+    See Also
+    --------
+    periodogram: Simple, optionally modified periodogram
+    lombscargle: Lomb-Scargle periodogram for unevenly sampled data
+    welch: Power spectral density by Welch's method.
+    csd: Cross spectral density by Welch's method.
+    ShortTimeFFT: Newer STFT/ISTFT implementation providing more features,
+                  which also includes a :meth:`~ShortTimeFFT.spectrogram`
+                  method.
+
+    Notes
+    -----
+    An appropriate amount of overlap will depend on the choice of window
+    and on your requirements. In contrast to welch's method, where the
+    entire data stream is averaged over, one may wish to use a smaller
+    overlap (or perhaps none at all) when computing a spectrogram, to
+    maintain some statistical independence between individual segments.
+    It is for this reason that the default window is a Tukey window with
+    1/8th of a window's length overlap at each end.
+
+
+    .. versionadded:: 0.16.0
+
+    References
+    ----------
+    .. [1] Oppenheim, Alan V., Ronald W. Schafer, John R. Buck
+           "Discrete-Time Signal Processing", Prentice Hall, 1999.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy import signal
+    >>> from scipy.fft import fftshift
+    >>> import matplotlib.pyplot as plt
+    >>> rng = np.random.default_rng()
+
+    Generate a test signal, a 2 Vrms sine wave whose frequency is slowly
+    modulated around 3kHz, corrupted by white noise of exponentially
+    decreasing magnitude sampled at 10 kHz.
+
+    >>> fs = 10e3
+    >>> N = 1e5
+    >>> amp = 2 * np.sqrt(2)
+    >>> noise_power = 0.01 * fs / 2
+    >>> time = np.arange(N) / float(fs)
+    >>> mod = 500*np.cos(2*np.pi*0.25*time)
+    >>> carrier = amp * np.sin(2*np.pi*3e3*time + mod)
+    >>> noise = rng.normal(scale=np.sqrt(noise_power), size=time.shape)
+    >>> noise *= np.exp(-time/5)
+    >>> x = carrier + noise
+
+    Compute and plot the spectrogram.
+
+    >>> f, t, Sxx = signal.spectrogram(x, fs)
+    >>> plt.pcolormesh(t, f, Sxx, shading='gouraud')
+    >>> plt.ylabel('Frequency [Hz]')
+    >>> plt.xlabel('Time [sec]')
+    >>> plt.show()
+
+    Note, if using output that is not one sided, then use the following:
+
+    >>> f, t, Sxx = signal.spectrogram(x, fs, return_onesided=False)
+    >>> plt.pcolormesh(t, fftshift(f), fftshift(Sxx, axes=0), shading='gouraud')
+    >>> plt.ylabel('Frequency [Hz]')
+    >>> plt.xlabel('Time [sec]')
+    >>> plt.show()
+
+    """
+    modelist = ['psd', 'complex', 'magnitude', 'angle', 'phase']
+    if mode not in modelist:
+        raise ValueError(f'unknown value for mode {mode}, must be one of {modelist}')
+
+    # need to set default for nperseg before setting default for noverlap below
+    window, nperseg = _triage_segments(window, nperseg,
+                                       input_length=x.shape[axis])
+
+    # Less overlap than welch, so samples are more statisically independent
+    if noverlap is None:
+        noverlap = nperseg // 8
+
+    if mode == 'psd':
+        freqs, time, Sxx = _spectral_helper(x, x, fs, window, nperseg,
+                                            noverlap, nfft, detrend,
+                                            return_onesided, scaling, axis,
+                                            mode='psd')
+
+    else:
+        freqs, time, Sxx = _spectral_helper(x, x, fs, window, nperseg,
+                                            noverlap, nfft, detrend,
+                                            return_onesided, scaling, axis,
+                                            mode='stft')
+
+        if mode == 'magnitude':
+            Sxx = np.abs(Sxx)
+        elif mode in ['angle', 'phase']:
+            Sxx = np.angle(Sxx)
+            if mode == 'phase':
+                # Sxx has one additional dimension for time strides
+                if axis < 0:
+                    axis -= 1
+                Sxx = np.unwrap(Sxx, axis=axis)
+
+        # mode =='complex' is same as `stft`, doesn't need modification
+
+    return freqs, time, Sxx
+
+
+def check_COLA(window, nperseg, noverlap, tol=1e-10):
+    r"""Check whether the Constant OverLap Add (COLA) constraint is met.
+
+    Parameters
+    ----------
+    window : str or tuple or array_like
+        Desired window to use. If `window` is a string or tuple, it is
+        passed to `get_window` to generate the window values, which are
+        DFT-even by default. See `get_window` for a list of windows and
+        required parameters. If `window` is array_like it will be used
+        directly as the window and its length must be nperseg.
+    nperseg : int
+        Length of each segment.
+    noverlap : int
+        Number of points to overlap between segments.
+    tol : float, optional
+        The allowed variance of a bin's weighted sum from the median bin
+        sum.
+
+    Returns
+    -------
+    verdict : bool
+        `True` if chosen combination satisfies COLA within `tol`,
+        `False` otherwise
+
+    See Also
+    --------
+    check_NOLA: Check whether the Nonzero Overlap Add (NOLA) constraint is met
+    stft: Short Time Fourier Transform
+    istft: Inverse Short Time Fourier Transform
+
+    Notes
+    -----
+    In order to enable inversion of an STFT via the inverse STFT in
+    `istft`, it is sufficient that the signal windowing obeys the constraint of
+    "Constant OverLap Add" (COLA). This ensures that every point in the input
+    data is equally weighted, thereby avoiding aliasing and allowing full
+    reconstruction.
+
+    Some examples of windows that satisfy COLA:
+        - Rectangular window at overlap of 0, 1/2, 2/3, 3/4, ...
+        - Bartlett window at overlap of 1/2, 3/4, 5/6, ...
+        - Hann window at 1/2, 2/3, 3/4, ...
+        - Any Blackman family window at 2/3 overlap
+        - Any window with ``noverlap = nperseg-1``
+
+    A very comprehensive list of other windows may be found in [2]_,
+    wherein the COLA condition is satisfied when the "Amplitude
+    Flatness" is unity.
+
+    .. versionadded:: 0.19.0
+
+    References
+    ----------
+    .. [1] Julius O. Smith III, "Spectral Audio Signal Processing", W3K
+           Publishing, 2011,ISBN 978-0-9745607-3-1.
+    .. [2] G. Heinzel, A. Ruediger and R. Schilling, "Spectrum and
+           spectral density estimation by the Discrete Fourier transform
+           (DFT), including a comprehensive list of window functions and
+           some new at-top windows", 2002,
+           http://hdl.handle.net/11858/00-001M-0000-0013-557A-5
+
+    Examples
+    --------
+    >>> from scipy import signal
+
+    Confirm COLA condition for rectangular window of 75% (3/4) overlap:
+
+    >>> signal.check_COLA(signal.windows.boxcar(100), 100, 75)
+    True
+
+    COLA is not true for 25% (1/4) overlap, though:
+
+    >>> signal.check_COLA(signal.windows.boxcar(100), 100, 25)
+    False
+
+    "Symmetrical" Hann window (for filter design) is not COLA:
+
+    >>> signal.check_COLA(signal.windows.hann(120, sym=True), 120, 60)
+    False
+
+    "Periodic" or "DFT-even" Hann window (for FFT analysis) is COLA for
+    overlap of 1/2, 2/3, 3/4, etc.:
+
+    >>> signal.check_COLA(signal.windows.hann(120, sym=False), 120, 60)
+    True
+
+    >>> signal.check_COLA(signal.windows.hann(120, sym=False), 120, 80)
+    True
+
+    >>> signal.check_COLA(signal.windows.hann(120, sym=False), 120, 90)
+    True
+
+    """
+    nperseg = int(nperseg)
+
+    if nperseg < 1:
+        raise ValueError('nperseg must be a positive integer')
+
+    if noverlap >= nperseg:
+        raise ValueError('noverlap must be less than nperseg.')
+    noverlap = int(noverlap)
+
+    if isinstance(window, str) or type(window) is tuple:
+        win = get_window(window, nperseg)
+    else:
+        win = np.asarray(window)
+        if len(win.shape) != 1:
+            raise ValueError('window must be 1-D')
+        if win.shape[0] != nperseg:
+            raise ValueError('window must have length of nperseg')
+
+    step = nperseg - noverlap
+    binsums = sum(win[ii*step:(ii+1)*step] for ii in range(nperseg//step))
+
+    if nperseg % step != 0:
+        binsums[:nperseg % step] += win[-(nperseg % step):]
+
+    deviation = binsums - np.median(binsums)
+    return np.max(np.abs(deviation)) < tol
+
+
+def check_NOLA(window, nperseg, noverlap, tol=1e-10):
+    r"""Check whether the Nonzero Overlap Add (NOLA) constraint is met.
+
+    Parameters
+    ----------
+    window : str or tuple or array_like
+        Desired window to use. If `window` is a string or tuple, it is
+        passed to `get_window` to generate the window values, which are
+        DFT-even by default. See `get_window` for a list of windows and
+        required parameters. If `window` is array_like it will be used
+        directly as the window and its length must be nperseg.
+    nperseg : int
+        Length of each segment.
+    noverlap : int
+        Number of points to overlap between segments.
+    tol : float, optional
+        The allowed variance of a bin's weighted sum from the median bin
+        sum.
+
+    Returns
+    -------
+    verdict : bool
+        `True` if chosen combination satisfies the NOLA constraint within
+        `tol`, `False` otherwise
+
+    See Also
+    --------
+    check_COLA: Check whether the Constant OverLap Add (COLA) constraint is met
+    stft: Short Time Fourier Transform
+    istft: Inverse Short Time Fourier Transform
+
+    Notes
+    -----
+    In order to enable inversion of an STFT via the inverse STFT in
+    `istft`, the signal windowing must obey the constraint of "nonzero
+    overlap add" (NOLA):
+
+    .. math:: \sum_{t}w^{2}[n-tH] \ne 0
+
+    for all :math:`n`, where :math:`w` is the window function, :math:`t` is the
+    frame index, and :math:`H` is the hop size (:math:`H` = `nperseg` -
+    `noverlap`).
+
+    This ensures that the normalization factors in the denominator of the
+    overlap-add inversion equation are not zero. Only very pathological windows
+    will fail the NOLA constraint.
+
+    .. versionadded:: 1.2.0
+
+    References
+    ----------
+    .. [1] Julius O. Smith III, "Spectral Audio Signal Processing", W3K
+           Publishing, 2011,ISBN 978-0-9745607-3-1.
+    .. [2] G. Heinzel, A. Ruediger and R. Schilling, "Spectrum and
+           spectral density estimation by the Discrete Fourier transform
+           (DFT), including a comprehensive list of window functions and
+           some new at-top windows", 2002,
+           http://hdl.handle.net/11858/00-001M-0000-0013-557A-5
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy import signal
+
+    Confirm NOLA condition for rectangular window of 75% (3/4) overlap:
+
+    >>> signal.check_NOLA(signal.windows.boxcar(100), 100, 75)
+    True
+
+    NOLA is also true for 25% (1/4) overlap:
+
+    >>> signal.check_NOLA(signal.windows.boxcar(100), 100, 25)
+    True
+
+    "Symmetrical" Hann window (for filter design) is also NOLA:
+
+    >>> signal.check_NOLA(signal.windows.hann(120, sym=True), 120, 60)
+    True
+
+    As long as there is overlap, it takes quite a pathological window to fail
+    NOLA:
+
+    >>> w = np.ones(64, dtype="float")
+    >>> w[::2] = 0
+    >>> signal.check_NOLA(w, 64, 32)
+    False
+
+    If there is not enough overlap, a window with zeros at the ends will not
+    work:
+
+    >>> signal.check_NOLA(signal.windows.hann(64), 64, 0)
+    False
+    >>> signal.check_NOLA(signal.windows.hann(64), 64, 1)
+    False
+    >>> signal.check_NOLA(signal.windows.hann(64), 64, 2)
+    True
+
+    """
+    nperseg = int(nperseg)
+
+    if nperseg < 1:
+        raise ValueError('nperseg must be a positive integer')
+
+    if noverlap >= nperseg:
+        raise ValueError('noverlap must be less than nperseg')
+    if noverlap < 0:
+        raise ValueError('noverlap must be a nonnegative integer')
+    noverlap = int(noverlap)
+
+    if isinstance(window, str) or type(window) is tuple:
+        win = get_window(window, nperseg)
+    else:
+        win = np.asarray(window)
+        if len(win.shape) != 1:
+            raise ValueError('window must be 1-D')
+        if win.shape[0] != nperseg:
+            raise ValueError('window must have length of nperseg')
+
+    step = nperseg - noverlap
+    binsums = sum(win[ii*step:(ii+1)*step]**2 for ii in range(nperseg//step))
+
+    if nperseg % step != 0:
+        binsums[:nperseg % step] += win[-(nperseg % step):]**2
+
+    return np.min(binsums) > tol
+
+
+def stft(x, fs=1.0, window='hann', nperseg=256, noverlap=None, nfft=None,
+         detrend=False, return_onesided=True, boundary='zeros', padded=True,
+         axis=-1, scaling='spectrum'):
+    r"""Compute the Short Time Fourier Transform (legacy function).
+
+    STFTs can be used as a way of quantifying the change of a
+    nonstationary signal's frequency and phase content over time.
+
+    .. legacy:: function
+
+        `ShortTimeFFT` is a newer STFT / ISTFT implementation with more
+        features. A :ref:`comparison <tutorial_stft_legacy_stft>` between the
+        implementations can be found in the :ref:`tutorial_stft` section of the
+        :ref:`user_guide`.
+
+    Parameters
+    ----------
+    x : array_like
+        Time series of measurement values
+    fs : float, optional
+        Sampling frequency of the `x` time series. Defaults to 1.0.
+    window : str or tuple or array_like, optional
+        Desired window to use. If `window` is a string or tuple, it is
+        passed to `get_window` to generate the window values, which are
+        DFT-even by default. See `get_window` for a list of windows and
+        required parameters. If `window` is array_like it will be used
+        directly as the window and its length must be nperseg. Defaults
+        to a Hann window.
+    nperseg : int, optional
+        Length of each segment. Defaults to 256.
+    noverlap : int, optional
+        Number of points to overlap between segments. If `None`,
+        ``noverlap = nperseg // 2``. Defaults to `None`. When
+        specified, the COLA constraint must be met (see Notes below).
+    nfft : int, optional
+        Length of the FFT used, if a zero padded FFT is desired. If
+        `None`, the FFT length is `nperseg`. Defaults to `None`.
+    detrend : str or function or `False`, optional
+        Specifies how to detrend each segment. If `detrend` is a
+        string, it is passed as the `type` argument to the `detrend`
+        function. If it is a function, it takes a segment and returns a
+        detrended segment. If `detrend` is `False`, no detrending is
+        done. Defaults to `False`.
+    return_onesided : bool, optional
+        If `True`, return a one-sided spectrum for real data. If
+        `False` return a two-sided spectrum. Defaults to `True`, but for
+        complex data, a two-sided spectrum is always returned.
+    boundary : str or None, optional
+        Specifies whether the input signal is extended at both ends, and
+        how to generate the new values, in order to center the first
+        windowed segment on the first input point. This has the benefit
+        of enabling reconstruction of the first input point when the
+        employed window function starts at zero. Valid options are
+        ``['even', 'odd', 'constant', 'zeros', None]``. Defaults to
+        'zeros', for zero padding extension. I.e. ``[1, 2, 3, 4]`` is
+        extended to ``[0, 1, 2, 3, 4, 0]`` for ``nperseg=3``.
+    padded : bool, optional
+        Specifies whether the input signal is zero-padded at the end to
+        make the signal fit exactly into an integer number of window
+        segments, so that all of the signal is included in the output.
+        Defaults to `True`. Padding occurs after boundary extension, if
+        `boundary` is not `None`, and `padded` is `True`, as is the
+        default.
+    axis : int, optional
+        Axis along which the STFT is computed; the default is over the
+        last axis (i.e. ``axis=-1``).
+    scaling: {'spectrum', 'psd'}
+        The default 'spectrum' scaling allows each frequency line of `Zxx` to
+        be interpreted as a magnitude spectrum. The 'psd' option scales each
+        line to a power spectral density - it allows to calculate the signal's
+        energy by numerically integrating over ``abs(Zxx)**2``.
+
+        .. versionadded:: 1.9.0
+
+    Returns
+    -------
+    f : ndarray
+        Array of sample frequencies.
+    t : ndarray
+        Array of segment times.
+    Zxx : ndarray
+        STFT of `x`. By default, the last axis of `Zxx` corresponds
+        to the segment times.
+
+    See Also
+    --------
+    istft: Inverse Short Time Fourier Transform
+    ShortTimeFFT: Newer STFT/ISTFT implementation providing more features.
+    check_COLA: Check whether the Constant OverLap Add (COLA) constraint
+                is met
+    check_NOLA: Check whether the Nonzero Overlap Add (NOLA) constraint is met
+    welch: Power spectral density by Welch's method.
+    spectrogram: Spectrogram by Welch's method.
+    csd: Cross spectral density by Welch's method.
+    lombscargle: Lomb-Scargle periodogram for unevenly sampled data
+
+    Notes
+    -----
+    In order to enable inversion of an STFT via the inverse STFT in
+    `istft`, the signal windowing must obey the constraint of "Nonzero
+    OverLap Add" (NOLA), and the input signal must have complete
+    windowing coverage (i.e. ``(x.shape[axis] - nperseg) %
+    (nperseg-noverlap) == 0``). The `padded` argument may be used to
+    accomplish this.
+
+    Given a time-domain signal :math:`x[n]`, a window :math:`w[n]`, and a hop
+    size :math:`H` = `nperseg - noverlap`, the windowed frame at time index
+    :math:`t` is given by
+
+    .. math:: x_{t}[n]=x[n]w[n-tH]
+
+    The overlap-add (OLA) reconstruction equation is given by
+
+    .. math:: x[n]=\frac{\sum_{t}x_{t}[n]w[n-tH]}{\sum_{t}w^{2}[n-tH]}
+
+    The NOLA constraint ensures that every normalization term that appears
+    in the denomimator of the OLA reconstruction equation is nonzero. Whether a
+    choice of `window`, `nperseg`, and `noverlap` satisfy this constraint can
+    be tested with `check_NOLA`.
+
+
+    .. versionadded:: 0.19.0
+
+    References
+    ----------
+    .. [1] Oppenheim, Alan V., Ronald W. Schafer, John R. Buck
+           "Discrete-Time Signal Processing", Prentice Hall, 1999.
+    .. [2] Daniel W. Griffin, Jae S. Lim "Signal Estimation from
+           Modified Short-Time Fourier Transform", IEEE 1984,
+           10.1109/TASSP.1984.1164317
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy import signal
+    >>> import matplotlib.pyplot as plt
+    >>> rng = np.random.default_rng()
+
+    Generate a test signal, a 2 Vrms sine wave whose frequency is slowly
+    modulated around 3kHz, corrupted by white noise of exponentially
+    decreasing magnitude sampled at 10 kHz.
+
+    >>> fs = 10e3
+    >>> N = 1e5
+    >>> amp = 2 * np.sqrt(2)
+    >>> noise_power = 0.01 * fs / 2
+    >>> time = np.arange(N) / float(fs)
+    >>> mod = 500*np.cos(2*np.pi*0.25*time)
+    >>> carrier = amp * np.sin(2*np.pi*3e3*time + mod)
+    >>> noise = rng.normal(scale=np.sqrt(noise_power),
+    ...                    size=time.shape)
+    >>> noise *= np.exp(-time/5)
+    >>> x = carrier + noise
+
+    Compute and plot the STFT's magnitude.
+
+    >>> f, t, Zxx = signal.stft(x, fs, nperseg=1000)
+    >>> plt.pcolormesh(t, f, np.abs(Zxx), vmin=0, vmax=amp, shading='gouraud')
+    >>> plt.title('STFT Magnitude')
+    >>> plt.ylabel('Frequency [Hz]')
+    >>> plt.xlabel('Time [sec]')
+    >>> plt.show()
+
+    Compare the energy of the signal `x` with the energy of its STFT:
+
+    >>> E_x = sum(x**2) / fs  # Energy of x
+    >>> # Calculate a two-sided STFT with PSD scaling:
+    >>> f, t, Zxx = signal.stft(x, fs, nperseg=1000, return_onesided=False,
+    ...                         scaling='psd')
+    >>> # Integrate numerically over abs(Zxx)**2:
+    >>> df, dt = f[1] - f[0], t[1] - t[0]
+    >>> E_Zxx = sum(np.sum(Zxx.real**2 + Zxx.imag**2, axis=0) * df) * dt
+    >>> # The energy is the same, but the numerical errors are quite large:
+    >>> np.isclose(E_x, E_Zxx, rtol=1e-2)
+    True
+
+    """
+    if scaling == 'psd':
+        scaling = 'density'
+    elif scaling != 'spectrum':
+        raise ValueError(f"Parameter {scaling=} not in ['spectrum', 'psd']!")
+
+    freqs, time, Zxx = _spectral_helper(x, x, fs, window, nperseg, noverlap,
+                                        nfft, detrend, return_onesided,
+                                        scaling=scaling, axis=axis,
+                                        mode='stft', boundary=boundary,
+                                        padded=padded)
+
+    return freqs, time, Zxx
+
+
+def istft(Zxx, fs=1.0, window='hann', nperseg=None, noverlap=None, nfft=None,
+          input_onesided=True, boundary=True, time_axis=-1, freq_axis=-2,
+          scaling='spectrum'):
+    r"""Perform the inverse Short Time Fourier transform (legacy function).
+
+    .. legacy:: function
+
+        `ShortTimeFFT` is a newer STFT / ISTFT implementation with more
+        features. A :ref:`comparison <tutorial_stft_legacy_stft>` between the
+        implementations can be found in the :ref:`tutorial_stft` section of the
+        :ref:`user_guide`.
+
+    Parameters
+    ----------
+    Zxx : array_like
+        STFT of the signal to be reconstructed. If a purely real array
+        is passed, it will be cast to a complex data type.
+    fs : float, optional
+        Sampling frequency of the time series. Defaults to 1.0.
+    window : str or tuple or array_like, optional
+        Desired window to use. If `window` is a string or tuple, it is
+        passed to `get_window` to generate the window values, which are
+        DFT-even by default. See `get_window` for a list of windows and
+        required parameters. If `window` is array_like it will be used
+        directly as the window and its length must be nperseg. Defaults
+        to a Hann window. Must match the window used to generate the
+        STFT for faithful inversion.
+    nperseg : int, optional
+        Number of data points corresponding to each STFT segment. This
+        parameter must be specified if the number of data points per
+        segment is odd, or if the STFT was padded via ``nfft >
+        nperseg``. If `None`, the value depends on the shape of
+        `Zxx` and `input_onesided`. If `input_onesided` is `True`,
+        ``nperseg=2*(Zxx.shape[freq_axis] - 1)``. Otherwise,
+        ``nperseg=Zxx.shape[freq_axis]``. Defaults to `None`.
+    noverlap : int, optional
+        Number of points to overlap between segments. If `None`, half
+        of the segment length. Defaults to `None`. When specified, the
+        COLA constraint must be met (see Notes below), and should match
+        the parameter used to generate the STFT. Defaults to `None`.
+    nfft : int, optional
+        Number of FFT points corresponding to each STFT segment. This
+        parameter must be specified if the STFT was padded via ``nfft >
+        nperseg``. If `None`, the default values are the same as for
+        `nperseg`, detailed above, with one exception: if
+        `input_onesided` is True and
+        ``nperseg==2*Zxx.shape[freq_axis] - 1``, `nfft` also takes on
+        that value. This case allows the proper inversion of an
+        odd-length unpadded STFT using ``nfft=None``. Defaults to
+        `None`.
+    input_onesided : bool, optional
+        If `True`, interpret the input array as one-sided FFTs, such
+        as is returned by `stft` with ``return_onesided=True`` and
+        `numpy.fft.rfft`. If `False`, interpret the input as a a
+        two-sided FFT. Defaults to `True`.
+    boundary : bool, optional
+        Specifies whether the input signal was extended at its
+        boundaries by supplying a non-`None` ``boundary`` argument to
+        `stft`. Defaults to `True`.
+    time_axis : int, optional
+        Where the time segments of the STFT is located; the default is
+        the last axis (i.e. ``axis=-1``).
+    freq_axis : int, optional
+        Where the frequency axis of the STFT is located; the default is
+        the penultimate axis (i.e. ``axis=-2``).
+    scaling: {'spectrum', 'psd'}
+        The default 'spectrum' scaling allows each frequency line of `Zxx` to
+        be interpreted as a magnitude spectrum. The 'psd' option scales each
+        line to a power spectral density - it allows to calculate the signal's
+        energy by numerically integrating over ``abs(Zxx)**2``.
+
+    Returns
+    -------
+    t : ndarray
+        Array of output data times.
+    x : ndarray
+        iSTFT of `Zxx`.
+
+    See Also
+    --------
+    stft: Short Time Fourier Transform
+    ShortTimeFFT: Newer STFT/ISTFT implementation providing more features.
+    check_COLA: Check whether the Constant OverLap Add (COLA) constraint
+                is met
+    check_NOLA: Check whether the Nonzero Overlap Add (NOLA) constraint is met
+
+    Notes
+    -----
+    In order to enable inversion of an STFT via the inverse STFT with
+    `istft`, the signal windowing must obey the constraint of "nonzero
+    overlap add" (NOLA):
+
+    .. math:: \sum_{t}w^{2}[n-tH] \ne 0
+
+    This ensures that the normalization factors that appear in the denominator
+    of the overlap-add reconstruction equation
+
+    .. math:: x[n]=\frac{\sum_{t}x_{t}[n]w[n-tH]}{\sum_{t}w^{2}[n-tH]}
+
+    are not zero. The NOLA constraint can be checked with the `check_NOLA`
+    function.
+
+    An STFT which has been modified (via masking or otherwise) is not
+    guaranteed to correspond to a exactly realizible signal. This
+    function implements the iSTFT via the least-squares estimation
+    algorithm detailed in [2]_, which produces a signal that minimizes
+    the mean squared error between the STFT of the returned signal and
+    the modified STFT.
+
+
+    .. versionadded:: 0.19.0
+
+    References
+    ----------
+    .. [1] Oppenheim, Alan V., Ronald W. Schafer, John R. Buck
+           "Discrete-Time Signal Processing", Prentice Hall, 1999.
+    .. [2] Daniel W. Griffin, Jae S. Lim "Signal Estimation from
+           Modified Short-Time Fourier Transform", IEEE 1984,
+           10.1109/TASSP.1984.1164317
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy import signal
+    >>> import matplotlib.pyplot as plt
+    >>> rng = np.random.default_rng()
+
+    Generate a test signal, a 2 Vrms sine wave at 50Hz corrupted by
+    0.001 V**2/Hz of white noise sampled at 1024 Hz.
+
+    >>> fs = 1024
+    >>> N = 10*fs
+    >>> nperseg = 512
+    >>> amp = 2 * np.sqrt(2)
+    >>> noise_power = 0.001 * fs / 2
+    >>> time = np.arange(N) / float(fs)
+    >>> carrier = amp * np.sin(2*np.pi*50*time)
+    >>> noise = rng.normal(scale=np.sqrt(noise_power),
+    ...                    size=time.shape)
+    >>> x = carrier + noise
+
+    Compute the STFT, and plot its magnitude
+
+    >>> f, t, Zxx = signal.stft(x, fs=fs, nperseg=nperseg)
+    >>> plt.figure()
+    >>> plt.pcolormesh(t, f, np.abs(Zxx), vmin=0, vmax=amp, shading='gouraud')
+    >>> plt.ylim([f[1], f[-1]])
+    >>> plt.title('STFT Magnitude')
+    >>> plt.ylabel('Frequency [Hz]')
+    >>> plt.xlabel('Time [sec]')
+    >>> plt.yscale('log')
+    >>> plt.show()
+
+    Zero the components that are 10% or less of the carrier magnitude,
+    then convert back to a time series via inverse STFT
+
+    >>> Zxx = np.where(np.abs(Zxx) >= amp/10, Zxx, 0)
+    >>> _, xrec = signal.istft(Zxx, fs)
+
+    Compare the cleaned signal with the original and true carrier signals.
+
+    >>> plt.figure()
+    >>> plt.plot(time, x, time, xrec, time, carrier)
+    >>> plt.xlim([2, 2.1])
+    >>> plt.xlabel('Time [sec]')
+    >>> plt.ylabel('Signal')
+    >>> plt.legend(['Carrier + Noise', 'Filtered via STFT', 'True Carrier'])
+    >>> plt.show()
+
+    Note that the cleaned signal does not start as abruptly as the original,
+    since some of the coefficients of the transient were also removed:
+
+    >>> plt.figure()
+    >>> plt.plot(time, x, time, xrec, time, carrier)
+    >>> plt.xlim([0, 0.1])
+    >>> plt.xlabel('Time [sec]')
+    >>> plt.ylabel('Signal')
+    >>> plt.legend(['Carrier + Noise', 'Filtered via STFT', 'True Carrier'])
+    >>> plt.show()
+
+    """
+    # Make sure input is an ndarray of appropriate complex dtype
+    Zxx = np.asarray(Zxx) + 0j
+    freq_axis = int(freq_axis)
+    time_axis = int(time_axis)
+
+    if Zxx.ndim < 2:
+        raise ValueError('Input stft must be at least 2d!')
+
+    if freq_axis == time_axis:
+        raise ValueError('Must specify differing time and frequency axes!')
+
+    nseg = Zxx.shape[time_axis]
+
+    if input_onesided:
+        # Assume even segment length
+        n_default = 2*(Zxx.shape[freq_axis] - 1)
+    else:
+        n_default = Zxx.shape[freq_axis]
+
+    # Check windowing parameters
+    if nperseg is None:
+        nperseg = n_default
+    else:
+        nperseg = int(nperseg)
+        if nperseg < 1:
+            raise ValueError('nperseg must be a positive integer')
+
+    if nfft is None:
+        if (input_onesided) and (nperseg == n_default + 1):
+            # Odd nperseg, no FFT padding
+            nfft = nperseg
+        else:
+            nfft = n_default
+    elif nfft < nperseg:
+        raise ValueError('nfft must be greater than or equal to nperseg.')
+    else:
+        nfft = int(nfft)
+
+    if noverlap is None:
+        noverlap = nperseg//2
+    else:
+        noverlap = int(noverlap)
+    if noverlap >= nperseg:
+        raise ValueError('noverlap must be less than nperseg.')
+    nstep = nperseg - noverlap
+
+    # Rearrange axes if necessary
+    if time_axis != Zxx.ndim-1 or freq_axis != Zxx.ndim-2:
+        # Turn negative indices to positive for the call to transpose
+        if freq_axis < 0:
+            freq_axis = Zxx.ndim + freq_axis
+        if time_axis < 0:
+            time_axis = Zxx.ndim + time_axis
+        zouter = list(range(Zxx.ndim))
+        for ax in sorted([time_axis, freq_axis], reverse=True):
+            zouter.pop(ax)
+        Zxx = np.transpose(Zxx, zouter+[freq_axis, time_axis])
+
+    # Get window as array
+    if isinstance(window, str) or type(window) is tuple:
+        win = get_window(window, nperseg)
+    else:
+        win = np.asarray(window)
+        if len(win.shape) != 1:
+            raise ValueError('window must be 1-D')
+        if win.shape[0] != nperseg:
+            raise ValueError(f'window must have length of {nperseg}')
+
+    ifunc = sp_fft.irfft if input_onesided else sp_fft.ifft
+    xsubs = ifunc(Zxx, axis=-2, n=nfft)[..., :nperseg, :]
+
+    # Initialize output and normalization arrays
+    outputlength = nperseg + (nseg-1)*nstep
+    x = np.zeros(list(Zxx.shape[:-2])+[outputlength], dtype=xsubs.dtype)
+    norm = np.zeros(outputlength, dtype=xsubs.dtype)
+
+    if np.result_type(win, xsubs) != xsubs.dtype:
+        win = win.astype(xsubs.dtype)
+
+    if scaling == 'spectrum':
+        xsubs *= win.sum()
+    elif scaling == 'psd':
+        xsubs *= np.sqrt(fs * sum(win**2))
+    else:
+        raise ValueError(f"Parameter {scaling=} not in ['spectrum', 'psd']!")
+
+    # Construct the output from the ifft segments
+    # This loop could perhaps be vectorized/strided somehow...
+    for ii in range(nseg):
+        # Window the ifft
+        x[..., ii*nstep:ii*nstep+nperseg] += xsubs[..., ii] * win
+        norm[..., ii*nstep:ii*nstep+nperseg] += win**2
+
+    # Remove extension points
+    if boundary:
+        x = x[..., nperseg//2:-(nperseg//2)]
+        norm = norm[..., nperseg//2:-(nperseg//2)]
+
+    # Divide out normalization where non-tiny
+    if np.sum(norm > 1e-10) != len(norm):
+        warnings.warn(
+            "NOLA condition failed, STFT may not be invertible."
+            + (" Possibly due to missing boundary" if not boundary else ""),
+            stacklevel=2
+        )
+    x /= np.where(norm > 1e-10, norm, 1.0)
+
+    if input_onesided:
+        x = x.real
+
+    # Put axes back
+    if x.ndim > 1:
+        if time_axis != Zxx.ndim-1:
+            if freq_axis < time_axis:
+                time_axis -= 1
+            x = np.moveaxis(x, -1, time_axis)
+
+    time = np.arange(x.shape[0])/float(fs)
+    return time, x
+
+
+def coherence(x, y, fs=1.0, window='hann', nperseg=None, noverlap=None,
+              nfft=None, detrend='constant', axis=-1):
+    r"""
+    Estimate the magnitude squared coherence estimate, Cxy, of
+    discrete-time signals X and Y using Welch's method.
+
+    ``Cxy = abs(Pxy)**2/(Pxx*Pyy)``, where `Pxx` and `Pyy` are power
+    spectral density estimates of X and Y, and `Pxy` is the cross
+    spectral density estimate of X and Y.
+
+    Parameters
+    ----------
+    x : array_like
+        Time series of measurement values
+    y : array_like
+        Time series of measurement values
+    fs : float, optional
+        Sampling frequency of the `x` and `y` time series. Defaults
+        to 1.0.
+    window : str or tuple or array_like, optional
+        Desired window to use. If `window` is a string or tuple, it is
+        passed to `get_window` to generate the window values, which are
+        DFT-even by default. See `get_window` for a list of windows and
+        required parameters. If `window` is array_like it will be used
+        directly as the window and its length must be nperseg. Defaults
+        to a Hann window.
+    nperseg : int, optional
+        Length of each segment. Defaults to None, but if window is str or
+        tuple, is set to 256, and if window is array_like, is set to the
+        length of the window.
+    noverlap: int, optional
+        Number of points to overlap between segments. If `None`,
+        ``noverlap = nperseg // 2``. Defaults to `None`.
+    nfft : int, optional
+        Length of the FFT used, if a zero padded FFT is desired. If
+        `None`, the FFT length is `nperseg`. Defaults to `None`.
+    detrend : str or function or `False`, optional
+        Specifies how to detrend each segment. If `detrend` is a
+        string, it is passed as the `type` argument to the `detrend`
+        function. If it is a function, it takes a segment and returns a
+        detrended segment. If `detrend` is `False`, no detrending is
+        done. Defaults to 'constant'.
+    axis : int, optional
+        Axis along which the coherence is computed for both inputs; the
+        default is over the last axis (i.e. ``axis=-1``).
+
+    Returns
+    -------
+    f : ndarray
+        Array of sample frequencies.
+    Cxy : ndarray
+        Magnitude squared coherence of x and y.
+
+    See Also
+    --------
+    periodogram: Simple, optionally modified periodogram
+    lombscargle: Lomb-Scargle periodogram for unevenly sampled data
+    welch: Power spectral density by Welch's method.
+    csd: Cross spectral density by Welch's method.
+
+    Notes
+    -----
+    An appropriate amount of overlap will depend on the choice of window
+    and on your requirements. For the default Hann window an overlap of
+    50% is a reasonable trade off between accurately estimating the
+    signal power, while not over counting any of the data. Narrower
+    windows may require a larger overlap.
+
+    .. versionadded:: 0.16.0
+
+    References
+    ----------
+    .. [1] P. Welch, "The use of the fast Fourier transform for the
+           estimation of power spectra: A method based on time averaging
+           over short, modified periodograms", IEEE Trans. Audio
+           Electroacoust. vol. 15, pp. 70-73, 1967.
+    .. [2] Stoica, Petre, and Randolph Moses, "Spectral Analysis of
+           Signals" Prentice Hall, 2005
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy import signal
+    >>> import matplotlib.pyplot as plt
+    >>> rng = np.random.default_rng()
+
+    Generate two test signals with some common features.
+
+    >>> fs = 10e3
+    >>> N = 1e5
+    >>> amp = 20
+    >>> freq = 1234.0
+    >>> noise_power = 0.001 * fs / 2
+    >>> time = np.arange(N) / fs
+    >>> b, a = signal.butter(2, 0.25, 'low')
+    >>> x = rng.normal(scale=np.sqrt(noise_power), size=time.shape)
+    >>> y = signal.lfilter(b, a, x)
+    >>> x += amp*np.sin(2*np.pi*freq*time)
+    >>> y += rng.normal(scale=0.1*np.sqrt(noise_power), size=time.shape)
+
+    Compute and plot the coherence.
+
+    >>> f, Cxy = signal.coherence(x, y, fs, nperseg=1024)
+    >>> plt.semilogy(f, Cxy)
+    >>> plt.xlabel('frequency [Hz]')
+    >>> plt.ylabel('Coherence')
+    >>> plt.show()
+
+    """
+    freqs, Pxx = welch(x, fs=fs, window=window, nperseg=nperseg,
+                       noverlap=noverlap, nfft=nfft, detrend=detrend,
+                       axis=axis)
+    _, Pyy = welch(y, fs=fs, window=window, nperseg=nperseg, noverlap=noverlap,
+                   nfft=nfft, detrend=detrend, axis=axis)
+    _, Pxy = csd(x, y, fs=fs, window=window, nperseg=nperseg,
+                 noverlap=noverlap, nfft=nfft, detrend=detrend, axis=axis)
+
+    Cxy = np.abs(Pxy)**2 / Pxx / Pyy
+
+    return freqs, Cxy
+
+
+def _spectral_helper(x, y, fs=1.0, window='hann', nperseg=None, noverlap=None,
+                     nfft=None, detrend='constant', return_onesided=True,
+                     scaling='density', axis=-1, mode='psd', boundary=None,
+                     padded=False):
+    """Calculate various forms of windowed FFTs for PSD, CSD, etc.
+
+    This is a helper function that implements the commonality between
+    the stft, psd, csd, and spectrogram functions. It is not designed to
+    be called externally. The windows are not averaged over; the result
+    from each window is returned.
+
+    Parameters
+    ----------
+    x : array_like
+        Array or sequence containing the data to be analyzed.
+    y : array_like
+        Array or sequence containing the data to be analyzed. If this is
+        the same object in memory as `x` (i.e. ``_spectral_helper(x,
+        x, ...)``), the extra computations are spared.
+    fs : float, optional
+        Sampling frequency of the time series. Defaults to 1.0.
+    window : str or tuple or array_like, optional
+        Desired window to use. If `window` is a string or tuple, it is
+        passed to `get_window` to generate the window values, which are
+        DFT-even by default. See `get_window` for a list of windows and
+        required parameters. If `window` is array_like it will be used
+        directly as the window and its length must be nperseg. Defaults
+        to a Hann window.
+    nperseg : int, optional
+        Length of each segment. Defaults to None, but if window is str or
+        tuple, is set to 256, and if window is array_like, is set to the
+        length of the window.
+    noverlap : int, optional
+        Number of points to overlap between segments. If `None`,
+        ``noverlap = nperseg // 2``. Defaults to `None`.
+    nfft : int, optional
+        Length of the FFT used, if a zero padded FFT is desired. If
+        `None`, the FFT length is `nperseg`. Defaults to `None`.
+    detrend : str or function or `False`, optional
+        Specifies how to detrend each segment. If `detrend` is a
+        string, it is passed as the `type` argument to the `detrend`
+        function. If it is a function, it takes a segment and returns a
+        detrended segment. If `detrend` is `False`, no detrending is
+        done. Defaults to 'constant'.
+    return_onesided : bool, optional
+        If `True`, return a one-sided spectrum for real data. If
+        `False` return a two-sided spectrum. Defaults to `True`, but for
+        complex data, a two-sided spectrum is always returned.
+    scaling : { 'density', 'spectrum' }, optional
+        Selects between computing the cross spectral density ('density')
+        where `Pxy` has units of V**2/Hz and computing the cross
+        spectrum ('spectrum') where `Pxy` has units of V**2, if `x`
+        and `y` are measured in V and `fs` is measured in Hz.
+        Defaults to 'density'
+    axis : int, optional
+        Axis along which the FFTs are computed; the default is over the
+        last axis (i.e. ``axis=-1``).
+    mode: str {'psd', 'stft'}, optional
+        Defines what kind of return values are expected. Defaults to
+        'psd'.
+    boundary : str or None, optional
+        Specifies whether the input signal is extended at both ends, and
+        how to generate the new values, in order to center the first
+        windowed segment on the first input point. This has the benefit
+        of enabling reconstruction of the first input point when the
+        employed window function starts at zero. Valid options are
+        ``['even', 'odd', 'constant', 'zeros', None]``. Defaults to
+        `None`.
+    padded : bool, optional
+        Specifies whether the input signal is zero-padded at the end to
+        make the signal fit exactly into an integer number of window
+        segments, so that all of the signal is included in the output.
+        Defaults to `False`. Padding occurs after boundary extension, if
+        `boundary` is not `None`, and `padded` is `True`.
+
+    Returns
+    -------
+    freqs : ndarray
+        Array of sample frequencies.
+    t : ndarray
+        Array of times corresponding to each data segment
+    result : ndarray
+        Array of output data, contents dependent on *mode* kwarg.
+
+    Notes
+    -----
+    Adapted from matplotlib.mlab
+
+    .. versionadded:: 0.16.0
+    """
+    if mode not in ['psd', 'stft']:
+        raise ValueError("Unknown value for mode %s, must be one of: "
+                         "{'psd', 'stft'}" % mode)
+
+    boundary_funcs = {'even': even_ext,
+                      'odd': odd_ext,
+                      'constant': const_ext,
+                      'zeros': zero_ext,
+                      None: None}
+
+    if boundary not in boundary_funcs:
+        raise ValueError("Unknown boundary option '{}', must be one of: {}"
+                         .format(boundary, list(boundary_funcs.keys())))
+
+    # If x and y are the same object we can save ourselves some computation.
+    same_data = y is x
+
+    if not same_data and mode != 'psd':
+        raise ValueError("x and y must be equal if mode is 'stft'")
+
+    axis = int(axis)
+
+    # Ensure we have np.arrays, get outdtype
+    x = np.asarray(x)
+    if not same_data:
+        y = np.asarray(y)
+        outdtype = np.result_type(x, y, np.complex64)
+    else:
+        outdtype = np.result_type(x, np.complex64)
+
+    if not same_data:
+        # Check if we can broadcast the outer axes together
+        xouter = list(x.shape)
+        youter = list(y.shape)
+        xouter.pop(axis)
+        youter.pop(axis)
+        try:
+            outershape = np.broadcast(np.empty(xouter), np.empty(youter)).shape
+        except ValueError as e:
+            raise ValueError('x and y cannot be broadcast together.') from e
+
+    if same_data:
+        if x.size == 0:
+            return np.empty(x.shape), np.empty(x.shape), np.empty(x.shape)
+    else:
+        if x.size == 0 or y.size == 0:
+            outshape = outershape + (min([x.shape[axis], y.shape[axis]]),)
+            emptyout = np.moveaxis(np.empty(outshape), -1, axis)
+            return emptyout, emptyout, emptyout
+
+    if x.ndim > 1:
+        if axis != -1:
+            x = np.moveaxis(x, axis, -1)
+            if not same_data and y.ndim > 1:
+                y = np.moveaxis(y, axis, -1)
+
+    # Check if x and y are the same length, zero-pad if necessary
+    if not same_data:
+        if x.shape[-1] != y.shape[-1]:
+            if x.shape[-1] < y.shape[-1]:
+                pad_shape = list(x.shape)
+                pad_shape[-1] = y.shape[-1] - x.shape[-1]
+                x = np.concatenate((x, np.zeros(pad_shape)), -1)
+            else:
+                pad_shape = list(y.shape)
+                pad_shape[-1] = x.shape[-1] - y.shape[-1]
+                y = np.concatenate((y, np.zeros(pad_shape)), -1)
+
+    if nperseg is not None:  # if specified by user
+        nperseg = int(nperseg)
+        if nperseg < 1:
+            raise ValueError('nperseg must be a positive integer')
+
+    # parse window; if array like, then set nperseg = win.shape
+    win, nperseg = _triage_segments(window, nperseg, input_length=x.shape[-1])
+
+    if nfft is None:
+        nfft = nperseg
+    elif nfft < nperseg:
+        raise ValueError('nfft must be greater than or equal to nperseg.')
+    else:
+        nfft = int(nfft)
+
+    if noverlap is None:
+        noverlap = nperseg//2
+    else:
+        noverlap = int(noverlap)
+    if noverlap >= nperseg:
+        raise ValueError('noverlap must be less than nperseg.')
+    nstep = nperseg - noverlap
+
+    # Padding occurs after boundary extension, so that the extended signal ends
+    # in zeros, instead of introducing an impulse at the end.
+    # I.e. if x = [..., 3, 2]
+    # extend then pad -> [..., 3, 2, 2, 3, 0, 0, 0]
+    # pad then extend -> [..., 3, 2, 0, 0, 0, 2, 3]
+
+    if boundary is not None:
+        ext_func = boundary_funcs[boundary]
+        x = ext_func(x, nperseg//2, axis=-1)
+        if not same_data:
+            y = ext_func(y, nperseg//2, axis=-1)
+
+    if padded:
+        # Pad to integer number of windowed segments
+        # I.e make x.shape[-1] = nperseg + (nseg-1)*nstep, with integer nseg
+        nadd = (-(x.shape[-1]-nperseg) % nstep) % nperseg
+        zeros_shape = list(x.shape[:-1]) + [nadd]
+        x = np.concatenate((x, np.zeros(zeros_shape)), axis=-1)
+        if not same_data:
+            zeros_shape = list(y.shape[:-1]) + [nadd]
+            y = np.concatenate((y, np.zeros(zeros_shape)), axis=-1)
+
+    # Handle detrending and window functions
+    if not detrend:
+        def detrend_func(d):
+            return d
+    elif not hasattr(detrend, '__call__'):
+        def detrend_func(d):
+            return _signaltools.detrend(d, type=detrend, axis=-1)
+    elif axis != -1:
+        # Wrap this function so that it receives a shape that it could
+        # reasonably expect to receive.
+        def detrend_func(d):
+            d = np.moveaxis(d, -1, axis)
+            d = detrend(d)
+            return np.moveaxis(d, axis, -1)
+    else:
+        detrend_func = detrend
+
+    if np.result_type(win, np.complex64) != outdtype:
+        win = win.astype(outdtype)
+
+    if scaling == 'density':
+        scale = 1.0 / (fs * (win*win).sum())
+    elif scaling == 'spectrum':
+        scale = 1.0 / win.sum()**2
+    else:
+        raise ValueError('Unknown scaling: %r' % scaling)
+
+    if mode == 'stft':
+        scale = np.sqrt(scale)
+
+    if return_onesided:
+        if np.iscomplexobj(x):
+            sides = 'twosided'
+            warnings.warn('Input data is complex, switching to return_onesided=False',
+                          stacklevel=3)
+        else:
+            sides = 'onesided'
+            if not same_data:
+                if np.iscomplexobj(y):
+                    sides = 'twosided'
+                    warnings.warn('Input data is complex, switching to '
+                                  'return_onesided=False',
+                                  stacklevel=3)
+    else:
+        sides = 'twosided'
+
+    if sides == 'twosided':
+        freqs = sp_fft.fftfreq(nfft, 1/fs)
+    elif sides == 'onesided':
+        freqs = sp_fft.rfftfreq(nfft, 1/fs)
+
+    # Perform the windowed FFTs
+    result = _fft_helper(x, win, detrend_func, nperseg, noverlap, nfft, sides)
+
+    if not same_data:
+        # All the same operations on the y data
+        result_y = _fft_helper(y, win, detrend_func, nperseg, noverlap, nfft,
+                               sides)
+        result = np.conjugate(result) * result_y
+    elif mode == 'psd':
+        result = np.conjugate(result) * result
+
+    result *= scale
+    if sides == 'onesided' and mode == 'psd':
+        if nfft % 2:
+            result[..., 1:] *= 2
+        else:
+            # Last point is unpaired Nyquist freq point, don't double
+            result[..., 1:-1] *= 2
+
+    time = np.arange(nperseg/2, x.shape[-1] - nperseg/2 + 1,
+                     nperseg - noverlap)/float(fs)
+    if boundary is not None:
+        time -= (nperseg/2) / fs
+
+    result = result.astype(outdtype)
+
+    # All imaginary parts are zero anyways
+    if same_data and mode != 'stft':
+        result = result.real
+
+    # Output is going to have new last axis for time/window index, so a
+    # negative axis index shifts down one
+    if axis < 0:
+        axis -= 1
+
+    # Roll frequency axis back to axis where the data came from
+    result = np.moveaxis(result, -1, axis)
+
+    return freqs, time, result
+
+
+def _fft_helper(x, win, detrend_func, nperseg, noverlap, nfft, sides):
+    """
+    Calculate windowed FFT, for internal use by
+    `scipy.signal._spectral_helper`.
+
+    This is a helper function that does the main FFT calculation for
+    `_spectral helper`. All input validation is performed there, and the
+    data axis is assumed to be the last axis of x. It is not designed to
+    be called externally. The windows are not averaged over; the result
+    from each window is returned.
+
+    Returns
+    -------
+    result : ndarray
+        Array of FFT data
+
+    Notes
+    -----
+    Adapted from matplotlib.mlab
+
+    .. versionadded:: 0.16.0
+    """
+    # Created sliding window view of array
+    if nperseg == 1 and noverlap == 0:
+        result = x[..., np.newaxis]
+    else:
+        step = nperseg - noverlap
+        result = np.lib.stride_tricks.sliding_window_view(
+            x, window_shape=nperseg, axis=-1, writeable=True
+        )
+        result = result[..., 0::step, :]
+
+    # Detrend each data segment individually
+    result = detrend_func(result)
+
+    # Apply window by multiplication
+    result = win * result
+
+    # Perform the fft. Acts on last axis by default. Zero-pads automatically
+    if sides == 'twosided':
+        func = sp_fft.fft
+    else:
+        result = result.real
+        func = sp_fft.rfft
+    result = func(result, n=nfft)
+
+    return result
+
+
+def _triage_segments(window, nperseg, input_length):
+    """
+    Parses window and nperseg arguments for spectrogram and _spectral_helper.
+    This is a helper function, not meant to be called externally.
+
+    Parameters
+    ----------
+    window : string, tuple, or ndarray
+        If window is specified by a string or tuple and nperseg is not
+        specified, nperseg is set to the default of 256 and returns a window of
+        that length.
+        If instead the window is array_like and nperseg is not specified, then
+        nperseg is set to the length of the window. A ValueError is raised if
+        the user supplies both an array_like window and a value for nperseg but
+        nperseg does not equal the length of the window.
+
+    nperseg : int
+        Length of each segment
+
+    input_length: int
+        Length of input signal, i.e. x.shape[-1]. Used to test for errors.
+
+    Returns
+    -------
+    win : ndarray
+        window. If function was called with string or tuple than this will hold
+        the actual array used as a window.
+
+    nperseg : int
+        Length of each segment. If window is str or tuple, nperseg is set to
+        256. If window is array_like, nperseg is set to the length of the
+        window.
+    """
+    # parse window; if array like, then set nperseg = win.shape
+    if isinstance(window, str) or isinstance(window, tuple):
+        # if nperseg not specified
+        if nperseg is None:
+            nperseg = 256  # then change to default
+        if nperseg > input_length:
+            warnings.warn(f'nperseg = {nperseg:d} is greater than input length '
+                          f' = {input_length:d}, using nperseg = {input_length:d}',
+                          stacklevel=3)
+            nperseg = input_length
+        win = get_window(window, nperseg)
+    else:
+        win = np.asarray(window)
+        if len(win.shape) != 1:
+            raise ValueError('window must be 1-D')
+        if input_length < win.shape[-1]:
+            raise ValueError('window is longer than input signal')
+        if nperseg is None:
+            nperseg = win.shape[0]
+        elif nperseg is not None:
+            if nperseg != win.shape[0]:
+                raise ValueError("value specified for nperseg is different"
+                                 " from length of window")
+    return win, nperseg
+
+
+def _median_bias(n):
+    """
+    Returns the bias of the median of a set of periodograms relative to
+    the mean.
+
+    See Appendix B from [1]_ for details.
+
+    Parameters
+    ----------
+    n : int
+        Numbers of periodograms being averaged.
+
+    Returns
+    -------
+    bias : float
+        Calculated bias.
+
+    References
+    ----------
+    .. [1] B. Allen, W.G. Anderson, P.R. Brady, D.A. Brown, J.D.E. Creighton.
+           "FINDCHIRP: an algorithm for detection of gravitational waves from
+           inspiraling compact binaries", Physical Review D 85, 2012,
+           :arxiv:`gr-qc/0509116`
+    """
+    ii_2 = 2 * np.arange(1., (n-1) // 2 + 1)
+    return 1 + np.sum(1. / (ii_2 + 1) - 1. / ii_2)

env-llmeval/lib/python3.10/site-packages/scipy/signal/ltisys.py

@@ -0,0 +1,30 @@
+# This file is not meant for public use and will be removed in SciPy v2.0.0.
+# Use the `scipy.signal` namespace for importing the functions
+# included below.
+
+from scipy._lib.deprecation import _sub_module_deprecation
+
+__all__ = [  # noqa: F822
+    'lti', 'dlti', 'TransferFunction', 'ZerosPolesGain', 'StateSpace',
+    'lsim', 'impulse', 'step', 'bode',
+    'freqresp', 'place_poles', 'dlsim', 'dstep', 'dimpulse',
+    'dfreqresp', 'dbode', 's_qr', 'linalg',
+    'tf2zpk', 'zpk2tf', 'normalize', 'freqs',
+    'freqz', 'freqs_zpk', 'freqz_zpk', 'tf2ss', 'abcd_normalize',
+    'ss2tf', 'zpk2ss', 'ss2zpk', 'cont2discrete', 'atleast_1d',
+    'squeeze', 'transpose', 'linspace',
+    'LinearTimeInvariant', 'TransferFunctionContinuous',
+    'TransferFunctionDiscrete', 'ZerosPolesGainContinuous',
+    'ZerosPolesGainDiscrete', 'StateSpaceContinuous',
+    'StateSpaceDiscrete', 'Bunch'
+]
+
+
+def __dir__():
+    return __all__
+
+
+def __getattr__(name):
+    return _sub_module_deprecation(sub_package="signal", module="ltisys",
+                                   private_modules=["_ltisys"], all=__all__,
+                                   attribute=name)

env-llmeval/lib/python3.10/site-packages/scipy/spatial/tests/data/cdist-X1.txt

@@ -0,0 +1,10 @@
+1.147593763490969421e-01 8.926156143344999849e-01 1.437758624645746330e-02 1.803435962879929022e-02 5.533046214065578949e-01 5.554315640747428118e-01 4.497546637814608950e-02 4.438089247948049376e-01 7.984582810220538507e-01 2.752880789161644692e-01 1.344667112315823809e-01 9.230479561452992199e-01 6.040471462941819913e-01 3.797251652770228247e-01 4.316042735592399149e-01 5.312356915348823705e-01 4.348143005129563310e-01 3.111531488508799681e-01 9.531194313908697424e-04 8.212995023500069269e-02 6.689953269869852726e-01 9.914864535288493430e-01 8.037556036341153565e-01
+9.608925123801395074e-01 2.974451233678974127e-01 9.001110330654185088e-01 5.824163330415995654e-01 7.308574928293812834e-01 2.276154562412870952e-01 7.306791076039623745e-01 8.677244866905511333e-01 9.160806456176984192e-01 6.157216959991280714e-01 5.149053524695440531e-01 3.056427344890983999e-01 9.790557366933895223e-01 4.484995861076724877e-01 4.776550391081165747e-01 7.210436977670631187e-01 9.136399501661039979e-01 4.260275733550000776e-02 5.943900041968954717e-01 3.864571606342745991e-01 9.442027665110838131e-01 4.779949058608601309e-02 6.107551944250865228e-01
+3.297286578103622023e-01 5.980207401936733502e-01 3.673301293561567205e-01 2.585830520887681949e-01 4.660558746104259686e-01 6.083795956610364986e-01 4.535206368070313632e-01 6.873989778785424276e-01 5.130152688495458468e-01 7.665877846542720198e-01 3.444402973525138023e-01 3.583658123644906102e-02 7.924818220986856732e-01 8.746685720522412444e-01 3.010105569182431884e-01 6.012239357385538163e-01 6.233737362204671006e-01 4.830438698668915176e-01 2.317286885842551047e-02 7.585989958123050547e-01 7.108257632278830451e-01 1.551024884178199281e-01 2.665485998155288083e-01
+2.456278068903017253e-02 4.148739837711815648e-01 1.986372227934196655e-01 6.920408530298168825e-01 1.003067576685774398e-01 7.421560456480125190e-01 1.808453980608998313e-01 4.251297882537475870e-01 6.773002683522370004e-01 4.084108792570182445e-01 7.462888013191590897e-01 8.069930220529277776e-01 9.211110587681808903e-01 4.141491046181076108e-01 7.486318689260342829e-01 9.515405507589296263e-01 4.634288892577109742e-03 8.027593488166355762e-01 3.010346805217798405e-01 8.663248877242523127e-01 2.479968181181605447e-01 5.619851096054278017e-01 3.903886764590250857e-01
+7.122019976035700584e-01 6.188878051047785878e-01 7.290897087051201320e-01 6.334802157757637442e-01 5.523084734954342156e-01 5.614937129563645213e-01 2.496741051791574462e-01 5.972227939599233926e-01 1.786590597761109622e-01 2.609525984850900038e-01 7.210438943286010538e-01 2.211429064605652250e-01 9.140497572472672250e-02 1.430242193668443962e-01 7.856446942916397447e-01 4.635256358156553125e-01 5.278744289813760426e-01 3.702808015407184072e-01 5.527073830480792038e-01 6.370732917599846168e-01 9.953487928925482953e-01 3.021789770611936765e-01 3.354901923998221402e-02
+6.509638560895427695e-01 8.387598220902757751e-01 7.761375971745763103e-01 1.481627639227802717e-01 3.529474982902305324e-01 4.883093646287851586e-01 9.652923033658690199e-01 9.500680513565308294e-01 3.061885005078281985e-01 7.271902818906019750e-01 2.358962978196710303e-03 7.359889703223099211e-01 8.988893768074724955e-01 4.135279653937307121e-02 8.516441856688283796e-01 4.889597623270667270e-01 5.575909822114655245e-01 9.010853652261575641e-01 2.912844516556202246e-01 9.088759383368658629e-01 8.104351227460024898e-01 8.080695436776826890e-01 1.430530913253185155e-01
+8.048001196608134400e-01 3.066089444418462762e-02 9.021887554292090661e-01 6.154331491807940591e-02 1.378912575206647784e-02 5.775720193142440673e-01 1.219298963069791464e-01 1.883270243412101808e-01 5.569262398688379356e-02 8.964817777510125651e-02 7.977092785346929782e-01 4.878149375226197293e-01 4.511973131518809410e-02 1.858690046801604323e-01 6.947686471083162063e-01 5.884058794291086025e-01 8.638884676612634816e-01 3.855470871341656336e-01 3.495049047300468059e-01 2.767740932353948136e-01 4.731087031714035218e-01 6.679001673437914288e-01 7.502944200696660682e-01
+6.527328264244687261e-01 8.289483383553154505e-01 9.179741348282299818e-01 1.065639864466713105e-01 6.253616929058514184e-01 5.927750325266062381e-01 3.039157425463192563e-01 2.452766763359194302e-01 6.514027700704632107e-01 5.529218485487964463e-01 4.941158239308394151e-01 6.605306467722642516e-01 2.273688037050677346e-01 4.282616592244774534e-01 2.956128257930247250e-01 1.154803628237965896e-01 9.228220410235263849e-01 6.663525307676617659e-01 1.908852615936970087e-01 9.921383408926374159e-01 4.988716450388516188e-01 1.014900352736023414e-01 3.363930180244284474e-01
+2.914369076275757919e-01 5.196673601143533272e-01 7.420144907858341465e-01 1.768984185504740569e-01 5.296766993228564369e-01 5.922023566159900776e-01 5.965161262020234334e-01 3.810272333046110793e-01 8.368797246118340194e-01 7.896422363801189892e-01 9.655797561098209414e-01 4.430034032346981121e-01 2.780869795706976122e-01 3.047310845416009162e-01 8.051138863500326703e-01 6.731468634690835895e-01 4.743383036815584930e-01 9.530709614322225853e-01 7.753587619850917934e-01 2.801137109357491051e-01 6.182543660889736614e-01 5.005218857766725593e-01 9.071447804755052857e-01
+2.075071644012620453e-01 4.834950086973934802e-01 3.037011473860764532e-01 6.476084284887700937e-01 8.107195771564194020e-01 7.869075869075803364e-01 6.851234019375299633e-01 3.544187468104398331e-02 4.847673235908021017e-01 5.690262846164507726e-01 1.663354142616256803e-01 9.692796809752548537e-01 4.133441725866372485e-01 6.729167604487583665e-01 3.998813427407297283e-01 8.272617414104491695e-01 2.129248316324727774e-01 6.517004761357130249e-01 7.363013506605019520e-01 4.072375306356985636e-01 4.463336683526665238e-01 5.485059309728204102e-01 1.981745754527846071e-01

env-llmeval/lib/python3.10/site-packages/scipy/spatial/tests/data/cdist-X2.txt

@@ -0,0 +1,20 @@
+7.680465556300619667e-02 4.675022344069014180e-01 8.955498989131543963e-01 3.816236071436276411e-01 1.109030077070989329e-01 2.318928815459808668e-02 7.477394240984251983e-01 1.202289789304434864e-01 8.007290497575981769e-01 6.795195698871731027e-01 6.568225762396605605e-01 2.231475263228478445e-01 7.064624077661341151e-02 1.081656666815267176e-02 1.592069359090128033e-01 1.363392203645097389e-01 9.277020735447568667e-01 8.103136564528209407e-01 5.229467676276455812e-02 7.708020259874025504e-01 6.527954747473352359e-02 5.516397414886525796e-01 3.653371861367954443e-01
+8.144399106025798085e-01 7.731852525462976633e-01 6.909477620673205589e-01 9.696063817000286633e-01 4.297887511677249694e-01 6.989600553425188156e-01 7.310201335033380543e-01 3.135256147868910048e-01 5.715578037275241829e-01 3.935000744675094531e-01 2.057715781268398825e-01 5.892508589665171881e-01 8.512951599236765476e-01 9.569808799061578775e-01 6.164885878024699561e-01 4.714185430004367294e-01 6.128831737628155363e-01 6.641799309623502845e-01 6.001985185338730711e-01 4.231922889723856995e-01 7.605249308075449077e-01 1.064530958018087281e-01 6.306470691957204444e-01
+4.265470127256254518e-01 5.933766716280767239e-01 3.698589270536845053e-02 2.173799740537294412e-01 3.032679325475639009e-01 4.271831790058847611e-01 1.828944535901013690e-01 4.772333422710156592e-01 2.564773455194128138e-01 7.120329875362141347e-01 8.952243430110462530e-01 1.808777012183288013e-01 3.612151871458374464e-01 3.960999167923041631e-01 1.821669970670747318e-02 8.835474857189200559e-01 1.353104648821573663e-01 3.457291739160937016e-01 1.126467375304566199e-01 4.107293162402323450e-01 4.051719311053743056e-01 4.007382985250427243e-01 1.286905671428811848e-01
+2.910657003883979632e-01 9.616259180685315933e-03 2.033032441536681834e-01 1.096599110293863255e-01 4.191101704605176836e-01 5.462131536027151624e-01 8.393047907010142694e-01 9.046805198676335369e-01 7.009863472176891541e-01 2.508215985039629059e-01 6.754410796667598138e-01 6.740895474032024826e-01 1.358993708621679675e-01 8.219861775211464439e-01 6.322220445623235596e-01 2.766813559002430090e-01 6.575983861590951607e-01 9.515869708336625044e-01 8.654526462353933081e-01 3.450245117834797037e-01 5.649032890631299209e-01 4.717687914789682191e-01 3.296483580510030098e-01
+9.172477457635394016e-01 3.057396583041891436e-01 7.335332344225760082e-01 8.370236206345178509e-01 3.765464253115927695e-01 5.089680319287778199e-01 1.202325719268168003e-01 9.717771065272349240e-01 5.907820104019682050e-01 9.809211614977710880e-01 9.064285003671219698e-01 8.848841466121748489e-01 2.043407730734815297e-01 9.157600394927275511e-01 4.532260315147775831e-01 4.241077335005828397e-01 1.751730149568804240e-01 4.090412146081819911e-01 3.632197861847064058e-02 5.832539334970230360e-01 4.041848151536805434e-01 3.603643989086504629e-01 1.838411383882069261e-01
+2.508806403290032572e-01 4.381403985282813496e-01 4.694787405018008286e-02 6.353900562024634713e-01 1.200813444244532846e-01 6.072397042913001419e-01 9.937255904754030977e-01 4.916670237677555066e-01 3.473845913923001572e-01 3.526875922864345370e-01 5.448595548197197047e-01 2.245096010156972799e-01 9.003258279804994269e-01 3.534560469735994470e-01 2.989266066346342177e-01 4.621024982808636938e-01 9.626538866576676012e-01 9.791401720716153001e-01 7.138514287330390840e-01 9.832862333928654719e-01 3.233999591031431198e-01 5.406467224926423398e-01 9.581890295057201579e-01
+5.210583601680578436e-01 4.598159993059653949e-01 2.111497132057748027e-01 5.949977700916546652e-01 6.342618461422359077e-01 9.888228769705599275e-01 6.096770711536318998e-01 7.548431368960863974e-01 7.490858664860100546e-01 3.186213496546415058e-01 7.895687083231245351e-01 4.178326793268141159e-01 8.095818334534051752e-01 7.886271673523481684e-01 4.038905626506847923e-01 3.652649247094948981e-01 8.267205959224892542e-01 6.433617243328785262e-01 3.117681563249452559e-01 9.675995575054980868e-01 3.675673836358472890e-01 5.863757289184046151e-01 9.099029857959717305e-02
+4.024573981231733821e-01 3.578997554002771864e-01 3.519299868071553705e-01 7.417747693762357653e-01 2.963713903285800644e-01 9.602967989298948348e-01 3.811392331739601458e-01 5.493237898295448840e-01 6.835113342793640578e-01 2.304506220807415184e-01 3.727299857731285471e-01 5.450263991912108752e-01 6.951521210987908761e-01 6.474582745861203747e-01 6.316089475403589004e-01 5.672043967425510758e-02 9.034937506977609445e-01 2.332567550780038079e-01 1.096955741449157085e-02 8.870663813493575578e-01 4.384385452180562526e-01 7.100898998169548060e-01 3.245358176196319056e-01
+9.162009194452818139e-01 5.572224742426723498e-02 3.445910686865658601e-01 9.683564008127462097e-01 9.375063149031520604e-01 9.128188852869822956e-02 9.613605414326487075e-01 5.298598697556915482e-01 6.724799695520149445e-01 1.269103938571825019e-02 1.008406153387807480e-01 8.951105272379104028e-01 1.585460318853607609e-01 6.739986455059543413e-01 5.345419321702655768e-01 6.248843899572337213e-01 3.050288488994817859e-01 1.423645553465189284e-01 1.802121190541096096e-01 9.474646822694763326e-01 2.345716438587298613e-01 9.688281784764296578e-01 1.845165243240991515e-01
+2.548297646910531178e-01 2.580877375379494465e-01 1.355482532666937301e-01 6.478812986505504412e-01 9.971695982152032345e-01 2.606721082477282403e-01 5.483439686378906996e-01 4.409612606704470528e-01 4.396442074915688503e-01 7.414262832597111608e-01 7.308840725375539416e-01 8.072095530497225280e-02 6.829509968656330976e-01 5.700030854230387911e-01 3.801845336730320657e-01 2.481059916867158766e-01 3.977295094395927322e-03 5.749480512407895150e-01 4.112033136603401307e-01 8.676159710377848722e-01 9.062646588480167686e-01 3.326691167317923359e-01 8.498307982774666591e-01
+4.464338109330643345e-01 8.546516760817471914e-01 7.384800352329814466e-01 3.692485164984804502e-02 2.915662689505471583e-02 9.010049994217171898e-01 8.622900253010918892e-01 9.786230638032608065e-01 6.546824077297251909e-01 6.342297560006789903e-01 2.230339826582647955e-01 7.658846744185553446e-01 4.603043831539479491e-01 2.017100469861691225e-01 4.891590639893540482e-01 1.937140918314912419e-01 8.161582138652878626e-01 5.597293607114051106e-02 8.423261093326828153e-02 5.105392204475533990e-02 8.234193902673621057e-01 1.784268309975372002e-01 9.118997881986501408e-02
+8.588746913421980711e-01 1.479641118621310980e-02 1.375875301146138874e-01 7.533888774725254756e-01 5.782592791549248101e-01 9.128573037619659436e-01 1.831275762880391067e-01 3.471382864827737835e-01 4.859524740929310749e-02 8.955146541561730400e-01 4.787220791101074457e-01 4.222803577759057791e-01 8.469923964908064873e-01 6.300290047587608910e-02 1.020873237837905956e-01 3.585612487182909813e-02 6.320107119904569970e-01 5.891245970008752719e-01 1.104698053665007507e-01 4.233226558073774903e-01 4.432217054386708988e-01 2.864765416628194394e-01 2.489777211814803159e-02
+5.343810659756068615e-01 4.829076396403546578e-01 8.364480888953172988e-01 8.931374995414760321e-01 6.034161442354715188e-01 3.578336000768178593e-03 4.100579775972763574e-01 3.968667908067096128e-01 5.897163653686778861e-01 3.003241263928478899e-01 2.520935203143799264e-01 3.112129371563532310e-02 9.052865295974613646e-01 1.172285124002711010e-01 4.840001666149388315e-01 3.424620676348436588e-01 5.526057133826853818e-01 6.346139530261846184e-01 5.747945930485597321e-01 1.389915612177697879e-01 2.413801217666421417e-01 7.829900796662081497e-01 7.213528084845653998e-01
+9.384509283406079483e-01 6.303019601671526750e-01 1.787921522728125323e-01 1.556003868047917127e-02 5.662397078816850948e-01 3.437473614806091371e-01 8.615844972800188462e-01 7.624380237306396246e-01 1.096468347898514883e-01 1.276566836610887323e-01 8.479188493443535757e-01 3.634713454428405432e-01 7.478112314318967613e-01 9.856395696968375253e-01 6.250293654177319080e-02 1.919327272501809567e-01 1.415594476031050153e-01 7.224057351041784925e-01 8.452145259310355208e-01 5.434318833772002755e-01 5.177620959731277228e-02 3.358977598185840518e-01 2.542654881527960375e-01
+4.800909104006243489e-01 3.651345393613150137e-01 3.657093052788148446e-01 8.579662326651369408e-01 5.787694361240260932e-01 6.491966196891312268e-01 3.252508517294879775e-01 8.639694334693422961e-01 3.028097078756678551e-01 6.295814666338699350e-01 7.305627351548695803e-01 6.975931849120264872e-03 8.321205159004851915e-01 2.681809305821257761e-01 3.628869474597150591e-01 9.598981434716586936e-01 5.947913523332928332e-01 7.794864238003402779e-01 2.819511239444029149e-01 5.134200958476284882e-01 7.284684743064278045e-01 3.099571109539331903e-01 1.502222882866774967e-01
+2.463382654375219083e-01 4.465700737264240994e-01 7.180855317941433613e-01 5.056099420785193921e-01 6.182117344332578313e-01 2.370453793561340117e-01 9.831748018047525850e-01 6.397098184531551102e-01 8.260469782208745837e-02 7.474671691560941245e-01 9.963429983418570224e-02 5.450078811081275898e-01 5.370188678062637333e-02 2.774024442708808991e-01 2.082643088545442778e-01 2.704155352788065736e-01 7.225035580445194894e-01 4.866791976239246420e-01 1.357043111201584606e-01 7.911335827987711067e-01 7.278977102006007893e-01 6.880892094410231419e-01 1.029231496520791600e-01
+6.901796117735281566e-01 1.558248977395644275e-01 4.241818789360329855e-01 5.055658246392458199e-01 1.756288758075611467e-01 4.215083703818177652e-01 7.809231602323289945e-01 1.170053878686481141e-01 6.497026323614403243e-01 5.733120641440232479e-01 4.407703406152092551e-01 5.608677124532297498e-01 7.471045703286000039e-01 3.334604336022076732e-01 8.927208811415126011e-01 9.794565286182396191e-01 9.621542824973521313e-01 3.945825239405253981e-01 8.338963875792834157e-01 9.310552325082104286e-01 7.688283033784242271e-01 3.798823731047119567e-01 1.459993613028365278e-02
+7.848623555505630511e-01 2.681039365355797344e-03 7.833208051794043891e-01 8.184381915171493604e-01 4.682581645582317709e-01 2.391069309436419932e-01 1.765377537168698607e-01 9.863494676539893424e-01 4.378412300863872009e-01 7.494505491149090481e-01 1.942180356195394308e-01 9.981402467222395547e-01 7.992190944052800505e-01 1.350875702852057936e-01 4.950149186748543650e-01 7.243422481248201761e-01 3.544596746353472216e-01 8.320192561472177228e-01 9.776840296475269865e-01 7.733852731914863110e-01 2.305732998099923048e-01 9.746878189802981041e-01 7.747723331200035979e-01
+6.521099013127149568e-01 5.452399443648201505e-01 8.146707517183656710e-01 3.827256063695345656e-01 7.954832091744263867e-01 7.834427643148527132e-01 9.661317930643520402e-02 9.215673965718058636e-01 4.914305728788055383e-01 4.105628408027649501e-01 9.844647830893304974e-02 3.974831165301851987e-01 3.857608898053827007e-01 5.520210781401946321e-01 3.445787541654143915e-03 4.552922057017416702e-01 7.456544561760444223e-01 4.753985092154335845e-01 2.821385239833401615e-01 7.560136035104459973e-01 8.453142510471420845e-01 6.679627143276523071e-01 6.910882868284401459e-01
+8.526493480446283302e-01 1.183917973068240315e-01 6.163988861865119517e-01 5.751899460059114455e-01 1.638797964925038375e-01 8.214597298784013235e-01 5.424670654187370156e-01 1.806631819658732763e-01 9.268107278221827672e-01 4.127397378597359445e-01 7.529877485901653733e-01 1.714251090083847018e-01 2.601487784245806179e-01 2.028326156742237263e-01 5.299879450122358948e-01 7.587877062981395193e-01 4.070738595375062996e-01 3.546903049793261875e-01 8.695365138547607176e-01 1.447085661525142619e-01 3.193366245820845606e-01 8.797841086211429795e-01 2.666562188639977071e-01

env-llmeval/lib/python3.10/site-packages/scipy/spatial/tests/data/iris.txt

@@ -0,0 +1,150 @@
+5.099999999999999645e+00 3.500000000000000000e+00 1.399999999999999911e+00 2.000000000000000111e-01
+4.900000000000000355e+00 3.000000000000000000e+00 1.399999999999999911e+00 2.000000000000000111e-01
+4.700000000000000178e+00 3.200000000000000178e+00 1.300000000000000044e+00 2.000000000000000111e-01
+4.599999999999999645e+00 3.100000000000000089e+00 1.500000000000000000e+00 2.000000000000000111e-01
+5.000000000000000000e+00 3.600000000000000089e+00 1.399999999999999911e+00 2.000000000000000111e-01
+5.400000000000000355e+00 3.899999999999999911e+00 1.699999999999999956e+00 4.000000000000000222e-01
+4.599999999999999645e+00 3.399999999999999911e+00 1.399999999999999911e+00 2.999999999999999889e-01
+5.000000000000000000e+00 3.399999999999999911e+00 1.500000000000000000e+00 2.000000000000000111e-01
+4.400000000000000355e+00 2.899999999999999911e+00 1.399999999999999911e+00 2.000000000000000111e-01
+4.900000000000000355e+00 3.100000000000000089e+00 1.500000000000000000e+00 1.000000000000000056e-01
+5.400000000000000355e+00 3.700000000000000178e+00 1.500000000000000000e+00 2.000000000000000111e-01
+4.799999999999999822e+00 3.399999999999999911e+00 1.600000000000000089e+00 2.000000000000000111e-01
+4.799999999999999822e+00 3.000000000000000000e+00 1.399999999999999911e+00 1.000000000000000056e-01
+4.299999999999999822e+00 3.000000000000000000e+00 1.100000000000000089e+00 1.000000000000000056e-01
+5.799999999999999822e+00 4.000000000000000000e+00 1.199999999999999956e+00 2.000000000000000111e-01
+5.700000000000000178e+00 4.400000000000000355e+00 1.500000000000000000e+00 4.000000000000000222e-01
+5.400000000000000355e+00 3.899999999999999911e+00 1.300000000000000044e+00 4.000000000000000222e-01
+5.099999999999999645e+00 3.500000000000000000e+00 1.399999999999999911e+00 2.999999999999999889e-01
+5.700000000000000178e+00 3.799999999999999822e+00 1.699999999999999956e+00 2.999999999999999889e-01
+5.099999999999999645e+00 3.799999999999999822e+00 1.500000000000000000e+00 2.999999999999999889e-01
+5.400000000000000355e+00 3.399999999999999911e+00 1.699999999999999956e+00 2.000000000000000111e-01
+5.099999999999999645e+00 3.700000000000000178e+00 1.500000000000000000e+00 4.000000000000000222e-01
+4.599999999999999645e+00 3.600000000000000089e+00 1.000000000000000000e+00 2.000000000000000111e-01
+5.099999999999999645e+00 3.299999999999999822e+00 1.699999999999999956e+00 5.000000000000000000e-01
+4.799999999999999822e+00 3.399999999999999911e+00 1.899999999999999911e+00 2.000000000000000111e-01
+5.000000000000000000e+00 3.000000000000000000e+00 1.600000000000000089e+00 2.000000000000000111e-01
+5.000000000000000000e+00 3.399999999999999911e+00 1.600000000000000089e+00 4.000000000000000222e-01
+5.200000000000000178e+00 3.500000000000000000e+00 1.500000000000000000e+00 2.000000000000000111e-01
+5.200000000000000178e+00 3.399999999999999911e+00 1.399999999999999911e+00 2.000000000000000111e-01
+4.700000000000000178e+00 3.200000000000000178e+00 1.600000000000000089e+00 2.000000000000000111e-01
+4.799999999999999822e+00 3.100000000000000089e+00 1.600000000000000089e+00 2.000000000000000111e-01
+5.400000000000000355e+00 3.399999999999999911e+00 1.500000000000000000e+00 4.000000000000000222e-01
+5.200000000000000178e+00 4.099999999999999645e+00 1.500000000000000000e+00 1.000000000000000056e-01
+5.500000000000000000e+00 4.200000000000000178e+00 1.399999999999999911e+00 2.000000000000000111e-01
+4.900000000000000355e+00 3.100000000000000089e+00 1.500000000000000000e+00 1.000000000000000056e-01
+5.000000000000000000e+00 3.200000000000000178e+00 1.199999999999999956e+00 2.000000000000000111e-01
+5.500000000000000000e+00 3.500000000000000000e+00 1.300000000000000044e+00 2.000000000000000111e-01
+4.900000000000000355e+00 3.100000000000000089e+00 1.500000000000000000e+00 1.000000000000000056e-01
+4.400000000000000355e+00 3.000000000000000000e+00 1.300000000000000044e+00 2.000000000000000111e-01
+5.099999999999999645e+00 3.399999999999999911e+00 1.500000000000000000e+00 2.000000000000000111e-01
+5.000000000000000000e+00 3.500000000000000000e+00 1.300000000000000044e+00 2.999999999999999889e-01
+4.500000000000000000e+00 2.299999999999999822e+00 1.300000000000000044e+00 2.999999999999999889e-01
+4.400000000000000355e+00 3.200000000000000178e+00 1.300000000000000044e+00 2.000000000000000111e-01
+5.000000000000000000e+00 3.500000000000000000e+00 1.600000000000000089e+00 5.999999999999999778e-01
+5.099999999999999645e+00 3.799999999999999822e+00 1.899999999999999911e+00 4.000000000000000222e-01
+4.799999999999999822e+00 3.000000000000000000e+00 1.399999999999999911e+00 2.999999999999999889e-01
+5.099999999999999645e+00 3.799999999999999822e+00 1.600000000000000089e+00 2.000000000000000111e-01
+4.599999999999999645e+00 3.200000000000000178e+00 1.399999999999999911e+00 2.000000000000000111e-01
+5.299999999999999822e+00 3.700000000000000178e+00 1.500000000000000000e+00 2.000000000000000111e-01
+5.000000000000000000e+00 3.299999999999999822e+00 1.399999999999999911e+00 2.000000000000000111e-01
+7.000000000000000000e+00 3.200000000000000178e+00 4.700000000000000178e+00 1.399999999999999911e+00
+6.400000000000000355e+00 3.200000000000000178e+00 4.500000000000000000e+00 1.500000000000000000e+00
+6.900000000000000355e+00 3.100000000000000089e+00 4.900000000000000355e+00 1.500000000000000000e+00
+5.500000000000000000e+00 2.299999999999999822e+00 4.000000000000000000e+00 1.300000000000000044e+00
+6.500000000000000000e+00 2.799999999999999822e+00 4.599999999999999645e+00 1.500000000000000000e+00
+5.700000000000000178e+00 2.799999999999999822e+00 4.500000000000000000e+00 1.300000000000000044e+00
+6.299999999999999822e+00 3.299999999999999822e+00 4.700000000000000178e+00 1.600000000000000089e+00
+4.900000000000000355e+00 2.399999999999999911e+00 3.299999999999999822e+00 1.000000000000000000e+00
+6.599999999999999645e+00 2.899999999999999911e+00 4.599999999999999645e+00 1.300000000000000044e+00
+5.200000000000000178e+00 2.700000000000000178e+00 3.899999999999999911e+00 1.399999999999999911e+00
+5.000000000000000000e+00 2.000000000000000000e+00 3.500000000000000000e+00 1.000000000000000000e+00
+5.900000000000000355e+00 3.000000000000000000e+00 4.200000000000000178e+00 1.500000000000000000e+00
+6.000000000000000000e+00 2.200000000000000178e+00 4.000000000000000000e+00 1.000000000000000000e+00
+6.099999999999999645e+00 2.899999999999999911e+00 4.700000000000000178e+00 1.399999999999999911e+00
+5.599999999999999645e+00 2.899999999999999911e+00 3.600000000000000089e+00 1.300000000000000044e+00
+6.700000000000000178e+00 3.100000000000000089e+00 4.400000000000000355e+00 1.399999999999999911e+00
+5.599999999999999645e+00 3.000000000000000000e+00 4.500000000000000000e+00 1.500000000000000000e+00
+5.799999999999999822e+00 2.700000000000000178e+00 4.099999999999999645e+00 1.000000000000000000e+00
+6.200000000000000178e+00 2.200000000000000178e+00 4.500000000000000000e+00 1.500000000000000000e+00
+5.599999999999999645e+00 2.500000000000000000e+00 3.899999999999999911e+00 1.100000000000000089e+00
+5.900000000000000355e+00 3.200000000000000178e+00 4.799999999999999822e+00 1.800000000000000044e+00
+6.099999999999999645e+00 2.799999999999999822e+00 4.000000000000000000e+00 1.300000000000000044e+00
+6.299999999999999822e+00 2.500000000000000000e+00 4.900000000000000355e+00 1.500000000000000000e+00
+6.099999999999999645e+00 2.799999999999999822e+00 4.700000000000000178e+00 1.199999999999999956e+00
+6.400000000000000355e+00 2.899999999999999911e+00 4.299999999999999822e+00 1.300000000000000044e+00
+6.599999999999999645e+00 3.000000000000000000e+00 4.400000000000000355e+00 1.399999999999999911e+00
+6.799999999999999822e+00 2.799999999999999822e+00 4.799999999999999822e+00 1.399999999999999911e+00
+6.700000000000000178e+00 3.000000000000000000e+00 5.000000000000000000e+00 1.699999999999999956e+00
+6.000000000000000000e+00 2.899999999999999911e+00 4.500000000000000000e+00 1.500000000000000000e+00
+5.700000000000000178e+00 2.600000000000000089e+00 3.500000000000000000e+00 1.000000000000000000e+00
+5.500000000000000000e+00 2.399999999999999911e+00 3.799999999999999822e+00 1.100000000000000089e+00
+5.500000000000000000e+00 2.399999999999999911e+00 3.700000000000000178e+00 1.000000000000000000e+00
+5.799999999999999822e+00 2.700000000000000178e+00 3.899999999999999911e+00 1.199999999999999956e+00
+6.000000000000000000e+00 2.700000000000000178e+00 5.099999999999999645e+00 1.600000000000000089e+00
+5.400000000000000355e+00 3.000000000000000000e+00 4.500000000000000000e+00 1.500000000000000000e+00
+6.000000000000000000e+00 3.399999999999999911e+00 4.500000000000000000e+00 1.600000000000000089e+00
+6.700000000000000178e+00 3.100000000000000089e+00 4.700000000000000178e+00 1.500000000000000000e+00
+6.299999999999999822e+00 2.299999999999999822e+00 4.400000000000000355e+00 1.300000000000000044e+00
+5.599999999999999645e+00 3.000000000000000000e+00 4.099999999999999645e+00 1.300000000000000044e+00
+5.500000000000000000e+00 2.500000000000000000e+00 4.000000000000000000e+00 1.300000000000000044e+00
+5.500000000000000000e+00 2.600000000000000089e+00 4.400000000000000355e+00 1.199999999999999956e+00
+6.099999999999999645e+00 3.000000000000000000e+00 4.599999999999999645e+00 1.399999999999999911e+00
+5.799999999999999822e+00 2.600000000000000089e+00 4.000000000000000000e+00 1.199999999999999956e+00
+5.000000000000000000e+00 2.299999999999999822e+00 3.299999999999999822e+00 1.000000000000000000e+00
+5.599999999999999645e+00 2.700000000000000178e+00 4.200000000000000178e+00 1.300000000000000044e+00
+5.700000000000000178e+00 3.000000000000000000e+00 4.200000000000000178e+00 1.199999999999999956e+00
+5.700000000000000178e+00 2.899999999999999911e+00 4.200000000000000178e+00 1.300000000000000044e+00
+6.200000000000000178e+00 2.899999999999999911e+00 4.299999999999999822e+00 1.300000000000000044e+00
+5.099999999999999645e+00 2.500000000000000000e+00 3.000000000000000000e+00 1.100000000000000089e+00
+5.700000000000000178e+00 2.799999999999999822e+00 4.099999999999999645e+00 1.300000000000000044e+00
+6.299999999999999822e+00 3.299999999999999822e+00 6.000000000000000000e+00 2.500000000000000000e+00
+5.799999999999999822e+00 2.700000000000000178e+00 5.099999999999999645e+00 1.899999999999999911e+00
+7.099999999999999645e+00 3.000000000000000000e+00 5.900000000000000355e+00 2.100000000000000089e+00
+6.299999999999999822e+00 2.899999999999999911e+00 5.599999999999999645e+00 1.800000000000000044e+00
+6.500000000000000000e+00 3.000000000000000000e+00 5.799999999999999822e+00 2.200000000000000178e+00
+7.599999999999999645e+00 3.000000000000000000e+00 6.599999999999999645e+00 2.100000000000000089e+00
+4.900000000000000355e+00 2.500000000000000000e+00 4.500000000000000000e+00 1.699999999999999956e+00
+7.299999999999999822e+00 2.899999999999999911e+00 6.299999999999999822e+00 1.800000000000000044e+00
+6.700000000000000178e+00 2.500000000000000000e+00 5.799999999999999822e+00 1.800000000000000044e+00
+7.200000000000000178e+00 3.600000000000000089e+00 6.099999999999999645e+00 2.500000000000000000e+00
+6.500000000000000000e+00 3.200000000000000178e+00 5.099999999999999645e+00 2.000000000000000000e+00
+6.400000000000000355e+00 2.700000000000000178e+00 5.299999999999999822e+00 1.899999999999999911e+00
+6.799999999999999822e+00 3.000000000000000000e+00 5.500000000000000000e+00 2.100000000000000089e+00
+5.700000000000000178e+00 2.500000000000000000e+00 5.000000000000000000e+00 2.000000000000000000e+00
+5.799999999999999822e+00 2.799999999999999822e+00 5.099999999999999645e+00 2.399999999999999911e+00
+6.400000000000000355e+00 3.200000000000000178e+00 5.299999999999999822e+00 2.299999999999999822e+00
+6.500000000000000000e+00 3.000000000000000000e+00 5.500000000000000000e+00 1.800000000000000044e+00
+7.700000000000000178e+00 3.799999999999999822e+00 6.700000000000000178e+00 2.200000000000000178e+00
+7.700000000000000178e+00 2.600000000000000089e+00 6.900000000000000355e+00 2.299999999999999822e+00
+6.000000000000000000e+00 2.200000000000000178e+00 5.000000000000000000e+00 1.500000000000000000e+00
+6.900000000000000355e+00 3.200000000000000178e+00 5.700000000000000178e+00 2.299999999999999822e+00
+5.599999999999999645e+00 2.799999999999999822e+00 4.900000000000000355e+00 2.000000000000000000e+00
+7.700000000000000178e+00 2.799999999999999822e+00 6.700000000000000178e+00 2.000000000000000000e+00
+6.299999999999999822e+00 2.700000000000000178e+00 4.900000000000000355e+00 1.800000000000000044e+00
+6.700000000000000178e+00 3.299999999999999822e+00 5.700000000000000178e+00 2.100000000000000089e+00
+7.200000000000000178e+00 3.200000000000000178e+00 6.000000000000000000e+00 1.800000000000000044e+00
+6.200000000000000178e+00 2.799999999999999822e+00 4.799999999999999822e+00 1.800000000000000044e+00
+6.099999999999999645e+00 3.000000000000000000e+00 4.900000000000000355e+00 1.800000000000000044e+00
+6.400000000000000355e+00 2.799999999999999822e+00 5.599999999999999645e+00 2.100000000000000089e+00
+7.200000000000000178e+00 3.000000000000000000e+00 5.799999999999999822e+00 1.600000000000000089e+00
+7.400000000000000355e+00 2.799999999999999822e+00 6.099999999999999645e+00 1.899999999999999911e+00
+7.900000000000000355e+00 3.799999999999999822e+00 6.400000000000000355e+00 2.000000000000000000e+00
+6.400000000000000355e+00 2.799999999999999822e+00 5.599999999999999645e+00 2.200000000000000178e+00
+6.299999999999999822e+00 2.799999999999999822e+00 5.099999999999999645e+00 1.500000000000000000e+00
+6.099999999999999645e+00 2.600000000000000089e+00 5.599999999999999645e+00 1.399999999999999911e+00
+7.700000000000000178e+00 3.000000000000000000e+00 6.099999999999999645e+00 2.299999999999999822e+00
+6.299999999999999822e+00 3.399999999999999911e+00 5.599999999999999645e+00 2.399999999999999911e+00
+6.400000000000000355e+00 3.100000000000000089e+00 5.500000000000000000e+00 1.800000000000000044e+00
+6.000000000000000000e+00 3.000000000000000000e+00 4.799999999999999822e+00 1.800000000000000044e+00
+6.900000000000000355e+00 3.100000000000000089e+00 5.400000000000000355e+00 2.100000000000000089e+00
+6.700000000000000178e+00 3.100000000000000089e+00 5.599999999999999645e+00 2.399999999999999911e+00
+6.900000000000000355e+00 3.100000000000000089e+00 5.099999999999999645e+00 2.299999999999999822e+00
+5.799999999999999822e+00 2.700000000000000178e+00 5.099999999999999645e+00 1.899999999999999911e+00
+6.799999999999999822e+00 3.200000000000000178e+00 5.900000000000000355e+00 2.299999999999999822e+00
+6.700000000000000178e+00 3.299999999999999822e+00 5.700000000000000178e+00 2.500000000000000000e+00
+6.700000000000000178e+00 3.000000000000000000e+00 5.200000000000000178e+00 2.299999999999999822e+00
+6.299999999999999822e+00 2.500000000000000000e+00 5.000000000000000000e+00 1.899999999999999911e+00
+6.500000000000000000e+00 3.000000000000000000e+00 5.200000000000000178e+00 2.000000000000000000e+00
+6.200000000000000178e+00 3.399999999999999911e+00 5.400000000000000355e+00 2.299999999999999822e+00
+5.900000000000000355e+00 3.000000000000000000e+00 5.099999999999999645e+00 1.800000000000000044e+00

env-llmeval/lib/python3.10/site-packages/scipy/spatial/tests/data/pdist-boolean-inp.txt

@@ -0,0 +1,20 @@
+1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00
+1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00
+1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00
+0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00
+1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00
+1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00
+1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00
+1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00
+1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00
+1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00
+0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00
+1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00
+1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00
+1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00
+0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00
+1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00
+1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00
+0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00
+1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00
+1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00

env-llmeval/lib/python3.10/site-packages/scipy/spatial/tests/data/pdist-chebyshev-ml.txt

@@ -0,0 +1 @@
+   8.9084734e-01   9.3573853e-01   9.3507398e-01   9.6040691e-01   9.2918157e-01   9.6617342e-01   9.0430930e-01   9.5753424e-01   8.7106898e-01   9.2169905e-01   9.7401159e-01   8.9013416e-01   9.3956689e-01   9.0041896e-01   9.2588355e-01   9.3849417e-01   8.9713468e-01   9.1481804e-01   9.7500539e-01   9.0012586e-01   9.0962559e-01   8.5860091e-01   8.6981095e-01   8.9995771e-01   8.8070172e-01   9.1456657e-01   8.6711474e-01   9.2593917e-01   8.7560376e-01   8.5193121e-01   9.0898542e-01   8.7765302e-01   8.6555584e-01   8.6093485e-01   9.0447028e-01   8.7614405e-01   9.4803522e-01   8.4998062e-01   7.8398996e-01   8.9538612e-01   8.3902291e-01   9.9039470e-01   9.5480519e-01   8.9152195e-01   9.1623329e-01   7.9094921e-01   9.1777100e-01   9.8972335e-01   9.0429093e-01   8.7646362e-01   9.2136649e-01   9.7178177e-01   8.9610979e-01   9.4710327e-01   9.3612450e-01   9.0241499e-01   7.7992538e-01   8.7262126e-01   9.3325183e-01   8.5796531e-01   9.4267977e-01   6.7224167e-01   7.9568368e-01   8.6411267e-01   9.3311642e-01   9.0160114e-01   9.0698887e-01   8.5833256e-01   9.6902830e-01   9.5072298e-01   8.6808495e-01   9.7879599e-01   8.8060729e-01   8.2818573e-01   8.4366706e-01   8.4506700e-01   9.4532981e-01   9.1792306e-01   7.8917825e-01   9.8337805e-01   8.1751613e-01   9.3037855e-01   9.1618832e-01   8.6568874e-01   8.9751397e-01   8.7923710e-01   8.6814329e-01   9.0330164e-01   8.2426213e-01   9.4644643e-01   8.8431293e-01   8.8497426e-01   9.0633818e-01   9.5537161e-01   8.2167575e-01   8.7771053e-01   9.0681167e-01   8.7626143e-01   8.7463464e-01   9.8033940e-01   9.2920881e-01   9.5108549e-01   9.1287466e-01   8.0052218e-01   9.2409517e-01   8.8252650e-01   8.7873923e-01   9.2989402e-01   9.1985043e-01   9.6172646e-01   8.8223856e-01   9.4477822e-01   8.8310948e-01   9.4461306e-01   9.1875210e-01   9.1233363e-01   9.2124013e-01   9.5460897e-01   8.4640982e-01   9.0882657e-01   9.8169468e-01   9.7828355e-01   8.4150533e-01   8.6888923e-01   9.7138825e-01   8.7988144e-01   9.6720910e-01   8.9450147e-01   9.5331584e-01   8.8871809e-01   8.9736685e-01   8.6258146e-01   9.1331565e-01   9.0968870e-01   9.4833654e-01   9.0536967e-01   9.5099871e-01   8.0251958e-01   9.2526150e-01   9.8971957e-01   9.0340947e-01   9.4955892e-01   9.6838162e-01   8.7534901e-01   9.1178797e-01   9.2649154e-01   9.5260993e-01   9.3178143e-01   9.4943000e-01   8.7816171e-01   9.6506542e-01   8.3422958e-01   9.3443585e-01   9.3220084e-01   8.5706573e-01   8.4666325e-01   9.0474744e-01   9.1080644e-01   9.2406899e-01   8.7901768e-01   9.3265263e-01   9.5992829e-01   9.5696271e-01   9.1932272e-01   8.0937044e-01   9.0904917e-01   8.9516756e-01   9.4797906e-01   8.4159421e-01   9.6773901e-01   9.7099825e-01   9.6941820e-01   9.8174088e-01   9.7569951e-01   9.3655362e-01   8.4130333e-01   9.5994549e-01   8.4235414e-01   9.1429418e-01   9.3418117e-01   8.4600977e-01   8.8166496e-01   8.7594776e-01   8.8571112e-01   9.6308174e-01   9.5315927e-01   8.6997519e-01   8.9383032e-01   9.4686804e-01   9.4399596e-01

env-llmeval/lib/python3.10/site-packages/scipy/spatial/tests/data/pdist-cityblock-ml.txt

@@ -0,0 +1 @@
+   3.2420590e+01   3.3246607e+01   3.0526910e+01   3.5166573e+01   3.1868301e+01   3.6025002e+01   3.2513623e+01   3.6557796e+01   3.3752212e+01   3.4422130e+01   3.2526018e+01   3.2581161e+01   3.3743555e+01   3.6960777e+01   3.4225270e+01   3.2965308e+01   3.4591031e+01   3.4204203e+01   3.4678123e+01   3.5728720e+01   3.0830047e+01   3.1550681e+01   3.3304790e+01   3.2676753e+01   3.2742330e+01   3.1684556e+01   3.2830915e+01   3.2956614e+01   2.7365639e+01   3.3207307e+01   3.3420925e+01   3.4357941e+01   2.8280126e+01   3.4523458e+01   3.2705274e+01   3.2455891e+01   3.1636060e+01   3.1594957e+01   3.1805202e+01   3.3886574e+01   3.3438829e+01   3.3330030e+01   3.4168514e+01   3.0637353e+01   4.2149167e+01   3.6340559e+01   2.9315308e+01   3.5778314e+01   3.7693050e+01   3.2598714e+01   3.2990836e+01   3.4967659e+01   3.9748920e+01   3.6745043e+01   2.7117550e+01   3.6014760e+01   2.9367558e+01   3.3845350e+01   3.5477339e+01   3.1513372e+01   3.2517953e+01   2.4755097e+01   3.0229897e+01   3.4799343e+01   3.3371710e+01   2.9600910e+01   3.3275088e+01   3.3567110e+01   3.4527016e+01   3.4942320e+01   3.2359383e+01   3.2607100e+01   3.1467914e+01   2.9032039e+01   3.3122878e+01   2.8496709e+01   2.9908448e+01   2.9962886e+01   3.0345299e+01   3.1737613e+01   2.8551485e+01   3.2610551e+01   3.3082660e+01   3.3719298e+01   3.6434018e+01   3.6589278e+01   3.3889586e+01   3.8036774e+01   3.1483497e+01   3.4196794e+01   3.5154035e+01   3.5488608e+01   3.6143183e+01   3.3473491e+01   3.4686446e+01   2.8687495e+01   3.5725742e+01   3.0188298e+01   3.3084534e+01   3.3538519e+01   3.6226849e+01   2.9052099e+01   3.6032733e+01   3.0811503e+01   3.2616190e+01   3.3888566e+01   3.3074570e+01   2.9683515e+01   3.0600771e+01   3.4345247e+01   3.6983843e+01   3.3692824e+01   3.3762461e+01   3.4024582e+01   3.3698854e+01   3.1238613e+01   3.4978833e+01   3.4991078e+01   3.4577741e+01   3.3749227e+01   3.4982272e+01   3.0487868e+01   3.2317632e+01   3.1125588e+01   3.4413791e+01   3.1881871e+01   3.1373821e+01   3.0416864e+01   3.2066187e+01   3.1128313e+01   3.0240249e+01   3.0125198e+01   3.1343454e+01   3.5479092e+01   3.4450767e+01   3.2953507e+01   3.4456795e+01   3.0136375e+01   3.3462150e+01   2.9894274e+01   3.1367432e+01   3.2839320e+01   3.1440398e+01   2.9400374e+01   3.1106338e+01   3.1242624e+01   3.5537892e+01   3.3056459e+01   2.8610281e+01   3.4296217e+01   3.5819772e+01   3.2503922e+01   3.0963029e+01   3.4762112e+01   3.4796284e+01   2.9645345e+01   3.4468088e+01   2.6975590e+01   3.3738555e+01   2.8825009e+01   3.2663999e+01   3.2547878e+01   3.2308091e+01   3.2489966e+01   3.0868597e+01   3.2974220e+01   3.0866111e+01   3.8197342e+01   3.0609568e+01   3.5478978e+01   2.9249184e+01   3.6185622e+01   3.1948258e+01   3.2649719e+01   3.3305650e+01   3.4643955e+01   3.6566241e+01   3.4968484e+01   3.2632218e+01   3.6741383e+01   3.5700008e+01   3.1962468e+01   3.1410623e+01   3.0412061e+01   3.3749077e+01   3.5649661e+01   3.7649263e+01   3.2832574e+01   3.1783914e+01   2.8264292e+01

env-llmeval/lib/python3.10/site-packages/scipy/spatial/tests/data/pdist-correlation-ml.txt

@@ -0,0 +1 @@
+   9.2507465e-01   9.6528566e-01   8.7255441e-01   1.1287379e+00   8.7318727e-01   1.0767102e+00   9.1419676e-01   1.1503304e+00   9.8074509e-01   1.0135025e+00   1.0495025e+00   9.4794536e-01   9.6829273e-01   1.1345767e+00   1.1048008e+00   9.2407796e-01   1.0228634e+00   9.3853195e-01   9.9377619e-01   1.0407662e+00   9.5048989e-01   9.0465688e-01   9.8056930e-01   8.9777156e-01   9.6357127e-01   9.3864452e-01   9.9754613e-01   9.7271356e-01   8.4383151e-01   9.6981983e-01   9.7510267e-01   1.0112663e+00   7.8730400e-01   1.0299498e+00   9.9307979e-01   9.0239520e-01   8.5428231e-01   8.8972742e-01   8.5933162e-01   9.6625934e-01   9.4175449e-01   9.9120729e-01   1.0503963e+00   8.8223053e-01   1.3261434e+00   1.1063209e+00   8.4058398e-01   1.0844267e+00   1.1153093e+00   1.0092643e+00   8.9585237e-01   1.0599818e+00   1.2321707e+00   1.1359624e+00   8.3503556e-01   1.1792243e+00   7.9159781e-01   1.0830419e+00   1.2181870e+00   9.9888500e-01   1.0227144e+00   6.8557277e-01   9.6836193e-01   1.1061227e+00   1.0883453e+00   9.5681974e-01   9.9436299e-01   1.0304323e+00   1.1273949e+00   1.0735563e+00   1.0582583e+00   9.6040272e-01   1.0032137e+00   8.4900547e-01   1.1035351e+00   8.7867480e-01   9.6433176e-01   9.1850122e-01   8.9337435e-01   1.0449390e+00   8.9639384e-01   9.6704971e-01   1.0084258e+00   1.0528587e+00   1.1764481e+00   1.0913280e+00   1.0136672e+00   1.2737156e+00   9.5130359e-01   1.0367909e+00   1.1983402e+00   1.1319901e+00   1.1117462e+00   1.0343695e+00   1.0838628e+00   7.5266057e-01   1.0763316e+00   8.8067924e-01   9.6734383e-01   9.8800551e-01   1.2265742e+00   7.8833055e-01   1.0338670e+00   8.6666625e-01   9.9039950e-01   9.7142684e-01   9.3138616e-01   8.5849977e-01   8.5486301e-01   1.0516028e+00   1.1105313e+00   9.5943505e-01   9.8845171e-01   1.0566288e+00   9.9712198e-01   9.5545756e-01   1.1817974e+00   9.9128482e-01   1.0117892e+00   1.0979115e+00   1.0493943e+00   9.1318848e-01   9.3157311e-01   8.7073304e-01   1.2459441e+00   9.3412689e-01   1.0482297e+00   9.4224032e-01   9.5134153e-01   9.0857493e-01   9.7264161e-01   8.2900820e-01   9.3140549e-01   1.1330242e+00   1.0333002e+00   1.0117861e+00   1.2053255e+00   8.5291396e-01   1.0148928e+00   8.6641379e-01   9.7080819e-01   9.5457159e-01   9.5207457e-01   9.3539674e-01   9.0769069e-01   9.5322590e-01   1.1181803e+00   9.9765614e-01   7.5370610e-01   1.0807114e+00   1.0804601e+00   9.0214124e-01   8.7101998e-01   1.0167435e+00   1.2045936e+00   8.7300539e-01   1.1054300e+00   7.9145574e-01   1.0279340e+00   8.7623462e-01   1.0034756e+00   1.0386933e+00   9.3910970e-01   1.0028455e+00   9.9868824e-01   9.8752945e-01   9.8319327e-01   1.3110209e+00   8.6180633e-01   1.0993856e+00   8.5912563e-01   1.1303979e+00   9.8690459e-01   9.6910090e-01   9.1456819e-01   1.1525339e+00   1.1064552e+00   1.1062255e+00   9.7226683e-01   1.1091447e+00   1.1072238e+00   9.6544444e-01   9.6681036e-01   9.3247685e-01   9.6854634e-01   1.1035119e+00   1.1317148e+00   9.5557793e-01   9.8908485e-01   7.4873648e-01

env-llmeval/lib/python3.10/site-packages/scipy/spatial/tests/data/pdist-cosine-ml.txt

@@ -0,0 +1 @@
+   2.5695885e-01   2.6882042e-01   2.3470353e-01   2.9299329e-01   2.2742702e-01   3.1253572e-01   2.4986352e-01   3.0770122e-01   2.5191977e-01   2.7931567e-01   2.8133743e-01   2.6316239e-01   2.6067201e-01   3.2982339e-01   2.8993002e-01   2.5506356e-01   2.8728051e-01   2.4952121e-01   2.8613379e-01   2.6894157e-01   2.3606353e-01   2.1670935e-01   2.3470242e-01   2.4294172e-01   2.4376454e-01   2.3228195e-01   2.3554918e-01   2.4851241e-01   2.0917546e-01   2.4971488e-01   2.4264224e-01   2.7405461e-01   1.9086415e-01   2.6346574e-01   2.5908801e-01   2.2138495e-01   2.2910721e-01   2.2169919e-01   2.0660065e-01   2.3207102e-01   2.5554688e-01   2.5153751e-01   2.6073682e-01   2.0919640e-01   3.3984433e-01   2.7503792e-01   2.1709889e-01   2.7068095e-01   3.0307041e-01   2.4529612e-01   2.2987015e-01   2.7736967e-01   3.0310708e-01   3.0544316e-01   1.9205388e-01   2.7098021e-01   2.0722466e-01   2.6387343e-01   2.8998308e-01   2.2633010e-01   2.5177075e-01   1.6347011e-01   2.4036389e-01   2.6485871e-01   2.8491965e-01   2.2273619e-01   2.4511873e-01   2.5930533e-01   2.6589995e-01   2.7797191e-01   2.3357373e-01   2.4279909e-01   2.3544532e-01   1.9447286e-01   2.3993534e-01   2.0856243e-01   2.2125251e-01   2.1988206e-01   2.0590152e-01   2.6441952e-01   2.0052739e-01   2.2978496e-01   2.4483670e-01   2.3879510e-01   2.9398425e-01   2.7541852e-01   2.3777469e-01   2.9151131e-01   2.0672752e-01   2.4584031e-01   2.7475025e-01   2.7064343e-01   2.5603684e-01   2.6165327e-01   2.4233155e-01   1.7892657e-01   2.6111203e-01   1.9965682e-01   2.4201634e-01   2.6281353e-01   3.1928221e-01   1.9731963e-01   2.7752862e-01   2.2633080e-01   2.6783167e-01   2.5447186e-01   2.6424243e-01   2.1960672e-01   2.2984242e-01   2.8788736e-01   2.8681630e-01   2.6949787e-01   2.3993685e-01   2.4440073e-01   2.5010397e-01   2.3230769e-01   2.9879682e-01   2.4200592e-01   2.6957748e-01   2.6073240e-01   2.6355347e-01   2.3403674e-01   2.2411413e-01   2.2956729e-01   2.8105976e-01   2.2913304e-01   2.4898608e-01   2.3304000e-01   2.2692988e-01   2.3728251e-01   2.2552243e-01   2.0364084e-01   2.3359511e-01   2.6619167e-01   2.6666588e-01   2.3666880e-01   2.7239113e-01   2.0146697e-01   2.3045559e-01   2.1695523e-01   2.1387991e-01   2.2366404e-01   2.2809635e-01   2.0901297e-01   2.2441100e-01   2.3418882e-01   2.8552218e-01   2.4609015e-01   2.0282492e-01   2.5940295e-01   2.7407006e-01   2.3344890e-01   2.1179142e-01   2.7047821e-01   2.9832768e-01   2.0859082e-01   2.8881331e-01   1.8384598e-01   2.5286491e-01   2.2012615e-01   2.3615775e-01   2.6845565e-01   2.3356355e-01   2.7164193e-01   2.4179380e-01   2.5247973e-01   2.5637548e-01   3.2126483e-01   2.3100774e-01   2.8832546e-01   2.0043257e-01   2.7918333e-01   2.4884522e-01   2.2904723e-01   2.3738940e-01   2.9461278e-01   2.9782005e-01   3.0332073e-01   2.5175971e-01   3.1203784e-01   2.6611535e-01   2.3713507e-01   2.2203585e-01   2.3602325e-01   2.5093670e-01   2.6860434e-01   3.0137874e-01   2.3759606e-01   2.6840346e-01   1.9200556e-01

env-llmeval/lib/python3.10/site-packages/scipy/spatial/tests/data/pdist-double-inp.txt

@@ -0,0 +1,20 @@
+8.278938049410748956e-01 9.035293984476246987e-01 1.862188994679486731e-01 8.921151312310462433e-01 2.061859119379583216e-02 3.440636727385729676e-01 1.533779912830328662e-01 5.701372300009802663e-01 5.510020730211558915e-01 1.792362258426003496e-01 8.086175120876580857e-01 6.115487184317183189e-01 1.233471787164852618e-02 1.441643531871039663e-03 4.044309209045688913e-01 3.561398959499905148e-01 1.281985712929750720e-01 8.663300833847481508e-01 8.696027786291581352e-01 3.611727370363766454e-01 5.283537658772616830e-01 1.440241088090119526e-01 3.112457227138950566e-01 6.031280796897889873e-01 9.230324792742518047e-01 2.332121881136874908e-01 3.192652267403439659e-02 3.466206294995559656e-01 2.988687728046366399e-01 5.116749542048093513e-02 2.584975830914494344e-01 4.302023478042227289e-01 8.003972751713522849e-01 9.364931911368097328e-01 9.737098649964673891e-01 4.718038453972229762e-01 4.526591686607864817e-01 1.056485678520797666e-01 5.883019714285405710e-01 3.846092237676981274e-01 6.461500053435473845e-01 1.013239729848824933e-01 1.216151561651189761e-01 5.159668929484659827e-01 8.452074473510227115e-01 9.885170962247968873e-01 7.623883073490128615e-01 2.291163243615434997e-02 5.775530980802381364e-01 7.820699896828091635e-01 8.239186345842965942e-01 3.391800105260227571e-01 9.546318451614538292e-01 3.789677917867695367e-01 4.526533399649290690e-02 8.366786473238587707e-01 3.082636811049858094e-01 1.173936820793450853e-01 7.631994969169442200e-02 2.997416650722183329e-01 5.795208655160232203e-01 3.942350892542011431e-01 1.175126383297261379e-01 4.928232513950027149e-01 9.421293996225950096e-01 8.365391053841342295e-02 6.868059693571844093e-01 3.589527962429440722e-01 7.592939427166059962e-01 5.623849466131448649e-01 2.110746828032050715e-01 9.824683704668600859e-01 2.661230142246236996e-01 6.162272315007123469e-01 5.023254536607497656e-01 5.202854476669782624e-02 5.835090668842095596e-01 7.864642118889143552e-01 2.504012386867506823e-01 6.728308641135989365e-01 4.610793534576096420e-01 4.820508770515909980e-01 9.720403251022265989e-01 3.100069285263498120e-01 7.681017126461753275e-01 7.956539306007082146e-02 2.593389637887737464e-01 1.137852590403054531e-01 3.885303073284454012e-01 8.599094660075957686e-01 5.215167875918280682e-02 1.620908248572288102e-01 1.859236090457663249e-01 6.247716512610480555e-01 3.415128495520775020e-01 7.034903368378029320e-01 6.037564640019568163e-01 2.338969434423310290e-01 1.002104885609900187e-02 7.866058403969036217e-01
+8.033694116033356369e-01 8.653264545544031572e-01 7.468340410754038539e-01 6.362430919910603278e-01 5.120006306625468628e-02 9.503348372633585450e-01 4.697732609626817935e-01 4.221305288459429317e-01 3.153452119838391354e-01 2.991014843442657556e-01 1.190667967280257811e-01 3.486567714509342109e-01 8.289493649885054660e-01 8.454811050800014049e-01 9.149673018211901265e-01 7.708707837193897738e-01 2.640157732122547785e-01 2.107897022189605396e-01 4.207633055054439408e-01 6.719500284654699174e-01 1.458031684893063007e-01 1.800412735886125493e-02 8.402733435220011149e-02 4.206760156883160295e-02 1.376933515041314227e-01 1.716717341022133692e-01 1.788220727652158892e-01 8.224310433402118869e-01 7.729093666867475898e-01 2.064223621025984556e-01 9.592092036227207741e-01 8.312490243754996344e-01 6.673289360369902834e-01 4.632847903690773261e-02 7.643954098358983762e-01 9.359341525615098023e-01 1.914966319163026176e-01 4.536590469402868031e-01 8.640836016538007147e-01 3.941529178175462444e-02 5.602101995205478469e-01 9.263806161941660067e-01 1.555995325944817820e-01 6.172208102950116348e-01 6.335576752812099866e-01 9.766975460368043649e-02 4.475795689539874278e-02 3.248842796104995934e-01 5.700377122149502540e-01 9.066962967256807504e-01 5.458460621505676347e-01 6.833401285581487405e-01 2.887244409544044155e-01 1.316338647016834784e-01 2.325673305245992140e-01 4.150121963188406760e-01 3.834845466366055833e-01 8.149365773968725302e-01 1.867003849450201702e-01 3.170322173543018707e-01 6.832093662682684476e-01 1.729728518929105618e-01 9.236557359702636250e-01 9.152941252150086360e-01 7.224879983096620384e-01 8.557920626598064517e-01 5.344883059251644974e-01 4.876873274449112783e-01 8.308277804506420949e-01 3.916624489322212410e-01 3.459695122273966916e-01 4.033512499027409604e-01 6.555726444913008155e-01 7.138452409380238173e-01 1.683937314599968094e-01 1.769382143486440961e-01 7.588683655178136700e-01 3.750589892880819010e-01 7.525176245126207197e-01 6.083961152538303052e-01 1.145972309907993258e-01 6.239614485809552580e-01 1.307655482065895880e-01 8.530458750670916190e-01 4.801602070124768584e-01 8.168122189863546989e-02 3.793139622744635675e-01 1.496986997776840189e-01 7.129023878302899186e-01 6.830979237438047358e-01 7.635375943876505644e-01 1.824004963251233402e-01 5.764695848992339444e-01 8.865113248731604223e-01 5.784337085544002388e-01 9.700026628755119562e-01 7.318207347905059112e-01 3.851401393936705331e-01 1.774291851193399161e-01 9.763423229242296220e-01
+9.287178470949695175e-01 1.748282433617460718e-01 9.238531711586964734e-01 8.291274445125006443e-01 9.513259272578692416e-01 7.486316801165745494e-01 6.257378457524477300e-01 2.062711693536473101e-01 3.970721244184766130e-01 2.738325225026445597e-01 8.735038948299954642e-01 5.415282140033768066e-01 5.176317904298315398e-01 5.347036264518250093e-01 7.482056965410627258e-01 4.140672582824351800e-01 8.709067272363142376e-01 9.499605569181273079e-01 5.380266748336398619e-01 4.369252161707162241e-01 8.235722216228258397e-03 4.308187193646527691e-01 6.030581482859224129e-01 7.316831195156517920e-01 5.540499846834291420e-01 2.044203040111662872e-01 8.645251782981867583e-01 1.816095717570278545e-01 9.639119168018674966e-01 3.572031072322333634e-01 5.580226816834680248e-01 5.586629875016585478e-01 7.213854320902782780e-01 8.513998260042524580e-01 6.308764347277173723e-02 4.299855362100638567e-01 8.789303907444128150e-01 9.178850359236285783e-01 2.275205845091231582e-01 1.899395443939643213e-01 7.103070862773533944e-01 9.450015289553428399e-01 1.691856364522159595e-01 7.368719616877857925e-01 9.600189536623833231e-01 5.128846522932454244e-01 6.209162727118655578e-02 7.992250598838029907e-01 9.141050280518014937e-01 1.471297785256820978e-01 7.466162372930541524e-01 4.656107650642931084e-01 6.399324135161845728e-01 2.023617619481610230e-01 1.019104648900100996e-01 4.390693688536728700e-02 9.822620353006089600e-01 2.881951852926285529e-01 6.191575015960482098e-02 8.989580763251467932e-01 4.635958631890454429e-01 1.781973138114967270e-02 7.906911683818984571e-02 6.525270776225711167e-02 3.620583622807886925e-01 2.651673718940715796e-01 5.829372395929610651e-01 2.118159824373908595e-01 5.900287159143694504e-01 9.405929925178391215e-01 9.262415619063500971e-01 5.639581506302312475e-01 4.529556154689695635e-02 2.873819210518682166e-01 5.718545934306838996e-01 9.877670791317306742e-01 4.120364488714320927e-01 9.896078045634184583e-01 3.796586997026456523e-01 1.178183652203194098e-01 6.641068305236120795e-01 4.045960610587706618e-03 2.262690437428437340e-01 7.839938005832693957e-01 7.695391333937223743e-01 3.713918392552509884e-01 4.245533341514018399e-01 1.475072494020331915e-01 6.011975181419888514e-01 5.158174017998343741e-01 1.788706151398071764e-01 8.880707130134481986e-01 6.463351030474082659e-01 6.499920635615744624e-01 8.570273676455353318e-01 6.055019270899113515e-01 2.123561211054603159e-02 2.027688787664126968e-01 1.930834215328548487e-01 5.131906052747271518e-01
+2.599990881903107010e-01 6.767857524909899336e-01 7.188217446352963558e-01 3.037178903357997672e-01 4.252381412838680541e-01 4.070924411439535984e-02 8.426710493038247485e-02 8.301517457289483426e-01 8.254603255702420705e-01 7.258533909453509514e-01 9.958706809470796451e-01 1.323408451651194584e-01 8.523995455245143571e-01 2.572405385832454705e-02 4.715363690065482727e-01 7.920130365690022378e-01 7.613745641534582775e-01 5.108305991695683002e-01 7.908714335912382376e-01 4.641131983754837043e-01 3.112627109831845873e-01 4.218013908715474436e-01 3.291577909008427394e-01 2.538715054071232213e-01 1.362470842487485401e-01 2.716429790290709745e-01 1.485325814161112534e-01 4.514539027544387517e-01 6.900835128673067365e-01 7.793407072946112457e-02 5.938024345270752624e-01 1.497853829906865553e-01 5.399567982652856424e-01 1.419209916759478496e-03 7.719776132867679497e-01 3.130795105576239523e-01 6.670071611167494030e-01 8.900596881158256979e-01 8.011158503301568645e-01 7.089295605187424520e-01 4.671116382997058114e-01 6.682965170673403899e-01 6.524835265739736823e-02 5.454288420771494783e-01 7.751910790556310049e-01 8.192595541387335256e-01 3.098855848167891835e-01 3.689971355659119601e-01 8.666507475054133769e-01 2.749042684253171220e-01 3.566565602478318775e-01 4.838173174723044978e-01 1.032975933616413489e-01 5.063065339610417492e-02 5.791168455729079900e-01 3.573337411289496668e-01 6.714098909652352898e-01 2.917057662433912846e-01 2.654964332620638467e-01 7.171804039048814694e-01 3.314488637898249657e-01 5.230399837442840649e-01 6.866534136026025692e-02 1.252966394621071178e-01 5.349397882659551184e-01 2.841423847455760709e-01 4.158473635710734362e-01 7.197062989831272128e-01 5.123869045047864113e-01 8.675622821594339840e-01 8.097441845042540054e-01 7.317178252133832439e-01 3.300847596465853462e-01 5.922311859141077273e-01 8.852619511417836318e-02 2.673412917259408994e-01 6.878259052441990651e-01 3.223000927116328462e-01 8.859387123976615319e-01 5.722722388300067742e-01 8.254877606669521750e-01 5.705299682290687624e-01 7.046478734972855262e-01 1.316324413616759559e-01 3.056358395675535800e-01 2.396516834600909140e-01 2.041201422493257311e-01 1.610755140653103989e-01 1.617012564641111538e-01 4.449920510036902144e-01 2.731012972755201274e-01 7.826874666257994662e-01 5.193612375350010746e-01 8.688804522977213729e-01 3.742157602758655610e-02 6.649628920608219307e-01 5.978149424619171315e-01 5.345645500553952711e-01 9.443202650415919441e-01 6.105837075491723498e-01
+6.387761328141735584e-01 4.210087412162694109e-01 3.777306694964789324e-01 3.576349403292201634e-01 7.272699618880260619e-01 9.173392803607671731e-02 1.212535698300880593e-01 3.871229381194544183e-01 7.735150198351389284e-01 4.687200483013695962e-01 5.161778571874678923e-01 9.839646447226980674e-01 8.626932748911960713e-01 9.618485576577924245e-01 2.997996427525421170e-01 3.955404657388794654e-01 8.480126027102616870e-01 8.194992325050480808e-01 2.800213436873294492e-01 7.188391466620779324e-01 2.289766105875049584e-01 3.838547514028287644e-01 1.363553401061209369e-01 2.131328253542326134e-01 2.666779468144075960e-02 3.252883844200405994e-01 4.207860197469600605e-01 2.991365385037647595e-01 9.180779845534067229e-01 8.787338732192649937e-01 5.404510999105649471e-01 1.735493827761729335e-01 7.405224640747264386e-01 3.927355563629583157e-01 3.957109873399460298e-01 1.313029813325972128e-01 6.434498219738993274e-01 7.162213694578050127e-01 6.454998257494671821e-01 3.808124530008022424e-01 2.027201015737234435e-01 6.667632842770417900e-01 1.609491052365198405e-01 1.192413785409307536e-02 4.546773323526854815e-01 7.733541911050207940e-01 3.902525737195561284e-01 4.006023779897505133e-01 5.156517815815246930e-01 6.135685498584592112e-01 7.062153114980724844e-01 5.505858882117883324e-01 3.541308807182554919e-01 5.237151122342533771e-01 5.230649229131387745e-01 1.973541027697351957e-01 7.940327858595511712e-01 9.998588700623055603e-01 3.878271015153827994e-01 4.455006584967207139e-01 8.376414508056347907e-01 3.310833863524501597e-01 8.020469097392601832e-01 1.890327633084128989e-01 3.830289472395409511e-01 8.605040171046141051e-02 9.978185524023941433e-01 8.333890591892906263e-01 4.509013468741837061e-01 6.355778557686052599e-01 1.422515991097305088e-01 9.549891485963732940e-01 7.535776302868563148e-01 9.306005301880662106e-01 2.444330347211679522e-01 5.828218427569508142e-01 1.261938242968304591e-01 2.829188731405173352e-01 8.100246952078660190e-01 2.032739130996042975e-01 3.997268448390065565e-01 3.882777703107541667e-01 1.102505652624736765e-01 5.826634725328041498e-01 6.508734477956333864e-01 1.777287661702166011e-01 4.857051012052149286e-02 6.850537712379254351e-01 5.012281307761055071e-01 3.329154880061502286e-01 5.006261767216675374e-01 4.542081454976160115e-01 6.777801995399822532e-01 4.271303586474960445e-01 7.820470659692947413e-01 5.143462618485082904e-01 4.071273891563575997e-02 8.503383643856671226e-01 6.877485768345151795e-01 6.498843855014626580e-01
+5.539512747016193117e-01 6.329206647391879548e-01 2.798533500321682688e-01 4.825977295850051307e-01 7.625297023172977751e-01 9.081309101427640362e-01 4.124792086535029600e-01 3.647019658319609059e-01 7.529595202332928228e-02 3.072404010876803593e-01 7.890673660964639957e-01 4.079781478915127657e-01 1.440519120695739064e-01 2.538968953804546791e-01 1.595028243568367143e-01 9.066545851872198636e-02 6.367601114674349416e-01 7.622263643880089479e-02 3.015728236404162654e-01 2.424070469873378375e-01 5.711440390241000475e-01 5.717001375511508998e-01 2.237853674032181939e-01 7.112101625753678436e-01 4.321054197012103026e-01 2.505322169010260058e-02 5.877307077139551916e-01 4.415771174397812304e-01 3.766022855145171322e-01 9.803490652619811785e-01 1.229258314111529860e-01 8.108351868714478439e-01 8.558595456964329662e-01 2.168217533833206589e-01 2.034022719386595623e-01 8.687457137579783772e-01 9.013327195854559104e-01 8.156766512673154779e-01 2.717576187546973943e-01 1.756417893371479133e-01 7.555856977566548505e-01 6.708809351312817748e-01 8.998789237886926085e-01 1.936367585946979775e-01 7.949724635465026390e-01 3.164799312763589834e-01 5.493048513173155456e-01 1.608917269168268493e-01 3.048667492191803330e-01 5.599401537727016764e-01 5.779501360842279611e-01 1.296714605309662316e-01 9.160752328055997706e-01 8.058674476110374574e-01 4.385508937505578908e-01 9.212419718012100356e-01 2.249887451242467140e-01 6.283927745352599903e-01 3.778992451536005159e-01 3.571958698867505611e-03 7.276526470528231760e-01 9.051678673805297892e-01 8.465837072484881931e-01 4.548317505393462135e-02 3.189318261926020748e-01 4.446388607398673587e-01 4.292356336344156365e-01 4.203980977718795309e-01 4.698059253071955599e-01 6.151991200848159203e-01 8.479986139404802614e-01 9.870993262459623052e-01 3.164206525899861955e-01 6.464672171639846976e-01 8.508781429592480183e-01 4.733667503354813677e-01 8.076014176740163863e-01 6.671443255679101458e-01 6.639213267047979761e-01 3.681688930741919830e-01 4.679870252651611162e-01 1.790041740686979521e-01 8.446070273663058847e-01 3.350737544979878191e-01 6.600272349677447359e-01 4.356083218487936115e-01 7.995134167346013010e-01 9.083660261041469619e-01 9.743975306734570241e-01 8.144839650654719376e-01 6.865011984586443239e-01 1.709747281999153268e-01 8.534933687161740945e-01 9.494753729726415070e-01 8.140124992294850426e-01 8.936241255316055287e-01 9.087976860818796077e-01 9.030687493451383663e-02 4.025785149840914734e-01 9.592005611533803711e-01
+5.714058727476275523e-01 7.913573761505965365e-02 9.301773447377043036e-01 4.302822433307075256e-01 4.618892554175407783e-01 1.882471300213742760e-01 6.231472878215863487e-01 2.350437450940777717e-01 8.483410480771292894e-01 8.580803842040533036e-01 4.246398783388435350e-01 5.667321565946502604e-01 7.247417018955526480e-02 5.373984417482219333e-01 8.794242091541510931e-01 9.699025554453030162e-01 8.254197752548814160e-01 7.739723972867470492e-01 6.365819416181199841e-01 3.451230687021222820e-02 1.829102490094791644e-02 9.179618383026147965e-01 4.481667270072077214e-01 4.771270250445739380e-01 1.588469404953456454e-01 3.766332499200618633e-01 5.057026248713025751e-02 9.125900914275182352e-01 8.438133644246305076e-01 3.282972411719701222e-01 6.042003956122835584e-01 7.423456085393266290e-01 1.389012737541106546e-02 3.674754266702850991e-02 2.126646727703802586e-01 3.085666164246750887e-01 4.303440338750976757e-01 1.749037978865556342e-01 2.177699993322510519e-01 6.675614739991906355e-01 1.926533336347433512e-01 8.032010572660308600e-01 4.611412981769049679e-01 9.907201268457492827e-01 8.973785930837320235e-01 6.286342392657409128e-01 8.111266245859546364e-01 1.154230969025437092e-01 8.382880466301794176e-01 1.053753927827069115e-01 9.921712862234919328e-01 9.041662667920956631e-01 3.626267376021269362e-01 2.262225368932846425e-02 8.669003741626111204e-01 7.597054897704164089e-01 4.700318514995387442e-01 4.338185014241978665e-01 1.205425463362067573e-01 2.413879270602589111e-01 5.483334840461459025e-01 2.042653841254596925e-01 5.452588940366013270e-01 3.164646091706100339e-01 1.878958248945691301e-01 2.188622304737641855e-01 2.970982599823450698e-01 5.952148400199362976e-01 9.614251220149501176e-01 5.446813400697393392e-01 5.900748097930779146e-01 2.653062526715309621e-01 5.459933097767216692e-01 3.174185404661935550e-01 1.412133354129242457e-01 1.487441669790685594e-01 3.953776242211952674e-01 5.274261039692862418e-01 1.756132307607755072e-01 4.481942852746899630e-01 6.390660088765629521e-01 2.860380430081067571e-01 5.866902519902850166e-03 3.026687645174785946e-02 1.952533570196290924e-01 2.154769096186736066e-01 8.920573593276575064e-01 5.644513191915436767e-01 5.551464696654353492e-01 4.378199413349500579e-01 8.685737643974280608e-01 7.493934764293597173e-02 9.556749726352036234e-01 6.386433482536227890e-01 8.714694524097754691e-02 1.722786161701279628e-01 6.526867532768643176e-01 8.950304705281527662e-01 6.158198776753203152e-01 9.587176904005377809e-01
+7.705718397401561948e-01 3.165816092999733655e-01 4.334200859975760878e-01 8.639807015515663657e-01 5.576514209532534849e-03 2.456745447057938625e-01 1.664686313299922338e-01 9.637084729617834133e-01 1.083448720752323569e-01 1.865218070380464388e-01 3.730358890475884426e-01 5.015351872138350542e-01 7.420710795841709562e-01 4.919420674769692248e-01 3.426558201886464872e-02 8.669984854934246199e-01 2.204243734202966376e-01 4.109792246853891662e-01 4.361732572946559472e-01 6.819306998053020763e-02 9.986304248057148447e-01 4.119289455392274313e-01 8.533050041845835487e-01 3.416914861912183632e-01 6.522191951039880697e-01 4.162803668786793088e-01 9.051674379917418189e-02 4.552378661306888397e-02 2.122677193466918633e-01 7.461518531655018105e-01 4.654688019259497489e-01 7.877564083548750373e-01 4.518328005682387127e-01 7.173857464237374248e-01 6.940056370290903498e-02 2.804574410412373764e-01 6.095681113112718652e-01 3.680596478602831123e-01 1.814569150719304025e-01 6.505055517979729807e-01 2.759585245701871026e-01 1.429501104786028431e-01 7.813891153083207808e-02 8.925314279991185540e-01 6.692056941902108091e-01 1.915141341107173822e-01 5.750233129581091562e-01 2.051961006251528108e-01 3.849013692629975614e-01 9.503788222043518807e-01 7.690419386411734282e-01 9.978147530014782607e-01 1.719584162437415298e-01 4.890758882401113894e-01 7.195660736040896399e-01 2.485818040997200828e-01 9.706486601870933928e-01 5.182604282071262558e-01 8.082072245463804983e-01 4.889961284821118248e-01 8.042893959057633158e-01 3.200685313413229593e-01 8.983245016887355661e-01 2.811495336955205371e-01 3.986095833814048417e-01 8.607229214132059436e-01 4.827620119717191960e-01 6.715610252037491623e-01 9.330824374137768329e-01 7.537710530085762750e-01 9.840804224010484269e-01 2.319352541177217564e-01 9.569114943157627229e-01 5.821928104654411351e-01 6.700479524814679788e-01 5.663434680086896211e-01 8.851091082101365526e-01 6.800562815862243315e-01 3.578475213752868589e-01 2.900164669281133367e-01 8.379170683569914235e-02 9.929972839740475177e-02 5.946248553621906741e-01 1.991332889320840405e-01 8.115065723822508792e-01 2.023388190440008616e-01 4.056545651129230823e-01 2.966825350250481552e-01 7.457176343507545546e-01 9.856015771246517954e-01 2.264338016147812160e-01 8.366528670045663141e-01 6.116829813603242849e-01 2.605933184296719274e-01 5.765962146558850643e-01 5.064075092266390188e-01 5.499615769589756287e-01 9.240234698632640020e-01 7.169900155229913530e-02 3.544181364560751168e-01
+8.154844535553099627e-01 4.797965609394789777e-01 7.476703385713100447e-01 9.086708404761600910e-01 3.191752505450355937e-01 7.611128630021511965e-01 6.246790343299296611e-01 1.942001426217137006e-01 2.789860414631386565e-01 3.236359785042408621e-02 3.178191288741717413e-01 8.372264298357038337e-01 8.872692914664047636e-01 9.589758852077276963e-01 3.123722260380168425e-01 8.980164015338999439e-01 7.260784140459818348e-01 6.567013512265649222e-01 1.028743505926521529e-01 6.821705410750319443e-01 6.889838995316139858e-01 5.587525493094736007e-02 6.921487028366646310e-01 3.616312929861494885e-01 1.673758008792780583e-01 6.626504595920326146e-01 9.125680913222075086e-01 1.424077784972291871e-01 6.508496429060767197e-01 6.615417385775157477e-01 9.654167310675311198e-01 5.536662974550183858e-01 7.092622144968085962e-03 6.694595400455760625e-01 1.828533619119211417e-01 3.421514408394116247e-01 1.242580151818144518e-01 9.888774797458224075e-01 9.777955172739735135e-01 4.271370765628749178e-01 1.211608384809655936e-01 1.580132417172936954e-01 3.242705395708289640e-01 3.268994391754735940e-01 5.213767653645562383e-03 4.475169480357120699e-01 9.593245219293577986e-01 6.994304536782350867e-01 7.063863152769014331e-01 8.381620829497931080e-01 2.760441799736219615e-01 3.755200946645842475e-01 3.627729621737311172e-01 9.518310606719182498e-01 3.577273025276901386e-01 3.991159901003488164e-01 4.187060513068554535e-01 7.422605403637314581e-01 6.697944269780702342e-01 6.020599837037767799e-01 1.571185850817550245e-01 7.519860911185742847e-01 6.635775704496444938e-01 9.487848173531471252e-01 7.900030232338028924e-01 4.143783957270819052e-01 5.618429740858444932e-01 3.737804619062014000e-01 6.179941187802344693e-01 6.553638605616040058e-01 1.009709416658691739e-01 4.935037098582963910e-01 5.485489972455533936e-01 1.024147956480448984e-01 1.195764707555347917e-01 4.910516327810896531e-01 3.551185778630389089e-01 3.857601645798814927e-01 2.074975219600547760e-01 2.084038664460790002e-01 5.268616653491025037e-01 6.948014877618717833e-01 6.179744044618615817e-01 7.063658085955483168e-01 7.925757227686872630e-01 6.199016959584816577e-01 1.163676037434490107e-01 7.425752264755586252e-01 5.403115665133301215e-01 2.546191951391015840e-01 6.961300925345208501e-01 4.003013072125547467e-01 5.906120962720950995e-02 5.879915846330325824e-01 1.213602408288709800e-01 3.801780679842765576e-01 1.731477742402802722e-01 4.624568816669496485e-01 3.304453744619206823e-01 8.810445876116090869e-02
+5.140190515373614932e-01 1.419225260054487459e-01 7.777845802285945354e-01 3.327562899409282071e-01 8.916875699762913943e-01 7.212852862736146564e-01 5.727327199433507321e-01 5.897820225918504189e-01 7.318614954542906892e-01 7.393985144455500480e-01 4.531340740296823100e-01 9.903061584426188224e-01 4.213350938331624773e-01 4.542342471963995987e-01 9.788786426453045530e-01 1.881707000343846303e-02 8.005433413647761176e-01 1.523502822273363755e-01 5.630164732287495921e-01 5.946603842470724599e-01 1.225547698678740582e-01 1.531136594724622491e-01 8.157973612638946825e-02 2.752046015644330490e-01 6.809045821946161370e-01 6.455289724528190387e-01 3.830356726830793646e-01 4.446144649678575034e-01 4.969038423960672191e-01 5.497873820641221432e-01 9.471879627821714331e-01 5.933046675329255448e-01 4.099233758501530378e-02 5.790409810134594659e-01 9.546095885251496549e-01 2.608616052375664074e-01 6.910160339170060562e-01 1.293709850476291168e-01 6.407264616302255078e-03 6.186037089828009261e-01 5.537861302543241049e-01 3.527421038298221845e-01 8.033232052121624944e-01 8.128114152830284711e-01 8.319982582278713235e-01 5.939566376046836460e-01 2.291090283499520597e-01 5.438101817725821130e-01 6.881146379117278888e-01 2.421968586304659166e-01 5.874047918543783275e-01 6.210102709484541794e-01 7.041387566450251212e-01 6.959223476278774134e-01 9.133877300988062498e-01 9.230647706207778525e-01 6.856884219815310155e-01 6.997988808693775820e-01 6.177944932528769417e-01 5.512902545683161515e-01 5.818280341729102911e-01 6.538267999985679646e-01 6.946673485935980219e-01 4.817938258357623571e-02 9.352008817207906333e-01 4.774162142215661042e-01 5.768063588692976529e-01 4.589648891483899540e-02 7.998946815651652997e-01 4.434260476954369201e-01 9.850053510925722566e-01 6.648626681529369309e-01 4.606293826856903140e-01 3.309042418210563774e-01 1.438901922508034614e-01 7.986559119276418484e-01 7.037818421334554042e-01 3.605119534240813772e-01 3.785959549258922641e-01 9.562491516841659100e-01 4.997955143590974147e-01 1.029540300938682762e-01 1.819017177001992502e-01 3.665425750262368831e-01 1.688063588370778412e-01 7.030735208313992901e-01 8.922375654244527610e-01 1.055706412056253152e-01 2.664739907746691561e-01 9.906029568647586325e-01 6.043845090140997911e-03 3.495786295043534775e-01 5.989441999519146131e-01 6.776147193866479679e-01 7.012991789852640601e-01 1.825838783477321536e-01 7.612293578749116385e-01 1.564769891240175292e-01 2.762157292905387251e-01 7.641900040015234818e-01
+4.746013333880729768e-01 7.609202966712714788e-01 2.537820854162747830e-01 1.709362234877408460e-01 1.886635378734374813e-01 2.439567014093724229e-02 7.640304718272151741e-01 3.483216170435471382e-01 7.744289278738043514e-01 4.190437573644867353e-01 5.319091476394965934e-02 8.580130976087452233e-01 6.259446446786639529e-01 8.793213970773006150e-01 2.441023074890465994e-01 7.753405549489799098e-01 8.760187573193888300e-01 5.946480724009295393e-02 2.873093046571124631e-01 8.710837851946537924e-01 9.103181731924696596e-01 6.534637257615111272e-01 4.128420398577182793e-01 4.905858108576378607e-01 6.178275806701372108e-02 6.368043900016381320e-01 2.865296941219959148e-01 6.371773028539067241e-01 4.924322796636745325e-01 1.709313290387282080e-01 1.856892551689268700e-01 9.592782603102242289e-01 5.402593764193130976e-02 7.287312244390512506e-01 5.679467572000697073e-01 6.255587794305905724e-02 3.069660218141317953e-01 1.089960430557104232e-01 5.550748245336984965e-01 2.555948886689661803e-01 4.140925514039996980e-01 1.180376445052062628e-01 8.832322629884041820e-01 7.784546946701487169e-02 3.177678935473182698e-01 6.681804863429485764e-02 7.047099396645268854e-01 4.133897376851528582e-01 5.600656990480865627e-01 3.883995683475501837e-01 4.459430113152932362e-01 4.214077227574740681e-01 4.763369230200156235e-01 2.701480661168440545e-01 4.296286564389811824e-01 9.601402258758658936e-01 6.326999441846863359e-01 2.442086919688498670e-01 8.407708423957936938e-01 3.626867985638081437e-01 3.641441713291436733e-01 7.932397565989488530e-01 8.902073520619256941e-01 1.929173010337000838e-01 7.309376779324568973e-01 7.305852858337777977e-01 6.510197444582447313e-01 9.512661608643838695e-01 8.461467164366111016e-01 9.245490147941206605e-01 2.658844813385705663e-01 9.538758859344749208e-01 8.215517204998477041e-01 8.217795540390903097e-01 7.569662091300560780e-01 6.262685322871274218e-01 5.597770510574888725e-01 8.155720175123675197e-01 8.545688745180864965e-01 8.986051518529034610e-01 2.477911506572628708e-01 8.462580108996445860e-01 6.065941220995090255e-01 6.500490804973033665e-01 1.120463882674053169e-01 9.299049132942927010e-02 1.388364074229719858e-02 5.901199124540731367e-01 2.795110110544174464e-02 1.644097083463245124e-01 5.341029647603202646e-01 5.276816677181681570e-01 5.439849107754858304e-01 5.371677986392331405e-02 4.515163125788429488e-01 5.036243367087100964e-01 5.721818679625961801e-01 5.271368612400184617e-03 7.720961020546839304e-01 9.015383457479009266e-01
+8.301526916287945701e-01 8.704609696144033348e-01 2.955689129581380303e-01 1.762209253489944727e-01 2.698172933050072553e-01 1.138095349991521399e-01 4.092588531860634760e-01 8.202978121681584467e-01 2.822241377079557356e-01 6.117376205659387223e-01 7.169923068016897938e-01 9.310256256264415331e-02 3.989664052931106708e-01 1.651874953308862803e-02 7.890202597932294282e-02 9.068686774810821305e-01 5.203866694486933842e-01 4.297748572844445336e-01 5.208786995443430712e-01 2.163224881365530816e-01 7.274307306357226111e-01 1.675784956180090823e-01 5.969822786565782691e-01 8.959750832846602453e-02 1.253794151891943764e-01 5.352628522116801291e-01 2.562706125890066300e-01 6.030433202137867044e-01 8.330717547440393833e-01 9.603613683422040914e-02 7.569714244468559450e-01 3.184801677796517128e-01 1.667069341164499896e-01 3.132470247801235619e-01 6.417752836394801097e-01 6.433909425912354152e-02 4.056860213146201710e-01 3.166772891331335327e-01 9.574059746098845247e-01 1.492907964460536974e-01 8.311513764927496162e-01 6.652928354977717396e-01 2.396804722185036374e-01 5.812361618600220270e-01 9.724228681350225445e-01 2.853983236378453414e-01 5.337719354896472979e-01 6.779446197712412081e-01 5.485102006140557540e-01 9.010109155962182648e-01 5.724439967467525037e-01 5.965540527411405947e-01 1.598667990086183321e-01 1.363934512727023041e-01 5.327536522697270405e-01 4.123866715061276222e-01 4.617251396918636841e-01 6.935944951381239898e-01 4.300337419593377453e-01 1.892407993760835128e-01 1.666936825594794724e-01 4.625634184864588772e-01 4.805197636774838355e-02 7.003542850133466224e-01 2.130226006716084974e-03 8.678863343041013367e-01 4.874478520451258623e-01 7.043560228741558848e-01 6.317719270475393722e-01 5.372392256296196766e-01 2.982649812986511995e-01 1.272558612133412037e-01 2.467337555730741983e-01 6.546893200021091097e-01 6.291921159383098150e-01 8.505920470407707379e-01 4.046520490181828578e-01 3.875732096593392795e-01 8.551517214319142024e-01 4.152602284179877090e-01 9.587779137989138611e-01 6.977437468944928112e-01 3.240620775541913634e-02 4.025873770391376061e-01 5.485549335619134270e-01 7.146066156157020455e-01 3.012702534568838519e-01 3.526414480395153594e-01 3.309707144485515284e-01 4.315687014460974913e-01 6.641934530697197747e-01 2.172886798352815507e-01 4.807480925564590057e-01 5.006795397998469177e-01 5.818100901154411586e-01 2.107716091585690732e-01 6.606606051140029301e-01 9.317629042790995797e-01 9.840326342340242061e-01 5.752000964817773898e-01
+9.843444595454536872e-01 1.339523968066913540e-02 6.082172659959028671e-03 7.828244785439336662e-01 5.069653703872761819e-01 2.804896494365415327e-01 2.112385836660957139e-02 6.016479440778699228e-02 7.457477935084961818e-01 3.445503949245375397e-01 4.063494277166557200e-01 8.630275274433116817e-01 5.948396018456146850e-01 1.400867933474212457e-01 6.997522422654076646e-01 5.766519767930851081e-01 5.419976500582250889e-01 7.474121304089603735e-01 2.951600193008566686e-01 7.980170422334191827e-01 1.829036799578199757e-01 6.317636496261300749e-01 2.812612231140887431e-02 5.464747656105657381e-01 3.909873503320924204e-01 4.940850205957293406e-01 8.157850130814222611e-01 5.111092739445756150e-01 9.336823640685747439e-01 7.157105167170837445e-01 7.778989455994214097e-01 1.398722535910470466e-01 5.642653936300449091e-01 3.218717164845980028e-01 9.717427501967056402e-01 3.665791984428700134e-01 3.874321311211759156e-02 9.437600858738082188e-02 5.679526822961932231e-01 5.141385991358327079e-01 7.497840799582222715e-02 5.736515309094968318e-01 1.928132849879083954e-01 6.924244068001785823e-01 1.748389677952593146e-01 4.469577663506929532e-01 1.738527450963387455e-01 7.195287763517190793e-01 8.861150811892871682e-01 1.058443750714600506e-01 1.941789362229970894e-01 9.188374820700584422e-02 7.706736301449305104e-01 6.718642548609364828e-01 5.981029087121966237e-01 4.832880127232569434e-01 3.073688779938709148e-01 5.156312334804930009e-01 1.777418420119527553e-01 8.885462205165685079e-01 4.486254681289014723e-02 1.345398129556140132e-01 7.467627984379916484e-01 4.384565546058830643e-01 7.217750080760946263e-01 3.949550352625393890e-01 4.307950907642028593e-01 6.087680934849041270e-01 3.294516167246774874e-01 1.316682090209408962e-01 1.824857738754404046e-01 5.332379826483617524e-01 3.567136182864261151e-02 1.976220743086236631e-01 5.849349042822560296e-01 1.133174406357483344e-01 7.711522754393199675e-01 8.557306786807005183e-01 3.038353471344266143e-01 4.422747047768413875e-01 2.537160404215925702e-01 2.372714099723788328e-01 5.906462765375103396e-01 4.849909323133470007e-01 2.692576210504484813e-01 4.540849506602829821e-01 9.664935719107857759e-01 2.044371576459835804e-01 4.505417469690352616e-01 7.110722322201217249e-01 3.051357995214963870e-01 8.978937034341526457e-01 6.090501112506481185e-01 6.595415779178889215e-01 6.565426836745864581e-01 6.565608489824376059e-01 2.679102664248229626e-01 3.819533138204529443e-01 6.609794961162380744e-01 2.289558446859882856e-01
+9.274935298374649140e-01 1.174096651033715855e-01 3.030761852629033637e-01 1.605508209527917174e-01 9.601854834873225775e-01 4.341959513718630648e-01 6.320768160802121560e-01 4.213429090614078110e-01 3.695553969042019160e-01 5.965457437116089556e-01 3.520335041155040479e-01 7.702703502247409961e-01 8.571112772962534709e-01 7.904077282532658844e-01 2.247339318352784554e-01 6.823720204503556097e-01 5.883435710582129996e-02 6.786037033312407596e-01 9.721137137641507886e-01 2.042576970668320557e-01 8.394085754806240862e-01 7.433082729552867862e-01 4.072614159870893147e-01 7.451483066617257123e-01 1.699472962789440045e-01 1.753052015584344314e-01 2.255269204788400428e-01 7.794755643807432799e-01 8.407732260470973662e-01 9.301182862857163558e-01 3.701995309382508648e-01 4.481909027604019657e-01 1.261889085033987001e-01 5.600591735875248833e-01 8.244692493969552061e-01 8.969188061645969601e-01 4.802217973423368313e-01 3.556164122713412201e-02 3.393317823164623270e-01 2.491242957582864292e-01 9.863253789366602797e-01 5.585415885291432625e-01 3.702350606362231344e-01 6.766101432620400535e-01 6.999259389475386284e-01 6.676108316872160220e-01 7.870681827507105544e-01 8.746765411259082024e-01 9.125268371282718727e-01 6.638849997061806452e-01 3.253268113800632522e-01 7.968625619248901337e-01 7.584122525443606211e-01 9.028886850768532701e-01 5.381622293189292083e-02 8.097562873320752752e-01 7.092942088208666895e-01 9.915538877968065323e-01 4.319294903327922652e-01 4.307127933969153721e-01 2.768507739641907772e-01 8.076253078288621046e-01 2.569233696442670967e-01 7.595893829724666979e-01 5.768081727897018673e-01 2.537536777625452045e-01 8.874419624636734616e-01 5.091705681832693342e-01 4.811826624992353585e-01 2.794462461940371290e-01 3.846927898276129021e-01 5.129562951959991679e-01 8.515004062224775794e-01 7.103144978683579858e-01 9.526388607201888847e-01 2.367905569592337889e-01 9.137336039323161740e-01 5.722969943101696710e-02 2.019723935481291255e-01 3.098764675203513619e-02 1.121146613918624357e-01 9.937693067724532314e-01 8.476717958861412772e-02 2.059652110343795917e-01 2.139791918759540446e-01 9.137860316709250919e-01 9.530862653366889425e-03 2.027843281683039400e-03 2.506229951837134484e-01 6.244523528392044165e-01 5.523937894075592325e-01 3.712168074031840792e-01 4.218847794299319665e-01 4.827576239387890711e-01 5.244634168840578425e-01 5.182241092381567604e-01 3.308639956263292881e-03 9.370528021570383448e-01 4.694554875029453012e-01 4.950447554541728135e-01
+1.525818111800841814e-01 4.708012184002630107e-02 3.899035965341954846e-01 3.928304521031263929e-01 5.602286661727436945e-01 9.738256658043862313e-01 9.404465779766183475e-01 5.750862754958349088e-01 9.547546956257608741e-01 2.750275291553152535e-01 1.682773435862793265e-01 5.865928471016079726e-04 8.543378154943809255e-01 3.547649971465383079e-01 5.058056647397523031e-01 9.116332486700751137e-02 7.534666421106954726e-01 3.082429494433007733e-01 4.527145111847344916e-01 5.456680635225539255e-01 2.504131242494785914e-01 2.509240770568589296e-01 3.949236999582302898e-01 8.782959620323271821e-03 2.474641132111736752e-01 8.229417958971670943e-01 3.444225768479134420e-01 4.000027489436257522e-01 4.247741954177396417e-01 2.497745404169693373e-02 4.325768602588443423e-01 7.336592463477830117e-01 7.667663267650381975e-02 4.179022553581047683e-01 8.745172741480690126e-01 9.417705509525042817e-02 2.807522782799587446e-01 8.212710101351362590e-01 2.211181944001613386e-01 4.319929503523877168e-01 1.858636923768219873e-02 6.737037795085246694e-01 7.997187114913413275e-01 2.976552505976116647e-01 3.272347030789168887e-01 5.550935453236346406e-01 9.224109746648162522e-01 3.192827922106745708e-01 3.500098324549234530e-01 7.821988386980260888e-01 4.478417135239194380e-01 1.580956175222456572e-01 5.300807813550156844e-01 5.806154798468634581e-01 9.456842911054151868e-01 7.688127895655872956e-01 8.456527833650537840e-01 1.784229089865225770e-01 8.114517450321339087e-01 8.062506298824222428e-01 2.113482500442499523e-01 2.629226789210241666e-01 6.478686221690072022e-01 6.006672861605766300e-02 7.013679843242253131e-01 8.784753961212666828e-01 3.487138165323044880e-02 4.928426758517070461e-01 5.976224683315064512e-01 7.629063997052759616e-01 2.761721278953045422e-01 7.240740503283805696e-01 6.131065729985127888e-01 1.630885615792579957e-01 8.473783868551159060e-01 8.347614542399306448e-02 8.137265626844719657e-01 8.512508664918938539e-01 2.777097816703766320e-01 1.729154355214796990e-01 2.203382750835449766e-01 6.134780912629795857e-01 3.524352564238901753e-01 5.370314860129862256e-01 8.013986113284543578e-02 2.555842138998117852e-01 6.553915758947851389e-01 9.679125599178584061e-01 2.549566319678178150e-01 4.008180804370896633e-01 9.145789951670967310e-01 2.787926039163850511e-01 8.599455912576436933e-02 9.637558000691170967e-02 8.274101203974880692e-01 1.803747268179315411e-01 2.175735407836230095e-01 7.825994939720237742e-01 7.928519890958951599e-02 8.707949373106749213e-01
+6.398420210047787160e-01 5.739624494012524059e-01 3.359672805578653998e-01 1.130399363175038641e-02 3.349439685346782269e-01 2.315484030880912147e-01 4.575228302577399875e-01 1.149494135594463229e-01 2.888244352925943836e-01 3.625470995156252485e-01 3.795973190611611203e-01 6.567047810450010736e-01 1.484039742710284715e-01 9.273251916560719676e-01 4.334256728976307871e-01 6.734771102219323513e-01 9.125080197222198430e-01 4.974393931097168542e-01 8.301481563280355136e-01 4.526450714147856047e-01 2.414236092573898151e-01 8.070129698367667359e-02 7.260400697427102923e-01 1.396509691839398215e-02 2.496450588391967429e-01 4.335741205447194435e-01 3.089314419194891803e-01 9.543503534526003307e-01 5.457977547458532364e-01 3.139663643587058406e-01 5.034762326753475792e-01 4.756788330475764104e-01 6.849334942793482428e-01 3.880666613022351052e-01 6.483446580176778218e-01 5.217503801099343530e-01 5.371145824070304720e-01 3.121260159429154468e-01 8.314121854062171968e-01 4.538695969561833410e-01 8.598896961203845724e-01 9.961993522734106099e-01 8.865717795946430613e-01 7.828987966783660379e-01 3.412415531643435695e-01 7.421170530151157685e-01 4.484104178639959359e-01 6.793217012099640462e-01 3.756179958191659951e-01 7.821287098222597933e-01 6.227726265188193722e-02 8.552983413221663112e-01 4.824668768009222619e-01 2.241531065858231031e-01 4.939536577599041856e-01 5.129566641128722182e-01 1.057984177672518511e-01 9.541452507300716146e-01 3.396646181755047511e-01 7.452588103611947901e-01 5.315559265659929311e-01 5.493475179850665358e-01 5.214824278139198466e-01 5.150075718147916204e-01 1.196075368500321146e-01 9.035665331176232495e-01 7.522653903639873185e-01 6.638708679914825384e-01 5.584174553800479446e-01 5.015819402508836511e-01 5.507698483308445248e-01 5.978677577011723976e-01 8.450418028759657529e-01 3.266677322748618995e-01 1.321610045897971819e-01 2.394354042746985600e-01 2.723972163557076831e-01 5.523301747352814539e-01 5.518043850608547185e-01 5.283968096837132755e-02 8.192733312104071297e-01 2.277106024970321219e-02 1.414998099027269252e-01 6.517281615256080851e-01 1.811694734825117781e-01 9.472370614713256920e-01 5.454497319021770485e-01 1.364119913158231556e-01 8.446142008509562871e-01 7.671725984742419069e-01 2.461161648406858804e-01 1.421724627107351369e-01 6.290652581179481118e-01 7.094144689448004248e-01 4.419656923472803367e-02 6.614741876652251440e-01 8.712193265403500586e-02 4.734931280852430202e-01 5.382037050480286133e-01 1.396459758005891283e-01
+9.709329844415439670e-01 8.998575745276288229e-01 9.151313462895852568e-01 6.920489275523904471e-01 2.892231405199537919e-01 6.750679746268205550e-01 5.515642485826798280e-01 1.065253097812824956e-01 2.957026803465776510e-01 8.937347659632134400e-01 9.800016515925590310e-01 7.745900896182087436e-01 1.570977683146633774e-01 1.482028765821026273e-01 2.111147779712029271e-01 9.683759902485811200e-01 6.550951580826911425e-01 8.728324682592377703e-01 5.044803166579884257e-01 8.285704754811143991e-01 1.693574499337324735e-02 6.032669995180495182e-02 1.687026879086964692e-01 7.701554026145973619e-01 1.429888016593102718e-01 5.881172815379975827e-02 9.704206919487038396e-01 4.450807650730836951e-01 1.597445784258376689e-01 9.849229394397314152e-01 4.220083573536804744e-01 9.357693600374825671e-01 2.313199262338369033e-01 4.556443403861323294e-01 2.590791012828855822e-01 8.438664994487065085e-01 5.519045677502344427e-01 4.702170125676508050e-01 6.814723205638187897e-01 7.418295483665861001e-01 3.684921032028853904e-01 1.501895844844561845e-01 4.214513377519605308e-01 8.600279963652578408e-01 6.625616611189292238e-01 5.200151456470966105e-01 7.881072743086801058e-01 2.771703241081423519e-01 9.034135930616548071e-01 5.848441705791300738e-01 8.341698181274771473e-01 1.966638677318299777e-01 7.059747894371543042e-01 7.013854316067694716e-01 1.828430942760242983e-01 4.745548949934464966e-01 6.306422394641082452e-01 7.760751707194470939e-01 9.813187212598396547e-01 2.293595795266353266e-01 7.749261876107090830e-01 2.384106107787011819e-01 9.721209688979495223e-01 2.715569353686980714e-01 2.915573577694993146e-01 3.579601509630966349e-01 3.085697512342830962e-01 4.070219981627976047e-01 1.989632411372218579e-01 7.330003339460906542e-01 5.397259604481572381e-01 6.931009942216573849e-01 1.385457419653816080e-01 1.140339999976658358e-01 3.980752590866034613e-01 9.471822621683767540e-01 5.476643721405823895e-01 6.824131903515884279e-02 5.844099130744569992e-01 2.346881692012994236e-01 9.436439228519653000e-01 4.855518260479008141e-02 8.157036123302675579e-01 1.169761256455048581e-01 5.532962903488753970e-01 1.100965596251435308e-01 9.789490602992410029e-01 8.433487462016989733e-01 1.272410782852178013e-01 2.885715258680641160e-01 7.990943955388217779e-01 1.565305358979097727e-01 9.160846960406943129e-02 8.521842244411678147e-01 4.474243106736998099e-01 3.843945818845087015e-01 4.710645906071458944e-01 2.398348154123419729e-01 6.435351435258193087e-01 7.656897921129046658e-01
+4.894328120406804539e-01 7.881019629214267574e-01 6.974585354155089512e-01 2.023858939857701156e-01 1.660984914264745926e-01 4.854517801734643534e-01 2.789848572630315715e-01 2.311636522410289718e-01 9.821076233980715608e-01 1.220641257408076052e-01 2.614036146663852866e-01 7.657560715165320220e-01 3.968360577545695378e-01 4.566023622802184434e-02 1.049701948619241598e-02 9.281162949127452766e-01 4.490137965769909201e-01 2.095846458383606725e-01 9.195504656719085679e-01 9.683515436855471004e-01 9.800174878114910060e-01 5.517610861380117804e-01 6.711570559348770670e-01 5.125258050287277989e-01 2.105581493613526423e-01 8.281813206544574868e-01 4.964783994807770995e-01 7.284974208756571645e-01 1.320629592816270348e-01 6.652194518096135045e-01 9.430156297917950958e-01 7.477263137894260003e-01 2.054087806450300979e-01 4.248209124837907247e-01 7.657518666018259257e-02 1.031614100713345028e-01 4.122242287567021712e-01 4.919658859336810686e-01 3.752650167259050651e-01 4.175771429986683270e-01 6.131376293448997927e-01 5.463797405837259591e-01 3.119918548921774004e-01 6.331762507678504459e-01 5.484632429281035559e-01 6.815448032785871302e-01 8.065695507425107991e-02 8.720129122297424207e-01 8.318188557125294480e-03 2.199323537180564170e-02 8.933872719887463454e-01 1.953120287872067706e-02 2.478721941404590234e-01 5.994061179859005994e-01 6.588362611693047155e-01 6.332808851020984564e-01 3.823849348043323326e-01 5.111091324899629251e-01 7.034808459110406531e-01 4.347681568463539481e-01 4.316973576672314961e-01 9.620411080123215664e-01 6.247837467655984467e-01 8.196961678222113301e-01 5.574601810887074294e-01 8.800635018469276094e-01 8.772255241161972528e-01 5.075275933138404527e-01 8.022583187266906224e-01 2.320670802521890286e-01 1.165626629103270195e-01 4.623759662685936744e-01 7.938327000737943617e-02 7.986374689793115378e-01 6.728842751465858862e-01 8.133909095059230765e-01 1.202639390769081329e-01 1.052937257108800262e-01 8.717600467040409473e-02 2.163819956545051104e-01 6.596483385763984852e-01 1.202843170392309258e-02 1.538789195854695091e-01 3.120247727263308901e-01 3.408168327248596308e-01 3.241861797851740556e-01 3.637074533655986208e-01 1.533669345890729119e-01 4.455921334699539660e-01 5.619140093874478437e-01 1.881731359879111887e-01 9.416670800570559052e-01 1.740018593664415247e-01 7.030242331869680505e-01 5.922055553954849172e-01 9.326211623391688077e-01 6.608322881013140027e-01 7.009721551241574478e-01 1.079126054675583202e-01 6.158176671761947940e-01
+5.185079639625639336e-01 9.613742991518259284e-01 5.555312825626229634e-01 2.647628827924735084e-01 6.003697207460141350e-01 5.392112376769145898e-01 6.781186965667050925e-01 9.908971748181496508e-01 4.124155872095397468e-01 9.814941401724619485e-02 2.684237785531295994e-02 1.774652505962848181e-01 1.707589529595294753e-01 4.640932098465534450e-01 2.882179883914587348e-01 7.276822905806898945e-01 6.145789546745269449e-01 1.100959863917608805e-01 6.798859723042820491e-01 9.096984032948918220e-01 3.971368455178179158e-01 2.959494950971321980e-01 3.742088799298171065e-02 1.960739526210202310e-01 7.536102695342027369e-01 6.680915510628401277e-01 4.136507204312135366e-01 3.613996339406737590e-01 3.605422038261204554e-01 7.098503555159476619e-01 8.093719147087541366e-01 6.344097009128880638e-01 3.990082448083617228e-01 2.805918009906902544e-01 7.078488167363675698e-01 9.969917259866583059e-01 9.442054998992396309e-01 1.329075240769165278e-01 6.810681350588387861e-02 8.503491437913293094e-01 8.347117439165431252e-01 2.381858201903953587e-01 7.884260706938626129e-01 7.109907917419661105e-01 6.390916681983604963e-02 6.174365227062991179e-01 5.085733343630816083e-01 1.716846139694149231e-01 9.065664924270055991e-02 5.625330757196970177e-01 3.539663480209681579e-01 8.937139525947165319e-01 3.981380511900556307e-02 7.403597927449541150e-01 3.803872284089604427e-02 6.729519695709765825e-01 5.306080908840085097e-01 2.091237680402112664e-01 5.902903662907804661e-01 2.094778612095482551e-01 7.323447855684165342e-01 3.644574495843493356e-01 2.006215478057034041e-01 3.737617545555030896e-01 5.253471759602216240e-01 4.287889547869583318e-01 7.086098806190446187e-01 4.510792335515292351e-01 6.383187180169215269e-01 8.779355722397681472e-01 4.221338898667141848e-01 6.375840144651815367e-01 8.683057298299173832e-01 6.093730356952498095e-01 9.297141161056151626e-01 7.770838342807246946e-01 6.549661287008456956e-02 2.835060738158660110e-01 4.474138867374952699e-01 8.530336387421445510e-01 3.160209657891883683e-01 8.301538680518486535e-01 6.646903097549101691e-01 7.187130118106234145e-01 1.651862041735395747e-01 9.578252676762609719e-01 6.490273812885494209e-02 9.777273484666341163e-01 8.930729829254262508e-01 9.851054752118463265e-01 4.094323402286751401e-01 1.139176240124337713e-01 7.612865863899589414e-01 2.266379302491570158e-01 6.998882496157835531e-01 9.945043379099228753e-01 7.111578056749194854e-01 7.806190603886183910e-01 3.410170920712443099e-01 9.446084168886822452e-01
+5.015172758330755931e-01 5.569527971282052237e-01 1.122406928736449094e-01 8.960352822124777461e-01 6.049568585854003810e-02 1.202196001338627918e-01 1.870314295763603196e-01 9.017590029396971296e-01 3.597904628087450485e-01 2.130941062746317671e-01 2.556281834629479111e-01 5.123669364829196438e-01 4.754061129282013409e-01 9.764470380372083369e-01 8.038663983900646848e-01 6.960491266420890666e-01 2.940135977911654264e-01 2.857282759910040326e-03 4.599343225832352999e-02 5.597554495210212977e-01 7.445266674304001908e-01 3.387528030535971180e-01 6.429542922125383031e-01 2.123331785532429627e-01 5.302332654117811739e-01 7.262555377662539557e-01 3.982425859900724507e-01 3.243388301740235402e-01 6.191064123738921898e-01 8.988047781373914580e-01 7.819700328765150088e-01 7.664269102804815992e-01 6.734095355422575757e-03 2.904762329148526945e-01 5.097537644843168625e-01 9.524734606001823423e-01 4.812869576591960463e-01 6.236868013640477493e-01 1.459170943214320726e-01 9.874505139403206844e-01 7.561708982837871407e-01 3.798591332432484924e-01 6.056633451375117438e-01 7.935708170258731764e-01 1.458141583518740569e-01 7.082511296391911237e-01 1.098798009731616343e-02 3.655618484905173160e-01 9.551862303858617009e-01 8.148959351152762487e-02 4.739306219219985294e-02 7.963357515359494876e-01 6.208332695202813944e-01 3.884182264923189409e-01 4.589167647950288531e-01 6.496652974138312775e-01 2.467528128074852889e-01 5.309593064844935206e-01 5.364606369543487574e-01 2.421352989851309756e-01 3.776834556696828660e-02 1.564861233558080267e-01 5.197231021782636740e-01 8.725375120634637494e-01 2.441225493455024820e-01 2.320363366041028330e-01 5.026358683423555185e-01 7.035766000474735771e-01 8.347805591467084563e-01 2.303229841813967393e-01 6.908373419683054850e-01 2.646662377366995056e-01 1.259467197942290007e-01 9.372770922994989595e-01 6.674216272867254940e-01 1.027944489143072238e-01 5.686267290346079806e-01 3.948222804451942958e-01 4.689706944496729868e-01 4.446117700449114807e-02 6.817992275557515081e-01 9.084821829413957106e-01 9.184021015315092518e-01 3.045815734169987632e-01 2.204958624923980537e-03 7.542672057172502553e-01 9.460844786545006269e-01 3.373139094575949848e-02 9.059565314915285494e-01 9.938525461318854504e-01 2.542072661725306437e-01 9.685734112479216229e-02 8.223629541824816203e-01 1.057429056898460118e-01 8.080679390260248063e-01 5.823014244609205914e-01 6.413551528031806725e-01 1.787341975438894170e-01 1.250471413912357388e-01 8.390281297596062782e-01

env-llmeval/lib/python3.10/site-packages/scipy/spatial/tests/data/pdist-euclidean-ml.txt

@@ -0,0 +1 @@
+   4.0515260e+00   4.2121458e+00   3.7357405e+00   4.2313317e+00   3.9136009e+00   4.3843298e+00   3.9811426e+00   4.3624182e+00   4.0642508e+00   4.2105933e+00   4.0747226e+00   3.9068586e+00   4.1637004e+00   4.4303203e+00   4.1841564e+00   4.1063279e+00   4.1862390e+00   4.0719925e+00   4.2227579e+00   4.3173531e+00   3.8811067e+00   3.7577567e+00   4.0623722e+00   3.9882453e+00   4.0432671e+00   3.9085109e+00   4.0283414e+00   4.0846110e+00   3.6459235e+00   3.9544001e+00   4.1134244e+00   4.1805752e+00   3.5121011e+00   4.2747789e+00   4.1048323e+00   3.9269426e+00   3.8932032e+00   3.8281172e+00   3.7288430e+00   4.0863477e+00   4.1527428e+00   4.1646409e+00   4.2027433e+00   3.8441594e+00   4.8419117e+00   4.2455384e+00   3.7622220e+00   4.3967923e+00   4.4663183e+00   4.0435853e+00   4.0421692e+00   4.3124625e+00   4.6499961e+00   4.5595743e+00   3.4230430e+00   4.2612266e+00   3.5676603e+00   4.0866580e+00   4.2307103e+00   3.8521940e+00   3.9951183e+00   3.1022409e+00   3.7290193e+00   4.1931517e+00   4.1127027e+00   3.6633651e+00   4.0235815e+00   3.9729858e+00   4.1980132e+00   4.1579993e+00   3.9948955e+00   3.9081966e+00   3.9031152e+00   3.5069036e+00   4.0015727e+00   3.6763496e+00   3.6614339e+00   3.6227109e+00   3.7357992e+00   4.0170026e+00   3.5216829e+00   3.9322227e+00   3.9094621e+00   4.0170286e+00   4.3264246e+00   4.3435483e+00   4.0788635e+00   4.4761765e+00   3.8468186e+00   4.1490333e+00   4.2800007e+00   4.2260191e+00   4.3031858e+00   4.1897413e+00   4.0530244e+00   3.5893641e+00   4.2186615e+00   3.7979503e+00   4.0915473e+00   4.1343073e+00   4.5063851e+00   3.6394889e+00   4.2508448e+00   3.7160826e+00   4.0105262e+00   4.1578269e+00   4.0290590e+00   3.6971819e+00   3.9414087e+00   4.2522313e+00   4.4091714e+00   4.1542292e+00   3.9594691e+00   4.0923600e+00   4.0855497e+00   3.8253075e+00   4.3034717e+00   4.0976731e+00   4.1316523e+00   4.0872717e+00   4.2643353e+00   3.8887280e+00   3.9411273e+00   3.8848001e+00   4.3481996e+00   3.8716733e+00   3.9084684e+00   3.7546361e+00   3.9354816e+00   3.8293694e+00   3.7568515e+00   3.7184961e+00   3.8404278e+00   4.2570811e+00   4.1423777e+00   4.0291411e+00   4.2094682e+00   3.6127418e+00   4.0459839e+00   3.7737985e+00   3.7647653e+00   3.9762006e+00   3.8999512e+00   3.8509090e+00   3.8975941e+00   3.8432839e+00   4.2109046e+00   4.1339124e+00   3.5898873e+00   4.0794519e+00   4.3504966e+00   3.8862612e+00   3.8332931e+00   4.2190310e+00   4.1366595e+00   3.7220268e+00   4.1250795e+00   3.3169452e+00   4.0757181e+00   3.6487114e+00   3.9513724e+00   4.0735549e+00   3.9137880e+00   3.9656942e+00   3.7724953e+00   4.0505153e+00   3.9062302e+00   4.5671852e+00   3.7542175e+00   4.3731708e+00   3.6733907e+00   4.4667545e+00   4.1004635e+00   4.0530038e+00   4.0346958e+00   4.2145752e+00   4.4298637e+00   4.2982360e+00   4.0878239e+00   4.4061563e+00   4.2115971e+00   3.8263277e+00   3.8603258e+00   3.8572375e+00   4.1051910e+00   4.3787786e+00   4.5309659e+00   4.0047055e+00   4.1308854e+00   3.6283561e+00

env-llmeval/lib/python3.10/site-packages/scipy/spatial/tests/data/pdist-hamming-ml.txt

@@ -0,0 +1 @@
+   4.6000000e-01   4.3000000e-01   4.3000000e-01   5.4000000e-01   4.1000000e-01   5.3000000e-01   4.3000000e-01   5.9000000e-01   4.8000000e-01   4.7000000e-01   4.6000000e-01   4.9000000e-01   4.5000000e-01   5.5000000e-01   5.3000000e-01   4.5000000e-01   4.8000000e-01   4.7000000e-01   4.8000000e-01   5.1000000e-01   4.9000000e-01   4.4000000e-01   4.9000000e-01   4.7000000e-01   4.9000000e-01   4.7000000e-01   5.2000000e-01   4.7000000e-01   4.2000000e-01   4.9000000e-01   4.7000000e-01   5.5000000e-01   3.9000000e-01   5.5000000e-01   4.6000000e-01   4.5000000e-01   4.0000000e-01   4.8000000e-01   4.5000000e-01   4.8000000e-01   4.8000000e-01   5.0000000e-01   4.8000000e-01   4.5000000e-01   6.4000000e-01   5.7000000e-01   4.6000000e-01   5.4000000e-01   5.6000000e-01   4.8000000e-01   4.8000000e-01   5.3000000e-01   5.4000000e-01   5.3000000e-01   4.5000000e-01   5.8000000e-01   4.2000000e-01   5.4000000e-01   6.0000000e-01   5.1000000e-01   4.6000000e-01   4.1000000e-01   4.4000000e-01   5.6000000e-01   5.4000000e-01   4.8000000e-01   4.8000000e-01   5.1000000e-01   5.2000000e-01   5.5000000e-01   4.5000000e-01   4.3000000e-01   4.7000000e-01   4.7000000e-01   5.6000000e-01   4.9000000e-01   4.8000000e-01   4.5000000e-01   4.9000000e-01   4.7000000e-01   4.5000000e-01   4.5000000e-01   5.6000000e-01   4.9000000e-01   5.8000000e-01   5.4000000e-01   4.6000000e-01   5.8000000e-01   5.3000000e-01   5.4000000e-01   5.5000000e-01   5.0000000e-01   5.2000000e-01   4.8000000e-01   5.0000000e-01   3.8000000e-01   5.3000000e-01   4.8000000e-01   5.1000000e-01   4.8000000e-01   5.2000000e-01   4.7000000e-01   5.0000000e-01   4.3000000e-01   4.8000000e-01   5.2000000e-01   5.0000000e-01   4.2000000e-01   4.2000000e-01   4.7000000e-01   5.4000000e-01   5.1000000e-01   5.4000000e-01   5.1000000e-01   4.8000000e-01   4.7000000e-01   5.2000000e-01   5.2000000e-01   5.4000000e-01   5.4000000e-01   5.0000000e-01   4.5000000e-01   4.4000000e-01   4.1000000e-01   5.7000000e-01   4.6000000e-01   5.1000000e-01   5.2000000e-01   5.0000000e-01   4.8000000e-01   5.0000000e-01   4.4000000e-01   5.3000000e-01   5.2000000e-01   4.9000000e-01   5.7000000e-01   5.8000000e-01   4.9000000e-01   5.1000000e-01   4.5000000e-01   5.3000000e-01   4.5000000e-01   4.4000000e-01   3.5000000e-01   4.2000000e-01   5.3000000e-01   5.2000000e-01   5.0000000e-01   3.8000000e-01   5.2000000e-01   5.6000000e-01   4.7000000e-01   4.4000000e-01   5.1000000e-01   5.7000000e-01   4.5000000e-01   5.7000000e-01   4.3000000e-01   5.1000000e-01   3.8000000e-01   5.3000000e-01   4.8000000e-01   4.4000000e-01   5.0000000e-01   4.8000000e-01   5.0000000e-01   4.7000000e-01   6.4000000e-01   4.9000000e-01   5.2000000e-01   4.8000000e-01   5.6000000e-01   4.3000000e-01   4.8000000e-01   4.7000000e-01   6.0000000e-01   5.4000000e-01   5.5000000e-01   4.0000000e-01   5.5000000e-01   5.6000000e-01   4.9000000e-01   5.0000000e-01   4.3000000e-01   5.7000000e-01   5.0000000e-01   5.7000000e-01   4.9000000e-01   4.2000000e-01   3.9000000e-01

env-llmeval/lib/python3.10/site-packages/scipy/spatial/tests/data/pdist-jaccard-ml.txt

@@ -0,0 +1 @@
+   6.5714286e-01   6.0563380e-01   6.3235294e-01   7.3972603e-01   6.0294118e-01   7.3611111e-01   6.4179104e-01   7.7631579e-01   6.4000000e-01   6.6197183e-01   6.6666667e-01   7.0000000e-01   6.4285714e-01   7.7464789e-01   7.1621622e-01   6.4285714e-01   6.8571429e-01   6.4383562e-01   6.6666667e-01   6.5384615e-01   6.6216216e-01   6.1971831e-01   6.5333333e-01   6.5277778e-01   6.7123288e-01   6.4383562e-01   6.5000000e-01   6.3513514e-01   6.0000000e-01   6.7123288e-01   6.3513514e-01   7.4324324e-01   5.5714286e-01   7.0512821e-01   6.3888889e-01   6.0000000e-01   5.6338028e-01   6.3157895e-01   6.0810811e-01   6.2337662e-01   6.4000000e-01   6.5789474e-01   6.3157895e-01   5.6962025e-01   7.5294118e-01   7.1250000e-01   6.2162162e-01   6.7500000e-01   7.2727273e-01   6.2337662e-01   6.2337662e-01   6.7948718e-01   6.5853659e-01   6.6250000e-01   6.3380282e-01   7.3417722e-01   6.0869565e-01   7.2000000e-01   7.5949367e-01   6.4556962e-01   6.3013699e-01   5.9420290e-01   6.2857143e-01   7.1794872e-01   7.3972603e-01   6.4864865e-01   6.4864865e-01   6.8918919e-01   6.6666667e-01   7.0512821e-01   6.2500000e-01   6.2318841e-01   6.6197183e-01   6.5277778e-01   6.9135802e-01   6.6216216e-01   6.6666667e-01   6.4285714e-01   6.6216216e-01   6.8115942e-01   6.2500000e-01   6.2500000e-01   7.3684211e-01   6.4473684e-01   7.3417722e-01   7.1052632e-01   6.3888889e-01   7.3417722e-01   6.5432099e-01   6.9230769e-01   7.1428571e-01   6.7567568e-01   6.7532468e-01   6.7605634e-01   6.5789474e-01   5.4285714e-01   6.9736842e-01   6.2337662e-01   6.6233766e-01   6.7605634e-01   7.0270270e-01   6.1842105e-01   6.7567568e-01   6.2318841e-01   6.7605634e-01   6.9333333e-01   7.1428571e-01   6.0000000e-01   6.0000000e-01   6.6197183e-01   6.9230769e-01   6.8000000e-01   7.2000000e-01   6.5384615e-01   6.5753425e-01   6.6197183e-01   7.1232877e-01   6.9333333e-01   7.5000000e-01   7.1052632e-01   6.7567568e-01   6.4285714e-01   6.0273973e-01   5.8571429e-01   6.9512195e-01   6.3013699e-01   6.8918919e-01   7.0270270e-01   6.6666667e-01   6.8571429e-01   6.6666667e-01   6.1111111e-01   7.0666667e-01   6.6666667e-01   6.5333333e-01   6.8674699e-01   7.0731707e-01   6.3636364e-01   6.3750000e-01   6.1643836e-01   6.5432099e-01   5.8441558e-01   5.8666667e-01   4.7297297e-01   5.5263158e-01   6.9736842e-01   6.9333333e-01   6.5789474e-01   5.7575758e-01   6.7532468e-01   7.0886076e-01   6.4383562e-01   5.8666667e-01   6.6233766e-01   7.5000000e-01   6.2500000e-01   7.7027027e-01   6.0563380e-01   6.8000000e-01   5.6716418e-01   6.7948718e-01   6.4864865e-01   6.1971831e-01   7.1428571e-01   6.5753425e-01   6.7567568e-01   6.6197183e-01   7.7108434e-01   6.6216216e-01   7.1232877e-01   6.4000000e-01   7.0886076e-01   6.0563380e-01   6.2337662e-01   6.2666667e-01   7.7922078e-01   7.2972973e-01   7.5342466e-01   5.7971014e-01   7.3333333e-01   7.0886076e-01   6.6216216e-01   6.4102564e-01   5.8904110e-01   7.3076923e-01   6.4102564e-01   7.1250000e-01   6.4473684e-01   5.9154930e-01   5.3424658e-01

env-llmeval/lib/python3.10/site-packages/scipy/spatial/tests/data/pdist-jensenshannon-ml.txt

@@ -0,0 +1 @@
+0.320369972991 0.338972466 0.308199372323 0.3452431902 0.310024768313 0.357115225615 0.311131096357 0.357391534414 0.329718053755 0.347365921475 0.335272625287 0.336451560653 0.33015370606 0.369628769749 0.344499490029 0.321622508707 0.345377707016 0.321007207534 0.350728979121 0.32809430086 0.30207071308 0.291663252492 0.30760470102 0.315976639534 0.308132467187 0.313014586878 0.310463895925 0.321091616502 0.290044394125 0.322213459935 0.315509196522 0.3331114403 0.281071919202 0.320854431887 0.332190658438 0.299342730178 0.313528775154 0.310049073937 0.288821516545 0.307662081954 0.328387688508 0.317185603454 0.332046170365 0.291912213887 0.37870970117 0.336080073379 0.304593343921 0.330138983604 0.355071759299 0.311946140607 0.302025400768 0.330940761586 0.351140062502 0.354772884287 0.272605322053 0.327957349848 0.28871110366 0.320821172951 0.340976919806 0.30757488831 0.320975346884 0.252776262329 0.314549731907 0.326876483 0.337684418756 0.296520013735 0.31493077245 0.327721982167 0.325802862624 0.341908184107 0.300481749419 0.312499767894 0.301061762121 0.27665157989 0.3082566692 0.287466396145 0.288313694552 0.296629698731 0.283556095025 0.322489360684 0.280765581604 0.297958166613 0.313189657041 0.303470399659 0.348652898212 0.331594734387 0.299446687464 0.339047458559 0.286979246044 0.316326095312 0.321618884109 0.330065896317 0.324500638067 0.328300795872 0.309002568222 0.262587468469 0.31974123777 0.286316182293 0.321162329165 0.328160620315 0.356618051635 0.289733970648 0.344507756538 0.301485561986 0.335785898715 0.322635066518 0.331480718646 0.297897604494 0.306942928189 0.350843442517 0.342585296966 0.341311053315 0.306780105123 0.313401804298 0.319978145568 0.302460397612 0.346105758567 0.312802351189 0.331552275517 0.321624157344 0.318798118247 0.301906095501 0.301585920138 0.314556178985 0.333215221158 0.306929663844 0.317083256901 0.309667679181 0.306529028004 0.30865993751 0.296031907986 0.28742420979 0.311584483038 0.319043629504 0.330278008622 0.314466433681 0.327937382021 0.296448162218 0.307033121385 0.296391953011 0.292691206116 0.297146209653 0.307929858983 0.291863681454 0.307300188104 0.306597817799 0.34718100163 0.317436210259 0.29952626739 0.330762834707 0.334951064852 0.323806678898 0.296203706701 0.33398466797 0.344931265559 0.293948734727 0.332764639313 0.272651853935 0.317324315923 0.300493570867 0.307008231016 0.333263322802 0.31390648462 0.332416491248 0.314766869708 0.321015549211 0.322909289307 0.356882966656 0.310596945263 0.343939748528 0.286269629586 0.33173459898 0.323848483719 0.305841388975 0.319266258167 0.34012363898 0.3443280395 0.353885654057 0.320544729867 0.353280499623 0.315621795536 0.312176062734 0.301562130879 0.312061680573 0.312642847966 0.326222109701 0.357417912858 0.313083593142 0.334033412713 0.295630506074

env-llmeval/lib/python3.10/site-packages/scipy/spatial/tests/data/pdist-minkowski-3.2-ml.txt

@@ -0,0 +1 @@
+   2.0215050e+00   2.0988154e+00   1.8614681e+00   2.0510161e+00   1.9210911e+00   2.1323516e+00   1.9565454e+00   2.1029889e+00   1.9617871e+00   2.0544792e+00   2.0357408e+00   1.8811414e+00   2.0694693e+00   2.1245977e+00   2.0632165e+00   2.0452823e+00   2.0249330e+00   1.9635489e+00   2.0508580e+00   2.0838578e+00   1.9324052e+00   1.8224609e+00   1.9795343e+00   1.9536534e+00   1.9694910e+00   1.9075569e+00   1.9590397e+00   2.0022087e+00   1.8814000e+00   1.8884208e+00   1.9961121e+00   2.0215351e+00   1.7515769e+00   2.0756437e+00   2.0109476e+00   1.9234849e+00   1.9160076e+00   1.8550862e+00   1.7733640e+00   2.0071906e+00   2.0209542e+00   2.0616569e+00   2.0565503e+00   1.9083573e+00   2.2732431e+00   1.9975503e+00   1.9080072e+00   2.1437809e+00   2.1296295e+00   1.9739085e+00   1.9834166e+00   2.1078664e+00   2.2016840e+00   2.2080962e+00   1.7340579e+00   2.0549287e+00   1.7331748e+00   1.9559688e+00   2.0343364e+00   1.8736929e+00   1.9730416e+00   1.5308944e+00   1.8421831e+00   2.0174240e+00   2.0137378e+00   1.7956151e+00   1.9606596e+00   1.9074857e+00   2.0413879e+00   2.0070305e+00   1.9584677e+00   1.8977851e+00   1.9176239e+00   1.7067419e+00   1.9461927e+00   1.8431700e+00   1.8284576e+00   1.7778704e+00   1.8350329e+00   2.0175415e+00   1.7459063e+00   1.9242505e+00   1.8757370e+00   1.9312506e+00   2.0574808e+00   2.0894636e+00   1.9780203e+00   2.1374036e+00   1.8900436e+00   2.0273032e+00   2.0681953e+00   2.0234699e+00   2.0666449e+00   2.0663485e+00   1.9281402e+00   1.7846314e+00   2.0372479e+00   1.8831230e+00   2.0186015e+00   2.0193231e+00   2.2022665e+00   1.8145737e+00   2.0466545e+00   1.8092421e+00   1.9600687e+00   2.0322961e+00   1.9556364e+00   1.8266422e+00   1.9950345e+00   2.1038429e+00   2.1164145e+00   2.0188062e+00   1.8863331e+00   2.0006971e+00   1.9971068e+00   1.8771862e+00   2.1148855e+00   1.9570638e+00   1.9859615e+00   2.0030854e+00   2.0737344e+00   1.9739259e+00   1.9266524e+00   1.9200535e+00   2.1376689e+00   1.8944425e+00   1.9330553e+00   1.8561590e+00   1.9422954e+00   1.8874178e+00   1.8624808e+00   1.8265563e+00   1.8840519e+00   2.0515092e+00   2.0174226e+00   1.9771196e+00   2.0635988e+00   1.7334466e+00   1.9912604e+00   1.8915711e+00   1.8262636e+00   1.9369173e+00   1.9560446e+00   1.9549934e+00   1.9279230e+00   1.9021073e+00   2.0113391e+00   2.0305786e+00   1.8066806e+00   1.9656739e+00   2.1219217e+00   1.8820250e+00   1.8936826e+00   2.0565131e+00   1.9839441e+00   1.8553479e+00   1.9923760e+00   1.6393276e+00   1.9786440e+00   1.8274394e+00   1.9322611e+00   2.0404318e+00   1.9216532e+00   1.9361171e+00   1.8401373e+00   1.9908059e+00   1.9495117e+00   2.1975655e+00   1.8413913e+00   2.1528773e+00   1.8434374e+00   2.1668863e+00   2.0429273e+00   1.9980016e+00   1.9790129e+00   2.0264829e+00   2.1478843e+00   2.0899600e+00   2.0280670e+00   2.1210881e+00   1.9993891e+00   1.8646871e+00   1.9099983e+00   1.9263353e+00   2.0042495e+00   2.1365919e+00   2.1830279e+00   1.9631961e+00   2.0880004e+00   1.8348369e+00