Exemplo n.º 1
0
 def _pvoc(self, X_hat, Phi_hat=None, R=None):
     """
     ::
       a phase vocoder - time-stretch
       inputs:
         X_hat - estimate of signal magnitude
         [Phi_hat] - estimate of signal phase
         [R] - resynthesis hop ratio
       output:
         updates self.X_hat with modified complex spectrum
     """
     N = self.nfft
     W = self.wfft
     H = self.nhop
     R = 1.0 if R is None else R
     dphi = (2 * P.pi * H * P.arange(N / 2 + 1)) / N
     print("Phase Vocoder Resynthesis...", N, W, H, R)
     A = P.angle(self.STFT) if Phi_hat is None else Phi_hat
     phs = A[:, 0]
     self.X_hat = []
     n_cols = X_hat.shape[1]
     t = 0
     while P.floor(t) < n_cols:
         tf = t - P.floor(t)
         idx = P.arange(2) + int(P.floor(t))
         idx[1] = n_cols - 1 if t >= n_cols - 1 else idx[1]
         Xh = X_hat[:, idx]
         Xh = (1 - tf) * Xh[:, 0] + tf * Xh[:, 1]
         self.X_hat.append(Xh * P.exp(1j * phs))
         U = A[:, idx[1]] - A[:, idx[0]] - dphi
         U = U - P.np.round(U / (2 * P.pi)) * 2 * P.pi
         phs += (U + dphi)
         t += P.randn() * P.sqrt(PVOC_VAR * R) + R  # 10% variance
     self.X_hat = P.np.array(self.X_hat).T
def ThreeD_Scatter(x, y, z, selected_checkboxes, panel, auto_rotate, axis_3d=True):

	ax = Axes3D(panel.fig)
	ax.grid(False)
	ax.set_xlabel(selected_checkboxes[0][1])
	ax.set_ylabel(selected_checkboxes[1][1])
	ax.set_zlabel(selected_checkboxes[2][1])
	ax.set_xlim(np.min(x), np.max(x))
	ax.set_ylim(np.min(y), np.max(y))
	ax.set_ylim(np.min(z), np.max(z))

	if not axis_3d:
		ax._axis3don = False
	
	ax.scatter3D(x, y, z,  s=15, c= plt.randn(len(x)))
#	ax.plot_surface(x, y, z,  s=1)
#	def onpick(event):
#		ind = event.ind[0]
#		x, y, z = event.artist._offsets3d
#		print x[ind], y[ind], z[ind]
#	panel.fig.canvas.mpl_connect('pick_event', onpick)	


	
	if auto_rotate:
		for i in xrange(0,360,5):
			ax._axis3don = axis_3d
			ax.view_init(elev=10. +i, azim=i)
			panel.canvas.draw()
		return 
	panel.canvas.draw()
	return
def TwoD_Scatter(x, y, selected_checkboxes, panel, s=None, c=None):
    """
	This method is used to plot a two dimensional graphs on the basis of the selected checkboxes from the pyscrolledwindow
	s is the size of the points being drawn
	c is the color of the points being drawn
	"""
    if c is None:
        c = "b"
    if s is None:
        s = 10

    plt.xlabel(selected_checkboxes[0][1])
    plt.ylabel(selected_checkboxes[1][1])
    try:

        panel.canvas.figure.clf()
        plt.xlim(np.min(x), np.max(x))
        plt.ylim(np.min(y), np.max(y))
        plt.grid(True)
        scatter = plt.scatter(x,
                              y,
                              marker="o",
                              s=s,
                              c=plt.randn(len(x)),
                              picker=True)
        plt.subplots_adjust(left=0.05, right=0.94, top=0.95, bottom=0.09)
    except:
        try:
            panel.canvas.figure.clf()
            ax = panel.canvas.figure.add_subplot(111)
            y_ticks = list(set(y))
            ax.set_yticks(range(len(y_ticks)))
            ax.set_yticklabels(y_ticks)
            for direction in ["left", "right", "top", "bottom"]:
                ax.spines[direction].set_color("none")
            y_data = [y_ticks.index(element) for element in y]
            plt.scatter(x, y_data)
        except:
            panel.canvas.figure.clf()
            ax = panel.canvas.figure.add_subplot(111)
            y_ticks = list(set(y))
            ax.set_yticks(range(len(y_ticks)))
            ax.set_yticklabels(y_ticks)
            for direction in ["left", "right", "top", "bottom"]:
                ax.spines[direction].set_color("none")
            y_data = [y_ticks.index(element) for element in y]
            x_ticks = list(set(x))
            ax.set_xticks(range(len(x_ticks)))
            ax.set_xticklabels(x_ticks)
            x_data = [x_ticks.index(element) for element in x]
            plt.scatter(x_data, y_data)

    panel.canvas.draw()
    return
def TwoD_Scatter(x, y, selected_checkboxes,  panel, s=None, c=None):
	"""
	This method is used to plot a two dimensional graphs on the basis of the selected checkboxes from the pyscrolledwindow
	s is the size of the points being drawn
	c is the color of the points being drawn
	"""
	if c is None:
		c = "b"
	if s is None:
		s= 10
	
	plt.xlabel(selected_checkboxes[0][1])
	plt.ylabel(selected_checkboxes[1][1])
	try:

		panel.canvas.figure.clf()
		plt.xlim(np.min(x), np.max(x))
		plt.ylim(np.min(y), np.max(y))
		plt.grid(True)
		scatter = plt.scatter(x, y,marker="o", s=s, c=plt.randn(len(x)), picker= True)
		plt.subplots_adjust(left=0.05, right=0.94, top=0.95, bottom=0.09)
	except:
		try:
			panel.canvas.figure.clf()
			ax = panel.canvas.figure.add_subplot(111)  
			y_ticks = list(set(y))
			ax.set_yticks(range(len(y_ticks)))
			ax.set_yticklabels(y_ticks)
			for direction in ["left", "right", "top", "bottom"]:
				ax.spines[direction].set_color("none")
			y_data= [y_ticks.index(element) for element in y]
			plt.scatter(x, y_data)
		except:
			panel.canvas.figure.clf()
			ax = panel.canvas.figure.add_subplot(111)  
			y_ticks = list(set(y))
			ax.set_yticks(range(len(y_ticks)))
			ax.set_yticklabels(y_ticks)
			for direction in ["left", "right", "top", "bottom"]:
				ax.spines[direction].set_color("none")
			y_data= [y_ticks.index(element) for element in y]
			x_ticks = list(set(x))
			ax.set_xticks(range(len(x_ticks)))
			ax.set_xticklabels(x_ticks)
			x_data= [x_ticks.index(element) for element in x]
			plt.scatter(x_data, y_data)
		
	panel.canvas.draw()
	return
#% 16 = rand3 17 = rand9 18 = rand10 19 = 0.8 20 = sineroot27
#% 21 = sineroot19 22 = sineroot50 23 = sineroot75
#% 24 = sineroot10 25 = sineroot110 26 = sineroot75tenth
#% 27 = sineroots20plus40  28 = sineroot75third
#% 29 = sineroot243  30 = sineroot150  31 = sineroot200
#% 32 = sine10pt587352723 33 = sine10pt10.387352723
#% 34 = rand7  35 = sine12  36 = rand5  37 = sine11
#% 38 = sine10pt17352723  39 = sine5 40 = sine6
#% 41 = sine7 42 = sine8  43 = sine9 44 = sine12
#% 45 = sine13  46 = sine14  47 = sine10.8342522
#% 48 = sine11.8522311  49 = sine12.5223223  50 = sine13.1900453
#% 51 = sine7.1900453  52 = sine7.9004531  53 = sine8.4900453
#% 54 = sine9.1900453 55 = sine5.19004  56 = sine5.8045
#% 57 = sine6.49004 58 = sine6.9004 59 = sine13.9004
#%%% Initializations
plt.randn('state', randstate)
np.random.rand('twister', randstate)
I = np.eye(Netsize)
Np = length(patts)
#% Create raw weights
if newNets:
    if Netsize<=20.:
        Netconnectivity = 1.
    else:
        Netconnectivity = 10./Netsize
        
    
    WRaw = generate_internal_weights(Netsize, Netconnectivity)
    WinRaw = plt.randn(Netsize, 1.)
    WbiasRaw = plt.randn(Netsize, 1.)
