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_sep_gdtfd.m

@@ -1,241 +0,0 @@
-%-------------------------------------------------------------------------------
-% dec_sep_gdtfd: Decimated TFD with separable kernel of the form g[l,m]=G1[l]g2[m]. For
-% efficient implement define windows G1[l] and g2[m] as band-limited functions.
-%
-% TFD is decimated with integer factors a,b as ρ[an,bk]
-%
-% Syntax: tfd=dec_sep_gdtfd(x,dopp_win_params,lag_win_params,time_dec,freq_dec,Ntime,Nfreq)
-%
-% 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}
-%
-%      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 1 (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
-%      Ntime = time oversampling value; must be greater than length of Doppler window
-%
-% Outputs: 
-%     tfd = (a/Ntime) x (b/Nfreq) time–frequency distribution
-%
-% See also: SEP_GDTFD, GET_ANALYTIC_SIGNAL, GEN_LAG_KERN, GEN_DOPPLER_KERN, FFT
-%
-% Example:
-%     N=1024; Ntime=64; Nfreq=128; a=1; b=2;
-%     x=gen_LFM(N,0.1,0.3)+gen_LFM(N,0.4,0.1);
-%
-%     c=dec_sep_gdtfd(x,{51,'hann'},{101,'hann'},a,b,Ntime,Nfreq);
-%     vtfd(c,x);
-
-% John M. O' Toole, University College Cork
-% Started: 24-04-2014
-%
-% last update: Time-stamp: <2014-07-23 15:25:51 (otoolej)>
-%-------------------------------------------------------------------------------
-function tfd=dec_sep_gdtfd(x,dopp_win_params,lag_win_params,time_dec,freq_dec,Ntime, ...
-                           Nfreq)
-if(nargin<2 || isempty(dopp_win_params)), dopp_win_params={51,'hann'}; end
-if(nargin<3 || isempty(lag_win_params)), lag_win_params={151,'hann'}; end
-if(nargin<4 || isempty(time_dec)), time_dec=1; end
-if(nargin<5 || isempty(freq_dec)), freq_dec=1; end
-if(nargin<6 || isempty(Ntime)), Ntime=[]; end
-if(nargin<7 || 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 kernel windows and check decimation parameters
-%---------------------------------------------------------------------
-[G1,Q,Ntime]=gen_Doppler_kern(dopp_win_params,N,Ntime);
-Qh=ceil(Q/2);
-
-[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(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,Ntime,'time',1);
-[k_seq,J,freq_dec]=check_dec_params_seq(freq_dec,Nfreq,'frequency',1);
-Jh=ceil(J/2);  J_extend=2*Jh+2; P_extend=2*Ph+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(DBverbose), 
-    dispVars(N,Ntime,Nfreq,L,J,Jh,J_extend,P,Ph,Q,Qh,P_extend); 
-    dispVars(length(m_real),length(m_imag),m_real(end),m_imag(1));
-end
-
-if(DBmem), s=whos; fprintf('declare TFD: mem=%s\n',disp_bytes(sum([s.bytes]))); end
-
-
-%---------------------------------------------------------------------
-% 2. generate time--lag signal function (for positive-lag values only)
-%---------------------------------------------------------------------
-l=0:(Qh-1); lb=1:(Qh-1);
-n=0:N-1;
-for m=0:Jh
-
-    %-------------------------------------------------------------------------
-    % a) Form lag-slice of windowed time-lag function and then fold in
-    %    the lag direction.
-    %-------------------------------------------------------------------------
-    R_lag_slice=zeros(N,1);
-    for p=0:freq_dec-1
-        mmod=p.*J+m;
-        
-        if(mmod<=Ph)
-            inp=mod(n+mmod,N2);  inn=mod(n-mmod,N2);           
-            i1=mod(n+mmod,N2); i2=mod(n-mmod,N2);
-
-            R_lag_slice=R_lag_slice+z(inp+1).*conj(z(inn+1)).*g2(mmod+1);
-        elseif(mmod>Nfreq-Ph)
-            inp=mod(n+Nfreq-mmod,N2); inn=mod(n-Nfreq+mmod,N2);
-            
-            R_lag_slice=R_lag_slice+conj(z(inp+1)).*z(inn+1).*g2(P-Nfreq+mmod+1);
-        end
-    end
-    
-
-    %-------------------------------------------------------------------------
-    % b) DFT to the Doppler--lag domain..
-    %-------------------------------------------------------------------------
-    R_lag_slice=fft(R_lag_slice);
-
-    %-------------------------------------------------------------------------
-    % c) Multiply by Doppler window G1
-    %-------------------------------------------------------------------------
-    r_lag_slice=zeros(Ntime,1);
-    r_lag_slice(l+1)=R_lag_slice(l+1).*G1(l+1);
-    r_lag_slice(Ntime-lb+1)=R_lag_slice(N-lb+1).*G1(Q-lb+1);    
-    
-    %-------------------------------------------------------------------------
-    % d) Fold in the Doppler direction
-    %-------------------------------------------------------------------------
-    r_lag_fold=fold_vector_full(r_lag_slice,L,time_dec);
-  
-    %-------------------------------------------------------------------------
-    % e) DFT the lag slice to the time--lag domain
-    %-------------------------------------------------------------------------
-    r_lag_fold=ifft(r_lag_fold);
-
-    tfd(:,m_real(m+1))=real(r_lag_fold);
-    tfd(:,m_imag(m+1))=imag(r_lag_fold);    
-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/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,'sep',{dopp_win_params,lag_win_params});
-    if(DBtime),  dispVars( toc(time_start) ); end
-
-    a=N/Ntime; b=N/Nfreq; 
-    if( a==floor(a) && b==floor(b) )
-        dispEE(tfd_test( (a.*n_seq)+1,(b.*k_seq)+1),tfd./(a*b));
-    end
-    
-% $$$     figure(100); clf; hold all;
-% $$$     k=10; plot(tfd_test(n_seq+1,k_seq(k)+1)); plot(tfd(:,k+1));
-% $$$     keyboard;
-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

