# Python numpy.imag() 使用实例

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

def phormants(x, Fs):
N = len(x)
w = numpy.hamming(N)

# Apply window and high pass filter.
x1 = x * w
x1 = lfilter([1], [1., 0.63], x1)

# Get LPC.
ncoeff = 2 + Fs / 1000
A, e, k = lpc(x1, ncoeff)
#A, e, k = lpc(x1, 8)

# Get roots.
rts = numpy.roots(A)
rts = [r for r in rts if numpy.imag(r) >= 0]

# Get angles.
angz = numpy.arctan2(numpy.imag(rts), numpy.real(rts))

# Get frequencies.
frqs = sorted(angz * (Fs / (2 * math.pi)))

return frqs 

Example 2

def mdst(x, odd=True):
""" Calculate modified discrete sine transform of input signal

Parameters
----------
X : array_like
The input signal
odd : boolean, optional
Switch to oddly stacked transform. Defaults to :code:True.

Returns
-------
out : array_like
The output signal

"""
return -1 * numpy.imag(cmdct(x, odd=odd)) * numpy.sqrt(2) 

Example 3

def get_phases(self):
sizeimg = np.real(self.imgfft).shape
mag = np.zeros(sizeimg)
for x in range(sizeimg[0]):
for y in range(sizeimg[1]):
mag[x][y] = np.arctan2(np.real(self.imgfft[x][y]), np.imag(self.imgfft[x][y]))
rpic = MyImage(mag)
rpic.limit(1)
return rpic

#      int my = y-output.height/2;
#      int mx = x-output.width/2;
#      float angle = atan2(my, mx) - HALF_PI ;
#      float radius = sqrt(mx*mx+my*my) / factor;
#      float ix = map(angle,-PI,PI,input.width,0);
#      int inputIndex = int(ix) + int(iy) * input.width;
#      int outputIndex = x + y * output.width;
#      if (inputIndex <= input.pixels.length-1) {
#        output.pixels[outputIndex] = input.pixels[inputIndex]; 

Example 4

def fftDf( df , part = "abs") :
#Handle series or DataFrame
if type(df) == pd.Series :
df = pd.DataFrame(df)
ise = True
else :
ise = False
res = pd.DataFrame( index = np.fft.rfftfreq( df.index.size, d = dx( df ) ) )
for col in df.columns :
if part == "abs" :
res["FFT_"+col] = np.abs( np.fft.rfft(df[col]) )  / (0.5*df.index.size)
elif part == "real" :
res["FFT_"+col] = np.real( np.fft.rfft(df[col]) ) / (0.5*df.index.size)
elif part == "imag" :
res["FFT_"+col] = np.imag( np.fft.rfft(df[col]) ) / (0.5*df.index.size)
if ise :
return res.iloc[:,0]
else :
return res 

Example 5

def test_psi(adjcube):
"""Tests retrieval of the wave functions and eigenvalues.
"""
from pydft.bases.fourier import psi, O, H
V = QHO(cell)
W = W4(cell)
Ns = W.shape[1]
Psi, epsilon = psi(V, W, cell, forceR=False)

#Make sure that the eigenvalues are real.
assert np.sum(np.imag(epsilon)) < 1e-13

checkI = np.dot(Psi.conjugate().T, O(Psi, cell))
assert abs(np.sum(np.diag(checkI))-Ns) < 1e-13 # Should be the identity
assert np.abs(np.sum(checkI)-Ns) < 1e-13

checkD = np.dot(Psi.conjugate().T, H(V, Psi, cell))
diagsum = np.sum(np.diag(checkD))
assert np.abs(np.sum(checkD)-diagsum) < 1e-12 # Should be diagonal

# Should match the diagonal elements of previous matrix
assert np.allclose(np.diag(checkD), epsilon) 

Example 6

def fcn_ComputeFrequencyResponse(self,f,sig,mur,a,x0,y0,z0,X,Y,Z):
"""Compute Single Frequency Response at (X,Y,Z)"""

m = self.m
orient = self.orient
xtx = self.xtx
ytx = self.ytx
ztx = self.ztx

chi = fcn_ComputeExcitation_FEM(f,sig,mur,a)
Hpx,Hpy,Hpz = fcn_ComputePrimary(m,orient,xtx,ytx,ztx,x0,y0,z0)

mx = 4*np.pi*a**3*chi*Hpx/3
my = 4*np.pi*a**3*chi*Hpy/3
mz = 4*np.pi*a**3*chi*Hpz/3
R = np.sqrt((X-x0)**2 + (Y-y0)**2 + (Z-z0)**2)

Hx = (1/(4*np.pi))*(3*(X-x0)*(mx*(X-x0) + my*(Y-y0) + mz*(Z-z0))/R**5 - mx/R**3)
Hy = (1/(4*np.pi))*(3*(Y-y0)*(mx*(X-x0) + my*(Y-y0) + mz*(Z-z0))/R**5 - my/R**3)
Hz = (1/(4*np.pi))*(3*(Z-z0)*(mx*(X-x0) + my*(Y-y0) + mz*(Z-z0))/R**5 - mz/R**3)
Habs = np.sqrt(np.real(Hx)**2 + np.real(Hy)**2 + np.real(Hz)**2) + 1j*np.sqrt(np.imag(Hx)**2 + np.imag(Hy)**2 + np.imag(Hz)**2)

