ukiddlmZddlmZmZddlmZddlZddlZddl m Z ddl Z ddl Z ddlmZddlmZddlmZdd lmZdd lm Zdd lmZdd lmZdd lmZddlmZddlmZmZmZm Z ddl!m"Z"ddl#m$Z$m%Z%ddl&m'Z'm(Z(m)Z) d# d$dZ*d%dZ+d&dZ, d' d(dZ- d) d*dZ. d' d(dZ/ d) d*dZ0 d+ d,dZ1 d-dZ2d.d/dZ3 d0 d1dZ4 d2 d3dZ5 d4 d5dZ6 d4 d6d Z7d7d!Z8 d8 d9d"Z9y):) annotations)CallableSequence)partialN)Any)api)core)dtypes)lax)numpy)_ensure_index_tuple) PrecisionLike)fft)linalg)check_arraylikeensure_arraylikepromote_dtypes_complexpromote_dtypes_inexact) signal_helper)Array ArrayLike)canonicalize_axis tuple_delete tuple_insertcJtdt\jjk7r td|dvr tdt t |}| |St |}tfd|D}ttjt|z }tfd|Dr(tdjd jd |t|D]}tj||| }|S) a& Convolve two N-dimensional arrays using Fast Fourier Transform (FFT). JAX implementation of :func:`scipy.signal.fftconvolve`. Args: in1: left-hand input to the convolution. in2: right-hand input to the convolution. Must have ``in1.ndim == in2.ndim``. mode: controls the size of the output. Available operations are: * ``"full"``: (default) output the full convolution of the inputs. * ``"same"``: return a centered portion of the ``"full"`` output which is the same size as ``in1``. * ``"valid"``: return the portion of the ``"full"`` output which do not depend on padding at the array edges. axes: optional sequence of axes along which to apply the convolution. Returns: Array containing the convolved result. See Also: - :func:`jax.numpy.convolve`: 1D convolution - :func:`jax.scipy.signal.convolve`: direct convolution Examples: A few 1D convolution examples. Because FFT-based convolution is approximate, We use :func:`jax.numpy.printoptions` below to adjust the printing precision: >>> x = jnp.array([1, 2, 3, 2, 1]) >>> y = jnp.array([1, 1, 1]) Full convolution uses implicit zero-padding at the edges: >>> with jax.numpy.printoptions(precision=3): ... print(jax.scipy.signal.fftconvolve(x, y, mode='full')) [1. 3. 6. 7. 6. 3. 1.] Specifying ``mode = 'same'`` returns a centered convolution the same size as the first input: >>> with jax.numpy.printoptions(precision=3): ... print(jax.scipy.signal.fftconvolve(x, y, mode='same')) [3. 6. 7. 6. 3.] Specifying ``mode = 'valid'`` returns only the portion where the two arrays fully overlap: >>> with jax.numpy.printoptions(precision=3): ... print(jax.scipy.signal.fftconvolve(x, y, mode='valid')) [6. 7. 6.] fftconvolvez/in1 and in2 should have the same dimensionality)samefullvalidz-mode must be one of ['same', 'full', 'valid']modec3JK|]}t|jywN)rndim).0axin1s P/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/jax/_src/scipy/signal.py zfftconvolve..ns>2 SXX.>s #c3\K|]#}j|j|k7%ywr#shape)r%ir'in2s r(r)zfftconvolve..ps&;!11 %;s),z0mapped axes must have same shape; got in1.shape=z in2.shape=z axes=)in_axesout_axes)rrr$ ValueErrorr_fftconvolve_unbatchedr tuplesetrangeanyr,sortedrvmap)r'r.r!axes _fftconvolve mapped_axesr&s`` r(rr.sl-c* #C -(#sXX F GG ** D EE/d;, \ S !! T "$ >> >$E#((O$s4y0+;{;; Hcii\399,V]X\W^_ `` ; Cb88L"rBLC c3 c tdt|j|jD}|}|dk(rutdt|j|jD}tdt|j|jD}|s |s t d|r||}}tdt|j|jDr||z}nt j |r5t jjt jj} }n4t jjt jj} }|||} |||} | | | z|}|dk(r|} nV|dk(r |j} nD|dk(r1td t|j|jD} nt d |td t|| D} tj|| | S) Nc32K|]\}}||zdz ywNr%s1s2s r(r)z)_fftconvolve_unbatched..wsIVRR"Wq[Irc3,K|] \}}||k\ywr#rArBs r(r)z)_fftconvolve_unbatched..}sCvr2"(Cc3,K|] \}}||kywr#rArBs r(r)z)_fftconvolve_unbatched..~s@FBrRx@rGzVFor 'valid' mode, One input must be at least as large as the other in every dimension.c3:K|]\}}|dk(xs|dk(ywr?rArBs r(r)z)_fftconvolve_unbatched..s$ ER"' R1W  Esrrc32K|]\}}||z dzywr?rArBs r(r)z)_fftconvolve_unbatched..sJfb"b2gkJrEzUnrecognized mode=c32K|]\}}||z dzyw)NrA)r% full_sizeout_sizes r(r)z)_fftconvolve_unbatched..s(O/Ix#X-!3OrE)r3zipr,allr1jnp iscomplexobjrfftnifftnrfftnirfftnr dynamic_slice)r'r.r! full_shape fft_shapeno_swapswapconvrifftsp1sp2 out_shape start_indicess r(r2r2vsIs399cii/HII*) W_CSYY )BCCG @c#))SYY&?@ @D t @ AA c3c E3syy#))+D EE 9D '',, 4c''--4c c9 C c9 C c 9 %D V^I v~ I wJCIIsyy0IJJI *TG, --O36z93MOO-  4 ::r<c|dvr td|j|jk7r td|jdk(s|jdk(r&td|jd|jdt ||\}}t dt |j|jD}t d t |j|jD}|s |s td |j}|r||}}|j}tj|}|d k(r|Dcgc]}d } }nZ|d k(r9t ||D cgc]!\}} |dz | dz dzz || z | dz dzzf#} }} n|dk(r|Dcgc] }|dz |dz f} }td|D} tj|d|d|  |} | d Scc}wcc} }wcc}w)N)rrrz-mode must be one of ['full', 'same', 'valid']z3in1 and in2 must have the same number of dimensionsrz;zero-size arrays not supported in convolutions, got shapes z and .c3,K|] \}}||k\ywr#rArBs r(r)z_convolve_nd..sAVRbArGc3,K|] \}}||kywr#rArBs r(r)z_convolve_nd.. >&"bR2X >rGz.s#!#s )NN precision) r1r$sizer,rrPrOrQflipr3r conv_general_dilated) r'r.r!rkrZr[shape_or,ripaddings_ostridesresults r( _convolve_ndrts ** D EEXX J KKXX]chh!m RSVS\S\R]]bcfclclbmmno pp #C -(#s As399cii'@A A' >C 399$= > >$ T S TT II' CC ))%  # W_$%!v%G% v~"5'24AsAqQ&C37q.(@A4G4 v~',-!Aq1u~-G- #U# #'  # #C OS_g$+y B& &4.s2 G&GGcl|dk(rt|||S|dvrt||||Std|d)aConvolution of two N-dimensional arrays. JAX implementation of :func:`scipy.signal.convolve`. Args: in1: left-hand input to the convolution. in2: right-hand input to the convolution. Must have ``in1.ndim == in2.ndim``. mode: controls the size of the output. Available operations are: * ``"full"``: (default) output the full convolution of the inputs. * ``"same"``: return a centered portion of the ``"full"`` output which is the same size as ``in1``. * ``"valid"``: return the portion of the ``"full"`` output which do not depend on padding at the array edges. method: controls the computation method. Options are * ``"auto"``: (default) always uses the ``"direct"`` method. * ``"direct"``: lower to :func:`jax.lax.conv_general_dilated`. * ``"fft"``: compute the result via a fast Fourier transform. precision: Specify the precision of the computation. Refer to :class:`jax.lax.Precision` for a description of available values. Returns: Array containing the convolved result. See Also: - :func:`jax.numpy.convolve`: 1D convolution - :func:`jax.scipy.signal.convolve2d`: 2D convolution - :func:`jax.scipy.signal.correlate`: ND correlation Examples: A few 1D convolution examples: >>> x = jnp.array([1, 2, 3, 2, 1]) >>> y = jnp.array([1, 1, 1]) Full convolution uses implicit zero-padding at the edges: >>> jax.scipy.signal.convolve(x, y, mode='full') Array([1., 3., 6., 7., 6., 3., 1.], dtype=float32) Specifying ``mode = 'same'`` returns a centered convolution the same size as the first input: >>> jax.scipy.signal.convolve(x, y, mode='same') Array([3., 6., 7., 6., 3.], dtype=float32) Specifying ``mode = 'valid'`` returns only the portion where the two arrays fully overlap: >>> jax.scipy.signal.convolve(x, y, mode='valid') Array([6., 7., 6.], dtype=float32) rr )directautorjz Got method=z&; expected 'auto', 'fft', or 'direct'.)rrtr1r'r.r!methodrks r(convolverzsJr u_ sCd ++ ## S$) << |F9$JK LLr<c|dk7s|dk7r tdtj|dk7stj|dk7r tdt ||||S)a Convolution of two 2-dimensional arrays. JAX implementation of :func:`scipy.signal.convolve2d`. Args: in1: left-hand input to the convolution. Must have ``in1.ndim == 2``. in2: right-hand input to the convolution. Must have ``in2.ndim == 2``. mode: controls the size of the output. Available operations are: * ``"full"``: (default) output the full convolution of the inputs. * ``"same"``: return a centered portion of the ``"full"`` output which is the same size as ``in1``. * ``"valid"``: return the portion of the ``"full"`` output which do not depend on padding at the array edges. boundary: only ``"fill"`` is supported. fillvalue: only ``0`` is supported. method: controls the computation method. Options are * ``"auto"``: (default) always uses the ``"direct"`` method. * ``"direct"``: lower to :func:`jax.lax.conv_general_dilated`. * ``"fft"``: compute the result via a fast Fourier transform. precision: Specify the precision of the computation. Refer to :class:`jax.lax.Precision` for a description of available values. Returns: Array containing the convolved result. See Also: - :func:`jax.numpy.convolve`: 1D convolution - :func:`jax.scipy.signal.convolve`: ND convolution - :func:`jax.scipy.signal.correlate`: ND correlation Examples: A few 2D convolution examples: >>> x = jnp.array([[1, 2], ... [3, 4]]) >>> y = jnp.array([[2, 1, 1], ... [4, 3, 4], ... [1, 3, 2]]) Full 2D convolution uses implicit zero-padding at the edges: >>> jax.scipy.signal.convolve2d(x, y, mode='full') Array([[ 2., 5., 3., 2.], [10., 22., 17., 12.], [13., 30., 32., 20.], [ 3., 13., 18., 8.]], dtype=float32) Specifying ``mode = 'same'`` returns a centered 2D convolution of the same size as the first input: >>> jax.scipy.signal.convolve2d(x, y, mode='same') Array([[22., 17.], [30., 32.]], dtype=float32) Specifying ``mode = 'valid'`` returns only the portion of 2D convolution where the two arrays fully overlap: >>> jax.scipy.signal.convolve2d(x, y, mode='valid') Array([[22., 17.], [30., 32.]], dtype=float32) fillrz7convolve2d() only supports boundary='fill', fillvalue=0rLz0convolve2d() only supports 2-dimensional inputs.rj)NotImplementedErrornpr$r1rt)r'r.r!boundary fillvaluerks r( convolve2drs[F9> W XXWWS\Q"''#,!+ G HH c3 ::r<cdt|tj|j|||S)aCross-correlation of two N-dimensional arrays. JAX implementation of :func:`scipy.signal.correlate`. Args: in1: left-hand input to the cross-correlation. in2: right-hand input to the cross-correlation. Must have ``in1.ndim == in2.ndim``. mode: controls the size of the output. Available operations are: * ``"full"``: (default) output the full cross-correlation of the inputs. * ``"same"``: return a centered portion of the ``"full"`` output which is the same size as ``in1``. * ``"valid"``: return the portion of the ``"full"`` output which do not depend on padding at the array edges. method: controls the computation method. Options are * ``"auto"``: (default) always uses the ``"direct"`` method. * ``"direct"``: lower to :func:`jax.lax.conv_general_dilated`. * ``"fft"``: compute the result via a fast Fourier transform. precision: Specify the precision of the computation. Refer to :class:`jax.lax.Precision` for a description of available values. Returns: Array containing the cross-correlation result. See Also: - :func:`jax.numpy.correlate`: 1D cross-correlation - :func:`jax.scipy.signal.correlate2d`: 2D cross-correlation - :func:`jax.scipy.signal.convolve`: ND convolution Examples: A few 1D correlation examples: >>> x = jnp.array([1, 2, 3, 2, 1]) >>> y = jnp.array([1, 3, 2]) Full 1D correlation uses implicit zero-padding at the edges: >>> jax.scipy.signal.correlate(x, y, mode='full') Array([ 2., 7., 13., 15., 11., 5., 1.], dtype=float32) Specifying ``mode = 'same'`` returns a centered 1D correlation of the same size as the first input: >>> jax.scipy.signal.correlate(x, y, mode='same') Array([ 7., 13., 15., 11., 5.], dtype=float32) Specifying ``mode = 'valid'`` returns only the portion of 1D correlation where the two arrays fully overlap: >>> jax.scipy.signal.correlate(x, y, mode='valid') Array([13., 15., 11.], dtype=float32) )rkry)rzrQrmconjrxs r( correlaterNs'r #sxx +TYv VVr<c,|dk7s|dk7r tdtj|dk7stj|dk7r tdt dt |j |j D}t dt |j |j D}|dk(rItj||j}}tjt|||| }|S|d k(r|r8|s6tj||j}}t|||| }|Stj||j}}tjt|||| }|S|rDtj||j}}t|||| j}|Stj||j}}tjt|||| }|S) aX Cross-correlation of two 2-dimensional arrays. JAX implementation of :func:`scipy.signal.correlate2d`. Args: in1: left-hand input to the cross-correlation. Must have ``in1.ndim == 2``. in2: right-hand input to the cross-correlation. Must have ``in2.ndim == 2``. mode: controls the size of the output. Available operations are: * ``"full"``: (default) output the full cross-correlation of the inputs. * ``"same"``: return a centered portion of the ``"full"`` output which is the same size as ``in1``. * ``"valid"``: return the portion of the ``"full"`` output which do not depend on padding at the array edges. boundary: only ``"fill"`` is supported. fillvalue: only ``0`` is supported. method: controls the computation method. Options are * ``"auto"``: (default) always uses the ``"direct"`` method. * ``"direct"``: lower to :func:`jax.lax.conv_general_dilated`. * ``"fft"``: compute the result via a fast Fourier transform. precision: Specify the precision of the computation. Refer to :class:`jax.lax.Precision` for a description of available values. Returns: Array containing the cross-correlation result. See Also: - :func:`jax.numpy.correlate`: 1D cross-correlation - :func:`jax.scipy.signal.correlate`: ND cross-correlation - :func:`jax.scipy.signal.convolve`: ND convolution Examples: A few 2D correlation examples: >>> x = jnp.array([[2, 1, 3], ... [1, 3, 1], ... [4, 1, 2]]) >>> y = jnp.array([[1, 3], ... [4, 2]]) Full 2D correlation uses implicit zero-padding at the edges: >>> jax.scipy.signal.correlate2d(x, y, mode='full') Array([[ 4., 10., 10., 12.], [ 8., 15., 24., 7.], [11., 28., 14., 9.], [12., 7., 7., 2.]], dtype=float32) Specifying ``mode = 'same'`` returns a centered 2D correlation of the same size as the first input: >>> jax.scipy.signal.correlate2d(x, y, mode='same') Array([[15., 24., 7.], [28., 14., 9.], [ 7., 7., 2.]], dtype=float32) Specifying ``mode = 'valid'`` returns only the portion of 2D correlation where the two arrays fully overlap: >>> jax.scipy.signal.correlate2d(x, y, mode='valid') Array([[15., 24.], [28., 14.]], dtype=float32) r|rz8correlate2d() only supports boundary='fill', fillvalue=0rLz1correlate2d() only supports 2-dimensional inputs.c3,K|] \}}||kywr#rArBs r(r)zcorrelate2d..rfrGc3,K|] \}}||k(ywr#rArBs r(r)zcorrelate2d..sERB"HErGrrjr) r}r~r$r1rPrOr,rQrmrrt) r'r.r!rrrkr[ same_shaperss r( correlate2drsH9> X YYWWS\Q"''#,!+ H II >C 399$= > >$E3syy#))+DEE* V^xx}chhjC XXl3TYG HF - w J# 3cCdi@f -# 3cxx S#tyIJf -  # 3cCdi@EEGf -# 3cxx S#tyIJf -r<c | td|dvr tdttj|\}|dk(r||j |dz S|j |}tjtjtjd||f}|ddks|d|kDr td tj||d}|j }|j|d}tt|d z D] } || d z|| z } tjtj | |j" tj$d | d z|j" | j'|j"z gj(} t+|| || d z} t-j.| || ^} }|j0| j3tj4| | t6j8j:  }tj|j|d|S) a Remove linear or piecewise linear trends from data. JAX implementation of :func:`scipy.signal.detrend`. Args: data: The input array containing the data to detrend. axis: The axis along which to detrend. Default is -1 (the last axis). type: The type of detrending. Can be: * ``'linear'``: Fit a single linear trend for the entire data. * ``'constant'``: Remove the mean value of the data. bp: A sequence of breakpoints. If given, piecewise linear trends are fit between these breakpoints. overwrite_data: This argument is not supported by JAX's implementation. Returns: The detrended data array. Examples: A simple detrend operation in one dimension: >>> data = jnp.array([1., 4., 8., 8., 9.]) Removing a linear trend from the data: >>> detrended = jax.scipy.signal.detrend(data) >>> with jnp.printoptions(precision=3, suppress=True): # suppress float error ... print("Detrended:", detrended) ... print("Underlying trend:", data - detrended) Detrended: [-1. -0. 2. -0. -1.] Underlying trend: [ 2. 4. 6. 8. 10.] Removing a constant trend from the data: >>> detrended = jax.scipy.signal.detrend(data, type='constant') >>> with jnp.printoptions(precision=3): # suppress float error ... print("Detrended:", detrended) ... print("Underlying trend:", data - detrended) Detrended: [-5. -2. 2. 2. 3.] Underlying trend: [6. 6. 6. 6. 6.] z(overwrite_data argument not implemented.)constantlinearz*Trend type must be 'linear' or 'constant'.rT)keepdimsrzOBreakpoints must be non-negative and less than length of data along given axis.r@dtyperj)r}r1rrQasarraymeanr,r~sortuniquer_moveaxisreshaper5lenvstackonesrarangeastypeTslicerlstsqataddmatmulr PrecisionHIGHEST)dataaxistypebpoverwrite_datadata_arrNbp_arrr,mNptsAslcoef_s r(detrendrsZ H II '' A BB$S[[%67)( Z hmmD4m8 88tA WWRYYruuQAX/ 0F ay1}r Q h ii||HdA.H NNE2&H 3v;? #\ AE]VAY &d ** X^^, 1dQhhnn5 HNN8SS   F1q5M *ba".hdQR$$cjjDCMMDYDY&Z%Z[h\ <<((/D 99r<c|jjdk(r|j|j}|j^}}|dk(r|dk(r|dtj f} n]||z } t j||z dz| } ttj||d} tj| d | } || } t j|r t| \} |jd t!|zd|fz| z} |d k(rt#j$| | St#j&| j(| S)zBCalculate windowed FFT in the same way the original SciPy does. r-r@r.)stepr)operand slice_sizer)r0) start_index)r@twosided)n)rkindrr,r~newaxisrQrrr dynamic_slice_in_dimrr8rRrrrjnp_fftrrfftreal) xwin detrend_funcnpersegnoverlapnfftsides batch_shape signal_lengthrsrstarts slice_funcs r( _fft_helperr3s#WW\\S A !;  \h!m sBJJ F X D ZZ /!3$ ?F111WYZJ .SXXj2 .6 BF  & c$V,GF ;;tc+..!W= > G& j ;;v && << t ,,r<c|dkr|S||j|dz kDr"td|d|j|dz dtj|dd|}t j tj|d|dz||}tj|dd|}t j tj||dz d||}t j d |z|z |d |z|z f|}|S) a Extends `x` along with `axis` by odd-extension. This function was previously a part of "scipy.signal.signaltools" but is no longer exposed. Args: x : input array n : the number of points to be added to the both end axis: the axis to be extended r@zThe extension length n (z;) is too big. It must not exceed x.shape[axis]-1, which is rcrrrNrL)r,r1r slice_in_dimrQrm concatenate)rrrleft_endleft_ext right_end right_extexts r(odd_extrSsU H   "1#&889 8I7J! M NN  aAD 1( XXc&&q!QU>T J(q"d6)hhs''QU8RdC$O) X0Y24# $# *r<c  | dvrtd| dd}|dt|d|dd d d }| |vr(td | d t|jt j t j d t |j |2td|t|\}|}t|j }n| dk7r tdtd||t||\}}|j|jk7r td tjt|j t|j }t!j"|j$}t'j(|j$}d}d}d}|+t j t*|d}|dkr tdt-j.|||n||j |j$\}}||dz}nt j t*|d}||}nt j t*|d}|n|j0dk(rtj2|j|tj2|j|tj2|j|fS|j0dk(s|j0dk(rrt5|t7|j |j  }tj2||tj2||tj2||fStj8| d}|&|jdkDrtj8| d}||jd|jdk7r|jd|jdkret|j}|jd|jdz |d<tj:|tj<||fd}ndt|j}|jd|jdz |d<tj:|tj<||fd}||kr td||k\r td ||z }| #|| }|||dzd!}||||dzd!}| r|jd|z |z|z}tj:|tj<|g|jdd|fd!}|@tj:|tj<|g|jdd|fd!}t?t@rtCtDd"}n.tGr dk7r fd#}n}nsd$}ntd%| d&k(rd'|||zjIzz }n*| d(k(rd'|jIdzz }ntd)| | d*k(rtjJ|}tM|\}|rDd+} tjN|stjN|rd,} tQjRd-nd,} | d,k(rtUjV|d|z |.}!n | d+k(rtUjX|d|z |.}!t[||||||| }"|*t[||||||| }#tj\|"|#z}"n| dk(rtj\|"|"z}"|"|z}"| d+k(r0| dk(r+|dzrdnd}$|"j^d/d|$fjad}"tjb|dz |jd|dz z dz||z |.|z }%| |%|dz |z z}%|"je|}"|| d*k7r |"jf}"tj8|"d }"!|%|"fS#t$r}td|d}~wwxYw)0a3LAX-backend implementation of `scipy.signal._spectral_helper`. Unlike the original helper function, `y` can be None for explicitly indicating auto-spectral (non cross-spectral) computation. In addition to this, `detrend` argument is renamed to `detrend_type` for avoiding internal name overlap. )psdstftzUnknown value for mode z!, must be one of: ('psd', 'stft')cdfd }|S)Nct|jDcgc]}d}}||f||<tj||fiScc}w)Nrg)r5r$rQpad)rrrunused_n pad_widthkwargsr!s r(rz/_spectral_helper..make_pad..padsH*/-8h68i8Aio WWQ 4 26 229s ArrA)r!rrs`` r(make_padz"_spectral_helper..make_pads3 Jr<reflectedgerg)constant_valuesc|Sr#rA)rargsrs r(z"_spectral_helper..sqr<)evenoddrzerosNzUnknown boundary option 'z', must be one of: zaxis of windowed-FFTNspectral_helperrz4two-argument mode is available only when mode=='psd'z=two-arguments must have the same rank ({x.ndim} vs {y.ndim}).z%x and y cannot be broadcast together.rznperseg of windowed-FFTr@"nperseg must be a positive integer) input_lengthrrLznoverlap of windowed-FFTznfft of windowed-FFTrr+z.nfft must be greater than or equal to nperseg.#noverlap must be less than nperseg.r)rrcptj|d}|}tj|dS)Nr)rQr)dr detrend_types r(rz&_spectral_helper..detrend_funcs1 LLD" % O||Ar4((r<c|Sr#rA)rs r(rz"_spectral_helper..sQr<zUnsupported detrend type: density?spectrumzUnknown scaling: ronesidedrz9Input data is complex, switching to return_onesided=Falser.)4r1rlistkeysr concrete_or_erroroperatorindexrr$rrrr,rQbroadcast_shapesr to_complex_dtyperr~finfointr_triage_segmentsrlrrminrr zeros_like isinstancestrrrcallablesumsqrtrrRwarningswarnrfftfreqrfftfreqr conjugatermulrrr)&ryfswindowrrrrreturn_onesidedscalingrr!rpaddedrboundary_funcsy_arr outershapeerr result_dtype freq_dtype nperseg_intnfft_int noverlap_intrr, pad_shapenstepext_funcnaddrscalerfreqsrsresult_yendtimes& ` ` r(_spectral_helperr'os  .tf577 88y! 6" C8 ( .^#  #H:. 3 3 567 9 ::   6L M$ 4 ($Y%q)  "BA Eaggt,J u} M NN%q!,%a+HAuvv V WWI'' QWWd(C(4U[[$(GIj ((1,xx %++*+(, (( W/1KQ ; <<"33 gk774=1#{!#L)) X13L \H%%c41GHHYvv{ YYqww +SYYqww -KSYYWXW^W^`lMm mmvv{ejjAo:s1774=%++d:K'LdSe YYuj )399UJ+GSXZfIg gg ll1dB!]uzzA~ LLb )E]qwwr{ekk"o5wwr{U[[_$qww-ikk"o 3im //1cnnQi@A2 Fau{{#iggbkEKKO3imooucnnQi&HI2Ne  E FF[ : ;;  $%h'HK1$2.A}ukQ.R8e ggbk+% & .+ =D CNN14Iaggcrl4ID4IJKRTUA}ooucnnQ>W CR@P>WRV>W&XY`bce c"7B?L  rz) "l L 1,@ AA  2s)) *E* #'')Q, E ( 2 33 V^ HHUOE !% (&% E c..q1emm,- E j OOHad* =E    Xqt: >E q#|"L(E C&]5#|& hGH ]]6 "X -F u} ]]6 "V +FE/& jTU]Q,$BC YYsAcEz " & &q )F K!OQWWR[;?%BQ%F,.j BDF G$ [1_ ""D == &&Y46> [[F <<D )& f u I > ?SHIs&>_"" _<+ _77_<c 4t|d|||||||d| d|| S)a Compute the short-time Fourier transform (STFT). JAX implementation of :func:`scipy.signal.stft`. Args: x: Array representing a time series of input values. fs: Sampling frequency of the time series (default: 1.0). window: Data tapering window to apply to each segment. Can be a window function name, a tuple specifying a window length and function, or an array (default: ``'hann'``). nperseg: Length of each segment (default: 256). noverlap: Number of points to overlap between segments (default: ``nperseg // 2``). nfft: Length of the FFT used, if a zero-padded FFT is desired. If ``None`` (default), the FFT length is ``nperseg``. detrend: Specifies how to detrend each segment. Can be ``False`` (default: no detrending), ``'constant'`` (remove mean), ``'linear'`` (remove linear trend), or a callable accepting a segment and returning a detrended segment. return_onesided: If True (default), return a one-sided spectrum for real inputs. If False, return a two-sided spectrum. boundary: Specifies whether the input signal is extended at both ends, and how. Options are ``None`` (no extension), ``'zeros'`` (default), ``'even'``, ``'odd'``, or ``'constant'``. padded: Specifies whether the input signal is zero-padded at the end to make its length a multiple of `nperseg`. If True (default), the padded signal length is the next multiple of ``nperseg``. axis: Axis along which the STFT is computed; the default is over the last axis (-1). Returns: A length-3 tuple of arrays ``(f, t, Zxx)``. ``f`` is the Array of sample frequencies. ``t`` is the Array of segment times, and ``Zxx`` is the STFT of ``x``. See Also: :func:`jax.scipy.signal.istft`: inverse short-time Fourier transform. Nrr)rrr!rr)r') rrrrrrrrrrrs r(rrFs2L !T2vw",4%!'  ))r<c t|||||||||| | d \} } }||dz}|jdk\r<|jdkDr,|jddkDr| d k(rt j |jdj |j}tj|rYtjtj|d d tjtj|d zz}ntj|d }||z}| |fS| d k(r|jd }| |fStd | tj||jdd}| |fS)aM Estimate cross power spectral density (CSD) using Welch's method. This is a JAX implementation of :func:`scipy.signal.csd`. It is similar to :func:`jax.scipy.signal.welch`, but it operates on two input signals and estimates their cross-spectral density instead of the power spectral density (PSD). Args: x: Array representing a time series of input values. y: Array representing the second time series of input values, the same length as ``x`` along the specified ``axis``. If not specified, then assume ``y = x`` and compute the PSD ``Pxx`` of ``x`` via Welch's method. fs: Sampling frequency of the inputs (default: 1.0). window: Data tapering window to apply to each segment. Can be a window function name, a tuple specifying a window length and function, or an array (default: ``'hann'``). nperseg: Length of each segment (default: 256). noverlap: Number of points to overlap between segments (default: ``nperseg // 2``). nfft: Length of the FFT used, if a zero-padded FFT is desired. If ``None`` (default), the FFT length is ``nperseg``. detrend: Specifies how to detrend each segment. Can be ``False`` (default: no detrending), ``'constant'`` (remove mean), ``'linear'`` (remove linear trend), or a callable accepting a segment and returning a detrended segment. return_onesided: If True (default), return a one-sided spectrum for real inputs. If False, return a two-sided spectrum. scaling: Selects between computing the power spectral density (``'density'``, default) or the power spectrum (``'spectrum'``) axis: Axis along which the CSD is computed (default: -1). average: The type of averaging to use on the periodograms; one of ``'mean'`` (default) or ``'median'``. Returns: A length-2 tuple of arrays ``(f, Pxy)``. ``f`` is the array of sample frequencies, and ``Pxy`` is the cross spectral density of `x` and `y` Notes: The original SciPy function exhibits slightly different behavior between ``csd(x, x)`` and ``csd(x, x.copy())``. The LAX-backend version is designed to follow the latter behavior. To replicate the former, call this function function as ``csd(x, None)``. See Also: - :func:`jax.scipy.signal.welch`: Power spectral density. - :func:`jax.scipy.signal.stft`: Short-time Fourier transform. rr NyrLrrr@medianry?rz(average must be "median" or "mean", got )r'r$rlr,r _median_biasrrrQrRr*rimagrr1r)rrrrrrrrrrraverager#rPxybiass r(csdr0ssad#1aVWh")?GT',.-%C] (C XX]sxx!| yy}q H ))#))B-8?? J   C CHHSM3CHHSM;;<# 3R(# t   f hhBh  CG9MNN KKSYYs^ ,c r<c Rt|d||||||||| |  \} } | | jfS)aE Estimate power spectral density (PSD) using Welch's method. This is a JAX implementation of :func:`scipy.signal.welch`. It divides the input signal into overlapping segments, computes the modified periodogram for each segment, and averages the results to obtain a smoother estimate of the PSD. Args: x: Array representing a time series of input values. fs: Sampling frequency of the inputs (default: 1.0). window: Data tapering window to apply to each segment. Can be a window function name, a tuple specifying a window length and function, or an array (default: ``'hann'``). nperseg: Length of each segment (default: 256). noverlap: Number of points to overlap between segments (default: ``nperseg // 2``). nfft: Length of the FFT used, if a zero-padded FFT is desired. If ``None`` (default), the FFT length is ``nperseg``. detrend: Specifies how to detrend each segment. Can be ``False`` (default: no detrending), ``'constant'`` (remove mean), ``'linear'`` (remove linear trend), or a callable accepting a segment and returning a detrended segment. return_onesided: If True (default), return a one-sided spectrum for real inputs. If False, return a two-sided spectrum. scaling: Selects between computing the power spectral density (``'density'``, default) or the power spectrum (``'spectrum'``) axis: Axis along which the PSD is computed (default: -1). average: The type of averaging to use on the periodograms; one of ``'mean'`` (default) or ``'median'``. Returns: A length-2 tuple of arrays ``(f, Pxx)``. ``f`` is the array of sample frequencies, and ``Pxx`` is the power spectral density of ``x``. See Also: - :func:`jax.scipy.signal.csd`: Cross power spectral density. - :func:`jax.scipy.signal.stft`: Short-time Fourier transform. N) rrrrrrrrrr-)r0r) rrrrrrrrrrr-r#Pxxs r(welchr3s>P1dr&'$4#2Gg/*% r<ctd|tjt|d}|jdkr t d|j ^}}}tj|}|j|||f}||dz z|z}d|dz |zz}||z}tj|ddd||z ff}|j||||f}|jd}tj|ddd|fdf}|j ddz } |j|d f}|d d d || z|zf}|j||| |zf}|jd d d d |f}|jt|d zS) a4Utility function compatible with tf.signal.overlap_and_add. Args: x: An array with `(..., frames, frame_length)`-shape. step_size: An integer denoting overlap offsets. Must be less than `frame_length`. Returns: An array with `(..., output_size)`-shape containing overlapped signal. _overlap_and_addzstep_size for overlap_and_addrLz2Input must have (..., frames, frame_length) shape.r@rgr)rrLr@rNrr)rr rrr$r1r,mathprodrrQr transposerr3) r step_sizernframes segment_lenflat_batchsize output_sizenstep_per_segmentpadded_segment_lenshrunkens r(r5r5s$a($$ 957)VVaZ I JJ'(ww$;99[).ii+67!Wq[)K7+;?y88 )94 gga&&1&8;&F"GHI!ii*;YGH!kk,! gga&&1g,78! WWQZ!^(ii$%! 6  )I 5 667!ii!2Hy4HIJ!eeemA| |O$! 5%- ..r<c   td|}|jdkr tdt |j t|j k(r tdt j |t j|j}|rd|j dz zn|j } tjt|xs| d} | dkr tdd } || } |r)| | dzk(r!| dz } ntjt|d } | | krtd | d | dtjt|xs| dzd} | | k\r td| | z }|jdz k7s |jdz k7rCt fdt|jD}t j|| fz}|rt j"nt j$}||d|dd | d d f}t'|t(ry|dk(rt| dk(rt j*dgn>> x = jnp.array([1., 2., 3., 2., 1., 0., 1., 2.]) >>> f, t, Zxx = jax.scipy.signal.stft(x, nperseg=4) >>> print(Zxx) # doctest: +SKIP [[ 1. +0.j 2.5+0.j 1. +0.j 1. +0.j 0.5+0.j ] [-0.5+0.5j -1.5+0.j -0.5-0.5j -0.5+0.5j 0. -0.5j] [ 0. +0.j 0.5+0.j 0. +0.j 0. +0.j -0.5+0.j ]] >>> t, x_reconstructed = jax.scipy.signal.istft(Zxx) >>> print(x_reconstructed) [1. 2. 3. 2. 1. 0. 1. 2.] istftrLzInput stft must be at least 2d!z/Must specify differing time and frequency axes!rr@znperseg: segment length of STFTrrNz nfft of STFTz FFT length (z) must be longer than nperseg (z).znoverlap of STFTrc30K|] }|hvs |ywr#rA)r%idx freq_axis time_axiss r(r)zistft..vs$M#i5K*KMs r)rr.hannrF)endpoint) get_windowz&scipy must be available to use window=zwindow must be 1-Dzwindow must have length of rrg|=))rr$r1rrQrr rrr,r rrr3r5r9rirfftr]rrarraysinlinspacer~pir scipy.signalrJ ImportErrorrrr expand_dimsr5swapaxesrepeatwhererrr)Zxxrrrrrinput_onesidedrrGrF n_defaultrrrr outer_idxsifuncxsubsrrJrr win_squarednormr&s `` r(rCrC sb #&#XX\ 6 77 3884) 3884)) F GG Cv66syyAB#1?qCIIi(1,-IIi( &&sG,@y+LN+1_ 9 ::( \H+Q6!mh%%c4@H   xj ? }BO QQ'' 8 '{a');=,[ : ;;  $%#((Q,)sxx!|";MSXXMMJ --Z9i*@@ AC*'--w||% " %c$ #{A~ Q// /0A [!^k1n$555 6DsyytS))!VVaZCHHqL Y Q ,,q"i (a AGGAJbhhqww&7&=&= > C$ q.A N A&C D#MNs+R.. S 7SS )rN) r'rr.rr!rr9zSequence[int] | Nonereturnr)r'rr.rr!rr^r) r'rr.rr!rrkrr^r)rrwN) r'rr.rr!rryrrkrr^r)rr|rN)r'rr.rr!rrrrfloatrkrr^r)rrrN) rrrrrrrrrNoner^r)rrrrrzCallable[[Array], Array]rrrrr int | Nonerrr^rr)rrrrrrr^r) rrHNNNrTrrrNF)rrrArrayLike | Nonerrrrrrarrarrarz%bool | str | Callable[[Array], Array]rboolrrrrr!rr str | Nonerrcr^tuple[Array, Array, Array]) rrHNNFTrTr)rrrrrrrrrrarrarrcrrcrrdrrcrrr^re) rrHNNNrTrrr)rrrrbrrrrrrarrarrarrrrcrrrrr-rr^tuple[Array, Array])rrrrrrrrarrarrarrrrcrrrrr-rr^rg)rrr:rr^r) rrHNNNTTrr)rVrrrrrrrarrarrarWrcrrcrGrrFrr^rg): __future__rcollections.abcrr functoolsrr7rtypingrr r r~jax._srcrr r r rQjax._src.api_utilr jax._src.lax.laxrjax._src.numpyrrrjax._src.numpy.utilrrrrjax._src.third_party.scipyrjax._src.typingrr jax._src.utilrrrrr2rtrzrrrrrrr'rr0r3r5rCrAr<r(rts#. !1*)! 5,GG=C-1F *F 6;F P%;VDHN(,>M%>M16>MBLR@DG;G;0=G;ING;TIO)-9W&9W279WxMSAE] ]1>]JO]@NO#'F: F:,1F:R--(+-3=-FI-NS-@ 8EHAEEIKUBKOS$) T T4>T)T8BT$IT'+ T=@ T  T ,/ T CM T " T /I TnNQ9=U\*,*)*),6*)*)15*)HR*)*)%(*)2L*)ZKQ;?0:5>'- JJ.8JJ*-JJ03J J"% J3F JZ8>=A2<7@)/ --0:--,/- -25- -$' -5H -`-/`:@=A:>24 HH0:HH37HH-0H H#6 Hr<