Exemplo n.º 6
0
import matplotlib.pyplot as plt
import matplotlib.pylab as pl
plt.plot([1,2,3,4])
plt.ylabel('some numbers')
plt.savefig('pyplot01.png', format='png')

plt.hist(pl.randn(100000), 50)
plt.savefig('pyplot_randn_hist.png', format='png')


Exemplo n.º 7
0
def make_lor9d(tau_sec, numtrials, siglen_pre, kerlen_ratio, fs_Hz_pre, downsample):

    # Local Variables: siglen_pre, xlim, kerlen_ratio, psd_from_fft, psd_fft, sc_d_0, sc_rep, downsample, s2, tt, sc_d, var, kerlen, tau_sec, df, i0, c, psd, varinfo, numtrials, name, fs_Hz_post, siglen_post, VERBOSE, f, i, signal, freqs, kern, fs_Hz_pre, s, sc, x
    # Function calls: autocorrel, figure, warning, fprintf, make_lor9d, diff, find, size, plot, randn, conv, floor, reshape, sum, nargout, zeros, length, pi, sort, fftpsd, atan, squeeze, mod, decimate, exp, clf, mean
    #%9d: downsamples as well
    #%
    #%tau_sec in seconds. (can be big)
    #%siglen in samples.
    #%kerlen_ratio is about 2,3,4,...
    #%
    #%returns:
    #%    signal: trials x siglen
    #%    psd and varinfo are generated only if demanded.
    #%    only if varinfo is mentioned, the 8 variances are printed.
    #%main method imported from simulate_lorentzian8.m
    #%known problems:
    #%   1-bad at low fs_Hz (?)
    #%   2- bad at low tau_sec
    #%   But ok for natural ranges (e.g., A1 cortex data)
    VERBOSE = True
    #%for debuging
    if VERBOSE:
        print 'tau=%g(ms), trials=%d, len=%d (before downsampling), ker x=%g'%(tau_sec*1000., numtrials, siglen_pre, kerlen_ratio)
    
    
    if tau_sec > siglen_pre / fs_Hz_pre:
        matcompat.warning('tau_sec > T')
        #% although the result will be correct
    
    
    #%making the kernel
    kerlen = np.dot(kerlen_ratio, tau_sec)
    tt = np.arange(0., (kerlen)+(1./fs_Hz_pre), 1./fs_Hz_pre)
    kern = np.exp((-tt / tau_sec))
    if VERBOSE:
        #%this should be close to 1.0 :
        print('%g ?= 1.0\n'%( ((np.sum(kern) / tau_sec) / fs_Hz_pre)))
    
    #%pre = before downsampling
    #%post = after downsampling
    siglen_post = (siglen_pre / downsample)
    #%making the signal.
    signal = np.zeros([numtrials, siglen_post])
    for i in np.arange(1., (numtrials)+1):
        #%notes in simulate_lorentzian6.m



        #%notes in simulate_lorentzian6.m
        #s = plt.randn(1., (siglen_pre+len(kern)*2.+4.))
        s = plt.randn( (siglen_pre+len(kern)*2.+4.))
        #print s.shape
        #%+2!!
        xlim = len(kern)+np.array(np.hstack((1., siglen_pre)))-1.+1.+2.
        #%throwing away a few extra samples (for very long correlation lengths)
        #s2 = np.dot(plt.conv(s, matdiv(kern, fs_Hz_pre)), fs_Hz_pre)
        #print s.shape
        #print (kern / fs_Hz_pre).shape
        s2 = np.convolve(s, kern / fs_Hz_pre)* fs_Hz_pre
        #%integration
        sc = s2[int(xlim[0])-1:xlim[1]]
        #%cut the useful portion
        #%signal(i,:) = sc; %s2
        #%downsampling
        #%assert(mod(siglen_pre,downsample)==0);
        #%if 1
        #%sc_rep=reshape(sc,[1,siglen_pre/downsample,downsample]); %1 trial
        #sc_rep = np.reshape(sc, np.array(np.hstack((1., downsample, matdiv(siglen_pre, downsample)))))
        sc_rep = np.reshape(sc, [1, downsample, siglen_pre/ downsample])
        #%1 trial
        #%assert(floor(siglen_pre/downsample)==siglen_post)
        #%sc_d_0=mean(sc_rep,3);
        sc_d_0 = np.mean(sc_rep, axis=2-1)
        #%siglen_b=siglen/downsample;
        #%end

        #print signal.shape
        #print i,

        #sc_d = matcompat.decimate(sc, downsample)
        sc_d = sc[0::downsample]
        #signal[int(i)-1,:] = sc_d
        #print sc_d.shape

        signal[int(i)-1][:] = sc_d
        

        #%s2
        #%A=0
        #%if A
        if False:
            plt.figure(1.)
            plt.clf
            plt.plot((np.arange(1., (siglen_post)+1)-1.), np.squeeze(sc_d_0))
            plt.hold(on)
            plt.plot((np.arange(1., (siglen_post)+1)-1.), sc_d, 'r')
            #%plot((1:length(sc))/4/5+1,squeeze(sc),'k')
            plt.plot(matdiv(np.arange(1., (siglen_pre)+1)-1., downsample), np.squeeze(sc), 'k')
            #%end
        #%end

        
    #fs_Hz_post = matdiv(fs_Hz_pre, downsample)
    fs_Hz_post = fs_Hz_pre / downsample
    #%making & testing the fft
    #%FFT is done on DOWNSAMPLED signals (after downsampling)
    #% Only if fft psd is demanded. If not, only the signal is generated

    nargout = 1000 #extra_output +1

    if nargout > 1.:
        [psd_from_fft, freqs] = fftpsd(signal, fs_Hz_post)
        #psd_fft = np.array([])
        psd_fft_psd = psd_from_fft
        psd_fft_f = freqs
        psd_fft = (psd_fft_psd,psd_fft_f)
        if nargout > 2:
            varinfo = [{},{},{},{},{},{},{}] #np.array([])
            #%there are eight (!!) variance measures that can be used for normalization!!
            #%please note that the variance rate (i.e., var(:)/fs_Hz_post) is multiplied by fs_Hz_post.
            #% to get the approximation for var(signal(:))
            df = np.mean(np.diff(np.sort(freqs)))
            #%=1.0!
            varinfo[0]['_name'] = 'fft'
            varinfo[0]['_var'] = ((np.dot(np.sum(psd_from_fft), df) / fs_Hz_post)* fs_Hz_post)
            varinfo[1]['_name'] = 'vertical variance'
            #%var_v; % var_1;%varinfo(2)['_name']='mean(var(dim1))';
            #varinfo(2).var = mean(var(signal,[0],1))/fs_Hz_post * fs_Hz_post;
            varinfo[1]['_var'] = np.mean(np.var(signal,axis=0).flatten()) / fs_Hz_post* fs_Hz_post
            varinfo[2]['_name'] = 'var(:)'
            #%var_2;
            #varinfo(3).var = var(signal(:))/fs_Hz_post * fs_Hz_post;
            varinfo[2]['_var'] =  np.var(signal.flatten()) / fs_Hz_post * fs_Hz_post

            varinfo[3]['_name'] = 'horizontal variance'
            #%var_h;
            #varinfo(4).var = mean(var(signal,[0],2))/fs_Hz_post * fs_Hz_post;
            varinfo[3]['_var'] = np.mean(np.var(signal,axis=2-1).flatten()) / fs_Hz_post * fs_Hz_post

            #%can be very low if tau_sec is very big compared to siglen/fs_Hz
            varinfo[4]['_name'] = 'analytical varinace (nyquist)'
            #%var_a;
            #varinfo(5).var = 2*tau_sec*atan(2*pi*fs_Hz_post*tau_sec)/(2*pi) * fs_Hz_post;
            varinfo[4]['_var'] = 2.*tau_sec * np.arctan(2.*np.pi * fs_Hz_post * tau_sec) /  (2.*np.pi) * fs_Hz_post
            varinfo[5]['_name'] = 'ideal variance'
            #%var_a_inf;
            varinfo[5]['_var'] = tau_sec/2. * fs_Hz_post
            varinfo[6]['_name'] = 'kernel norm'
            varinfo[6]['_var'] = np.sum(kern) / tau_sec / fs_Hz_post
            #%this is not a 'variance'. This should be 1.0.
            #%slow
            if False:
                #autocorrel not converted into python
                [x, c] = autocorrel(signal, fs_Hz_post)
                i0 = nonzero((x >= 0.), 1., 'first') #find(,'first')
                print "Warning: nonzero()"
                #%plot(x*1000,c)
                varinfo[7]['_name'] = 'autocorrel(0) var'
                #varinfo(8).var=c(i0) * fs_Hz_post;
                varinfo[7]['_var'] = np.dot(c[int(i0)-1], fs_Hz_post)
                #%not very reliable.

            
            
            #if VERBOSE:
            #    fprintf('var*fs=')
            #    fprintf(' %g, ', np.array(np.hstack((varinfo[:]['_var']))))
            #    fprintf('.\n')

            return signal, psd_fft, fs_Hz_post, varinfo
            
    #return signal, psd_fft, fs_Hz_post
            
    #return signal #, psd_fft, fs_Hz_post, varinfo
    raise Exception("Bad usage")