return Hx, Hy, Hz, Habs 

Example 7

def genSpectra(time,dipole,signal):

fw_re = np.real(fw)
fw_im = np.imag(fw)
fw_abs = fw_re**2 + fw_im**2

#spectra = (fw_re*17.32)/(np.pi*field*damp_const)
#spectra = (fw_re*17.32*514.220652)/(np.pi*field*damp_const)
#numerator = np.imag((fw*np.conjugate(fw_sig)))
numerator = np.imag(fw_abs*np.conjugate(fw_sig))
#numerator = np.abs((fw*np.conjugate(fw_sig)))
#numerator = np.abs(fw)
denominator = np.real(np.conjugate(fw_sig)*fw_sig)
#denominator = 1.0
spectra = ((4.0*27.21138602*2*frequency*np.pi*(numerator))/(3.0*137.036*denominator))
spectra *= 1.0/100.0
#plt.plot(frequency*27.2114,fourier)
#plt.show()
return frequency, spectra 

Example 8

def histogram_plot(data, sfreq, toffset, bins, log_scale, title):
"""Plot a histogram of the data for a given bin size."""
print("histogram")

fig = plt.figure()
ax.hist(numpy.real(data), bins,
log=log_scale, histtype='bar', color=['green'])
ax.hold(True)
ax.hist(numpy.imag(data), bins,
log=log_scale, histtype='bar', color=['blue'])
ax.grid(True)
ax.set_ylabel('frequency')
ax.set_title(title)
ax.hold(False)

return fig 

Example 9

def __init__(self,jet,kernels,k,x,y,pt,subpixel):
self.jet = jet
self.kernels = kernels
self.k = k
self.x = x
self.y = y

re = np.real(jet)
im = np.imag(jet)

self.mag = np.sqrt(re*re + im*im)
self.phase = np.arctan2(re,im)

if subpixel:
d = np.array([[pt.X()-x],[pt.Y()-y]])
comp = np.dot(self.k,d)
self.phase -= comp.flatten()
self.jet = self.mag*np.exp(1.0j*self.phase) 

Example 10

def __init__(self, qubit_names, quad="real"):
super(PulseCalibration, self).__init__()
self.qubit_names = qubit_names if isinstance(qubit_names, list) else [qubit_names]
self.qubit     = [QubitFactory(qubit_name) for qubit_name in qubit_names] if isinstance(qubit_names, list) else QubitFactory(qubit_names)
self.filename   = 'None'
self.exp        = None
self.axis_descriptor = None
self.cw_mode    = False
self.settings = deepcopy(self.saved_settings) #make a copy for used during calibration
else:
raise ValueError('Quadrature to calibrate must be one of ("real", "imag", "amp", "phase").')
self.plot       = self.init_plot() 

Example 11

def fit_photon_number(xdata, ydata, params):
''' Fit number of measurement photons before a Ramsey. See McClure et al., Phys. Rev. App. 2016
input params:
1 - cavity decay rate kappa (MHz)
2 - detuning Delta (MHz)
3 - dispersive shift 2Chi (MHz)
4 - Ramsey decay time T2* (us)
5 - exp(-t_meas/T1) (us), only if starting from |1> (to include relaxation during the 1st msm't)
6 - initial qubit state (0/1)
'''
params = [2*np.pi*p for p in params[:3]] + params[3:] # convert to angular frequencies
def model_0(t, pa, pb):
return (-np.imag(np.exp(-(1/params[3]+params[1]*1j)*t + (pa-pb*params[2]*(1-np.exp(-((params[0] + params[2]*1j)*t)))/(params[0]+params[2]*1j))*1j)))
def model(t, pa, pb):
return  params[4]*model_0(t, pa, pb) + (1-params[4])*model_0(t, pa+np.pi, pb) if params[5] == 1  else model_0(t, pa, pb)
popt, pcov = curve_fit(model, xdata, ydata, p0 = [0, 1])
perr = np.sqrt(np.diag(pcov))
finer_delays = np.linspace(np.min(xdata), np.max(xdata), 4*len(xdata))
fit_curve = model(finer_delays, *popt)
return popt[1], perr[1], (finer_delays, fit_curve) 

Example 12

def make_layout(self):
self.lay = QtWidgets.QHBoxLayout()
self.lay.setContentsMargins(0, 0, 0, 0)
self.real = FloatSpinBox(label=self.labeltext,
min=self.minimum,
max=self.maximum,
increment=self.singleStep,
log_increment=self.log_increment,
halflife_seconds=self.halflife_seconds,
decimals=self.decimals)
self.imag = FloatSpinBox(label=self.labeltext,
min=self.minimum,
max=self.maximum,
increment=self.singleStep,
log_increment=self.log_increment,
halflife_seconds=self.halflife_seconds,
decimals=self.decimals)
self.real.value_changed.connect(self.value_changed)
self.label = QtWidgets.QLabel(" + j")
self.imag.value_changed.connect(self.value_changed)
self.setLayout(self.lay)
self.setFocusPolicy(QtCore.Qt.ClickFocus) 

