paradigma 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

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

@@ -0,0 +1,241 @@
+%-------------------------------------------------------------------------------
+% 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

@@ -0,0 +1,157 @@
+%-------------------------------------------------------------------------------
+% 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

@@ -0,0 +1,190 @@
+%-------------------------------------------------------------------------------
+% 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
+
+
+
+