#% 21 = sineroot19 22 = sineroot50 23 = sineroot75
#% 24 = sineroot10 25 = sineroot110 26 = sineroot75tenth
#% 27 = sineroots20plus40  28 = sineroot75third
#% 29 = sineroot243  30 = sineroot150  31 = sineroot200
#% 32 = sine10.587352723 33 = sine10.387352723
#% 34 = rand7  35 = sine12  36 = 10+perturb  37 = sine11
#% 38 = sine10.17352723  39 = sine5 40 = sine6
#% 41 = sine7 42 = sine8  43 = sine9 44 = sine12
#% 45 = sine13  46 = sine14  47 = sine10.8342522
#% 48 = sine11.8342522  49 = sine12.8342522  50 = sine13.1900453
#% 51 = sine7.1900453  52 = sine7.8342522  53 = sine8.8342522
#% 54 = sine9.8342522 55 = sine5.19004  56 = sine5.8045
#% 57 = sine6.49004 58 = sine6.9004 59 = sine13.9004
#% 60 = 18+perturb
#%%% Initializations
plt.randn('state', randstate)
np.random.rand('twister', randstate)
#% Create raw weights
if newNets:
    if Netsize<=20.:
        Netconnectivity = 1.
    else:
        Netconnectivity = 10./Netsize
        
    
    WstarRaw = generate_internal_weights(Netsize, Netconnectivity)
    WinRaw = plt.randn(Netsize, 1.)
    WbiasRaw = plt.randn(Netsize, 1.)


#% Scale raw weights and initialize weights
#% 21 = sineroot19 22 = sineroot50 23 = sineroot75
#% 24 = sineroot10 25 = sineroot110 26 = sineroot75tenth
#% 27 = sineroots20plus40  28 = sineroot75third
#% 29 = sineroot243  30 = sineroot150  31 = sineroot200
#% 32 = sine10.587352723 33 = sine10.387352723
#% 34 = rand7  35 = sine12  36 = 10+perturb  37 = sine11
#% 38 = sine10.17352723  39 = sine5 40 = sine6
#% 41 = sine7 42 = sine8  43 = sine9 44 = sine12
#% 45 = sine13  46 = sine14  47 = sine10.8342522
#% 48 = sine11.8342522  49 = sine12.8342522  50 = sine13.1900453
#% 51 = sine7.1900453  52 = sine7.8342522  53 = sine8.8342522
#% 54 = sine9.8342522 55 = sine5.19004  56 = sine5.8045
#% 57 = sine6.49004 58 = sine6.9004 59 = sine13.9004
#% 60 = 18+perturb
#%%% Initializations
plt.randn('state', randstate)
np.random.rand('twister', randstate)
#% Create raw weights
if newNets:
    if Netsize<=20.:
        Netconnectivity = 1.
    else:
        Netconnectivity = 10./Netsize
        
    
    WstarRaw = generate_internal_weights(Netsize, Netconnectivity)
    WinRaw = plt.randn(Netsize, 1.)
    WbiasRaw = plt.randn(Netsize, 1.)


#% Scale raw weights and initialize weights
Exemplo n.º 10
0
import scipy as sp
import scipy.signal as sg
import simpleSTC as sstc
import compiSTAC as ci
import matplotlib.pylab as plt

nt = 20 # number of temporal elements of filter
tvec = np.vstack(np.arange(-nt+1., 1)) # time vector
filt1 = np.exp(-(((tvec+4.5)/1.5)**2)/2) - .2*np.exp((-((tvec+nt/2)/3)**2)/2)  #1st filter
filt1 = filt1/np.linalg.norm(filt1) #normalize
filt2 = np.vstack((np.diff(filt1, 1, 0), 0)) # 2nd filter
filt2 = filt2 - filt1*np.sum(filt1*filt2) # orthogonalize to 1st filter
filt2 = (filt2)/np.linalg.norm(filt2) # normalize

slen = 2000 # Stimulus length
Stim = Stim = plt.randn(slen, 1.)
RefreshRate = 100. # refresh rate

linresp = (sg.convolve2d(np.concatenate((np.zeros((len(filt1)-1, Stim.shape[1])), Stim), 0), np.rot90(filt1, 2), 'valid')) # filter output
r = np.maximum(linresp, 0.)*50      # instantaneous spike rate
r = np.vstack(r)
spikes = np.random.poisson(r/RefreshRate)   # generate spikes
[sta, stc, rawmu, rawcov] = sstc.simpleSTC(Stim, spikes, nt) #% Compute STA and STC
u, s, v = np.linalg.svd(stc, 'full_matrices') # Compute eigenvectors of STC matrix
s = np.diag(s)
v = v.T

ndims = 1
vecs, vals, mu1, mu0, v1, v2, _ = ci.compiSTAC(sta, stc, rawmu, rawcov, ndims)