paradigma/ppg/hr_functions/TFD toolbox JOT/full_TFDs/di_gdtfd.m

@@ -1,157 +0,0 @@
-%-------------------------------------------------------------------------------
-% di_gdtfd: TFD with Doppler-independent (DI) kernel g[l,m]=g₂[m]
-%
-% Syntax: tfd=di_gdtfd(x,lag_win_params,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}
-%
-%      Nfreq = frequency oversampling value; must be greater than length of lag window
-%
-% Outputs: 
-%      tfd = N x Nfreq time-frequency distribution
-%
-% See also: DEC_DI_GDTFD, GET_ANALYTIC_SIGNAL, GEN_LAG_KERN, FFT
-%
-% Example:
-%      N=512; Ntime=256; Nfreq=256;
-%      x=gen_LFM(N,0.1,0.3)+gen_LFM(N,0.4,0.1);
-%
-%      c=di_gdtfd(x,{51,'hann'},Nfreq); 
-%      vtfd(c,x);
-
-% John M. O' Toole, University College Cork
-% Started: 16-04-2014
-%
-% last update: Time-stamp: <2014-07-23 16:31:30 (otoolej)>
-%-------------------------------------------------------------------------------
-function tfd=di_gdtfd(x,lag_win_params,Nfreq)
-if(nargin<2 || isempty(lag_win_params)), lag_win_params={101,'hamm'}; end
-if(nargin<3 || isempty(Nfreq)), Nfreq=[]; end
-
-
-DBplot=0;
-DBmem=0;
-DBcompare=0;
-DBtest=0;
-DBtime=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);
-
-if(DBmem), s=whos; fprintf('start: mem=%s\n',disp_bytes(sum([s.bytes]))); end
-tfd=zeros(N,Nfreq); 
-m_real=1:Ph; m_imag=(Nfreq-Ph+1):Nfreq;
-
-m=0:(Ph-1);
-for n=0:N-1
-    inp=mod(n+m,N2);  inn=mod(n-m,N2); 
-    K_time_slice=g2(m+1).*z(inp+1).*conj( z(inn+1) );
-    
-    tfd(n+1,m_real)=real( K_time_slice );
-    tfd(n+1,m_imag)=imag( K_time_slice );    
-end
-
-
-if(DBcompare)
-    K=zeros(N,Nh);
-    for n=0:N-1
-        inp=mod(n+m,N2);  inn=mod(n-m,N2); 
-        K(n+1,m+1)=g2(m+1).*z(inp+1).*conj( z(inn+1) );
-    end
-    Ktest=complex(tfd(:,m_real),tfd(:,m_imag));
-    dispEE(Ktest,K(:,m+1));
-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
-%-------------------------------------------------------------------------
-m=0:(Ph-1); mb=1:(Ph-1);
-for n=0:2:N-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,Nfreq);  R_tslice_odd=zeros(1,Nfreq);
-    R_tslice_even(m+1)=R_even_half(m+1);
-    R_tslice_odd(m+1) =R_odd_half(m+1);
-    R_tslice_even(Nfreq-mb+1)=conj( R_even_half(mb+1) );
-    R_tslice_odd(Nfreq-mb+1) =conj( R_odd_half(mb+1) );
-    
-    tfd_time_slice=fft( R_tslice_even+j.*R_tslice_odd );
-
-    tfd(n+1,:)=real(tfd_time_slice);
-    tfd(n+2,:)=imag(tfd_time_slice);
-end
-
-if(DBmem), s=whos; fprintf('tfd: mem=%s\n',disp_bytes(sum([s.bytes]))); end
-
-
-if(DBcompare)
-    Rfull=zeros(N,Nfreq);
-    Rfull(:,m+1)=K(:,m+1); 
-    Rfull(:,Nfreq-mb+1)=conj( Rfull(:,mb+1) );
-
-    tfd_test=fft( Rfull.' ).';
-    dispEE(tfd_test,tfd);
-end
-
-
-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,tfd);
-    else
-        b=N/Nfreq; 
-        if( b==floor(b) )
-            dispEE(tfd_test(:,1:b:end),tfd./b);
-        end
-    end
-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(1:N)).^2 );    
-end
-

