`iZdZddlZddlZddlmcmcmZddlm Z m Z m Z m Z m Z ddlmZdZdZdZejedd d g Zd Z ddZdZdZdZdS)a Spectral analysis functions and utilities. Some of the functions defined here were ported directly from CuSignal under terms of the MIT license, under the following notice: Copyright (c) 2019-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. N)odd_exteven_extzero_ext const_ext _as_strided) get_windowc4tj|jSN)cupydtypename)r s u/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupyx/scipy/signal/_spectral_impl.py_get_raw_typenamer&s :e   !!cd|D}d|}|r|d|n|}||}|S)Nc6g|]}t|jS)rr ).0args r z(_get_module_func_raw..+s#IIIC$SY//IIIr_)join get_function)module func_name template_args args_dtypestemplate kernel_namekernels r_get_module_func_rawr!*s[II=IIIKxx $$H/<KY+++++)K   - -F Mra> /////////////////////////////////////////////////////////////////////////////// // LOMBSCARGLE // /////////////////////////////////////////////////////////////////////////////// template __device__ void _cupy_lombscargle_float( const int x_shape, const int freqs_shape, const T *__restrict__ x, const T *__restrict__ y, const T *__restrict__ freqs, T *__restrict__ pgram, const T *__restrict__ y_dot ) { const int tx { static_cast( blockIdx.x * blockDim.x + threadIdx.x ) }; const int stride { static_cast( blockDim.x * gridDim.x ) }; T yD {}; if ( y_dot[0] == 0 ) { yD = 1.0f; } else { yD = 2.0f / y_dot[0]; } for ( int tid = tx; tid < freqs_shape; tid += stride ) { T freq { freqs[tid] }; T xc {}; T xs {}; T cc {}; T ss {}; T cs {}; T c {}; T s {}; for ( int j = 0; j < x_shape; j++ ) { sincosf( freq * x[j], &s, &c ); xc += y[j] * c; xs += y[j] * s; cc += c * c; ss += s * s; cs += c * s; } T c_tau {}; T s_tau {}; T tau { atan2f( 2.0f * cs, cc - ss ) / ( 2.0f * freq ) }; sincosf( freq * tau, &s_tau, &c_tau ); T c_tau2 { c_tau * c_tau }; T s_tau2 { s_tau * s_tau }; T cs_tau { 2.0f * c_tau * s_tau }; pgram[tid] = ( 0.5f * ( ( ( c_tau * xc + s_tau * xs ) * ( c_tau * xc + s_tau * xs ) / ( c_tau2 * cc + cs_tau * cs + s_tau2 * ss ) ) + ( ( c_tau * xs - s_tau * xc ) * ( c_tau * xs - s_tau * xc ) / ( c_tau2 * ss - cs_tau * cs + s_tau2 * cc ) ) ) ) * yD; } } extern "C" __global__ void __launch_bounds__( 512 ) _cupy_lombscargle_float32( const int x_shape, const int freqs_shape, const float *__restrict__ x, const float *__restrict__ y, const float *__restrict__ freqs, float *__restrict__ pgram, const float *__restrict__ y_dot ) { _cupy_lombscargle_float( x_shape, freqs_shape, x, y, freqs, pgram, y_dot ); } template __device__ void _cupy_lombscargle_double( const int x_shape, const int freqs_shape, const T *__restrict__ x, const T *__restrict__ y, const T *__restrict__ freqs, T *__restrict__ pgram, const T *__restrict__ y_dot ) { const int tx { static_cast( blockIdx.x * blockDim.x + threadIdx.x ) }; const int stride { static_cast( blockDim.x * gridDim.x ) }; T yD {}; if ( y_dot[0] == 0 ) { yD = 1.0; } else { yD = 2.0 / y_dot[0]; } for ( int tid = tx; tid < freqs_shape; tid += stride ) { T freq { freqs[tid] }; T xc {}; T xs {}; T cc {}; T ss {}; T cs {}; T c {}; T s {}; for ( int j = 0; j < x_shape; j++ ) { sincos( freq * x[j], &s, &c ); xc += y[j] * c; xs += y[j] * s; cc += c * c; ss += s * s; cs += c * s; } T c_tau {}; T s_tau {}; T tau { atan2( 2.0 * cs, cc - ss ) / ( 2.0 * freq ) }; sincos( freq * tau, &s_tau, &c_tau ); T c_tau2 { c_tau * c_tau }; T s_tau2 { s_tau * s_tau }; T cs_tau { 2.0 * c_tau * s_tau }; pgram[tid] = ( 0.5 * ( ( ( c_tau * xc + s_tau * xs ) * ( c_tau * xc + s_tau * xs ) / ( c_tau2 * cc + cs_tau * cs + s_tau2 * ss ) ) + ( ( c_tau * xs - s_tau * xc ) * ( c_tau * xs - s_tau * xc ) / ( c_tau2 * ss - cs_tau * cs + s_tau2 * cc ) ) ) ) * yD; } } extern "C" __global__ void __launch_bounds__( 512 ) _cupy_lombscargle_float64( const int x_shape, const int freqs_shape, const double *__restrict__ x, const double *__restrict__ y, const double *__restrict__ freqs, double *__restrict__ pgram, const double *__restrict__ y_dot ) { _cupy_lombscargle_double( x_shape, freqs_shape, x, y, freqs, pgram, y_dot ); } )z -std=c++11_cupy_lombscargle_float32_cupy_lombscargle_float64)codeoptionsname_expressionsctj}|jddz}d}t t d|}|jd|jd|||||f} ||f|f| dS)NMultiProcessorCounti_cupy_lombscargler)r cudaDevice attributesr!LOMBSCARGLE_MODULEshape) xyfreqspgramy_dot device_id num_blocksblock_szlombscargle_kernelargss r _lombscargler:s   ""I%&; | dvrtd| dttttdd}| |vrBtd| t |||u}|s| dkrtdt  tj |}|s5tj |}tj ||tj }ntj |tj }|st |j }t |j }| |  tjtj|tj|j }n#t$rtd wxYw|rV|jd krJtj|j tj|j tj|j fSnn|jd ks |jd krX|t%|j |j gfz}tjtj|d }|||fS|jd krc d kr]tj| t+|j }|s3|jd kr(tj| t+|j }|s|j d |j d kr|j d |j d kr\t |j }|j d |j d z |d <tj|tj|fd }n[t |j }|j d |j d z |d <tj|tj|fd }|$t|}|d krtd t1|||j d \}}||}n$||krtdt|}||dz}nt|}||krtd||z }| ,|| }|||dzd }|s|||dzd }| r|j d |z |z|z}t |j dd |gz}tj|tj|fd }|sJt |j dd |gz}tj|tj|fd }sd}n%t3dsfd}n d kr fd}n}tj |tj |kr||}| dkrd|||zzz }n3| dkrd|dzz }ntd| z| dkrtj|}|rZtj|rd}t=jdn1d}|s*tj|rd}t=jdnd}|dkr$tj !|d |z }n)|dkr#tj "|d |z }tG|||||||} |s-tG|||||||}!tj$| |!z} n| dkrtj$| | z} | |z} |dkr4| dkr.|dzr| dd dfxxdzcc<n| dd d fxxdzcc<tj%|dz |j d |dz z d z||z tM|z }"| |"|dz |z z}"| |} |r | dkr| j'} d kr d z tj| d } ||"| fS) a 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 )r@stftzUnknown value for mode z!, must be one of: {'psd', 'stft'}N)evenoddr=zerosNz2Unknown boundary option '{0}', must be one of: {1}r@z'x and y must be equal if mode is 'stft'z%x and y cannot be broadcast together.rr?z"nperseg must be a positive integer) input_lengthz.nfft must be greater than or equal to nperseg.z#noverlap must be less than nperseg.)axisc|Sr r)ds r detrend_funcz&_spectral_helper..detrend_funcsHr__call__c2tj|dS)Nr?)typerI) filteringdetrend)rKrQs rrLz&_spectral_helper..detrend_funcs$QW2>>> >rctj|d}|}tj|t|jS)Nr?)r rollaxislenr/)rKrIrQs rrLz&_spectral_helper..detrend_funcs? aT**A A=D#ag,,77 7rr>r;spectrumzUnknown scaling: %rrBtwosidedz9Input data is complex, switching to return_onesided=Falseonesided.)( ValueErrorrrrrformatlistkeysintr asarray result_type complex64r/pop broadcastemptysizeminrSndimrT concatenaterE_triage_segmentshasattrastypesumsqrt iscomplexobjwarningswarnfftfftfreqrfftfreq _fft_helperconjarangefloatreal)#r0r1fswindownpersegnoverlapnfftrQreturn_onesidedscalingrImodeboundarypaddedboundary_funcs same_dataoutdtypexouteryouter outershapeoutshapeemptyout pad_shapewinnstepext_funcnadd zeros_shaperLscalesidesr2resultresult_ytimes# ` ` r_spectral_helperrs L ?"" d       N~%% @ G G$~224455     QI DBCCC t99D QA 7 LOO#Aq$.99#At~66  Fagag 4 4 F 6""DJv$6$6888= J F F FDEE E F0 6Q;; 17##TZ%8%8$*QW:M:MO O  6Q;;!&A++!S!'$-)G%H%H$JJH}TZ%9%92tDDHXx/ /vzz 2:: as17||44A 9!M!T3qw<<88  E 72;!'"+ % %wr{QWR[(( MM ! agbk 9 " $aI)>)>%?DD MM ! agbk 9 " $aI)>)>%?DDg,, Q;;ABB B$FG!'"+NNNLC | IJJJ4yya<x==7>??? h E!(+ HQ1 2 . . . 3GqLr222A H'"+'(50G;173B3<((D61  aK!8!89 C C C Hqwss|,,v5K !TZ %<%F$$F>ct|tst|trE|d}||kr*tjd|||}t ||}ntj|}t|j dkrtd||j dkrtd||j d}n"| ||j dkrtd ||fS) a 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 6 window. NzLnperseg = {0:d} is greater than input length = {1:d}, using nperseg = {1:d}rFzwindow must be 1-Dr?z"window is longer than input signalrz>value specified for nperseg is different from length of window) isinstancestrtuplermrnrYrr r]rTr/rX)rxryrGrs rrgrgsH&#*VU";"; ?G \ ! ! M228&,2O2O   #G))l6"" sy>>Q  122 2 #)B- ' 'ABB B ?ilGG  #)A,&& - <rc|dkr|dkr|dtjf}ni||z }|jdd|jd|z |z|fz} |jdd||jdz|jdfz} t || | }||}||z}|dkrtjj} n|j}tjj} | ||}|S) a/ Calculate windowed FFT, for internal use by cusignal.spectral_analysis.spectral._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 rFr.Nr?)r/stridesrV)n)r newaxisr/rrrorvrfft) r0rrLryrzr{rrstepr/rfuncs rrrrrWs,!||A 3 $%! x!7D @'JJ)CRC.D19R=$8!)B-#HHQeW===\& ! !F6\F x|x} T&D ! ! !F Mrcdtjd|dz dzdzz}dtjd|dzz d|z z zS)a. Returns the bias of the median of a set of periodograms relative to the mean. See arXiv:gr-qc/0509116 Appendix B for details. Parameters ---------- n : int Numbers of periodograms being averaged. Returns ------- bias : float Calculated bias. rHr;rF)r rtrj)rii_2s r _median_biasrsN" t{3Q1 q 011 1D txtax(3:566 66r) r;r<NNNr=Tr>r?r@NF)__doc__rmr cupyx.scipy.signal._signaltoolsscipysignal _signaltoolsrPcupyx.scipy.signal._arraytoolsrrrrr#cupyx.scipy.signal.windows._windowsrrr!LOMBSCARGLE_KERNEL RawModuler.r:rrgrrrrrrrsy6 33333333333399999999999999::::::"""K\$T^ _113444 9 9 9        BBBBJ ===@...b77777r