Example 13

def set_value(self, obj, value):
"""
the master's setter writes its value to the slave lists
"""
real, complex = [], []
for v in value:
# separate real from complex values
if np.imag(v) == 0:
real.append(v.real)
else:
complex.append(v)
# avoid calling setup twice
with obj.do_setup:
setattr(obj, 'complex_' + self.name, complex)
setattr(obj, 'real_' + self.name, real)
# this property should have call_setup=True, such that obj._setup()
# is called automatically after this function 

Example 14

def plot_waveforms(waveforms, figTitle=''):
channels = waveforms.keys()
# plot
plots = []
for (ct, chan) in enumerate(channels):
fig = bk.figure(title=figTitle + repr(chan),
plot_width=800,
plot_height=350,
y_range=[-1.05, 1.05],
x_axis_label=u'Time (?s)')
fig.background_fill_color = config.plotBackground
if config.gridColor:
fig.xgrid.grid_line_color = config.gridColor
fig.ygrid.grid_line_color = config.gridColor
waveformToPlot = waveforms[chan]
xpts = np.linspace(0, len(waveformToPlot) / chan.phys_chan.sampling_rate
/ 1e-6, len(waveformToPlot))
fig.line(xpts, np.real(waveformToPlot), color='red')
fig.line(xpts, np.imag(waveformToPlot), color='blue')
plots.append(fig)
bk.show(column(*plots)) 

Example 15

def merge_waveform(n, chAB, chAm1, chAm2, chBm1, chBm2):
'''
Builds packed I and Q waveforms from the nth mini LL, merging in marker data.
'''
wfAB = np.array([], dtype=np.complex)
if not entry.isTimeAmp:
wfAB = np.append(wfAB, chAB['wfLib'][entry.key])
else:
wfAB = np.append(wfAB, chAB['wfLib'][entry.key][0] *
np.ones(entry.length * entry.repeat))

chAm1['wfLib'])
chAm2['wfLib'])
chBm1['wfLib'])
chBm2['wfLib'])

wfA = pack_waveform(np.real(wfAB), wfAm1, wfAm2)
wfB = pack_waveform(np.imag(wfAB), wfBm1, wfBm2)

return wfA, wfB 

Example 16

def check(value, value_list, difference):
n = True
if len(value_list) == 0:
value_list.append(value)
else:
for x in value_list:
if np.abs(np.real(x) - np.real(value)) < difference and \
np.abs(np.imag(x) - np.imag(value)) < difference:
n = False
else:
pass
if n == True:
value_list.append(value)
return value_list

# This function converts a list of lists into a numpy array. It only takes the
# list of lists as input, and returns the array as output. If the lists inside
# the list are of unequal lengths, it fills up the lines with None so that all
# lines in the output array are of equal length.
# Example input:
# a = [[1,3,4], [2,1], [2,3,4,7]]
# Output:
# array([[1, 3, 4, None],
#        [2, 1, None, None],
#        [2, 3, 4, 7]], dtype=object) 

Example 17

def csvd(arr):
"""
Do the complex SVD of a 2D array, returning real valued U, S, VT

http://stemblab.github.io/complex-svd/
"""
C_r = arr.real
C_i = arr.imag
block_x = C_r.shape[0]
block_y = C_r.shape[1]
K = np.zeros((2 * block_x, 2 * block_y))
# Upper left
K[:block_x, :block_y] = C_r
# Lower left
K[:block_x, block_y:] = C_i
# Upper right
K[block_x:, :block_y] = -C_i
# Lower right
K[block_x:, block_y:] = C_r
return svd(K, full_matrices=False) 

Example 18

def csvd(arr):
"""
Do the complex SVD of a 2D array, returning real valued U, S, VT

http://stemblab.github.io/complex-svd/
"""
C_r = arr.real
C_i = arr.imag
block_x = C_r.shape[0]
block_y = C_r.shape[1]
K = np.zeros((2 * block_x, 2 * block_y))
# Upper left
K[:block_x, :block_y] = C_r
# Lower left
K[:block_x, block_y:] = C_i
# Upper right
K[block_x:, :block_y] = -C_i
# Lower right
K[block_x:, block_y:] = C_r
return svd(K, full_matrices=False) 

Example 19

def fft_test2(self):
axis = str(self.axis_combobox.currentText())

if axis.startswith('a'):
normal_para = 16384.0
elif axis.startswith('g'):
normal_para = 131.0
signal =( self.raw_data[axis] - self.bias_dict[axis])/ normal_para

n = signal.size # Number of data points
dx = 0.007 # Sampling period (in meters)
Fk = np.fft.fft(signal) # Fourier coefficients (divided by n)
nu = np.fft.fftfreq(n,dx) # Natural frequencies
#Fk = np.fft.fftshift(Fk) # Shift zero freq to center
#nu = np.fft.fftshift(nu) # Shift zero freq to center
f, ax = plt.subplots(3,1,sharex=True)
ax[0].plot(nu, np.real(Fk)) # Plot Cosine terms
ax[0].set_ylabel(r'$Re[F_k]$', size = 'x-large')
ax[1].plot(nu, np.imag(Fk)) # Plot Sine terms
ax[1].set_ylabel(r'$Im[F_k]$', size = 'x-large')
ax[2].plot(nu, np.absolute(Fk)**2) # Plot spectral power
ax[2].set_ylabel(r'$\vert F_k \vert ^2$', size = 'x-large')
ax[2].set_xlabel(r'$\widetilde{\nu}$', size = 'x-large')
plt.title(axis)
plt.show() 

