[转载] real和imag在python_Python numpy.imag() 使用实例

参考链接： Python中的numpy.left_shift

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);

# float iy = map(radius,0,height,0,input.height);

# 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

cell = adjcube

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, frequency = pade(time,dipole)

fw_sig, frequency = pade(time,signal,alternate=True)

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 = fig.add_subplot(1, 1, 1)

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_xlabel('adc value')

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.saved_settings = config.load_meas_file(config.meas_file)

self.settings = deepcopy(self.saved_settings) #make a copy for used during calibration

self.quad = quad

if quad == "real":

self.quad_fun = np.real

elif quad == "imag":

self.quad_fun = np.imag

elif quad == "amp":

self.quad_fun = np.abs

elif quad == "phase":

self.quad_fun = np.angle

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.lay.addWidget(self.real)

self.label = QtWidgets.QLabel(" + j")

self.lay.addWidget(self.label)

self.imag.value_changed.connect(self.value_changed)

self.lay.addWidget(self.imag)

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)

for entry in chAB['linkList'][n % len(chAB['linkList'])]:

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))

wfAm1 = marker_waveform(chAm1['linkList'][n % len(chAm1['linkList'])],

chAm1['wfLib'])

wfAm2 = marker_waveform(chAm2['linkList'][n % len(chAm2['linkList'])],

chAm2['wfLib'])

wfBm1 = marker_waveform(chBm1['linkList'][n % len(chBm1['linkList'])],

chBm1['wfLib'])

wfBm2 = marker_waveform(chBm2['linkList'][n % len(chBm2['linkList'])],

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 :

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

frequencies[i].add(frequency)

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

cell = adjcube

#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.

Sprod = np.prod(adjcube.S)

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

Sprod = np.prod(adjcube.S)

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 = fig.add_subplot(2, 1, 1)

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 = fig.add_subplot(2, 1, 2)

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 = fig.add_subplot(1, 1, 1)

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:

bank.addFilter(wavelet)

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']

data[qubit_name] = self.quad_fun(buff_data)

if 'Variance' in dataset.dtype.names:

if self.quad in ['real', 'imag']:

var[qubit_name] = self.quad_fun(dataset['Variance'])/descriptor.metadata["num_averages"]

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)

[转载] real和imag在python_Python numpy.imag() 使用实例相关推荐

python数据处理实例-Python数据处理numpy.median的实例讲解
numpy模块下的median作用为: 计算沿指定轴的中位数返回数组元素的中位数其函数接口为: median(a, axis=None, out=None, overwrite_input=Fal ...
HTTP代理如何正确处理Cookie（2） - 转载（写的比较详细，并以实例讲解）
HTTP代理如何正确处理Cookie(2) - 转载(写的比较详细,并以实例讲解) http://hi.baidu.com/bdui/blog/item/de891ad90cb4b12f11df9ba ...
python把矩阵堆叠成大矩阵_python numpy 矩阵堆叠实例
在实际操作中,遇到了矩阵堆叠的操作,本来想着自己写一个函数,后来想,应该有库函数,于是一阵找寻 import numpy as np a = np.array([1,2,3]) b = np.arra ...
python遍历字符串数组_Python遍历numpy数组的实例
Python遍历numpy数组的实例在用python进行图像处理时,有时需要遍历numpy数组,下面是遍历数组的方法: [rows, cols] = num.shape for i in range ...
python的empty函数_python中numpy.empty()函数实例讲解
在使用python编程的过程中,想要快速的创建ndarray数组,可以使用numpy.empty()函数.numpy.empty()函数所创建的数组内所有元素均为空,没有实际意义,所以它也是创建数组最 ...
[转载] python radians函数_Python numpy.radians() 使用实例
参考链接: Python中的numpy.cos The following are code examples for showing how to use . They are extracted ...
[转载] Python学习（五）Numpy通用函数汇总
参考链接: Python中的numpy.isneginf 参考资料: https://github.com/lijin-THU/notes-python(相应实体书为:<自学Python--编程 ...
or函数python_Python numpy.bitwise_or函数方法的使用
numpy.bitwise_or numpy.bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K' ...
等比数列求和python_python numpy生成等差数列、等比数列的实例
如下所示:import numpy as np # 等差数列 print(np.linspace(0.1, 1, 10, endpoint=True)) print(np.arange(0.1, 1. ...

[转载] real和imag在python_Python numpy.imag() 使用实例

[转载] real和imag在python_Python numpy.imag() 使用实例相关推荐

最新文章

热门文章