fig1 = plt.figure()
Exemplo n.º 11
0
def x():

    dithering = False
    #% from test_lor3c2
    #% 2) down sampling changes SNR
    tau_s = 25./1.
    std_s = 3.53
    tau_n = 12./1.
    std_n = 5.55
    methid = 0
    #%NTA=2.^[4:5];
    #%NTA=2.^[4:8,9];

    #NTA = np.power(2, np.array(np.hstack((np.arange(4, 7), 8, 10, 12))))
    #NTA = np.power(2, np.array([4, 6, 8])) #12
    NTA = np.power(2, np.array([4])) #12
    nt_generate = np.max(NTA)
    b_msec = 7.  #3,5,1
    fs_Hz = 1000.
    siglen_msec = 10000.
    #%kerlenratio=5;
    siglen_msec = math.floor(siglen_msec / b_msec)* b_msec
    #%uses fs_Hz, and then downsamples. The downsampling is not quite correct.
    downsample_b = int(b_msec/1000. * fs_Hz + 0.00001)
    #print downsample_b #7
    assert downsample_b == 7
    #%happens to be equal to b, if fs=1000
    if False:
        r2_raw = makelorresponse(tau_s, std_s, tau_n, std_n, nt_generate, siglen_msec, fs_Hz, [], downsample_b)
    else:
        #test only
        r2_raw=np.random.randn(nt_generate, int((siglen_msec / b_msec))) #temporary
    if False:
        print    r2_raw.shape #1428x256
        print nt_generate
        print nt_generate
        print nt_generate
    del nt_generate
    
    siglen_b = (siglen_msec / b_msec)
    del siglen_msec
    #%M=4;
    #%M=8;
    #%M=4;
    M = 5
    #%M=8;
    #%M=15;
    #%M=3;
    [resp_dig, dithinfo1] = discr(r2_raw, M)
    #%not dithered
    #assert is_any_int_type(r2_raw[0,0])
    #r2_raw ois float

    [resp_dith, dithinfo2] = dith_unsure(r2_raw, (dithinfo1['centres']))
    #%not dithered
    
    resp_dig = resp_dith
    #del dithinfo

    resp_dig = resp_dig-1
    assert is_any_int_type(resp_dig[0,0])
    resp_cont = r2_raw
    sz=resp_cont.shape
    #print sz #1428 * 256
    resp_cont=resp_cont.flatten(1)
    resp_cont = resp_cont-np.mean(resp_cont.flatten(1))
    #%resp_cont=resp_cont/std(resp_cont(:))/2;
    #%resp_cont=resp_cont/std(resp_cont(:))/2*1.5*4*4;
    #resp_cont = matdiv(np.dot(matdiv(resp_cont, np.std(resp_cont.flatten(1)))/2.*1., M), M-1.)
    #resp_cont=resp_cont/std(resp_cont(:))/2*1*M/(M-1);
    resp_cont =  resp_cont / np.std(resp_cont.flatten()) /2.* M / (M-1.)
    #% [-1,+1]
    resp_cont = (resp_cont+1.)/2.
    #% [0,1]
    resp_cont = resp_cont * (M-1.)
    if 1:
        resp_cont[(resp_cont<0.)] = 0
        resp_cont[(resp_cont > M-1.)] = M-1
    resp_cont = resp_cont.reshape(sz)
    



    #print "HERE"
    #exit(0)
    
    #%clear r2_raw;
    #% analytical formula
    #%fs_Hz is used for Nyquist frequency
    #%ami=analytical_lor(tau_s,std_s, tau_n, std_n, fs_Hz, 0.0001);
    #%ami_perbin=mi/fs_Hz*b_msec;
    #% %WHY?!
    #%a=analytical_lor(tau_s/b_msec,std_s, tau_n/b_msec, std_n, fs_Hz/b_msec, 0.0001);
    #%ami_perbin=a / (fs_Hz/b_msec);
    #% (tau_s_msec,  sigma_s,  tau_n_msec,  sigma_n, fs_Hz, d_freq)
    #%Ia_bits_per_sec
    #% Ia_bps --> ami_bps = analytical mi
    ami_bps = analytical_lor(tau_s, std_s, tau_n, std_n, (1./b_msec/1000.), 0.0001)
    #%ami_perbin=ami_bps* (b_msec/1000);
    #% 1/ (fs_Hz/b_msec) = b_msec / fs = above (bcoz, fs=1000)
    #% previous: 0.2362
    #% new: 2.4512e-04
    binlen_sec = b_msec/1000.
    #%used later for normalization
    
    #del a
    del b_msec

    #%clearvars -except   resp_cont resp_dig M NTA binlen_sec siglen_b tau_s tau_n ami_bps ...
    #%    r2_raw std_* methid;
    don_plot_this = False
    #%size(respcut_dig)
    if don_plot_this:
            #%%
            #%mean(mean(resp_dig,1))
            [c, d] = plt.xcorr((matdiv(np.mean(resp_dig, 1.)-1.-(M-1.)/2.+1., M)*2.), 'unbiased')
            plt.figure(10.)
            plt.clf
            #% / sqrt(std_s^2+std_n^2)
            h = plt.plot((np.dot(d, binlen_sec)*1000.), matdiv(c, std_s**2.), 'k.-')
            set(h, 'linewidth', 2.)
            set(h, 'displayname', 'signal')
            plt.xlim((np.array(np.hstack((-1., 1.)))*100.*1.))
            #%set(gca,'xtick',-200:10:200);
            plt.title('\\tau_s, \\tau_n = %g,%g [msec]'%( tau_s, tau_n))
            #nn = matcompat.size(resp_dig, 1.)
            nn = resp_dig.shape[1-1]
            c1 = 0.
            for tri in np.arange(1., (nn)+1):
                #%mean(resp_dig(tri,:))
                #MISSING CODE!!!
                [c,d]=np.xcorr((resp_dig[tri,:]-1-(M-1)/2+1)/M*2,'unbiased');
                c1=c1+c/nn;
                pass

            del nn
            plt.hold(on)
            h = plt.plot((np.dot(d, binlen_sec)*1000.), matdiv(c1, std_n**2.), 'r.-')
            set(h, 'linewidth', 2.)
            set(h, 'displayname', 'noise')
            tt = np.dot(d, binlen_sec)
            h = plt.plot((tt*1000.), np.dot(binlen_sec, np.exp(matdiv(-np.abs(tt), tau_s/1000.))), 'k--')
            set(h, 'displayname', 'signal analytical')
            h = plt.plot((tt*1000.), np.dot(binlen_sec, np.exp(matdiv(-np.abs(tt), tau_n/1000.))), 'r--')
            set(h, 'displayname', 'noise analytical')
            h = plt.legend('show')
            set(h, 'box', 'off')
            set(h, 'location', 'NorthWest')
            plt.xlabel('Time [msec]')
            plt.title('cross correlation')
            #% my_save_png('test_lor4f1---signal-xcorr-v12-temp',{},[4,3]);
            
    begintime = time.time()
    #tic=time.time()

    #%estims=cell(4,4);
    #%LARR=[1,4,8,10];
    #%LARR=[1,2:2:10];
    #%LARR=[1,2:2:8];
    #%LARR=[1,2,3,6];
    #%LARR=[1,2,3,6,7];
    #%LARR=[1]; %
    #LARR = np.array(np.hstack((1., 3., 6., 7.)))
    #LARR = np.array(np.hstack((1+1, 3, 6, 7)))
    #LARR = [1+1, 3, 6, 7]
    LARR = [1,1+1, 4]
    MAX_L_DIRECT = np.Inf

    #estims_cell=[[],[],[],[]]
    #estims_cell=[[{}],[{}],[{}],[{}]]
    #estims_cell=[[{}]]
    estims_cell=[]
    #len(NTA)
    #print len(LARR),len(NTA), "******************"
    for i in range(0,len(LARR)):
            estims_cell.append([])
            for j in range(0,len(NTA)):
                print i,j
                estims_cell[i].append({})


    #%for nti=10:len(NTA)
    for nti in range(1, len(NTA)+1):
        nt = int(NTA[int(nti)-1])
        for li in range(1, len(LARR)+1):
            L = LARR[int(li)-1]
            #%lenL=floor(siglen_msec/b_msec/L)*L;
            #%lenL=floor(siglen_msec/L/b_msec)*L*b_msec;
            lenL = (int((siglen_b/ L)) * L)
            #%respcut=resp(:,1:lenL)';
            #%  respcut=resp(1:nt,1:lenL)';
            if dithering:
                respcut_cont = resp_cont[0:nt,0:lenL].conj().T


            #print "HERE"
            #exit(0)
            
            #print nt, max(NTA) #16,256
            #print resp_cont.shape  #1428x256
            #print resp_dig.shape
            #print "000"
            respcut_dig = resp_dig[0:nt,0:lenL].conj().T
            #% len x trials
            #%spk0 = zeros(1,LNum,size(signal,1), newlen );
            #%spk=reshape(respcut,  [1,L,size(resp)]);
            #% spk__=reshape(respcut,  1,L,lenL/L,[]);
            #%dithering = False
            if dithering:
                print "Using dithering"
                #spk__cont = np.reshape(respcut_cont, 1., L, matdiv(lenL, L), np.array([]))
                spk__cont = np.reshape(respcut_cont, [1, L, int(lenL/ L), -1])
                #% 1 x L x len x trials
                #spk2_cont = permute(spk__cont, np.array(np.hstack((1., 2., 4., 3.))))
                spk2_cont = spk__cont.transpose([1-1, 2-1, 4-1, 3-1]) #, np.array(np.hstack((1., 2., 4., 3.))))
                assert spk2_cont.shape == (1, L, nt, int(lenL/ L))

                #clear(spk__c)
                # #%slow
            else:
                print "Not using dithering"
            
            
            #% 1 x L x trials x len
            #print respcut_dig.shape, "*1"  #256 x 16  
            #print (lenL,L,nt), "*2" #1428.0, 1.0, 16
            spk__dig = np.reshape(respcut_dig, [1, L, int(lenL/ L), -1])
            spk2_dig = spk__dig.transpose([1-1, 2-1, 4-1, 3-1]) #permute(spk__dig, np.array(np.hstack((1., 2., 4., 3.))))
            assert spk2_dig.shape == (1, L, nt, int(lenL/ L))
            assert is_any_int_type(spk2_dig[0,0,0,0])

            del spk__dig

            #%slow
            
            assert type(nt) is int
            #nts = np.dot(np.ones(1., matdiv(lenL, L)), nt)
            #nts = np.ones([(lenL/ L)]) * nt
            nts = np.array([nt]*(lenL/ L), dtype=int) #np.ones([(lenL/ L)]) * nt
            #[nt]*int(lenL/ L)

            #print nts

            #assert type(nts[0]) is int
            #print type(nts), type(nts[0])
             

            
            print 'spk2: %dx%dx%dx%d ['%spk2_dig.shape
            if L<=MAX_L_DIRECT:
                ns = int(lenL/ L)
                #nta = np.arange(1., (ns)+1)*0.+nt
                nta = np.array([nt]*ns)
                if dithering:
                    #%[prs3,ps3]=my_prs_dith1(spk2, nta);
                    #%   [prs3_dith,ps3]=my_prs_dith1(spk2_c-1, nta);
                    #%[prs3_dith,ps3]=my_prs_dith1(spk2_cont-0, nta);
                    (prs_dith, ps_dith) = my_prs_dith1((spk2_cont-0.), nta)
                    #%    [prs3_dig,ps3]=my_prs(spk1, nta);
                    #%    sum(abs(prs3_dith(:)-prs3_dig(:)))
                    #%   if 0
                    #%       %[prs1,ps1]=my_prs(spk2, nta);
                    #%       [prs1,ps1]=my_prs(spk2_dig, nta);
                    #%   end
                    (prs_dig, ps_dig) = my_prs(spk2_dig, nta)
                    #print(repr((prs_dig, ps_dig)))
                    #%prs=prs3_dith;
                    #%ps=ps3;
                    fprintf('p')
                    hrs0_th = my_hrs(prs_dith, ps_dith, methid)
                    pr_dith = my_pr(prs_dith, ps_dith)
                    hr0_th = my_hr(pr_dith, methid)
                    #%hr1=hr(spk2_dig,nts,methid);
                    #%hrs1=hrs(spk2_dig,nts,methid);
                    hrs_dig = my_hrs(prs_dig, ps_dig, methid)
                    pr_dig = my_pr(prs_dig, ps_dig)
                    hr_dig = my_hr(pr_dig, methid)
                    #%[ my_hr(ps_dith, methid),my_hr(ps_dig, methid)]
                    #%m22= [...
                    #%    my_hr(pr_dith, methid),my_hr(pr_dig, methid);
                    #%    my_hrs(prs_dith,ps_dith, methid),my_hrs(prs_dig,ps_dig, methid)];
                    #%
                    vv1 = my_hr(pr_dith, methid)
                    my_hr(pr_dig, methid)
                    vv2 = my_hrs(prs_dith, ps_dith, methid)
                    my_hrs(prs_dig, ps_dig, methid)
                    m22 = vertcat(vv1, vv2)
                    #m22

                    #print li, nti
                    #%myminmax(spk2_dig(:))  % 1--4
                    #%myminmax(spk2_cont(:)) % 0--3
                    #estims.cell[int(li)-1,int(nti)-1]['hr_d'] = hr_dig
                    estims_cell[int(li)-1][int(nti)-1]['hr_d'] = hr_dig
                    #%hr1;
                    estims_cell[int(li)-1][int(nti)-1]['hrs_d'] = hrs_dig
                    #%hrs1;
                    estims_cell[int(li)-1][int(nti)-1]['hr_th'] = hr0_th
                    estims_cell[int(li)-1][int(nti)-1]['hrs_th'] = hrs0_th


                #print type(nts), type(nts[0])
                hr1_dig = hr(spk2_dig, nts, methid)
                hrs1_dig = hrs(spk2_dig, nts, methid)
                #print li, nti #1.0, 1.0
                #print int(li)-1,int(nti)-1
                #print estims_cell[int(li)-1][int(nti)-1]
                zz=estims_cell[int(li)-1][int(nti)-1]
                zz['hr_d'] = 1
                #print hr1_dig
                estims_cell[int(li)-1][int(nti)-1]['hr_d'] = hr1_dig
                #%hr1;
                estims_cell[int(li)-1][int(nti)-1]['hrs_d'] = hrs1_dig
                #%hrs1;
            
    
                if 1:

                    #print "***********"
                    #print nts
                    #%no dithering
                    estims_cell[int(li)-1][int(nti)-1]['hrs_sh'] = hrs_shuff(spk2_dig, nts, methid)

                    estims_cell[int(li)-1][int(nti)-1]['hrs_ind'] = hrsind(spk2_dig, nts, methid)
                    estims_cell[int(li)-1][int(nti)-1]['_xi'] = xi(spk2_dig, nts, methid)

                    #    
    
            else:
                estims_cell[int(li)-1][int(nti)-1]['_hr'] = 0.
                estims_cell[int(li)-1][int(nti)-1]['_hrs'] = 0.
                estims_cell[int(li)-1][int(nti)-1]['hrs_sh'] = 0.
                estims_cell[int(li)-1][int(nti)-1]['hrs_ind'] = 0.
                estims_cell[int(li)-1][int(nti)-1]['_xi'] = 0.
                
            
            #%we need: q-model in which , up to q0(=0) is shuffled: model=q, shuffle=0
            #%shuffle across:R (not S)
            #%if 1
            #print "HERE2"
            #exit(0)


            q = 1
            estims_cell[int(li)-1][int(nti)-1]['_hqrs'] = hqrs(spk2_dig, nts, q, methid)
            estims_cell[int(li)-1][int(nti)-1]['_hqr'] = hqr(spk2_dig, nts, q, methid)
            estims_cell[int(li)-1][int(nti)-1]['_xiq'] = xiq(spk2_dig, nts, q, methid)
            #%spk_q=q_shuffle(spk,nts,q);

            spk_q = q_shuffle(spk2_dig, nts, q)
            #%estims{li,nti}['hrs_q']=hrs(spk_q,nts,methid);
            estims_cell[int(li)-1][int(nti)-1]['hrs_q_sh'] = hrs(spk_q, nts, methid)
            #%estims{li,nti}.hqrs0=hqrs(spk,nts,q,meth);
            #%estims{li,nti}.hrss0=hrs_shuff(spk,nts,meth);
            #%estims{li,nti}.spks=q_shuffle(spk,nts,q);
            #%estims{li,nti}.hqrss0=hrs(spks,nts,meth);
            #%estims{li,nti}.hr0=hr(spk,nts,meth);
            #%estims{li,nti}.hqr0=hqr(spk,nts,q,meth);
            #%estims{li,nti}.hrs0=hrs(spk,nts,meth);
            #%estims{li,nti}.hrsi0=hrsind(spk,nmiu,meth);
            #%estims{li,nti}.xiq0=xiq(spk,nmiu,q,meth);
            #%estims{li,nti}.xi0=xi(spk,nmiu,meth);
            #%end
            estims_cell[int(li)-1][int(nti)-1]['L'] = L
            estims_cell[int(li)-1][int(nti)-1]['len'] = lenL/ L
            estims_cell[int(li)-1][int(nti)-1]['nt'] = nt
            print(']'),
            #print' (%g sec.)'%(np.floor(toc),)
            print('\n')
            #%estims{li,nti}

        #Takes long up to here. Cleaned up.
        #print "HERE"
        #exit(0)

        #%% -
        #%a2d1_th=[];
        #a2d1_d = [] #np.array([])
        a2d1_d = [] #np.array([])
        a2d2_qd = [] #np.array([])
        a2d3_dsh = [] #np.array([])
        nta1d = [] #np.array([])
        for ntj in range(1, nti+1):
            a2d1_d.append([])
            assert len(a2d1_d)-1 == ntj-1 #assert index number
            a2d3_dsh.append([])
            assert len(a2d3_dsh)-1 == ntj-1 #assert index number
            a2d2_qd.append([])
            assert len(a2d2_qd)-1 == ntj-1 #assert index number

            #ee=estims_cell[li-1][ntj-1]
            #nta1d.append( ee['nt'] )

            nta1d.append( estims_cell[0][ntj-1]['nt'] )
            assert len(nta1d)-1 == ntj-1

            for li in range(1, len(LARR)+1 ):
                #%L=LARR(li);
                #ee=estims{li,ntj};
                print estims_cell  #list of list of dict
                #print estims_cell.shape
                print estims_cell[0][0]
                print li,ntj
                ee=estims_cell[li-1][ntj-1]
                #%if  L<=MAX_L_DIRECT
                if 'hrs_d' in ee: #haskey(ee, 'hrs_d'):
                    #% mi1=(ee['_hr']-ee['_hrs'] -ee['hrs_ind'] + ee['hrs_sh']  )/ee['L'];
                    #%mi1=(ee['hr_th']-ee['hrs_th']  )/ee['L'];
                    #%mi1=(ee['hr_d']-ee['hrs_d'] -ee['hrs_ind'] + ee['hrs_sh']  )/ee['L'];
                    #%mi2=(ee['hr_d']-ee['hrs_d'])/ee['L'];
                    assert not type(ee['hr_d']) is list
                    #mi1_plugin = matdiv(ee['hr_d']-ee['hrs_d'], ee['L'])
                    #mi1_sh = matdiv(ee['hr_d']-ee['hrs_d']-ee['hrs_ind']+ee['hrs_sh'], ee['L'])
                    mi1_plugin = (ee['hr_d']-ee['hrs_d']) / ee['L']
                    mi1_sh = (ee['hr_d']-ee['hrs_d']-ee['hrs_ind']+ee['hrs_sh']) /  ee['L']
                else:
                    mi1_plugin = 0.
                    #%NaN;
                    mi1_sh = 0.
                    
                
                print mi1_plugin
                #%a2d1_th(ntj,li)=mi1;
                #a2d1_d[int(ntj)-1,int(li)-1] = mi1_plugin
                a2d1_d[ntj-1].append(mi1_plugin)
                assert len(a2d1_d[ntj-1])==li-1+1
                #a2d3_dsh[int(ntj)-1,int(li)-1] = mi1_sh
                a2d3_dsh[ntj-1].append( mi1_sh )
                assert len(a2d3_dsh[ntj-1])==li-1+1
                
                #%mi2=(ee['_xi']-ee['hrs_ind'])/ee['L'];
                #%mi2=(ee['_hqr']-ee['_hrs'] -ee['_hqrs'] + ee['hrs_q']  )/ee['L'];
                #%mi2=(ee['_xiq']-ee['hrs_q'] +ee['hrs_sh'] - ee['hrs_ind']  )/ee['L']; %DID NOT
                #%WORK
                #%mi2=(ee['_hqr']-ee['hrs_q'])/ee['L']; %+ee['hrs_sh'] - ee['hrs_ind']  )/ee['L'];
                #%slightly biased (uses hrs_q-sh)
                #% ************ CHECK THIS *************
                #mi2 = matdiv(ee['_xiq']-ee['_hqrs'], ee['L'])
                mi2 = (ee['_xiq']-ee['_hqrs']) /  ee['L']
                #%mi2=(ee['_hqr']-ee['_hqrs'])/ee['L'];
                #% ... %+ee['hrs_sh'] - ee['hrs_ind']  )/ee['L'];
                #%mi2=(ee['_xi']-ee['hrs_ind'])/ee['L'];
                #%mi2=(ee.hr1-ee.hrs1)/ee['L'];
                #%mi2=(ee['hr_d']-ee['hrs_d'])/ee['L'];
                #a2d2_qd[int(ntj)-1,int(li)-1] = mi2
                a2d2_qd[ntj-1].append( mi2 )
                assert len(a2d2_qd[ntj-1]) -1 == li-1
                #%mi3=(ee['_hqr']-ee['hrs_q'])/ee['L']; %+ee['hrs_sh'] - ee['hrs_ind']  )/ee['L'];
                #%mi3=(ee['_xiq']-ee['hrs_q'])/ee['L'];
                #nta1d[int(ntj)-1] = ee['nt']
                #nta1d.append( ee['nt'] )
                #print len(nta1d),ntj
                #print nta1d
                #assert len(nta1d)-1 == ntj-1
                #assert len(nta1d)-1 == ntj-1  ##COMPILE_TIME:CHECK_PATTERN: MATCH LAST_INDEX(nta1d) == ntj-1   #PLANGNOTE
                assert nta1d[ntj-1] == ee['nt']
                #%    end
                #%end
               
        if False:
            plt.figure(5.)
            plt.clf
            ax = np.array([])
            #%ax(1)=subplot(1,3,1:2);
            ax[0] = plt.subplot(2., 3., 1.)
            plt.hold(on)
            #%box on;
            lha = np.array([])
            #%h = plot(nta1d,a2d1_th/binlen_sec);
            h = plt.plot(nta1d, matdiv(a2d1_d, binlen_sec))
            #%if isempty(h)
            #%    h=plot(0,0,'w.');
            #%end
            set(h, 'linewidth', 2.)
            set(h, 'Displayname', 'L-direct')
            #%L-bin
            #%set(h,'Displayname','dithered'); %L-bin
            #%lha(1)=h(1);
            plt.ylabel('Information rate [bits/sec]')
            #% set(gca,'xscale','log');
            plt.title('direct plug-in')
            #%MARKOV
            ax[2] = plt.subplot(2., 3., 3.)
            h = plt.plot(nta1d, matdiv(a2d2_qd, binlen_sec), '-')
            #%if isempty(h)
            #%    h=plot(0,0,'w.');
            #%end
            #%plot(nta1d,a2d3,':');
            set(h, 'Displayname', 'q-Markov')
            #%L-bin
            #%set(h,'Displayname','L-direct');
            set(h, 'linewidth', 2.)
            #%lha(2)=h(1);
            #%  q=NaN;
            #%title('q=1');
            #%plot((ee['nt']),mi,'.');
            #%text((ee['nt']),mi, sprintf(' L=%d',ee['L']));
            #%   set(gca,'xscale','log');
            #%end
            #%  end
            #%hold on;
            #%plot(nta1d, ami_perbin + nta1d*0, 'k:');
            #%nta1d+100
            #%     nta1d_temp=myminmax(nta1d);  nta1d_temp(end)=nta1d(end)+100; nta1d_temp(1)=90;
            #%     h=plot(nta1d_temp, ami_bps + nta1d_temp*0, 'k-.');
            #%     set(h,'Displayname','analytical');
            #%lha(3)=h;
            plt.hold(on)
            #%    plot(nta1d, nta1d*0, 'k:');
            #%    xlabel('Trials');
            #%ylabel('Information [bits/bin]');
            #%xlim([10,(max(NTA)+100)*1.1]);
            #%xlim([min(NTA)-2,(max(NTA)+100)*1.1]);
            plt.title('q-Markov')
            lta=[]
            for li in np.arange(1., (len(LARR))+1):
                #%   text(nta1d(1),a2d1_d(1,li)/binlen_sec, sprintf(' L=%d',LARR(li)));
                lta[li]=' L=%d'%(LARR(li),);
                pass
 
            if False:
                lh = plt.legend(lta)
                set(lh, 'box', 'off')
                set(lh, 'Location', 'SouthWest')
                set(lh, 'FontSize', 7.)
            #% PANEL 2
            #%    h=legend(lha,'location','SouthEast'); set(h,'box','off');
            ax[1] = plt.subplot(2., 3., 2.)
            h = plt.plot(nta1d, matdiv(a2d3_dsh, binlen_sec), '-')
            #%if isempty(h)
            #%    h=plot(0,0,'w.');
            #%end
            set(h, 'Displayname', 'direct-sh')
            #%L-bin
            lha[2] = h[0]
            #% set(gca,'xscale','log');
            set(h, 'linewidth', 2.)
            plt.title('direct-sh')
            for pani in np.arange(1., 4.0):
                set(plt.gcf, 'CurrentAxes', ax[int(pani)-1])
                plt.hold(on)
                nta1d_temp = myminmax(nta1d)
                nta1d_temp[int(0)-1] = nta1d[int(0)-1]+100.
                nta1d_temp[0] = 20.
                #%90;
                #%h=plot(ax(pani),
                h = plt.plot(nta1d_temp, (ami_bps+nta1d_temp*0.), 'k--')
                set(h, 'Displayname', 'analytical')
                set(plt.gca, 'xscale', 'log')
                plt.plot(nta1d, (nta1d*0.), 'k:')
                plt.xlabel('Trials')
                set(plt.gca, 'xtick', np.unique(np.array(np.hstack(((2 ** np.array(np.hstack((5., 7., 9., np.log2(matcompat.max(NTA)))))))))))
                plt.ylim(np.array(np.hstack((-50., 100.))))
                plt.box(off)
                
            linkaxes(ax, 'y')
            linkaxes(ax, 'x')
            nta1d_temp = myminmax(nta1d)
            nta1d_temp[int(0)-1] = nta1d[int(0)-1]+1000.
            nta1d_temp[0] = nta1d_temp[0]-4.
            plt.xlim(nta1d_temp)
            #%a=[a2d3_dsh(:)/binlen_sec ; a2d1_d(:)/binlen_sec ;  a2d2_qd(:)/binlen_sec ];
            a = vertcat(matdiv(a2d3_dsh.flatten(1), binlen_sec), matdiv(a2d1_d.flatten(1), binlen_sec), matdiv(a2d2_qd.flatten(1), binlen_sec))
            #%ylim(myminmax(a)*1.5);
            #%ax(4)=
            plt.subplot(2., 3., 4.)
            plt.hold(on)
            WARR = np.dot(LARR, binlen_sec)*1000.
            #%bar(LARR,a2d2_qd(end,:) /binlen_sec);
            plt.plot(WARR, matdiv(a2d2_qd[int(0)-1,:], binlen_sec), 'ko-', 'displayname', 'q-Markov')
            plt.plot(WARR, matdiv(a2d1_d[int(0)-1,:], binlen_sec), 'r--', 'displayname', 'direct-sh')
            LA2 = np.array(np.hstack((WARR, WARR[int(0)-1]+1.)))
            h = plt.plot(LA2, (ami_bps+LA2*0.), 'k--')
            set(h, 'Displayname', 'analytical')
            #%xlabel('L');
            plt.xlabel('W [msec]')
            lh = plt.legend('show')
            set(lh, 'box', 'off')
            set(lh, 'Location', 'NorthEast')
            #%set(lh,'FontSize',7);
            #%linkaxes(ax, 'y')
            #%ylabel('Information rate [bits/sec]');
            plt.xlim(np.array(np.hstack((0.1, matcompat.max(LA2)+1.))))
            plt.ylabel('Information rate [bits/sec]')
            title_on_top2(sprintf('q=%d, DITHER, QE=%d, W=%g[ms]        \\tau_s,\\tau_n=%g,%g [ms]', q, methid, (1000.*binlen_sec), tau_s, tau_n), 0.)
            #%darbareye hichi be ghatiyat nemirese. va in kheili Pernicious, va
            #%PErvesaive, va daaem va hart dafe hastesh. bayad MM javab bekhad ta
            #%begam.
            #%save test_lor4???_all
            #% my_save_png('test_lor4f1---dither-v2',{},[7,5]);
        time.sleep(0.2)
        print("sleep")
        
    finishtime = time.time() #now()
    #toc=time.time()
    print('.')


    print estims_cell
    maxc = 0
    collect_keys={}
    for i in range(0,len(estims_cell)):
        for j in range(0,len(estims_cell[i])):
            for k in estims_cell[i][j]:
               collect_keys[k]=0
               if maxc < j+1:
                    maxc = j+1
    print collect_keys.keys()
    print
    ka={}
    for k in collect_keys:
       ka[k]=np.zeros((len(estims_cell),maxc))

    for i in range(0,len(estims_cell)):
        for j in range(0,len(estims_cell[i])):
            for k in collect_keys:
               ka[k][i,j]=estims_cell[i][j][k]
    for k in collect_keys:
        print k+":",
        print ka[k].T
    return

    dont_plot_this = False
    #%% - plots
    if dont_plot_this:
        DOUBLEPANEL = 0.
        plt.figure(6.)
        plt.clf
        if DOUBLEPANEL:
            plt.subplot(1., 2., 1.)
        
        
        #plt.hold(on)
        #%box on;
        styc = 'rgbmkckkk'
        for li in np.arange(1., (len(LARR))+1):
            lnt = np.array([])
            mi = np.array([])
            for ntj in np.arange(1., (nti)+1):
                ee = estims_cell[int(li)-1,int(ntj)-1]
                #%mi(ntj)=(ee['_hr']-ee['_hrs'])/ee['L'];
                #%mi(ntj)=(ee['_hr']-ee['_hrs'] -ee['hrs_ind'] + ee['hrs_sh']  )/ee['L'];
                #%mi(ntj)=(ee.hr1-ee.hrs1 -ee['hrs_ind'] + ee['hrs_sh']  )/ee['L'];
                mi[int(ntj)-1] = matdiv(ee['hr_d']-ee['hrs_d']-ee['hrs_ind']+ee['hrs_sh'], ee['L'])
                #%lnt(ntj)=log2(ee['nt']);
                lnt[int(ntj)-1] = matdiv(1., ee['nt'])
                plt.plot(lnt[int(ntj)-1], mi[int(ntj)-1], np.array(np.hstack((styc[int(li)-1], 'o'))))
                plt.text(lnt[int(ntj)-1], mi[int(ntj)-1], sprintf(' L=%d', (ee['L'])))
                
            h = plt.plot(lnt, mi, np.array(np.hstack((styc[int(li)-1], '--'))))
            set(h, 'LineWidth', 2.)
            h1[int(li)-1] = h
            
        #%set(gca,'xlim',[4,1+log2(max(NTA))]);
        ami_perbin = np.dot(ami_bps, binlen_sec)
        plt.plot(lnt, (ami_perbin+lnt*0.), 'k--')
        plt.xlabel('log_2(trials)')
        plt.ylabel('information (bits)')
        ylim = plt.get(plt.gca, 'ylim')
        #%set(gca,'ylim',[0,ylim(2)]);
        #%set(gca,'ylim',[0,0.5]);
        plt.title('direct method')
        #%  legend(h1, cell_sprintf('L=%d',LARR));
    
    
    #%%
    #%prs_dig(1,:)=[];
    #%%
    plt.figure(4.)
    plt.clf
    plt.plot(resp_cont[0,:])
    #plt.hold(on)
    plt.plot((resp_dig[0,:]-0.), 'r')
    plt.figure(10.)
    plt.clf
    mypcolor(prs_dig[0:,199:220.])
    plt.title('trunc')
    plt.figure(11.)
    plt.clf
    mypcolor(prs_dith[:,199:220.])
    plt.title('dith')
    plt.figure(12.)
    plt.clf
    plt.hist(np.array(np.hstack((prs_dith.flatten(1), prs_dig.flatten(1)))))
    #%%
    plt.figure(13.)
    plt.clf
    a = resp_cont[0,:]
    b = resp_dig[0,:]-0.
    c = r2_raw[0,:]
    plt.plot(a, (b+np.dot(plt.randn(matcompat.size(b)), 0.1)), 'k.')
    mm = myminmax((c.flatten(1)+np.dot(plt.randn(matcompat.size(a.flatten(1))), 0.01)))
    cx = np.arange(mm[0], (mm[1])+(np.diff(mm)/40.), np.diff(mm)/40.)
    h1 = histc(c.flatten(1), cx)
    h1 = matdiv(h1, np.sum(h1))
    #% *mean(diff(cx))
    plt.figure(14.)
    plt.clf
    plt.subplot(1., 2., 1.)
    plt.plot(c, (a+np.dot(plt.randn(matcompat.size(a)), 0.05)), 'k.', 'markersize', 1.)
    plt.hold(on)
    plt.plot(cx, (h1*20.+0.5), 'r')
    plt.subplot(1., 2., 2.)
    plt.plot(c, (b+np.dot(plt.randn(matcompat.size(a)), 0.05)), 'k.', 'markersize', 1.)
    plt.hold(on)
    plt.plot(cx, (h1*20.+0.5), 'r')
    for i in np.arange(1., 3.0):
        plt.subplot(1., 2., i)
        for x0 in np.array(np.hstack((-4., 4.))):
            plt.plot((x0+np.array(np.hstack((0., 0.)))), np.array(np.hstack((0., M))), 'b--', 'linewidth', 1.)
            
        
    #% my_save_png('test_lor4e2-v13-meth=1',{},[5,4]);
    #%%
    #%close all
    plt.figure(101.)
    plt.clf
    plt.plot(pr_dig, 'displayname', 'discrete')
    plt.hold(on)
    plt.plot(pr_dith, 'r.-', 'displayname', 'dith')
    np.array(np.hstack((np.sum(pr_dith), np.sum(pr_dig))))
    plt.legend(show)

    return estims_cell