Example 20

def estimate_pair(self, ts1, ts2):
"""

Returns
-------
ts : array-like, shape(1, n_samples)
Estimated iPLV time series.

avg : float
Average iPLV.

Notes
-----
Called from :mod:dyfunconn.tvfcgs.tvfcg.
"""
n_samples = len(ts1)

ts_plv = np.exp(1j * (ts1 - ts2))
avg_plv = np.abs(np.imag(np.sum((ts_plv))) / float(n_samples))

return np.imag(ts_plv), avg_plv 

Example 21

def edge_phase():
"""calculate edge phase"""
se = plane.UniformPlane(L=8, W=8, js=(0, 8 * 7), E=0, t=1, U=0, phase=.2 * 2 * np.pi, parasite=.1)

E1, psi1l, psi1r = eigenbasis(se, 1)
idx = np.argsort(np.real(E1))
E1 = E1[idx]
psi1l = psi1l[:, idx]
psi1r = psi1r[:, idx]

res = np.zeros((64, ))
idxs = se.edge_indices(dw=1, dl=1)
print(idxs)
s = len(idxs)

for i in range(s):
res += np.array([np.arctan2(np.real(psi1r[idxs[i], j] / psi1r[idxs[(i + 1) % s], j]), np.imag(psi1r[idxs[i], j] / psi1l[idxs[(i + 1) % s], j])) for j in np.arange(64)])

plt.plot(np.real(E1), res / (2 * np.pi), '-o')
Emin = np.min(np.real(E1))
Emax = np.max(np.real(E1))
for i in range(-10, 1, 1):
plt.plot([Emin, Emax], [i, i])
plt.plot([Emin, Emax], [-i, -i])
plt.show() 

Example 22

def BB(Y,index_PQ, index_P, n_PQ, n_P):
case_number, _ = np.shape(Y)
Y_p = Y.copy()
B_p = np.zeros((n_P,n_P))
B_pp = np.zeros((n_PQ,n_PQ))
#--------------------------------------------------
for i in xrange(case_number):
Y_p[i][i] = complex(0,0)
for j in xrange(case_number):
if i != j:
Y_p[i][i] -= Y_p[i][j]

B = np.imag(Y_p)
for i in xrange(n_P):
for j in xrange(0, n_P):
B_p[i][j] = B[index_P[i]][index_P[j]]
#--------------------------------------------------
for i in xrange(0, n_PQ):
for j in xrange(0, n_PQ):
B_pp[i][j] = B[index_PQ[i]][index_PQ[j]]

return B_p, B_pp

# A.M Van Amerongen----------------------------------------------------------------------------------------------------- 

Example 23

def vals2coeffs2(vals):
"""Map function values at Chebyshev points of 2nd kind to
first-kind Chebyshev polynomial coefficients"""
n = vals.size
if n <= 1:
coeffs = vals
return coeffs
tmp = np.append( vals[::-1], vals[1:-1] )
if np.isreal(vals).all():
coeffs = ifft(tmp)
coeffs = np.real(coeffs)
elif np.isreal( 1j*vals ).all():
coeffs = ifft(np.imag(tmp))
coeffs = 1j * np.real(coeffs)
else:
coeffs = ifft(tmp)
coeffs = coeffs[:n]
coeffs[1:n-1] = 2*coeffs[1:n-1]
return coeffs 

Example 24

def coeffs2vals2(coeffs):
"""Map first-kind Chebyshev polynomial coefficients to
function values at Chebyshev points of 2nd kind"""
n = coeffs.size
if n <= 1:
vals = coeffs
return vals
coeffs = coeffs.copy()
coeffs[1:n-1] = .5 * coeffs[1:n-1]
tmp = np.append( coeffs, coeffs[n-2:0:-1] )
if np.isreal(coeffs).all():
vals = fft(tmp)
vals = np.real(vals)
elif np.isreal(1j*coeffs).all():
vals = fft(np.imag(tmp))
vals = 1j * np.real(vals)
else:
vals = fft(tmp)
vals = vals[n-1::-1]
return vals 

Example 25

def _plot_samples(self, signal, ax, mag, real, imag, rms, noise=True):
if mag:
ax.plot(signal.mag, label='Mag')
if real:
ax.plot(np.real(signal), label='Real')
if imag:
ax.plot(np.imag(signal), label='Imag')
if rms:
ax.axhline(signal.rms, label='RMS', linestyle='--')
if noise:
noise_est = self.result.carrier_info.noise / np.sqrt(len(signal))
ax.axhline(noise_est, label='Noise', linestyle='--', color='g')
ax.legend()
ax.set_xlabel('Sample')
ax.set_ylabel('Value')
# ax2 = ax.twiny()
# ax2.set_xlim(0, len(signal) / self.sample_rate * 1e3)
# ax2.set_xlabel('Time (ms)')
ax.grid() 

Example 26