paradigma/ppg/hr_functions/TFD toolbox JOT/full_TFDs/li_gdtfd.m

@@ -1,190 +0,0 @@
-%-------------------------------------------------------------------------------
-% li_gdtfd: TFD with lag-independent (LI) kernel g[l,m]=G₁[l] 
-%
-% Syntax: tfd=li_gdtfd(x,dopp_win_params,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 the time domain)
-%                 e.g. {121, 'hamm'}; {121, 'tukey', 0.2}; {127,'cosh',0.01,0}
-%
-%      Ntime = time oversampling value; must be greater than length of Doppler window
-%
-% Outputs: 
-%      tfd = Ntime x N time-frequency distribution
-%
-% See also: DEC_LI_GDTFD, GET_ANALYTIC_SIGNAL, GEN_DOPPLER_KERN, FFT
-%
-% Example:
-%      N=10000; Ntime=256; 
-%      x=gen_LFM(N,0.1,0.3)+gen_LFM(N,0.4,0.1);
-%
-%      c=li_gdtfd(x,{51,'hamm'},Ntime); 
-%      vtfd(c,x);
-%
-% Example:
-%     
-%
-
-% John M. O' Toole, University College Cork
-% Started: 16-04-2014
-%
-% last update: Time-stamp: <2014-07-23 15:28:16 (otoolej)>
-%-------------------------------------------------------------------------------
-function [tfd,G1]=li_gdtfd(x,dopp_win_params,Ntime)
-if(nargin<2 || isempty(dopp_win_params)), dopp_win_params={11,'hamm',0,1}; end
-if(nargin<3 || isempty(Ntime)), Ntime=[]; end
-
-
-DBplot=0;
-DBmem=0;
-DBcompare=0;
-DBtest=0;
-DBtime=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 Doppler--frequency signal function 
-%    (for positive-Doppler values only)
-%---------------------------------------------------------------------
-[G1,Q,Ntime]=gen_Doppler_kern(dopp_win_params,N,Ntime);
-Nh=ceil(Ntime/2);
-Qh=ceil(Q/2);
-
-Z=fft(z);
-if(DBmem), s=whos; fprintf('start: mem=%s\n',disp_bytes(sum([s.bytes]))); end
-tfd=zeros(Ntime,N); 
-l_real=1:Qh; l_imag=(Ntime-Qh+1):Ntime;
-
-
-l=0:(Qh-1);
-for k=0:N-1
-    inp=mod(k+l,N2);  inn=mod(k-l,N2); 
-    inpN=mod(k+l+N,N2);  innN=mod(k-l-N,N2);     
-    K_doppler_slice=G1(l+1).*( Z(inp+1).*conj( Z(inn+1) )  + ...
-                               Z(inpN+1).*conj( Z(innN+1) ) );
-    
-    tfd(l_real,k+1)=real( K_doppler_slice )./2;
-    tfd(l_imag,k+1)=imag( K_doppler_slice )./2;    
-end
-
-
-% $$$ Ktesting=zeros(N,ceil(N/2)+1); m=0:(ceil(N/2));
-% $$$ for n=0:N-1
-% $$$     inp=mod(n+m,N2);  inn=mod(n-m,N2); 
-% $$$     Ktesting(n+1,m+1)=z(inp+1).*conj( z(inn+1) );
-% $$$ end
-% $$$ Kfull=zeros(N); mb=1:(ceil(N/2)-1);
-% $$$ Kfull(:,m+1)=Ktesting(:,m+1); 
-% $$$ Kfull(:,N-mb+1)=conj( Ktesting(:,mb+1) );
-% $$$ 
-% $$$ Ktest=complex(tfd(l_real,:),tfd(l_imag,:));
-% $$$ kk=fft(fft(Kfull.').');
-% $$$ kk=kk(l+1,:).*2;
-% $$$ dispVars(size(kk),size(Ktest));
-% $$$ dispEE(Ktest,kk);
-% $$$ figure(10); clf; vtfd(abs(Ktest));
-% $$$ figure(11); clf; vtfd(abs(Ktest-kk));
-
-if(DBcompare)
-    K=zeros(Nh,N);
-    for k=0:N-1
-        inp=mod(k+l,N2);  inn=mod(k-l,N2); 
-        inpN=mod(k+l+N,N2);  innN=mod(k-l-N,N2);     
-        K(l+1,k+1)=G1(l+1).*( Z(inp+1).*conj( Z(inn+1) ) + ...
-                              Z(inpN+1).*conj( Z(innN+1) ) );
-    end
-    Ktest=complex(tfd(l_real,:),tfd(l_imag,:));
-    dispEE(Ktest,K(l+1,:));
-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
-%-------------------------------------------------------------------------
-l=0:(Qh-1); lb=1:(Qh-1);
-for k=0:2:N-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(Ntime,1);  R_tslice_odd=zeros(Ntime,1);
-    R_tslice_even(l+1)=R_even_half(l+1);
-    R_tslice_odd(l+1) =R_odd_half(l+1);
-    R_tslice_even(Ntime-lb+1)=conj( R_even_half(lb+1) );
-    R_tslice_odd(Ntime-lb+1) =conj( R_odd_half(lb+1) );
-    
-    tfd_time_slice=ifft( R_tslice_even+j.*R_tslice_odd );
-
-    tfd(:,k+1)=real(tfd_time_slice);
-    tfd(:,k+2)=imag(tfd_time_slice);
-end
-
-if(DBmem), s=whos; fprintf('tfd: mem=%s\n',disp_bytes(sum([s.bytes]))); end
-
-
-
-if(DBcompare)
-    Rfull=zeros(Ntime,N);
-    Rfull(l+1,:)=K(l+1,:); 
-    Rfull(Ntime-lb+1,:)=conj( Rfull(lb+1,:) );
-
-    tfd_test=ifft( Rfull );
-    dispEE(tfd_test,tfd);
-end
-
-
-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,'swvd',dopp_win_params);
-    if(DBtime), dispVars( toc(time_start) ); end
-    if(Ntime==N)
-        dispEE(tfd_test,tfd);
-    else
-        a=N/Ntime; 
-        if( a==floor(a) )
-            dispEE(tfd_test(1:a:end,:),tfd./a);
-        end
-    end
-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(1:N)).^2./(2*N) );    
-end
-
-
-
-