Exemplo n.º 12
0
#!/usr/bin/python
# -*- coding: utf-8 -*-

from scipy.signal.ltisys import lti, lsim
from matplotlib.pylab import save, randn
from Numeric import sqrt, array, arange

n = 128
Q = 1.
R = 1.
w = 0.3 * sqrt(Q) * randn(n)
v = 0.2 * sqrt(R) * randn(n)
ureq = array([[-1.743] * n])

t = arange(0, 0.9999, 1. / 128)
#Generator().generateSin(n, 3, 33) #-0.37727

u = ureq + w

#A, B, C, D = [[-6.,-25.], [1.,0.]], [[1.],[0.]], [[0., 1.]], [[0.]]
#sys=lti(A, B, C, D)
#y = lsim(sys, u, t)
yv = u + v

##save('Q.txt', Q)
##save('R.txt', R)
save('w.txt', w)
save('v.txt', v)
save('yv.txt', yv)
save('u.txt', u)
save('ureq.txt', ureq)
Spart3 = Spart3.reshape(int(nt), 200)
Spart3 = np.transpose(Spart3)

S = Spart1 - Spart2 * Spart3

# In[3]:

#%%Further definitions
M = B + cg_tau
aw = a0 - a2 * x**2
kLf = k * Lf
#%%noise timeseries
sig_noise = sig / np.sqrt(dt)
print 'sig_noise'
print sig_noise
noise = sig_noise * plt.randn(1, int(dur * nt))
lp = 1. / 52.  #%1 week 'decorrelation' time
alpha = np.exp(-dt / lp)  # this alpha differs from the one below
nalpha = np.sqrt(1. - alpha**2)
N_red = noise * 0.
N_red[0] = noise[0]
for i in np.arange(1, (len(noise)) - 1):
    N_red[i] = alpha * N_red[i - 1] + nalpha * noise[i]