def interpolate_slice(f3d, rot, pfac=2, size=None):
nhalf = f3d.shape[0] / 2
if size is None:
phalf = nhalf
else:
phalf = size / 2
qot = rot * pfac  # Scaling!
px, py, pz = np.meshgrid(np.arange(-phalf, phalf), np.arange(-phalf, phalf), 0)
pr = np.sqrt(px ** 2 + py ** 2 + pz ** 2)
pcoords = np.vstack([px.reshape(-1), py.reshape(-1), pz.reshape(-1)])
mcoords = qot.T.dot(pcoords)
mcoords = mcoords[:, pr.reshape(-1) < nhalf]
pvals = map_coordinates(np.real(f3d), mcoords, order=1, mode="wrap") + \
1j * map_coordinates(np.imag(f3d), mcoords, order=1, mode="wrap")
pslice = np.zeros(pr.shape, dtype=np.complex)
pslice[pr < nhalf] = pvals
return pslice 

Example 27

def complex_quadrature(func, a, b, **kwargs):
"""
wraps the scipy qaudpack routines to handle complex valued functions

:param func: callable
:param a: lower limit
:param b: upper limit
:param kwargs: kwargs for func
:return:
"""

def real_func(x):
return np.real(func(x))

def imag_func(x):
return np.imag(func(x))

real_integral = integrate.quad(real_func, a, b, **kwargs)
imag_integral = integrate.quad(imag_func, a, b, **kwargs)

return real_integral[0] + 1j * imag_integral[0], real_integral[1] + imag_integral[1] 

Example 28

def plot(self):
""" Plot a realisation of the signal waveform """
Y=self.rvs()
Y_processed=linear_transform(Y,self.preprocessing_method)
N,L=Y_processed.shape

if ((L==3) or (L==1)):
n_vect=np.arange(N)/self.Fe
for l in range(L):
plt.plot(n_vect,Y_processed[:,l],label="signal %d" %l)
plt.xlabel("Time")
plt.ylabel("Signal")
plt.legend()

if L==2:
z=Y_processed[:,0]+1j*Y_processed[:,1]
plt.plot(np.real(z),np.imag(z))
plt.xlabel("Real Part")
plt.ylabel("Imag Part") 

Example 29

def make_node(self, a, s=None):
a = T.as_tensor_variable(a)
if a.ndim < 3:
raise TypeError('%s: input must have dimension >= 3,  with ' %
self.__class__.__name__ +
'first dimension batches and last real/imag parts')

if s is None:
s = a.shape[1:-1]
s = T.set_subtensor(s[-1], (s[-1] - 1) * 2)
s = T.as_tensor_variable(s)
else:
s = T.as_tensor_variable(s)
if (not s.dtype.startswith('int')) and \
(not s.dtype.startswith('uint')):
raise TypeError('%s: length of the transformed axis must be'
' of type integer' % self.__class__.__name__)
return gof.Apply(self, [a, s], [self.output_type(a)()]) 

Example 30

def add_scal_vec(self, val, vec):
"""
Perform in-place addition of a vector times a scalar.

Parameters
----------
val : int or float
scalar.
vec : <Vector>
this vector times val is added to self.
"""
if self._vector_info._under_complex_step:
r_val = np.real(val)
i_val = np.imag(val)
for set_name, data in iteritems(self._data):
data += r_val * vec._data[set_name] + i_val * vec._imag_data[set_name]
for set_name, data in iteritems(self._imag_data):
data += i_val * vec._data[set_name] + r_val * vec._imag_data[set_name]
else:
for set_name, data in iteritems(self._data):
data += val * vec._data[set_name] 

Example 31

def get_batch(batch_size):
samples = np.zeros([batch_size, sample_length])
frequencies = [set()] * batch_size
ffts = np.zeros([batch_size, fft_size])

for i in range(batch_size):
num_sources = np.random.randint(min_sources, max_sources + 1)
for source_idx in range(num_sources):
frequency, sample = generate_sample()
samples[i] += sample

samples[i] /= float(num_sources)

fft = np.fft.rfft(samples[i], norm="ortho")
fft = np.real(fft)**2 + np.imag(fft)**2

fft *= fft_norm

ffts[i] = fft

return frequencies, samples, ffts 

Example 32

def get_imag_part(self):
r = MyImage(np.imag(self.imgfft))
r.limit(1)
return r
# Correlate functions 

Example 33

def get_magnitude(self):
sizeimg = np.real(self.imgfft).shape
mag = np.zeros(sizeimg)
for x in range(sizeimg[0]):
for y in range(sizeimg[1]):
mag[x][y] = np.sqrt(np.real(self.imgfft[x][y])**2 + np.imag(self.imgfft[x][y])**2)
rpic = MyImage(mag)
rpic.limit(1)
return rpic 

Example 34

def draw_fft(self):
if len(self.points) < 1:
return
pts = map(lambda p: p[1] - self.offset, self.points)

out = numpy.fft.rfft(pts)
c = len(out)

norm = 0
for i in range(c/2):
norm += numpy.real(out[i])**2 + numpy.imag(out[i])**2

norm = math.sqrt(norm)
if norm <= 0:
return

