paradigma 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

paradigma/ppg/hr_functions/TFD toolbox JOT/decimated_TFDs/dec_di_gdtfd.m

@@ -1,194 +0,0 @@
-%-------------------------------------------------------------------------------
-% dec_di_gdtfd: decimated Doppler-independent kernel TFD ρ[nᵢ,bk], where b is an
-% integer value and nᵢ is the set nᵢ ={ nᵢ | 1≤i≤U }, with 0≤nᵢ≤N-1
-%
-% Syntax: tfd=dec_di_gdtfd(x,lag_win_params,time_dec,freq_dec,Nfreq)
-%
-% Inputs: 
-%      x = input signal (either real-valued signal of length-N or
-%          complex-valued analytic signal of length-2N)
-%
-%      lag_win_params = lag window parameters in cell form:
-%                 {win_length,win_type,win_param,lag_or_not} where
-%                     - win_length is the sample length of the window
-%                     - win_type is the type of window 
-%                     - [optional] win_param is the parameter of the window 
-%                     - [optional] lag_or_not is either 0 (define window in the lag
-%                     domain, which is the default) or 0 (define window the frequency domain)
-%                 e.g. {121, 'hamm'}; {121, 'tukey', 0.2}; {127,'cosh',0.01,0}
-%
-%      time_dec = decimation factor a in the time domain; a/Ntime is integer
-%      freq_dec = decimation factor b in the frequency domain; b/Nfreq is integer
-%
-%      Nfreq = frequency oversampling value; must be greater than length of lag window
-%
-% See also: DI_GDTFD, GET_ANALYTIC_SIGNAL, GEN_LAG_KERN, FFT
-%
-% Outputs: 
-%     tfd = U x (b/Nfreq) time–frequency distribution
-%
-% Example:
-%     N=1024; Nfreq=128; ni=[100:4:900]; b=2;
-%     x=gen_LFM(N,0.1,0.3)+gen_LFM(N,0.4,0.1);
-%     
-%     c=dec_di_gdtfd(x,{101,'hann'},ni,b,Nfreq);
-%     vtfd(c,x,1,ni);
-
-
-% John M. O' Toole, University College Cork
-% Started: 23-04-2014
-%
-% last update: Time-stamp: <2014-07-23 16:22:59 (otoolej)>
-%-------------------------------------------------------------------------------
-function tfd=dec_di_gdtfd(x,lag_win_params,time_dec,freq_dec,Nfreq)
-if(nargin<2 || isempty(lag_win_params)), lag_win_params={101,'hamm'}; end
-if(nargin<3 || isempty(time_dec)), time_dec=[]; end
-if(nargin<4 || isempty(freq_dec)), freq_dec=1; end
-if(nargin<5 || isempty(Nfreq)), Nfreq=[]; end
-
-DBplot=0;
-DBmem=0;
-DBtest=0;
-DBtime=0;
-DBverbose=0;
-
-
-if(DBtime), time_start=tic; end
-%---------------------------------------------------------------------
-% 1. convert real-valued signal to analytic signal of length 2N
-%---------------------------------------------------------------------
-[z,N2,N,Nh]=get_analytic_signal(x);
-
-
-%---------------------------------------------------------------------
-% 2. generate time--lag signal function (for positive-lag values only)
-%---------------------------------------------------------------------
-[g2,P,Ph_floor,Nfreq]=gen_lag_kern(lag_win_params,N,Nfreq);
-Nh=ceil(Nfreq/2);
-Ph=ceil(P/2);
-
-
-% check decimation parameters and return as sequence:
-if(length(freq_dec)>1)
-    error('Frequency decimation parameter should be scalar');
-end
-[n_seq,U]=check_dec_params_seq(time_dec,N,'time',0);
-[k_seq,J,freq_dec]=check_dec_params_seq(freq_dec,Nfreq,'frequency',1);
-Jh=ceil(J/2);  J_extend=2*Jh+2;
-
-
-if(DBmem), s=whos; fprintf('start: mem=%s\n',disp_bytes(sum([s.bytes]))); end
-tfd=zeros(U,J_extend); 
-if(J~=Nfreq)
-    m_real=1:Jh+1; m_imag=(J_extend-Jh):(J_extend);
-else
-    m_real=1:Ph; m_imag=(J-Ph+1):J;
-end
-
-
-
-m=0:(Ph-1); mb=1:(Ph-1);
-for in=1:U
-    n=n_seq(in);
-    inp=mod(n+m,N2);  inn=mod(n-m,N2); 
-    
-    if(J~=Nfreq)
-        % need to fold signal function (for decimation in frequency-direction):        
-        K_time_slice=zeros(1,Nfreq);
-        K_time_slice(m+1)=g2(m+1).*z(inp+1).*conj( z(inn+1) );
-        K_time_slice(Nfreq-mb+1)=conj(K_time_slice(mb+1));
-
-        R_fold=fold_vector_half(K_time_slice,J,Jh,freq_dec);
-    else
-        % or if not then do as usual:
-        K_time_slice(m+1)=g2(m+1).*z(inp+1).*conj( z(inn+1) );
-
-        R_fold=K_time_slice;
-    end
-    
-    tfd(in,m_real)=real( R_fold );
-    tfd(in,m_imag)=imag( R_fold );    
-end
-
-if(DBmem), s=whos; fprintf('K: mem=%s\n',disp_bytes(sum([s.bytes]))); end
-
-
-%-------------------------------------------------------------------------
-% 3.  Expand R for positive and negative lag values and DFT back to 
-%     time--frequency domain
-%-------------------------------------------------------------------------
-if(J~=Nfreq)
-    m=0:Jh; mb=1:(Jh-1);
-else
-    m=0:(Ph-1); mb=1:(Ph-1);
-end
-    
-
-for n=0:2:(U-2)
-    R_even_half=complex(tfd(n+1,m_real),tfd(n+1,m_imag));
-    R_odd_half =complex(tfd(n+2,m_real),tfd(n+2,m_imag));    
-    
-    R_tslice_even=zeros(1,J);  R_tslice_odd=zeros(1,J);
-    R_tslice_even(m+1)=R_even_half(m+1);
-    R_tslice_odd(m+1) =R_odd_half(m+1);
-    R_tslice_even(J-mb+1)=conj( R_even_half(mb+1) );
-    R_tslice_odd(J-mb+1) =conj( R_odd_half(mb+1) );
-    
-    tfd_time_slice=fft( R_tslice_even+j.*R_tslice_odd );
-
-    tfd(n+1,1:J)=real(tfd_time_slice);
-    tfd(n+2,1:J)=imag(tfd_time_slice);
-end
-
-% one extra FFT if U is odd:
-if(rem(U,2))
-    R_even_half=complex(tfd(U,m_real),tfd(U,m_imag));
-    R_tslice_even=zeros(1,J);
-    R_tslice_even(m+1)=R_even_half(m+1);
-    R_tslice_even(J-mb+1)=conj( R_even_half(mb+1) );
-    tfd_time_slice=fft( R_tslice_even );
-
-    tfd(U,1:J)=real(tfd_time_slice);
-end
-tfd=tfd(:,1:J);
-
-if(DBmem), s=whos; fprintf('end: mem=%s\n',disp_bytes(sum([s.bytes]))); end
-
-scale_factor=1/Nfreq;
-tfd=tfd.*scale_factor;
-
-if(DBtime), dispVars( toc(time_start) ); end
-
-
-%---------------------------------------------------------------------
-% END; testing and plotting
-%---------------------------------------------------------------------
-if(DBtest)
-    if(DBtime),  time_start=tic; end
-    tfd_test=full_gdtfd_testing_version(x,'pwvd',{P,lag_win_params{2:end}});
-    if(DBtime),  dispVars( toc(time_start) ); end
-
-    if(Nfreq==N)
-        dispEE(tfd_test(n_seq+1,k_seq+1),tfd);        
-    else
-        b=N/Nfreq; 
-        if( b==floor(b) )
-            dispEE(tfd_test(n_seq+1,(b.*k_seq)+1),tfd./b);
-        end
-    end
-
-end
-if(DBverbose)
-    fprintf('size=%dx%d; max=%g; total energ:%d\n', size(tfd,1), size(tfd,2), max(tfd(:)), ...
-            sum(tfd(:)));
-end
-if(DBplot)
-    figure(1); clf; 
-    vtfd(tfd,real(x(1:N)));
-    
-    figure(9); clf; hold all;
-    subplot(211); hold all; plot(sum(tfd')'); plot( abs(z(1:N)).^2 );
-    subplot(212); hold all; plot(sum(tfd')' - abs(z(n_seq+1)).^2 );    
-end
-
-

paradigma/ppg/hr_functions/TFD toolbox JOT/decimated_TFDs/dec_li_gdtfd.m

@@ -1,200 +0,0 @@
-%-------------------------------------------------------------------------------
-% dec_li_gdtfd: decimated lag-independent kernel TFD ρ[an,kᵢ], where a is an integer
-% value and kᵢ is the set kᵢ ={ kᵢ | 1≤i≤V }, with 0≤kᵢ≤N-1
-%
-% Syntax: tfd=dec_li_gdtfd(x,dopp_win_params,time_dec,freq_dec,Ntime)
-%
-% Inputs: 
-%      x = input signal (either real-valued signal of length-N or
-%          complex-valued analytic signal of length-2N)
-%
-%      dopp_win_params = Doppler window parameters in cell form:
-%                 {win_length,win_type,win_param,Doppler_or_not} where
-%                     - win_length is the sample length of the window
-%                     - win_type is the type of window 
-%                     - [optional] win_param is the parameter of the window 
-%                     - [optional] Doppler_or_not is either 1 (define window in the Doppler
-%                     domain, which is the default) or 0 (define window in the time domain)
-%                 e.g. {121, 'hamm'}; {121, 'tukey', 0.2}; {127,'cosh',0.01,0}
-%
-%      time_dec  = decimation factor a in the time domain; a/Ntime is integer
-%      freq_dec  = decimation factor b in the frequency domain; b/Nfreq is integer
-%
-%      Ntime = time oversampling value; must be greater than length of Doppler window
-%
-% Outputs: 
-%     tfd = (a/Ntime) x V time–frequency distribution
-%
-% See also: LI_GDTFD, GET_ANALYTIC_SIGNAL, GEN_DOPPLER_KERN, FFT
-%
-% Example:
-%     N=1024; Ntime=64; a=2; ki=[150:4:850]; 
-%     x=gen_LFM(N,0.1,0.3)+gen_LFM(N,0.4,0.1);
-%
-%     c=dec_li_gdtfd(x,{51,'hann'},a,ki,Ntime); 
-%     vtfd(c,x,1,[],ki./(N*2));
-
-% John M. O' Toole, University College Cork
-% Started: 23-04-2014
-%
-% last update: Time-stamp: <2014-07-23 16:19:59 (otoolej)>
-%-------------------------------------------------------------------------------
-function tfd=dec_li_gdtfd(x,dopp_win_params,time_dec,freq_dec,Ntime)
-if(nargin<2 || isempty(dopp_win_params)), dopp_win_params={51,'hann'}; end
-if(nargin<3 || isempty(time_dec)), time_dec=1; end
-if(nargin<4 || isempty(freq_dec)), freq_dec=1; end
-if(nargin<5 || isempty(Ntime)), Ntime=[]; end
-
-
-DBplot=0;
-DBmem=0;
-DBtest=0;
-DBtime=0;
-DBverbose=0;
-
-
-if(DBtime), time_start=tic; end
-%---------------------------------------------------------------------
-% 1. convert real-valued signal to analytic signal of length 2N
-%---------------------------------------------------------------------
-[z,N2,N,Nh]=get_analytic_signal(x);
-
-
-%---------------------------------------------------------------------
-% 2. generate time--lag signal function (for positive-lag values only)
-%---------------------------------------------------------------------
-[G1,Q,Ntime]=gen_Doppler_kern(dopp_win_params,N,Ntime);
-Qh=ceil(Q/2);
-
-
-% check decimation parameters and return as sequence:
-if(length(time_dec)>1)
-    error('Frequency decimation parameter should be scalar');
-end
-[n_seq,L,time_dec]=check_dec_params_seq(time_dec,Ntime,'time',1);
-[k_seq,V]=check_dec_params_seq(freq_dec,N,'frequency',0);
-Lh=ceil(L/2);  L_extend=2*Lh+2;
-
-
-if(DBmem), s=whos; fprintf('start: mem=%s\n',disp_bytes(sum([s.bytes]))); end
-tfd=zeros(L_extend,V); 
-if(L~=Ntime)
-    l_real=1:(Lh+1); l_imag=(L_extend-Lh):L_extend;
-else
-    l_real=1:Qh; l_imag=(L-Qh+1):L;
-end
-
-
-Z=fft(z);
-l=0:(Qh-1); lb=1:(Qh-1);
-for ik=1:V
-    k=k_seq(ik);
-    inp=mod(k+l,N2);  inn=mod(k-l,N2); 
-    inpN=mod(k+l+N,N2);  innN=mod(k-l-N,N2);     
-    
-    if(L~=Ntime)
-        K_doppler_slice=zeros(1,Ntime);
-        K_doppler_slice(l+1)=G1(l+1).*( Z(inp+1).*conj( Z(inn+1) )  + ...
-                                        Z(inpN+1).*conj( Z(innN+1) ) );
-        K_doppler_slice(Ntime-lb+1)=conj( K_doppler_slice(lb+1) );
-        
-        R_fold=fold_vector_half(K_doppler_slice./2,L,Lh,time_dec);
-    else
-        
-        K_doppler_slice=G1(l+1).*( Z(inp+1).*conj( Z(inn+1) )  + ...
-                                   Z(inpN+1).*conj( Z(innN+1) ) );
-        
-        R_fold=K_doppler_slice;
-    end
-    
-    tfd(l_real,ik)=real( R_fold );
-    tfd(l_imag,ik)=imag( R_fold );    
-end
-
-
-if(DBmem), s=whos; fprintf('K: mem=%s\n',disp_bytes(sum([s.bytes]))); end
-
-
-
-%-------------------------------------------------------------------------
-% 3.  Expand R for positive and negative lag values and DFT back to 
-%     time--frequency domain
-%-------------------------------------------------------------------------
-if(L~=Ntime)
-    l=0:Lh; lb=1:(Lh-1);
-else
-    l=0:(Qh-1); lb=1:(Qh-1);
-end
-
-for k=0:2:(V-2)
-    R_even_half=complex(tfd(l_real,k+1),tfd(l_imag,k+1));
-    R_odd_half =complex(tfd(l_real,k+2),tfd(l_imag,k+2));    
-    
-    R_tslice_even=zeros(L,1);  R_tslice_odd=zeros(L,1);
-    R_tslice_even(l+1)=R_even_half(l+1);
-    R_tslice_odd(l+1) =R_odd_half(l+1);
-    R_tslice_even(L-lb+1)=conj( R_even_half(lb+1) );
-    R_tslice_odd(L-lb+1) =conj( R_odd_half(lb+1) );
-    
-    tfd_freq_slice=ifft( R_tslice_even+j.*R_tslice_odd );
-
-    tfd(1:L,k+1)=real(tfd_freq_slice);
-    tfd(1:L,k+2)=imag(tfd_freq_slice);
-end
-
-% one extra FFT if V is odd
-if(rem(V,2))
-    R_even_half=complex(tfd(l_real,V),tfd(l_imag,V));
-    
-    R_tslice_even=zeros(L,1);  
-    R_tslice_even(l+1)=R_even_half(l+1);
-    R_tslice_even(L-lb+1)=conj( R_even_half(lb+1) );
-    
-    tfd_freq_slice=ifft( R_tslice_even );
-
-    tfd(1:L,V)=real(tfd_freq_slice);
-end
-tfd=tfd(1:L,:);
-
-if(DBmem), s=whos; fprintf('tfd (end): mem=%s\n',disp_bytes(sum([s.bytes]))); end
-
-
-if(time_dec==1)
-    scale_factor=1/(2*N);
-else
-    scale_factor=1/(N*time_dec);
-end
-tfd=tfd.*scale_factor;
-
-if(DBtime), dispVars( ['time: ' num2str(toc(time_start))] ); end
-
-
-%---------------------------------------------------------------------
-% END; testing and plotting
-%---------------------------------------------------------------------
-if(DBtest)
-    if(DBtime), time_start=tic; end
-    tfd_test=full_gdtfd_testing_version(x,'swvd',{Q,dopp_win_params{2:end}});
-    if(DBtime), dispVars( ['testing time: ' num2str(toc(time_start))] ); end
-    if(Ntime==N)
-        dispEE(tfd_test(n_seq+1,k_seq+1),tfd);
-    else
-        a=N/Ntime; 
-        if( a==floor(a) )
-            dispEE(tfd_test((a.*n_seq)+1,k_seq+1),tfd./a);
-        end
-    end
-end
-if(DBverbose)
-    fprintf('size=%dx%d; max=%g; total energ:%d\n', size(tfd,1), size(tfd,2), max(tfd(:)), ...
-            sum(tfd(:)));
-end
-if(DBplot)
-    figure(1); clf; 
-    vtfd(tfd,real(x(1:N)));
-    
-    figure(9); clf; hold all;
-    Z=fft(z);
-    subplot(211); hold all; plot(sum(tfd)); plot( abs(Z(1:N)).^2./(2*N) );
-    subplot(212); hold all; plot(sum(tfd)' - abs(Z(k_seq+1)).^2./(2*N) );    
-end

paradigma/ppg/hr_functions/TFD toolbox JOT/decimated_TFDs/dec_nonsep_gdtfd.m

@@ -1,229 +0,0 @@
-%-------------------------------------------------------------------------------
-% dec_nonsep_gdtfd: decimated TFD with non-separable kernel ρ[an,bk], where a,b are
-% integer values
-% 
-%
-% Syntax: tfd=dec_nonsep_gdtfd(x,kern_type,kern_params,time_dec,freq_dec)
-%
-% Inputs: 
-%      x = input signal (either real-valued signal of length-N or
-%          complex-valued analytic signal of length-2N)
-%
-%      kern_type = { 'wvd' | 'swvd' | 'pwvd' | 'sep' | 'cw' | 'mb' }
-%            wvd  - Wigner-Ville distribution
-%            swvd - Smoothed Wigner-Ville distribution
-%                   (lag-independent kernel)
-%            pwvd - Pseudo Wigner-Ville distribution
-%                   (Doppler-independent kernel)
-%            sep  - Separable-kernel distribution 
-%                   (combintation of SWVD and PWVD)
-%            mb   - Modified-B distribution
-%            cw   - Choi-Williams distribution
-% 
-%      kern_params = cell of kernel parameters:
-%            wvd  - {}
-%            swvd - {win_length,win_type,[win_param]}
-%                   e.g. {11,'hamm'}
-%            pwvd - {win_length,win_type,[win_param]}
-%                   e.g. {200,'cosh',0.1}
-%            sep  - { {win1_length,win1_type,[win1_param]}, 
-%                    {win2_length,win2_type,[win2_param]} }
-%                   where win1 is the doppler window and win2 is the 
-%                   lag window, e.g. { {11,'hamm'}, {200,'cosh',0.1} }
-%            mb   - {beta_parameter} in the range 1<beta<0
-%            cw   - {sigma_parameter}
-%
-%     time_dec  = decimation factor a in the time domain; a/N is integer
-%     freq_dec  = decimation factor b in the frequency domain; b/N is integer
-%
-% Outputs: 
-%     tfd = a/N x b/N time–frequency distribution
-%
-% See also: NONSEP_GDTFD, GET_ANALYTIC_SIGNAL, GEN_DOPPLER_LAG_KERN, FFT
-%
-% Example:
-%      N=1024; a=2; b=8;
-%      x=gen_LFM(N,0.1,0.3)+gen_LFM(N,0.4,0.1);
-%      c=dec_nonsep_gdtfd(x,'cw',{100},a,b); 
-%      vtfd(c,x);
-
-% John M. O' Toole, University College Cork
-% Started: 23-04-2014
-%
-% last update: Time-stamp: <2014-09-15 13:19:16 (otoolej)>
-%-------------------------------------------------------------------------------
-function tfd=dec_nonsep_gdtfd(x,kern_type,kern_params,time_dec,freq_dec)
-if(nargin<2 || isempty(kern_type)),   kern_type='cw'; end
-if(nargin<3 || isempty(kern_params)), kern_params=10; end
-if(nargin<4 || isempty(time_dec)),    time_dec=1; end
-if(nargin<5 || isempty(freq_dec)),    freq_dec=1; end
-
-
-DBplot=0;
-DBmem=0;
-DBtest=0;
-DBtime=0;
-DBverbose=0;
-
-
-if(DBtime), time_start=tic; end
-%---------------------------------------------------------------------
-% 1. convert real-valued signal to analytic signal of length 2N
-%---------------------------------------------------------------------
-[z,N2,N,Nh]=get_analytic_signal(x);
-
-% if product-kernel then generate window now:
-G1=get_prod_kernel(kern_type,kern_params,N);
-
-
-%---------------------------------------------------------------------
-% 2. check decimation parameters 
-%---------------------------------------------------------------------
-if(length(time_dec)>1 || length(freq_dec)>1)
-    error('Frequency and time decimation parameters should be scalar');
-end
-[n_seq,L,time_dec]=check_dec_params_seq(time_dec,N,'time',1);
-[k_seq,J,freq_dec]=check_dec_params_seq(freq_dec,N,'frequency',1);
-Jh=ceil(J/2);  J_extend=2*Jh+2;
-
-if(DBmem), s=whos; fprintf('start: mem=%s\n',disp_bytes(sum([s.bytes]))); end
-
-tfd=zeros(L,J_extend); 
-m_real=1:Jh+1; m_imag=(J_extend-Jh):(J_extend);
-
-if(DBmem), s=whos; fprintf('declare TFD: mem=%s\n',disp_bytes(sum([s.bytes]))); end
-
-
-%---------------------------------------------------------------------
-% 3. generate time--lag signal function (for positive-lag values only)
-%---------------------------------------------------------------------
-n=0:N-1; mb=1:Jh-1;
-for m=0:Jh
-
-    %------------------------------------
-    % Fold in the lag direction
-    %------------------------------------
-    af_lag_slice=zeros(N,1);    
-    for p=0:freq_dec-1
-        mmod=(p*J+m);
-        g_lag_slice=gen_Doppler_lag_kern(kern_type,kern_params,N,mmod+1);
-        
-        if(mmod<=Nh)
-            inp=mod(n+mmod,N2); inn=mod(n-mmod,N2);
-            K_lag_slice=z(inp+1).*conj(z(inn+1));
-        else
-            inp=mod(n+N-mmod,N2); inn=mod(n-N+mmod,N2);
-            K_lag_slice=conj(z(inp+1)).*z(inn+1);            
-        end
-        
-        af_lag_slice=af_lag_slice + fft(K_lag_slice).*g_lag_slice;
-    end
-
-    %------------------------------------
-    % Fold in the Doppler direction
-    %------------------------------------
-    af_lag_fold=fold_vector_full(af_lag_slice,L,time_dec);
-    
-    %------------------------------------
-    % DFT the lag slice to the time--lag 
-    % domain.
-    %------------------------------------
-    R_lag_slice=ifft(af_lag_fold);
-    tfd(:,m_real(m+1))=real(R_lag_slice);
-    tfd(:,m_imag(m+1))=imag(R_lag_slice);    
-end
-
-
-if(DBmem), s=whos; fprintf('R: mem=%s\n',disp_bytes(sum([s.bytes]))); end
-
-%-------------------------------------------------------------------------
-% 4.  Expand R for positive and negative lag values and DFT back to 
-%     time--frequency domain
-%-------------------------------------------------------------------------
-m=0:Jh; mb=1:(Jh-1);
-for n=0:2:(L-2)
-    R_even_half=complex(tfd(n+1,m_real),tfd(n+1,m_imag));
-    R_odd_half =complex(tfd(n+2,m_real),tfd(n+2,m_imag));
-    
-    R_tslice_even=zeros(J,1);  R_tslice_odd=zeros(J,1);
-    R_tslice_even(m+1)=R_even_half(m+1);
-    R_tslice_odd(m+1) =R_odd_half(m+1);
-    R_tslice_even(J-mb+1)=conj( R_even_half(mb+1) );
-    R_tslice_odd(J-mb+1) =conj( R_odd_half(mb+1) );
-    
-    tfd_time_slice=fft( R_tslice_even+j.*R_tslice_odd );
-
-    tfd(n+1,1:J)=real(tfd_time_slice);
-    tfd(n+2,1:J)=imag(tfd_time_slice);
-end
-
-
-% one extra FFT if L is odd:
-if(rem(L,2))
-    R_even_half=complex(tfd(L,m_real),tfd(L,m_imag));
-    
-    R_tslice_even=zeros(J,1);  
-    R_tslice_even(m+1)=R_even_half(m+1);
-    R_tslice_even(J-mb+1)=conj( R_even_half(mb+1) );
-    
-    tfd_time_slice=fft( R_tslice_even+j.*R_tslice_odd );
-
-    tfd(L,1:J)=real(tfd_time_slice);
-end
-
-tfd=tfd(:,1:J);
-
-if(DBmem), s=whos; fprintf('end: mem=%s\n',disp_bytes(sum([s.bytes]))); end
-
-scale_factor=1/N;
-tfd=tfd.*scale_factor;
-
-if(DBtime), dispVars( toc(time_start) ); end
-
-
-%---------------------------------------------------------------------
-% END; testing and plotting
-%---------------------------------------------------------------------
-if(DBtest)
-    if(DBtime),  time_start=tic; end
-    tfd_test=full_gdtfd_testing_version(x,kern_type,kern_params);
-    if(DBtime),  dispVars( toc(time_start) ); end
-
-    dispEE(tfd_test(n_seq+1,k_seq+1),tfd);
-end
-if(DBverbose)
-    fprintf('size=%dx%d; max=%g; total energ:%d\n', size(tfd,1), size(tfd,2), max(tfd(:)), ...
-            sum(tfd(:)));
-end
-if(DBplot)
-    figure(1); clf; 
-    vtfd(tfd,real(x(1:N)));
-    
-    figure(9); clf; hold all;
-    subplot(211); hold all; plot(sum(tfd')'); plot( abs(z(1:N)).^2 );
-    subplot(212); hold all; plot(sum(tfd')' - abs(z(n_seq+1)).^2 );    
-    
-    figure(10); clf; hold all;
-    Z=fft(z);
-    subplot(211); hold all; plot(sum(tfd)); plot( abs(Z(1:N)).^2./(2*N) );
-    subplot(212); hold all; plot(sum(tfd)' - abs(Z(k_seq+1)).^2./(2*N) );    
-end
-
-
-
-function G1=get_prod_kernel(tfd_type,tfd_params,N)
-%---------------------------------------------------------------------
-% Generate window for product-kernel
-%---------------------------------------------------------------------
-
-if( strcmp(tfd_type,'RID')==1 || strcmp(tfd_type,'prod')==1 || ...
-    strcmp(tfd_type,'product')==1 )
-    
-% $$$     % oversample the window:
-% $$$     L_dopp=N*N2;
-    
-    G1=gen_Doppler_kern(tfd_params,N);
-    G1=real(G1);
-else
-    G1=[];
-end