print 'N_red'
print N_red[0:10]
#%%Set up output arrays, saving 100 timesteps/year
E100 = np.zeros((int(n), int(dur * 100.)))
T100 = np.zeros((int(n), int(dur * 100.)))

# In[4]:
#% 16 = rand3 17 = rand9 18 = rand10 19 = 0.8 20 = sineroot27
#% 21 = sineroot19 22 = sineroot50 23 = sineroot75
#% 24 = sineroot10 25 = sineroot110 26 = sineroot75tenth
#% 27 = sineroots20plus40  28 = sineroot75third
#% 29 = sineroot243  30 = sineroot150  31 = sineroot200
#% 32 = sine10pt587352723 33 = sine10pt10.387352723
#% 34 = rand7  35 = sine12  36 = rand5  37 = sine11
#% 38 = sine10pt17352723  39 = sine5 40 = sine6
#% 41 = sine7 42 = sine8  43 = sine9 44 = sine12
#% 45 = sine13  46 = sine14  47 = sine10.8342522
#% 48 = sine11.8522311  49 = sine12.5223223  50 = sine13.1900453
#% 51 = sine7.1900453  52 = sine7.9004531  53 = sine8.4900453
#% 54 = sine9.1900453 55 = sine5.19004  56 = sine5.8045
#% 57 = sine6.49004 58 = sine6.9004 59 = sine13.9004
#%%% Initializations
plt.randn("state", randstate)
np.random.rand("twister", randstate)
I = np.eye(Netsize)
Np = length(patts)
#% Create raw weights
if newNets:
    if Netsize <= 20.0:
        Netconnectivity = 1.0
    else:
        Netconnectivity = 10.0 / Netsize

    WRaw = generate_internal_weights(Netsize, Netconnectivity)
    WinRaw = plt.randn(Netsize, 1.0)
    WbiasRaw = plt.randn(Netsize, 1.0)