for i in range(1, SignalKPlot.NUM_X_DIV):
x = float(i) / SignalKPlot.NUM_X_DIV
glRasterPos2d(x, .95)
period = 3/math.exp(x) # incorrect!!
SignalKPlot.drawputs(str(period))

glPushMatrix()
glBegin(GL_LINE_STRIP)
for i in range(c/2):
glVertex2d(float(i) * 2 / (c-2), abs(out[i]) / norm)
glEnd()
glPopMatrix() 

Example 35

def slidingFFT( se, T  ,  n = 1 , tStart = None , preSample = False , nHarmo = 5 , kind = abs , phase = None) :
"""
Harmonic analysis on a sliding windows
se : Series to analyse
T : Period
tStart : start _xAxis
n : size of the sliding windows in period.
reSample : reSample the signal so that a period correspond to a integer number of time step
nHarmo : number of harmonics to return
kind : module, real,  imaginary part, as a function (abs, np.imag, np.real ...)
phase : phase shift (for instance to extract in-phase with cos or sin)
"""

if (type(se) == pd.DataFrame) :
if len(se.columns) == 1 : se = se.iloc[:,0]

nWin = int(0.5 + n*T / dx(se) )
#ReSample to get round number of time step per period
if preSample :
new = reSample( se, dt = n*T / (nWin) )
else :
new = se
signal = new.values[:]
#Allocate results
res = np.zeros( (new.shape[0] , nHarmo ) )
for iWin in range(new.shape[0] - nWin) :
sig = signal[ iWin : iWin+nWin  ]  #windows
fft = np.fft.fft( sig )            #FTT
if phase !=None  :                 #Phase shift
fft *= np.exp( 1j* ( 2*pi*(iWin*1./nWin) + phase ))
fftp = kind( fft )       #Take module, real or imaginary part
spectre = 2*fftp/(nWin)  #Scale
for ih in range(nHarmo):
res[iWin, ih] = spectre[ih*n]
if ih == 0 : res[iWin, ih] /= 2.0
#if ih == 0 : res[iWin, ih] = 2.0
return pd.DataFrame( data = res , index = new.index , columns = map( lambda x : "Harmo {:} ({:})".format(x , se.name  ) , range(nHarmo)  ) ) 

Example 36

def test_E_real(adjcube):
"""Tests that the result of the calculation is real.
"""
from pydft.bases.fourier import E
from numpy.matlib import randn

#Single columns of random complex data
W = np.array(randn(np.prod(cell.S), 4) + 1j*randn(np.prod(cell.S), 4))
#Setup a harmonic oscillator potential
V = QHO(cell)
En = E(V, W, cell, forceR=False)

assert np.imag(En) < 1e-14 

Example 37

def test_IJ(adjcube):
"""Tests the I and J operators."""
from pydft.bases.fourier import I, J
#This also tests accessing the geometry via the global variable.
for i in range(10):
v = np.random.random(size=Sprod)
#Our v is real; but due to round-off problems, there will be
#tiny imaginary values. Chop them off.
it = J(I(v))
if abs(np.max(np.imag(it))) < 1e-14:
it = np.real(it)
assert np.allclose(it, v) 

Example 38

def test_LLinv(adjcube):
"""Tests L and its inverse.
"""
from pydft.bases.fourier import L, Linv
for i in range(10):
v = np.random.random(size=Sprod)
#Our v is real; but due to round-off problems, there will be
#tiny imaginary values. Chop them off. We only keep the last
#N-1 components because the 0 component is NaN.
it = Linv(L(v))[1:]
if abs(np.max(np.imag(it))) < 1e-14:
it = np.real(it)
assert np.allclose(it, v[1:]) 

Example 39

def plotResponseFEM(Ax,fi,f,H,Comp):

FS = 20

xTicks = (np.logspace(np.log(np.min(f)),np.log(np.max(f)),9))
Ylim = np.array([np.min(np.real(H)),np.max(np.real(H))])

Ax.grid('both', linestyle='-', linewidth=0.8, color=[0.8, 0.8, 0.8])
Ax.semilogx(f,0*f,color='k',linewidth=2)
Ax.semilogx(f,np.real(H),color='k',linewidth=4,label="Real")
Ax.semilogx(f,np.imag(H),color='k',linewidth=4,ls='--',label="Imaginary")
Ax.semilogx(np.array([fi,fi]),1.1*Ylim,linewidth=3,color='r')
Ax.set_xbound(np.min(f),np.max(f))
Ax.set_ybound(1.1*Ylim)
Ax.set_xlabel('Frequency [Hz]',fontsize=FS+2)
Ax.tick_params(labelsize=FS-2)
Ax.yaxis.set_major_formatter(FormatStrFormatter('%.1e'))

