o X۷i [@sdZddlmZddlZddlmZddlmZddlZ ddZ ej ej ej gZejejejejgZejejejejgZejejgZeeeeZdd eDZd d Zed d ddZ dBddZ!ed d ddZ"dCddZ#eddddZ$eddddZ%eddddZ&edd d!dZ' % %dDd&d'Z(ed(d)d*d+Z)ed(d,d-d+Z*ed.d)d/d0Z+ed(d)d1d2Z,ed(d)d3d4Z-dEd7d8Z.dFd9d:Z/d;d<Z0d=Z1ej2e1d>d eDd?Z3de4fd@dAZ5dS)Ga Waveform-generating functions. 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 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. ) annotationsN) get_typename)runtimecCs&t|}|dkrtjrd}|Sd}|S)Nfloat16__halfhalf)rris_hip)dtypetypenamer S/home/ubuntu/vllm_env/lib/python3.10/site-packages/cupyx/scipy/signal/_waveforms.py _get_typename%sr cCsg|]}t|qSr )r ).0tr r r 7srcGs>dd|D}d|}|r|d|dn|}||}|S)NcSsg|]}t|jqSr )r r )rargr r r r;sz$_get_module_func..z, <>)join get_function)module func_name template_args args_dtypestemplate kernel_namekernelr r r _get_module_func:s   rzT t, T wz float64 ya double out {}; const bool mask1 { ( ( w > 1 ) || ( w < 0 ) ) }; if ( mask1 ) { out = nan("0xfff8000000000000ULL"); } // Use Python-compatible modulo: result is always in [0, 2*pi) // C fmod can return negative values for negative inputs T tmod { fmod( t, 2.0 * M_PI ) }; if ( tmod < 0 ) { tmod += 2.0 * M_PI; } const bool mask2 { ( ( 1 - mask1 ) && ( tmod < ( w * 2.0 * M_PI ) ) ) }; if ( mask2 ) { out = tmod / ( M_PI * w ) - 1; } const bool mask3 { ( ( 1 - mask1 ) && ( 1 - mask2 ) ) }; if ( mask3 ) { out = ( M_PI * ( w + 1 ) - tmod ) / ( M_PI * ( 1 - w ) ); } y = out; _sawtooth_kernel?cC$t|t|}}t||}|S)a Return a periodic sawtooth or triangle waveform. The sawtooth waveform has a period ``2*pi``, rises from -1 to 1 on the interval 0 to ``width*2*pi``, then drops from 1 to -1 on the interval ``width*2*pi`` to ``2*pi``. `width` must be in the interval [0, 1]. Note that this is not band-limited. It produces an infinite number of harmonics, which are aliased back and forth across the frequency spectrum. Parameters ---------- t : array_like Time. width : array_like, optional Width of the rising ramp as a proportion of the total cycle. Default is 1, producing a rising ramp, while 0 produces a falling ramp. `width` = 0.5 produces a triangle wave. If an array, causes wave shape to change over time, and must be the same length as t. Returns ------- y : ndarray Output array containing the sawtooth waveform. Examples -------- A 5 Hz waveform sampled at 500 Hz for 1 second: >>> from cupyx.scipy import signal >>> import matplotlib.pyplot as plt >>> t = np.linspace(0, 1, 500) >>> plt.plot(t, signal.sawtooth(2 * np.pi * 5 * t)) )cupyasarrayr)rwidthwyr r r sawtoothbs% r&a: const bool mask1 { ( ( w > 1 ) || ( w < 0 ) ) }; if ( mask1 ) { y = nan("0xfff8000000000000ULL"); } // Use Python-compatible modulo: result is always in [0, 2*pi) // C fmod can return negative values for negative inputs T tmod { fmod( t, 2.0 * M_PI ) }; if ( tmod < 0 ) { tmod += 2.0 * M_PI; } const bool mask2 { ( ( 1 - mask1 ) && ( tmod < ( w * 2.0 * M_PI ) ) ) }; if ( mask2 ) { y = 1; } const bool mask3 { ( ( 1 - mask1 ) && ( 1 - mask2 ) ) }; if ( mask3 ) { y = -1; } _square_kernel?cCr )a Return a periodic square-wave waveform. The square wave has a period ``2*pi``, has value +1 from 0 to ``2*pi*duty`` and -1 from ``2*pi*duty`` to ``2*pi``. `duty` must be in the interval [0,1]. Note that this is not band-limited. It produces an infinite number of harmonics, which are aliased back and forth across the frequency spectrum. Parameters ---------- t : array_like The input time array. duty : array_like, optional Duty cycle. Default is 0.5 (50% duty cycle). If an array, causes wave shape to change over time, and must be the same length as t. Returns ------- y : ndarray Output array containing the square waveform. Examples -------- A 5 Hz waveform sampled at 500 Hz for 1 second: >>> import cupyx.scipy.signal >>> import cupy as cp >>> import matplotlib.pyplot as plt >>> t = cupy.linspace(0, 1, 500, endpoint=False) >>> plt.plot(cupy.asnumpy(t), cupy.asnumpy(cupyx.scipy.signal.square(2 * cupy.pi * 5 * t))) >>> plt.ylim(-2, 2) A pulse-width modulated sine wave: >>> plt.figure() >>> sig = cupy.sin(2 * cupy.pi * t) >>> pwm = cupyx.scipy.signal.square(2 * cupy.pi * 30 * t, duty=(sig + 1)/2) >>> plt.subplot(2, 1, 1) >>> plt.plot(cupy.asnumpy(t), cupy.asnumpy(sig)) >>> plt.subplot(2, 1, 2) >>> plt.plot(cupy.asnumpy(t), cupy.asnumpy(pwm)) >>> plt.ylim(-1.5, 1.5) )r!r"r')rdutyr$r%r r r squares1 r*zT t, T a, T fczT yIzL T yenv = exp(-a * t * t); yI = yenv * cos( 2 * M_PI * fc * t); _gausspulse_kernelz T yI, T yenvzJ yenv = exp(-a * t * t); yI = yenv * cos( 2 * M_PI * fc * t); z T yI, T yQz T yenv { exp(-a * t * t) }; T l_yI {}; T l_yQ {}; sincos(2 * M_PI * fc * t, &l_yQ, &l_yI); yI = yenv * l_yI; yQ = yenv * l_yQ; zT yI, T yQ, T yenvz yenv = exp(-a * t * t); T l_yI {}; T l_yQ {}; sincos(2 * M_PI * fc * t, &l_yQ, &l_yI); yI = yenv * l_yI; yQ = yenv * l_yQ; Fc Cs|dkr td||dkrtd||dkrtd|td|d}tj||d dt|}t|tr]|d krY|dkrGtd td|d} tt|  |Std t |}|sl|slt |||S|sv|rvt |||S|r|st |||S|r|rt |||Sd Sd S) a Return a Gaussian modulated sinusoid: ``exp(-a t^2) exp(1j*2*pi*fc*t).`` If `retquad` is True, then return the real and imaginary parts (in-phase and quadrature). If `retenv` is True, then return the envelope (unmodulated signal). Otherwise, return the real part of the modulated sinusoid. Parameters ---------- t : ndarray or the string 'cutoff' Input array. fc : int, optional Center frequency (e.g. Hz). Default is 1000. bw : float, optional Fractional bandwidth in frequency domain of pulse (e.g. Hz). Default is 0.5. bwr : float, optional Reference level at which fractional bandwidth is calculated (dB). Default is -6. tpr : float, optional If `t` is 'cutoff', then the function returns the cutoff time for when the pulse amplitude falls below `tpr` (in dB). Default is -60. retquad : bool, optional If True, return the quadrature (imaginary) as well as the real part of the signal. Default is False. retenv : bool, optional If True, return the envelope of the signal. Default is False. Returns ------- yI : ndarray Real part of signal. Always returned. yQ : ndarray Imaginary part of signal. Only returned if `retquad` is True. yenv : ndarray Envelope of signal. Only returned if `retenv` is True. See Also -------- cupyx.scipy.signal.morlet Examples -------- Plot real component, imaginary component, and envelope for a 5 Hz pulse, sampled at 100 Hz for 2 seconds: >>> import cupyx.scipy.signal >>> import cupy as cp >>> import matplotlib.pyplot as plt >>> t = cupy.linspace(-1, 1, 2 * 100, endpoint=False) >>> i, q, e = cupyx.scipy.signal.gausspulse(t, fc=5, retquad=True, retenv=True) >>> plt.plot(cupy.asnumpy(t), cupy.asnumpy(i), cupy.asnumpy(t), cupy.asnumpy(q), cupy.asnumpy(t), cupy.asnumpy(e), '--') rz'Center frequency (fc=%.2f) must be >=0.z+Fractional bandwidth (bw=%.2f) must be > 0.z7Reference level for bandwidth (bwr=%.2f) must be < 0 dBg$@g4@g@cutoffz.Reference level for time cutoff must be < 0 dBz'If `t` is a string, it must be 'cutoff'N) ValueErrorpownppilog isinstancestrsqrtr!r"_gausspulse_kernel_F_F_gausspulse_kernel_F_T_gausspulse_kernel_T_F_gausspulse_kernel_T_T) rfcbwbwrtprretquadretenvrefatrefr r r gausspulses:=  "      rFzT t, T f0, T t1, T f1, T phizT phasez const T beta { (f1 - f0) / t1 }; const T temp { 2 * M_PI * (f0 * t + 0.5 * beta * t * t) }; // Convert phi to radians. phase = cos(temp + phi); _chirp_phase_lin_kernelzY phasez const T beta { (f1 - f0) / t1 }; const T temp { 2 * M_PI * (f0 * t + 0.5 * beta * t * t) }; // Convert phi to radians. phase = Y(cos(temp + phi), cos(temp + phi + M_PI/2) * -1); z.T t, T f0, T t1, T f1, T phi, bool vertex_zeroag T temp {}; const T beta { (f1 - f0) / (t1 * t1) }; if ( vertex_zero ) { temp = 2 * M_PI * (f0 * t + beta * (t * t * t) / 3); } else { temp = 2 * M_PI * ( f1 * t + beta * ( ( (t1 - t) * (t1 - t) * (t1 - t) ) - (t1 * t1 * t1)) / 3); } // Convert phi to radians. phase = cos(temp + phi); _chirp_phase_quad_kernela T temp {}; if ( f0 == f1 ) { temp = 2 * M_PI * f0 * t; } else { T beta { t1 / log(f1 / f0) }; temp = 2 * M_PI * beta * f0 * ( pow(f1 / f0, t / t1) - 1.0 ); } // Convert phi to radians. phase = cos(temp + phi); _chirp_phase_log_kernela  T temp {}; if ( f0 == f1 ) { temp = 2 * M_PI * f0 * t; } else { T sing { -f1 * t1 / (f0 - f1) }; temp = 2 * M_PI * ( -sing * f0 ) * log( abs( 1 - t / sing ) ); } // Convert phi to radians. phase = cos(temp + phi); _chirp_phase_hyp_kernellinearTc CsFt|}t|jtjr|tj}|tjd9}d}|dvrb|dkr,t |||||S|dkr[|j jj dkrG|jj dkrGtj |jtjd}n tj |jtjd}t|||||||Std||d vrot||||||S|d vr||d kr}td t|||||S|d vr|dks|dkrtdt|||||Std|)a' Frequency-swept cosine generator. In the following, 'Hz' should be interpreted as 'cycles per unit'; there is no requirement here that the unit is one second. The important distinction is that the units of rotation are cycles, not radians. Likewise, `t` could be a measurement of space instead of time. Parameters ---------- t : array_like Times at which to evaluate the waveform. f0 : float Frequency (e.g. Hz) at time t=0. t1 : float Time at which `f1` is specified. f1 : float Frequency (e.g. Hz) of the waveform at time `t1`. method : {'linear', 'quadratic', 'logarithmic', 'hyperbolic'}, optional Kind of frequency sweep. If not given, `linear` is assumed. See Notes below for more details. phi : float, optional Phase offset, in degrees. Default is 0. vertex_zero : bool, optional This parameter is only used when `method` is 'quadratic'. It determines whether the vertex of the parabola that is the graph of the frequency is at t=0 or t=t1. Returns ------- y : ndarray A numpy array containing the signal evaluated at `t` with the requested time-varying frequency. More precisely, the function returns ``cos(phase + (pi/180)*phi)`` where `phase` is the integral (from 0 to `t`) of ``2*pi*f(t)``. ``f(t)`` is defined below. Examples -------- The following will be used in the examples: >>> from cupyx.scipy.signal import chirp, spectrogram >>> import matplotlib.pyplot as plt >>> import cupy as cp For the first example, we'll plot the waveform for a linear chirp from 6 Hz to 1 Hz over 10 seconds: >>> t = cupy.linspace(0, 10, 5001) >>> w = chirp(t, f0=6, f1=1, t1=10, method='linear') >>> plt.plot(cupy.asnumpy(t), cupy.asnumpy(w)) >>> plt.title("Linear Chirp, f(0)=6, f(10)=1") >>> plt.xlabel('t (sec)') >>> plt.show() For the remaining examples, we'll use higher frequency ranges, and demonstrate the result using `cupyx.scipy.signal.spectrogram`. We'll use a 10 second interval sampled at 8000 Hz. >>> fs = 8000 >>> T = 10 >>> t = cupy.linspace(0, T, T*fs, endpoint=False) Quadratic chirp from 1500 Hz to 250 Hz over 10 seconds (vertex of the parabolic curve of the frequency is at t=0): >>> w = chirp(t, f0=1500, f1=250, t1=10, method='quadratic') >>> ff, tt, Sxx = spectrogram(w, fs=fs, noverlap=256, nperseg=512, ... nfft=2048) >>> plt.pcolormesh(cupy.asnumpy(tt), cupy.asnumpy(ff[:513]), cupy.asnumpy(Sxx[:513]), cmap='gray_r') >>> plt.title('Quadratic Chirp, f(0)=1500, f(10)=250') >>> plt.xlabel('t (sec)') >>> plt.ylabel('Frequency (Hz)') >>> plt.grid() >>> plt.show() real)rKlinlicomplexf)r zNo kernel for type {}) quadraticquadq) logarithmicr5logzJFor a logarithmic chirp, f0 and f1 must be nonzero and have the same sign.) hyperbolichyprz2For a hyperbolic chirp, f0 and f1 must be nonzero.zbmethod must be 'linear', 'quadratic', 'logarithmic', or 'hyperbolic', but a value of %r was given.)r!r" issubdtyper integerastypefloat64r3r4_chirp_phase_lin_kernel_realrMkinditemsizeemptyshape complex128 complex64_chirp_phase_lin_kernel_cplxNotImplementedErrorformatrHr1rIrJ) rf0t1f1methodphi vertex_zerotypephaser r r chirpsD L  rpcCs&t||}|tjd9}t||S)a2 Frequency-swept cosine generator, with a time-dependent frequency. This function generates a sinusoidal function whose instantaneous frequency varies with time. The frequency at time `t` is given by the `poly` array. Parameters ---------- t : ndarray Times at which to evaluate the waveform. poly : 1-D array_like or instance of numpy.poly1d The desired frequency expressed as a polynomial. If `poly` is a list or ndarray of length n, then the elements of `poly` are the coefficients of the polynomial, and the instantaneous frequency is ``f(t) = poly[0]*t**(n-1) + poly[1]*t**(n-2) + ... + poly[n-1]`` If `poly` is an instance of cupy.poly1d, then the instantaneous frequency is ``f(t) = poly(t)`` phi : float, optional Phase offset, in degrees, Default: 0. Returns ------- sweep_poly : ndarray A numpy array containing the signal evaluated at `t` with the requested time-varying frequency. More precisely, the function returns ``cos(phase + (pi/180)*phi)``, where `phase` is the integral (from 0 to t) of ``2 * pi * f(t)``; ``f(t)`` is defined above. See Also -------- scipy.signal.sweep_poly chirp Notes ----- If `poly` is an ndarray of length `n`, then the elements of `poly` are the coefficients of the polynomial, and the instantaneous frequency is: ``f(t) = poly[0]*t**(n-1) + poly[1]*t**(n-2) + ... + poly[n-1]`` If `poly` is an instance of `numpy.poly1d`, then the instantaneous frequency is: ``f(t) = poly(t)`` Finally, the output `s` is: ``cos(phase + (pi/180)*phi)`` where `phase` is the integral from 0 to `t` of ``2 * pi * f(t)``, ``f(t)`` as defined above. rL)_sweep_poly_phaser!r4cos)rpolyrlror r r sweep_polyBs ?rtcCslt|tjr |j}t|jdd}|td|jddddd|dd<dtjt||}|S)z Calculate the phase used by sweep_poly to generate its output. See `sweep_poly` for a description of the arguments. rNr/) r6r!poly1dcoeffszerosrbaranger4polyval)rrsintpolyror r r rqs ,rqa #include #include #include #include // TODO(seberg): Add this via type_headers? template __global__ void unit_impulse(const int n, const int iidx, T* out) { const int idx = blockIdx.x * blockDim.x + threadIdx.x; if(idx >= n) { return; } if(idx == iidx) { out[idx] = 1; } else { out[idx] = 0; } } cCsg|]}d|dqS)z unit_impulse>> import cupyx.scipy.signal >>> import cupy as cp >>> cupyx.scipy.signal.unit_impulse(8) array([ 1., 0., 0., 0., 0., 0., 0., 0.]) Impulse offset by 2 samples (:math:`\delta[n-2]`): >>> cupyx.scipy.signal.unit_impulse(7, 2) array([ 0., 0., 1., 0., 0., 0., 0.]) 2-dimensional impulse, centered: >>> cupyx.scipy.signal.unit_impulse((3, 3), 'mid') array([[ 0., 0., 0.], [ 0., 1., 0.], [ 0., 0., 0.]]) Impulse at (2, 2), using broadcasting: >>> cupyx.scipy.signal.unit_impulse((4, 4), 2) array([[ 0., 0., 0., 0.], [ 0., 0., 0., 0.], [ 0., 0., 1., 0.], [ 0., 0., 0., 0.]]) Nrmidr/__iter__ru unit_impulse) r!rar3 atleast_1dlentuplehasattrravel_multi_indexrbsizer UNIT_MODULE) rbidxr outposnblock_szn_blocksunit_impulse_kernelr r r rs 8   r)r)r()r,r(r-r.FF)rKrTr)6__doc__ __future__rr!cupy._core._scalarrcupy_backends.cuda.apirnumpyr3r rfloat32r] FLOAT_TYPESint8int16int32int64 INT_TYPESuint8uint16uint32uint64UNSIGNED_TYPESrdrc COMPLEX_TYPESTYPES TYPE_NAMESrElementwiseKernelrr&r'r*r9r:r;r<rFr^rerHrIrJrprtrq UNIT_KERNEL RawModulerfloatrr r r r s      * 6     f       zE