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

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

@@ -0,0 +1,196 @@
+%-------------------------------------------------------------------------------
+% nonsep_gdtfd: Time-frequency distribution (quadratic class) with non-separable kernel
+%
+% Syntax: [tfd,g]=nonsep_gdtfd(x,kern_type,kern_params)
+%
+% 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}
+%
+% Outputs: 
+%     tfd = N x N time-frequency distribution
+%
+% See also: DEC_NONSEP_GDTFD, GET_ANALYTIC_SIGNAL, GEN_DOPPLER_LAG_KERN, FFT
+%
+% Example:
+%      N=128; 
+%      x=gen_LFM(N,0.1,0.3)+gen_LFM(N,0.4,0.1);
+%
+%      c=nonsep_gdtfd(x,'cw',{100}); 
+%      vtfd(c,x);
+
+
+% John M. O' Toole, University College Cork
+% Started: 14-04-2014
+%
+% last update: Time-stamp: <2016-08-25 17:39:48 (otoolej)>
+%-------------------------------------------------------------------------------
+function tfd=nonsep_gdtfd(x,kern_type,kern_params)
+if(nargin<2 || isempty(kern_type)), kern_type='cw'; end
+if(nargin<3 || isempty(kern_params)), kern_params=10; 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)
+%---------------------------------------------------------------------
+if(DBmem), s=whos; fprintf('start: mem=%s\n',disp_bytes(sum([s.bytes]))); end
+tfd=zeros(N,N); 
+m_real=1:Nh; m_imag=(Nh+1):N;
+
+m=0:(Nh-1);
+for n=0:N-1
+    inp=mod(n+m,N2);  inn=mod(n-m,N2); 
+    K_time_slice=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)
+    for n=0:N-1
+        inp=mod(n+m,N2);  inn=mod(n-m,N2); 
+        K(n+1,m+1)=z(inp+1).*conj( z(inn+1) );
+    end
+    Ktest=complex(tfd(:,m_real),tfd(:,m_imag));
+    dispEE(Ktest,K);
+end
+
+
+if(DBmem), s=whos; fprintf('K: mem=%s\n',disp_bytes(sum([s.bytes]))); end
+
+% $$$ if(strcmp(kern_type,'wvd'))
+% $$$     for n=0:2:N-2
+% $$$     
+% $$$         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
+% $$$     
+% $$$     
+% $$$     dispVars('here');
+% $$$     return;
+% $$$ end
+
+
+%-------------------------------------------------------------------------
+% 3. multiply kernel and signal function in the Doppler-lag domain
+%-------------------------------------------------------------------------
+for m=0:Nh-1
+    g_lag_slice=gen_Doppler_lag_kern(kern_type,kern_params,N,m+1);
+    
+    R_lag_slice=ifft( fft( complex(tfd(:,m_real(m+1)),tfd(:,m_imag(m+1))) ).*g_lag_slice );
+
+    
+    tfd(:,m_real(m+1))=real( R_lag_slice );
+    tfd(:,m_imag(m+1))=imag( R_lag_slice );    
+end
+
+if(DBcompare)
+    g=gen_Doppler_lag_kern(kern_type,kern_params,N);
+    R=ifft( fft(K).*g(:,1:Nh) );
+    Rtest=complex(tfd(:,m_real),tfd(:,m_imag));
+    dispEE(Rtest,R);
+    clear g;
+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:(Nh-1); mb=1:(Nh-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,N);  R_tslice_odd=zeros(1,N);
+    R_tslice_even(m+1)=R_even_half(m+1);
+    R_tslice_odd(m+1) =R_odd_half(m+1);
+    R_tslice_even(N-mb+1)=conj( R_even_half(mb+1) );
+    R_tslice_odd(N-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);
+    Rfull(:,m+1)=R; 
+    Rfull(:,N-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
+tfd=tfd./N;
+
+
+if(DBtime), dispVars( toc(time_start) ); end
+
+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,tfd);
+end
+if(DBplot)
+    figure(1); clf; 
+    vtfd(tfd,real(x(1:N)));
+end
+
+tfd = tfd';
+
+
+
+
+

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