if Comp == 'x':
Ax.set_ylabel('$\mathbf{Hx}$ [A/m]',fontsize=FS+4,labelpad=-5)
Ax.set_title('$\mathbf{Hx}$ Response at $\mathbf{Rx}$',fontsize=FS+6)
elif Comp == 'y':
Ax.set_ylabel('$\mathbf{Hy}$ [A/m]',fontsize=FS+4,labelpad=-5)
Ax.set_title('$\mathbf{Hy}$ Response at $\mathbf{Rx}$',fontsize=FS+6)
elif Comp == 'z':
Ax.set_ylabel('$\mathbf{Hz}$ [A/m]',fontsize=FS+4,labelpad=-5)
Ax.set_title('$\mathbf{Hz}$ Response at $\mathbf{Rx}$',fontsize=FS+6)
elif Comp == 'abs':
Ax.set_ylabel('$\mathbf{|H|}$ [A/m]',fontsize=FS+4,labelpad=-5)
Ax.set_title('$\mathbf{|H|}$ Response at $\mathbf{Rx}$',fontsize=FS+6)

if np.max(np.real(H[-1])) > 0.:
handles, labels = Ax.get_legend_handles_labels()
Ax.legend(handles, labels, loc='upper left', fontsize=FS)
elif np.max(np.real(H[-1])) < 0.:
handles, labels = Ax.get_legend_handles_labels()
Ax.legend(handles, labels, loc='lower left', fontsize=FS)

return Ax 

Example 40

def plot_InducedCurrent_FD(self,Ax,Is,fi):

FS = 20

R = self.R
L = self.L

Imax = np.max(-np.real(Is))

f = np.logspace(0,8,101)

Ax.grid('both', linestyle='-', linewidth=0.8, color=[0.8, 0.8, 0.8])
Ax.semilogx(f,-np.real(Is),color='k',linewidth=4,label="$I_{Re}$")
Ax.semilogx(f,-np.imag(Is),color='k',ls='--',linewidth=4,label="$I_{Im}$")
Ax.semilogx(fi*np.array([1.,1.]),np.array([0,1.1*Imax]),color='r',ls='-',linewidth=3)
handles, labels = Ax.get_legend_handles_labels()
Ax.legend(handles, labels, loc='upper left', fontsize=FS)

Ax.set_xlabel('Frequency [Hz]',fontsize=FS+2)
Ax.set_ylabel('$\mathbf{- \, I_s (\omega)}$ [A]',fontsize=FS+2,labelpad=-10)
Ax.set_title('Frequency Response',fontsize=FS)
Ax.set_ybound(0,1.1*Imax)
Ax.tick_params(labelsize=FS-2)
Ax.yaxis.set_major_formatter(FormatStrFormatter('%.1e'))

#R_str    = '{:.3e}'.format(R)
#L_str    = '{:.3e}'.format(L)
#f_str    = '{:.3e}'.format(fi)
#EMF_str  = '{:.2e}j'.format(EMFi.imag)
#I_str    = '{:.2e} - {:.2e}j'.format(float(np.real(Isi)),np.abs(float(np.imag(Isi))))

#Ax.text(1.4,1.01*Imax,'$R$ = '+R_str+' $\Omega$',fontsize=FS)
#Ax.text(1.4,0.94*Imax,'$L$ = '+L_str+' H',fontsize=FS)
#Ax.text(1.4,0.87*Imax,'$f$ = '+f_str+' Hz',fontsize=FS,color='r')
#Ax.text(1.4,0.8*Imax,'$V$ = '+EMF_str+' V',fontsize=FS,color='r')
#Ax.text(1.4,0.73*Imax,'$I_s$ = '+I_str+' A',fontsize=FS,color='r')

return Ax 

Example 41

def test_real(self):
y = np.random.rand(10,)
assert_array_equal(0, np.imag(y)) 

Example 42

def test_cmplx(self):
y = np.random.rand(10,)+1j*np.random.rand(10,)
assert_array_equal(y.imag, np.imag(y)) 

Example 43

def test_complex_bad2(self):
with np.errstate(divide='ignore', invalid='ignore'):
v = 1 + 1j
v += np.array(-1+1.j)/0.
vals = nan_to_num(v)
assert_all(np.isfinite(vals))
# Fixme
#assert_all(vals.imag > 1e10)  and assert_all(np.isfinite(vals))
# !! This is actually (unexpectedly) positive
# !! inf.  Comment out for now, and see if it
# !! changes
#assert_all(vals.real < -1e10) and assert_all(np.isfinite(vals)) 

Example 44

def voltage_plot(data, sfreq, toffset, log_scale, title):
"""Plot the real and imaginary voltage from IQ data."""

print("voltage")

t_axis = numpy.arange(0, len(data)) / sfreq + toffset

fig = plt.figure()
ax0.plot(t_axis, data.real)
ax0.grid(True)
maxr = numpy.max(data.real)
minr = numpy.min(data.real)

if minr == 0.0 and maxr == 0.0:
minr = -1.0
maxr = 1.0

ax0.axis([t_axis[0], t_axis[len(t_axis) - 1], minr, maxr])
ax0.set_ylabel('I sample value (A/D units)')

ax1.plot(t_axis, data.imag)
ax1.grid(True)
maxi = numpy.max(data.imag)
mini = numpy.min(data.imag)

if mini == 0.0 and maxi == 0.0:
mini = -1.0
maxi = 1.0

ax1.axis([t_axis[0], t_axis[len(t_axis) - 1], mini, maxi])

ax1.set_xlabel('time (seconds)')

ax1.set_ylabel('Q sample value (A/D units)')
ax1.set_title(title)

return fig 

Example 45