Exemplo n.º 15
0
 arm = P.arange(m).reshape(-1, 1)
 arsy_i = P.arange(seq_length + samps).reshape(1, -1)
 arsy_o = P.arange(samps).reshape(1, -1)
 arsx = P.arange(2 * seq_length + 1 + samps).reshape(1, -1)
 PERM = P.permutation(C * m) * stride + offset
 for c in range(C):
     # if ep==0 and c<C//2:
     #   continue
     print("On chunk {0}/{1}".format(c + 1, C))
     # I = c*m*stride + offset
     x_c = P.vstack([
         x[PERM[c * m + fn]:(PERM[c * m + fn] +
                             (2 * seq_length + 1 + samps))]
         for fn in range(m)
     ])
     x_c = x_c + P.randn(*x_c.shape) * vx * iSNR  # add light noise
     x_c[x_c > XMAX] = XMAX
     x_c[x_c < -XMAX] = -XMAX
     x_inds = mu_law(x_c, mu, XMAX)
     x_c = P.zeros((m, 2 * seq_length + 1 + samps, mu))
     x_c[arm, arsx, x_inds] = True
     y_c_i = P.vstack([
         y[PERM[c * m + fn]:(PERM[c * m + fn] + seq_length + samps)]
         for fn in range(m)
     ])
     y_c_i = y_c_i + P.randn(*y_c_i.shape) * vy * iSNR  # add light noise
     y_c_i[y_c_i > YMAX] = YMAX
     y_c_i[y_c_i < -YMAX] = -YMAX
     y_inds = mu_law(y_c_i, mu, YMAX)
     y_c_i = P.zeros((m, seq_length + samps, mu))
     y_c_i[arm, arsy_i, y_inds] = True