@@ -0,0 +1,199 @@
+%-------------------------------------------------------------------------------
+% sep_gdtfd: Time--frequency distribution (quadratic class) with separable kernel of
+% the form g[l,m]=G₁[l]g₂[m]
+%
+% Syntax: tfd=sep_gdtfd(x,dopp_win_params,lag_win_params,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 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 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
+%      Ntime = time oversampling value; must be greater than length of Doppler window
+%
+% Outputs: 
+%      tfd = Ntime x Nfreq time-frequency distribution
+%
+% See also: DEC_SEP_GDTFD, GET_ANALYTIC_SIGNAL, GEN_LAG_KERN, GEN_DOPPLER_KERN, FFT
+%
+% Example:
+%      N=10000; Ntime=256; Nfreq=256;
+%      x=gen_LFM(N,0.1,0.3)+gen_LFM(N,0.4,0.1);
+%
+%      c=sep_gdtfd(x,{51,'hann'},{171,'hann'},Ntime,Nfreq); 
+%      vtfd(c,x);
+
+
+% John M. O' Toole, University College Cork
+% Started: 16-04-2014
+%
+% last update: Time-stamp: <2019-02-19 15:12:35 (otoolej)>
+%-------------------------------------------------------------------------------
+function tfd=sep_gdtfd(x,dopp_win_params,lag_win_params,Ntime,Nfreq)
+if(nargin<4 || isempty(Ntime)), Ntime=[]; end
+if(nargin<5 || 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. compute lag and Doppler windows
+%---------------------------------------------------------------------
+[g2,P,Ph_floor,Nfreq]=gen_lag_kern(lag_win_params,N,Nfreq);
+Nh_freq=ceil(Nfreq/2);
+Ph=ceil(P/2);
+[G1,Q,Ntime,G1_pad]=gen_Doppler_kern(dopp_win_params,N,Ntime);
+Nh_time=ceil(Ntime/2);
+Qh=ceil(Q/2);
+
+
+%---------------------------------------------------------------------
+% 3. convolve signal function with kernel (multiplication in the 
+%    Doppler--lag domain). Do this in stages to minimise memory
+%---------------------------------------------------------------------
+if(DBmem), s=whos; fprintf('start: mem=%s\n',disp_bytes(sum([s.bytes]))); end
+tfd=zeros(Ntime,Nfreq); 
+
+if(DBmem), s=whos; fprintf('tfd declare: mem=%s\n',disp_bytes(sum([s.bytes]))); end
+
+n=0:N-1; l=0:(Qh-1); lb=1:(Qh-1);
+for m=0:(Ph-1);
+    inp=mod(n+m,N2);  inn=mod(n-m,N2); 
+    K_lag_slice=g2(m+1).*z(inp+1).*conj( z(inn+1) );
+    
+    K_lag_slice=fft(K_lag_slice);
+    
+    R_lag_slice=zeros(Ntime,1);
+    R_lag_slice(l+1)=K_lag_slice(l+1).*G1(l+1);
+    R_lag_slice(Ntime-lb+1)=K_lag_slice(N-lb+1).*G1(Q-lb+1);
+    
+    R_lag_slice=ifft(R_lag_slice);
+    
+    tfd(:,m+1)=real( R_lag_slice );
+    tfd(:,m+Nh_freq+1)=imag( R_lag_slice );    
+end
+
+if(DBmem), s=whos; fprintf('R: mem=%s\n',disp_bytes(sum([s.bytes]))); end
+
+
+
+if(DBcompare)
+    K=zeros(N,Nh_freq);
+    m=0:(Ph-1);
+    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
+    af=fft(K);
+
+    R=zeros(Ntime,Nh_freq);
+    for m=0:Ph-1
+        R(l+1,m+1)=af(l+1,m+1).*G1(l+1);
+        R(Ntime-lb+1,m+1)=af(N-lb+1,m+1).*G1(Q-lb+1);
+        
+        R(:,m+1)=ifft(R(:,m+1));
+    end
+    Rtest=complex(tfd(:,1:Nh_freq),tfd(:,(Nh_freq+1):end));
+    dispEE(R,Rtest);
+    clear Rtest K af;
+end
+
+
+%-------------------------------------------------------------------------
+% 4.  Expand R for positive and negative lag values and DFT back to 
+%     time--frequency domain
+%-------------------------------------------------------------------------
+m=0:(Ph-1); mb=1:(Ph-1);
+k_real=1:Nh_freq; k_imag=(Nh_freq+1):Nfreq;
+
+for n=0:2:Ntime-2
+    R_even_half=complex(tfd(n+1,k_real),tfd(n+1,k_imag));
+    R_odd_half =complex(tfd(n+2,k_real),tfd(n+2,k_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 (end): mem=%s\n',disp_bytes(sum([s.bytes]))); end
+
+
+if(DBcompare)
+    Rfull=zeros(Ntime,Nfreq);
+    Rfull(:,m+1)=R(:,m+1); 
+    Rfull(:,Nfreq-mb+1)=conj( Rfull(:,mb+1) );
+
+    tfd_test=fft( Rfull.' ).';
+    dispEE(tfd_test,tfd);
+    clear R test_test;
+end
+
+scale_factor=1/Nfreq;
+tfd=tfd.*scale_factor;
+
+
+%---------------------------------------------------------------------
+% END; testing and plotting
+%---------------------------------------------------------------------
+if(DBtime),  dispVars( toc(time_start) ); end
+
+if(DBtest) % && Ntime==N && Nfreq==N)
+    if(DBtime)
+        dispVars( toc(time_start) );
+        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
+    
+% $$$     dispVars( sum(tfd_test(:)), sum(tfd(:)) );
+    if(Ntime==N && Nfreq==N)
+        dispEE(tfd_test,tfd);
+    else
+        a=N/Ntime; b=N/Nfreq; 
+        if( a==floor(a) && b==floor(b) )
+            dispEE(tfd_test(1:a:end,1:b:end),tfd./(a*b));
+        end
+    end
+end
+if(DBplot)
+    figure(1); clf; 
+    vtfd(tfd,real(x(1:N)));
+end
+
+

paradigma/ppg/hr_functions/TFD toolbox JOT/full_tfd.m

@@ -0,0 +1,144 @@
+%-------------------------------------------------------------------------------
+% full_tfd: 
+%
+% Syntax: tf=full_tfd(x,kern_type,kern_params,Ntime,Nfreq)
+%
+% Inputs: 
+%      x = input signal (either real-valued signal of length-N or
+%          complex-valued analytic signal of length-2N)
+%
+%      kern_type   = kernel type, either nonseparable, separable, Doppler-independent
+%                    (DI) or lag-independent (LI):   { 'nonsep' | 'sep' | 'DI' | 'LI' }
+%
+%      kern_params = kernel parameters; different depending on kernel type
+%
+%                    if nonseparable kernel, then form: { kern_name, kern_param}
+%                      e.g. tf=full_tfd( x, 'nonsep', { 'cw', 100 } );
+%
+%                    if Doppler-independent kernel, then of the form: 
+%                      { window_length, window_type, [window_parameter (optional)] }
+%                      e.g. tf=full_tfd( x, 'DI', {101,'hann'} );
+%
+%                    if lag-independent kernel, then of the form: 
+%                      { window_length, window_type, [window_parameter (optional)] }
+%                      e.g. tf=full_tfd( x, 'LI', {101,'cosh',0.01} );
+%
+%                    if separable kernel, then of the form: { doppler_window, lag_window }
+%                    where doppler_window is of the form: { window_length, window_type,
+%                    [window_parameter (optional)] }; same format for lag window
+%                      e.g. tf=full_tfd( x, 'sep', { {101, 'cosh', 0.05}, {101,'hann'} } );
+%
+%     Ntime       = over-sampling in the time direction; only applicable for separable
+%                   and lag-independent kernels
+%
+%     Nfreq       = over-sampling in the frequency direction; only applicable for separable
+%                   and Doppler-independent kernels
+%
+% Outputs: 
+%     tf          =  time-frequency distribution of size N x N (nonseparable kernel), 
+%                    or Ntime x N (lag-independent kernel), 
+%                    or N x Nfreq (Doppler-independent kernel), 
+%                    or Ntime x Nfreq (separable kernel)
+%
+% See also: NONSEP_GDTFD, SEP_GDTFD, LI_GDTFD, DI_GDTFD
+%
+% Examples:
+%    N=512;
+%    x=gen_LFM(N,0.1,0.3) + gen_LFM(N,0.4,0.04);
+%    
+%    %  nonseparable kernel (Choi-Williams kernel):
+%    tf=full_tfd(x,'nonsep',{'cw',10});
+%    figure(1); clf; vtfd(tf,x);
+%    
+%    %  separable kernel:
+%    tf=full_tfd(x,'sep',{{51,'hann'},{101,'hann'}},256,256);
+%    figure(2); clf; vtfd(tf,x);
+%    
+%    %  Doppler-independent kernel:
+%    tf=full_tfd(x,'DI',{101,'hann'},256,[]);
+%    figure(3); clf; vtfd(tf,x);
+%    
+%    %  lag-independent kernel:
+%    tf=full_tfd(x,'LI',{51,'hann'},[],256);
+%    figure(4); clf; vtfd(tf,x);
+
+
+
+% John M. O' Toole, University College Cork
+% Started: 11-06-2014
+%
+% last update: Time-stamp: <2017-05-30 10:00:46 (otoolej)>
+%-------------------------------------------------------------------------------
+function tf=full_tfd(x,kern_type,kern_params,Ntime,Nfreq)
+if(nargin<2 || isempty(kern_type)), kern_type='sep'; end
+if(nargin<3 || isempty(kern_params)), kern_params={{51,'hann'},{101,'hann'}}; end
+if(nargin<4 || isempty(Ntime)), Ntime=[]; end
+if(nargin<5 || isempty(Nfreq)), Nfreq=[]; end
+
+
+% set to 1 if want to see how much memory is used:
+DBmem=1;
+
+
+kern_type=lower(kern_type);
+switch kern_type
+  case { 'nonsep', 'ns', 'nonseparable', 'non-separable', 'non-sep' }
+    %---------------------------------------------------------------------
+    % 1. Non-separable kernel; Doppler-lag form: g[l,m]
+    %---------------------------------------------------------------------
+    nonsep_params=[];
+    if(~iscell(kern_params))
+        nonsep_name=kern_params;
+    else
+        nonsep_name=kern_params{1};
+        if(length(kern_params)>1)
+            nonsep_params=kern_params{2};
+        end
+    end
+            
+    tf=nonsep_gdtfd(x,nonsep_name,nonsep_params);
+
+    
+  case  { 'sep', 'separable' }
+    %---------------------------------------------------------------------
+    % 2. separable kernel; Doppler-lag form: G1[l]g2[m]
+    %---------------------------------------------------------------------
+    if(~iscell(kern_params) | (iscell(kern_params) & length(kern_params)<2) )
+        error(['separable kernel parameters should be of the form: ' ...
+               '{ {dopp_win_length,dopp_win_name}, {lag_win_length,lag_win_name} }']);
+    end
+    
+    tf=sep_gdtfd(x,kern_params{1},kern_params{2},Ntime,Nfreq);
+    
+    
+  case { 'di', 'doppler-independent', 'dopp.-indep', 'dopp-indep', 'pwvd', 'p-wvd' }
+    %---------------------------------------------------------------------
+    % 3. Doppler-independent kernel: Doppler-lag form: g2[m]
+    %---------------------------------------------------------------------
+    if(~iscell(kern_params))
+        error(['Doppler-independent kernel parameters should be of the form: ' ...
+               '{win_length,win_name}']);
+    end
+    
+    
+    tf=di_gdtfd(x,kern_params,Nfreq);
+
+    
+  case { 'li', 'lag-independent',  'lag-indep', 'swvd', 's-wvd' }
+    %---------------------------------------------------------------------
+    % 4. Lag-independent kernel: Doppler-lag form: G1[l]
+    %---------------------------------------------------------------------
+    if(~iscell(kern_params))
+        error(['lag-independent kernel parameters should be of the form: ' ...
+               '{win_length,win_name}']);
+    end
+
+    tf=li_gdtfd(x,kern_params,Ntime);
+    
+  otherwise
+    warning('kern_type should be either: nonsep, sep, DI, or LI');
+    tf=[];
+end
+
+
+if(DBmem), s=whos; fprintf('total memory used: mem=%s\n',disp_bytes(sum([s.bytes]))); end

paradigma/ppg/hr_functions/TFD toolbox JOT/load_curdir.m

@@ -0,0 +1,13 @@
+
+% what directory is this file in?
+cur_full_path=mfilename('fullpath');
+cur_fname=mfilename();
+i=findstr(cur_full_path,cur_fname);
+cur_dir=cur_full_path(1:(i-1));
+
+% add the paths:
+addpath( genpath(cur_dir) );
+
+
+clear cur_full_path cur_fname cur_dir;
+

paradigma/ppg/hr_functions/TFD toolbox JOT/utils/check_dec_params_seq.m

@@ -0,0 +1,79 @@
+%-------------------------------------------------------------------------------
+% check_dec_params_seq: Check and return arbitrary set from {k_1,k_2,...,k_J} samples
+% could be for n (time) sample points also.
+%
+% Syntax: k=check_dec_params_seq(dec_param,N,time_freq_str)
+%
+% Inputs: 
+%     dec_param,N,time_freq_str - 
+%
+% Outputs: 
+%     k - 
+%
+% Example:
+%     
+%
+
+% John M. O' Toole, University College Cork
+% Started: 23-04-2014
+%
+% last update: Time-stamp: <2014-04-23 15:36:55 (otoolej)>
+%-------------------------------------------------------------------------------
+function [k,Nfreq,dec_param]=check_dec_params_seq(dec_param,N,time_freq_str,check_param)
+if(nargin<3 || isempty(time_freq_str)), time_freq_str='Frequency'; end
+if(nargin<4 || isempty(check_param)), check_param=1; end
+
+
+
+%---------------------------------------------------------------------
+% 0. check if parameters are ok:
+%---------------------------------------------------------------------
+dec_param=unique(dec_param);
+
+if(~all(dec_param==fix(dec_param)))
+  error([time_freq_str ' decimation parameters must be integers.']);
+end    
+if(any(dec_param>=N) || any(dec_param<0))
+    error([time_freq_str ' decimation values need to within 0<=k<=N-1']);
+end    
+    
+
+%---------------------------------------------------------------------
+% 1. set parameters:
+%---------------------------------------------------------------------
+if(length(dec_param)==1)
+    % decimation parameter is not a sequence:
+    if(check_param)
+        dec_param=check_dec_value(dec_param,N,time_freq_str);    
+    end
+    k=0:dec_param:N-1;
+    
+elseif(length(dec_param)>1)  
+    k=dec_param;
+else
+    k=0:N-1;
+end
+
+
+if(any(k>=N) || any(k<0))
+    error([time_freq_str ' decimation values need to within 0<=k<=N-1']);
+end
+Nfreq=length(k);
+
+
+function dec_param=check_dec_value(dec_param,N,time_freq_str)
+%---------------------------------------------------------------------
+% check (or set) that  N/a is an integer
+%---------------------------------------------------------------------
+if(rem(N,dec_param)) 
+  warning(['N not divisable by ' time_freq_str ' decimation factor. Increasing....']);
+  while( rem(N,dec_param) )  
+    dec_param=dec_param+1;   
+  end
+  disp( ['... decimation factor now=' num2str(dec_param)]); 
+  if(dec_param>=N)
+      error([time_freq_str ' decimation factor is equal to N. N is prime? Pick smaller ' ...
+                          'decimation parameter']);
+      dec_param=1;
+  end
+end

paradigma/ppg/hr_functions/TFD toolbox JOT/utils/dispEE.m

@@ -0,0 +1,9 @@
+%% disp error between two matrices ..
+function dispEE( a, b );
+ 
+ee = a - b;
+diff_re = max( abs(real(ee(:))) );
+diff_im = max( abs(imag(ee(:))) );
+a_name=deblank(inputname(1));
+b_name=deblank(inputname(2));
+fprintf('<< %s - %s = %g + j%g >>\n',a_name,b_name,diff_re,diff_im);

paradigma/ppg/hr_functions/TFD toolbox JOT/utils/dispVars.m

@@ -0,0 +1,26 @@
+%-------------------------------------------------------------------------------
+% Display variables to standard output
+%
+% DATE: 07-09-2010
+%-------------------------------------------------------------------------------
+function dispVars( varargin )
+% $$$ for i=1:nargin
+% $$$     keyboard;
+% $$$     varargin{i}
+% $$$ end
+
+str = '';
+for i=1:nargin
+  if( iscell(varargin{i}) )
+    for j=1:length(varargin{i})
+        str = [ str ' |' char(inputname(i)) '(' num2str(j) ') =' ...
+                num2str(varargin{i}{j}) ];
+    end
+  else
+    
+    str = strcat(str,' |',char(inputname(i)),'=',num2str(varargin{i}));
+  end
+  
+end
+
+disp(str);

paradigma/ppg/hr_functions/TFD toolbox JOT/utils/disp_bytes.m

@@ -0,0 +1,25 @@
+function str = disp_bytes(NumBytes)
+% BYTES2STR Private function to take integer bytes and convert it to
+% scale-appropriate size.
+%
+
+% taken from 'StackOverflow' response, by 'MatlabSorter', 31/1/11
+
+scale = floor(log(NumBytes)/log(1024));
+switch scale
+    case 0
+        str = [sprintf('%.0f',NumBytes) ' b'];
+    case 1
+        str = [sprintf('%.2f',NumBytes/(1024)) ' kb'];
+    case 2
+        str = [sprintf('%.2f',NumBytes/(1024^2)) ' Mb'];
+    case 3
+        str = [sprintf('%.2f',NumBytes/(1024^3)) ' Gb'];
+    case 4
+        str = [sprintf('%.2f',NumBytes/(1024^4)) ' Tb'];
+    case -inf
+        % Size occasionally returned as zero (eg some Java objects).
+        str = 'Not Available';
+    otherwise
+       str = 'Over a petabyte!!!';
+end