def iq_plot(data, toffset, log_scale, title):
"""Plot an IQ circle from the data in linear or log scale."""
print("iq")

if log_scale:
rx_raster_r = numpy.sign(
data.real) * numpy.log10(numpy.abs(data.real) + 1E-30) / numpy.log10(2.)
rx_raster_i = numpy.sign(
data.imag) * numpy.log10(numpy.abs(data.imag) + 1E-30) / numpy.log10(2.)
else:
data *= 1.0 / 32768.0
rx_raster_r = data.real
rx_raster_i = data.imag

fig = plt.figure()
ax.plot(rx_raster_r, rx_raster_i, '.')

axmx = numpy.max([numpy.max(rx_raster_r), numpy.max(rx_raster_i)])

ax.axis([-axmx, axmx, -axmx, axmx])
ax.grid(True)
ax.set_xlabel('I')
ax.set_ylabel('Q')
ax.set_title(title)

return fig 

Example 46

def show(self,*args,**kwargs):
print self.data.shape
tiles = []
w,h,n = self.data.shape
for i in range(n):
mat = self.data[:,:,i]
tiles.append(pv.Image(mat.real))
tiles.append(pv.Image(mat.imag))
mont = pv.ImageMontage(tiles,layout=(8,10),tileSize=(w,h))
mont.show(*args,**kwargs) 

Example 47

def test_gabor1(self):
ilog = None # pv.ImageLog(name="GaborTest1")

bank = FilterBank(tile_size=(128,128))
kernels = createGaborKernels()
for wavelet in kernels:

for i in range(len(bank.filters)):
filter = np.fft.ifft2(bank.filters[i])
if ilog:
ilog.log(pv.Image(np.fft.fftshift(filter.real)),label="Filter_RE_%d"%i)
ilog.log(pv.Image(np.fft.fftshift(filter.imag)),label="Filter_IM_%d"%i)

for im in self.test_images[:1]:
if ilog:
ilog.log(im,label="ORIG")
results = bank.convolve(im)
#print "RShape",results.shape[2]
if ilog:
for i in range(results.shape[2]):
ilog.log(pv.Image(results[:,:,i].real),label="CONV_RE_%d"%i)
ilog.log(pv.Image(results[:,:,i].imag),label="CONV_IM_%d"%i)
if ilog:
ilog.show() 

Example 48

def generate_fake_data(alpha, phi, sigma, N = 5000, plot=False):

N_samples = 256
data_start = 3
data_length = 100
gnd_mean = np.array([alpha*np.cos(phi), alpha*np.sin(phi)])
ex_mean = np.array([alpha*np.cos(phi + np.pi), alpha*np.sin(phi + np.pi)])
gndIQ = np.vectorize(complex)(np.random.normal(gnd_mean[0], sigma, N),
np.random.normal(gnd_mean[1], sigma, N))
exIQ = np.vectorize(complex)(np.random.normal(ex_mean[0], sigma, N),
np.random.normal(ex_mean[1], sigma, N))
gnd = np.zeros((N_samples, N), dtype=np.complex128)
ex = np.zeros((N_samples, N), dtype=np.complex128)
for idx, x in enumerate(zip(gndIQ, exIQ)):
gnd[data_start:data_start+data_length, idx] = x[0]
ex[data_start:data_start+data_length, idx] = x[1]

gnd += sigma/50 * (np.random.randn(N_samples, N) + 1j * np.random.randn(N_samples, N))
ex += sigma/50 * (np.random.randn(N_samples, N) + 1j * np.random.randn(N_samples, N))

if plot:
plt.figure()
plt.plot(np.real(gndIQ), np.imag(gndIQ), 'b.')
plt.plot(np.real(exIQ), np.imag(exIQ), 'r.')
plt.draw()
plt.show()

plt.figure()
plt.plot(np.real(gnd[:,15]), 'b.')
plt.plot(np.real(ex[:,15]), 'r.')
plt.draw()
plt.show()
return gnd, ex 

Example 49

def run(self, norm_pts = None):
self.exp.run_sweeps()
data = {}
var = {}
for buff in self.exp.buffers:
if self.exp.writer_to_qubit[buff.name][0] in self.qubit_names:
dataset, descriptor = buff.get_data(), buff.get_descriptor()
qubit_name = self.exp.writer_to_qubit[buff.name][0]
if norm_pts:
buff_data = normalize_data(dataset, zero_id = norm_pts[qubit_name][0], one_id = norm_pts[qubit_name][1])
else:
buff_data = dataset['Data']
if 'Variance' in dataset.dtype.names:
else:
raise Exception('Variance of {} not available. Choose real or imag'.format(self.quad))
else:
var[qubit_name] = None

# Return data and variance of the mean
if len(data) == 1:
# if single qubit, get rid of dictionary
data = list(data.values())[0]
var = list(var.values())[0]
return data, var 

Example 50

def update_references(self, frequency):
# store decimated reference for mix down
# phase_drift = 2j*np.pi*0.5e-6 * (abs(frequency) - 100e6)
ref = np.exp(2j*np.pi * -frequency * self.time_pts[::self.d1] + 1j*self._phase, dtype=np.complex64)

self.reference   = ref
self.reference_r = np.real(ref)
self.reference_i = np.imag(ref)