def _create_J_with_numba(Ybus, V, pvpq, pq, createJ, pvpq_lookup, npv, npq):
Ibus = zeros(len(V), dtype=complex128)
# create Jacobian from fast calc of dS_dV
dVm_x, dVa_x = dSbus_dV_numba_sparse(Ybus.data, Ybus.indptr, Ybus.indices,
V, V / abs(V), Ibus)
# data in J, space preallocated is bigger than acutal Jx -> will be reduced later on
Jx = empty(len(dVm_x) * 4, dtype=float64)
# row pointer, dimension = pvpq.shape[0] + pq.shape[0] + 1
Jp = zeros(pvpq.shape[0] + pq.shape[0] + 1, dtype=int32)
# indices, same with the preallocated space (see Jx)
Jj = empty(len(dVm_x) * 4, dtype=int32)
# fill Jx, Jj and Jp
createJ(dVm_x, dVa_x, Ybus.indptr, Ybus.indices, pvpq_lookup, pvpq, pq, Jx,
Jj, Jp)
# resize before generating the scipy sparse matrix
Jx.resize(Jp[-1], refcheck=False)
Jj.resize(Jp[-1], refcheck=False)
# generate scipy sparse matrix
dimJ = npv + npq + npq
J = sparse((Jx, Jj, Jp), shape=(dimJ, dimJ))
return J
def choi_to_stinespring(q_oper, thresh=1e-10):
# TODO: document!
kU, kV = _generalized_kraus(q_oper, thresh=thresh)
assert(len(kU) == len(kV))
dK = len(kU)
dL = kU[0].shape[0]
dR = kV[0].shape[1]
# Also remember the dims breakout.
out_dims, in_dims = q_oper.dims
out_left, out_right = out_dims
in_left, in_right = in_dims
A = Qobj(zeros((dK * dL, dL)), dims=[out_left + [dK], out_right + [1]])
B = Qobj(zeros((dK * dR, dR)), dims=[in_left + [dK], in_right + [1]])
for idx_kraus, (KL, KR) in enumerate(zip(kU, kV)):
A += tensor(KL, basis(dK, idx_kraus))
B += tensor(KR, basis(dK, idx_kraus))
# There is no input (right) Kraus index, so strip that off.
del A.dims[1][-1]
del B.dims[1][-1]
return A, B
def choi_to_stinespring(q_oper, thresh=1e-10):
# TODO: document!
kU, kV = _generalized_kraus(q_oper, thresh=thresh)
assert (len(kU) == len(kV))
dK = len(kU)
dL = kU[0].shape[0]
dR = kV[0].shape[1]
# Also remember the dims breakout.
out_dims, in_dims = q_oper.dims
out_left, out_right = out_dims
in_left, in_right = in_dims
A = Qobj(zeros((dK * dL, dL)), dims=[out_left + [dK], out_right + [1]])
B = Qobj(zeros((dK * dR, dR)), dims=[in_left + [dK], in_right + [1]])
for idx_kraus, (KL, KR) in enumerate(zip(kU, kV)):
A += tensor(KL, basis(dK, idx_kraus))
B += tensor(KR, basis(dK, idx_kraus))
# There is no input (right) Kraus index, so strip that off.
del A.dims[1][-1]
del B.dims[1][-1]
return A, B
def bincount(x, weights=None, minlength=None):
if minlength is None:
minlength = 0
else:
if not isinstance(minlength, (int, long)):
raise TypeError("an integer is required")
if minlength <= 0:
raise ValueError("minlength must be positive")
x = array(x)
len_output = minlength
if len(x) > 0:
if x.min() < 0:
raise ValueError("x must not be negative")
len_output = max(len_output, x.max() + 1)
if x.dtype.kind not in 'ui':
raise ValueError("x must be integer")
if weights is None:
output = zeros(len_output, dtype=dtype('int'))
for elem in x:
output[elem] += 1
else:
if len(weights) != len(x):
raise ValueError("x and weights arrays must have the same size")
output = zeros(len_output, dtype=dtype('float'))
for i in range(len(x)):
output[x[i]] += weights[i]
return output
def main():
"""
deflection of the lamina stretched over a frame under weight
elliptic equation of second order with partial derivatives
"""
#number of x points
nx = 31
#number of y points
ny = 31
#length of frame by x axis
len_x = 1
#length of frame by y axis
len_y = 1
#step by x
hx = len_x/nx
#step by y
hy = len_y/ny
#solution matrix
z = zeros((nx, ny))
#sets boundary conditions of the second order (we considers value of derivative on the left boundary of frame)
z[:, 0] = 1
#matrix of initial data (using method of cross)
ax = tile(1/(hx**2), (nx, ny))
cx = tile(1/(hx**2), (nx, ny))
ay = tile(1/(hy**2), (nx, ny))
cy = tile(1/(hy**2), (nx, ny))
b = tile(2/(hx**2) + 2/(hy**2), (nx, ny))
#right part of equation
#we can change value in right part of equation and, as result, get new graphics
d = tile(5, (nx, ny))
#we can set some value as anomaly in function of right part of equation
d[10, 17] -= 900
#using seidel method
z = seidel_method(z, ax, ay, cx, cy, b, d)
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
#initialize x and y coordinates for plotting solution of equation
#nx and ny may be different and we can use size of frame and not size of initial matrix
x = zeros(shape=(nx, ny))
x[:] = arange(0, nx)
y = zeros(shape=(nx, ny))
y[:] = arange(0, ny)
y = y.transpose()
#plots surface
ax.plot_surface(x, y, z, rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0, antialiased=False)
ax.view_init(50, -30)
#saves result into png file
plt.savefig("ex5.png")
#shows result on screen at the moment
plt.show()
def global_phaseflip_stack(stack):
""" Apply global phase flip to an image stack if needed.
Check if all images in a stack should be globally phase flipped so that
the molecule corresponds to brighter pixels and the background corresponds
to darker pixels. This is done by comparing the mean in a small circle
around the origin (supposed to correspond to the molecule) with the mean
of the noise, and making sure that the mean of the molecule is larger.
Examples:
>> import mrcfile
>> stack = mrcfile.open('stack.mrcs')
>> stack = global_phaseflip_stack(stack)
:param stack: stack of images to phaseflip if needed
:return stack: stack which might be phaseflipped when needed
"""
if not len(stack.shape) in [2, 3]:
raise Exception('illegal stack size/shape! stack should be either 2 or 3 dimensional. '
'(stack shape:{})'.format(stack.shape))
num_of_images = stack.shape[2] if len(stack.shape) == 3 else 1
# make sure images are square
if stack.shape[1] != stack.shape[2]:
raise Exception(f'images must be square! ({stack.shape[0]}, {stack.shape[1]})')
image_side_length = stack.shape[0]
image_center = (image_side_length + 1) / 2
coor_mat_m, coor_mat_n = meshgrid(range(image_side_length), range(image_side_length))
distance_from_center = sqrt((coor_mat_m - image_center)**2 + (coor_mat_n - image_center)**2)
# calculate indices of signal and noise samples assuming molecule is around the center
signal_indices = distance_from_center < round(image_side_length / 4)
signal_indices = signal_indices.astype(int) # fill_value by default is True/False
noise_indices = distance_from_center > round(image_side_length / 2 * 0.8)
noise_indices = noise_indices.astype(int)
signal_mean = zeros([num_of_images, 1])
noise_mean = zeros([num_of_images, 1])
for image_idx in range(num_of_images):
proj = stack[:, :, image_idx]
signal_mean[image_idx] = mean(proj[signal_indices])
noise_mean[image_idx] = mean(proj[noise_indices])
signal_mean = mean(signal_mean)
noise_mean = mean(noise_mean)
if signal_mean < noise_mean:
logger.info('phase-flipping stack..')
return -stack
logger.info('no need to phase-flip stack.')
return stack
def _decode_raptor_piece(self,rpiece):
assert len(rpiece) == self.L * self.blocksize
piece = ma.zeros(self.blocksize*self.K,numpy.uint8)
for i in xrange(0,self.K,1):
bitlist = LTlist(i,self.K,self.L,self.L1)
piece[i*self.blocksize:i*self.blocksize+self.blocksize] = create_random_block(bitlist,rpiece)
return piece
def stft(y, n_fft=2048, hop_length=None, win_func=DFLT_WIN_FUNC):
'''
:param y: Mx0 audio
:param n_fft: window size
:param hop_length: hop size
:return: S - DxN stft matrix
'''
if hop_length is None:
hop_length = n_fft
if win_func is not None:
win = win_func(n_fft)
else:
win = 1
# calculate STFT
M = len(y)
N = int(ceil(1.0 * (M - n_fft) / hop_length) + 1) # no. windows
S = zeros((n_fft, N), dtype='complex')
for f in range(N - 1):
S[:, f] = y[f * hop_length:n_fft + f * hop_length] * win
x_end = y[(N - 1) * hop_length:]
S[:len(x_end), N - 1] = x_end
S[:, N - 1] *= win
S = fft.fft(S, axis=0)
S = S[:n_fft // 2 + 1, :]
return S
def _create_J_without_numba(Ybus, V, ref, pvpq, pq, slack_weights, dist_slack):
# create Jacobian with standard pypower implementation.
dS_dVm, dS_dVa = dSbus_dV(Ybus, V)
## evaluate Jacobian
if dist_slack:
rows_pvpq = array(r_[ref, pvpq]).T
cols_pvpq = r_[ref[1:], pvpq]
J11 = dS_dVa[rows_pvpq, :][:, cols_pvpq].real
J12 = dS_dVm[rows_pvpq, :][:, pq].real
else:
rows_pvpq = array([pvpq]).T
cols_pvpq = pvpq
J11 = dS_dVa[rows_pvpq, cols_pvpq].real
J12 = dS_dVm[rows_pvpq, pq].real
if len(pq) > 0 or dist_slack:
J21 = dS_dVa[array([pq]).T, cols_pvpq].imag
J22 = dS_dVm[array([pq]).T, pq].imag
if dist_slack:
J10 = sparse(slack_weights[rows_pvpq].reshape(-1, 1))
J20 = sparse(zeros(shape=(len(pq), 1)))
J = vstack([hstack([J10, J11, J12]),
hstack([J20, J21, J22])],
format="csr")
else:
J = vstack([hstack([J11, J12]), hstack([J21, J22])], format="csr")
else:
J = vstack([hstack([J11, J12])], format="csr")
return J
def _decode_raptor_piece(self, rpiece):
assert len(rpiece) == self.L * self.blocksize
piece = ma.zeros(self.blocksize * self.K, numpy.uint8)
for i in xrange(0, self.K, 1):
bitlist = LTlist(i, self.K, self.L, self.L1)
piece[i * self.blocksize:i * self.blocksize +
self.blocksize] = create_random_block(bitlist, rpiece)
return piece
def sigmoid(feature_map):
shape = feature_map.shape
output = zeros(shape)
for channel_number in range(shape[-1]):
for row in arange(0, shape[0]):
for column in arange(0, shape[1]):
output[row, column, channel_number] = 1 / (
1 + math.exp(feature_map[row, column, channel_number]))
def cvMatToArray(cvmat):
'''Converts an OpenCV CvMat to numpy array.'''
from numpy.core.multiarray import zeros
a = zeros(
(cvmat.rows, cvmat.cols)) #array([[0.0]*cvmat.width]*cvmat.height)
for i in xrange(cvmat.rows):
for j in xrange(cvmat.cols):
a[i, j] = cvmat[i, j]
return a
def change_sample_size(n):
global number_of_samples, Sensor1, Sensor2, Sensor3, Sensor4, Sensor5, Sensor6, Sensor7, Sensor8
number_of_samples = n
Sensor1 = zeros((1, number_of_samples))
Sensor2 = zeros((1, number_of_samples))
Sensor3 = zeros((1, number_of_samples))
Sensor4 = zeros((1, number_of_samples))
Sensor5 = zeros((1, number_of_samples))
Sensor6 = zeros((1, number_of_samples))
Sensor7 = zeros((1, number_of_samples))
Sensor8 = zeros((1, number_of_samples))
def dSbus_dV_numba_sparse_csc(Yx, Yp, Yi, V): # pragma: no cover
"""
Compute the power injection derivatives w.r.t the voltage module and angle
:param Yx: data of Ybus in CSC format
:param Yp: indptr of Ybus in CSC format
:param Yi: indices of Ybus in CSC format
:param V: Voltages vector
:return: dS_dVm, dS_dVa data ordered in the CSC format to match the indices of Ybus
"""
# init buffer vector
n = len(Yp) - 1
Ibus = zeros(n, dtype=complex128)
Vnorm = V / np.abs(V)
dS_dVm = Yx.copy()
dS_dVa = Yx.copy()
# pass 1
for j in range(n): # for each column ...
for k in range(Yp[j], Yp[j + 1]): # for each row ...
# row index
i = Yi[k]
# Ibus = Ybus * V
Ibus[i] += Yx[k] * V[j] # Yx[k] -> Y(i,j)
# Ybus * diagVnorm
dS_dVm[k] = Yx[k] * Vnorm[j]
# Ybus * diag(V)
dS_dVa[k] = Yx[k] * V[j]
# pass 2
for j in range(n): # for each column ...
# set buffer variable: this cannot be done in the pass1
# because Ibus is not fully formed, but here it is.
buffer = conj(Ibus[j]) * Vnorm[j]
for k in range(Yp[j], Yp[j + 1]): # for each row ...
# row index
i = Yi[k]
# diag(V) * conj(Ybus * diagVnorm)
dS_dVm[k] = V[i] * conj(dS_dVm[k])
if j == i:
# diagonal elements
dS_dVa[k] -= Ibus[j]
dS_dVm[k] += buffer
# 1j * diagV * conj(diagIbus - Ybus * diagV)
dS_dVa[k] = conj(-dS_dVa[k]) * (1j * V[i])
return dS_dVm, dS_dVa
def create_random_block(bitlist, piece):
assert len(piece) % len(bitlist) == 0
blocksize = len(piece) / len(bitlist)
random_block = ma.zeros(blocksize, numpy.uint8)
for i in xrange(len(bitlist)):
if bitlist[i] == 1:
block = ma.fromstring(
piece[i * blocksize:i * blocksize + blocksize], numpy.uint8)
random_block ^= block
return random_block
def cvMatToArray(cvmat):
"""Converts an OpenCV CvMat to numpy array."""
print ("Deprecated, use new interface")
from numpy.core.multiarray import zeros
a = zeros((cvmat.rows, cvmat.cols)) # array([[0.0]*cvmat.width]*cvmat.height)
for i in xrange(cvmat.rows):
for j in xrange(cvmat.cols):
a[i, j] = cvmat[i, j]
return a
def multiply_matrices(a, b, n):
size = len(a)
out = zeros((size, size))
for i in range(size):
for j in range(size):
line_sum = 0
for k in range(size):
line_sum += a[i][k] * b[k][j]
out[i][j] = line_sum % n
return list(map(lambda row: list(map(int, row)), out))
def AC_jacobian(Ybus, V, pvpq, pq, pvpq_lookup, npv, npq):
"""
Create the AC Jacobian function with no embedded controls
:param Ybus: Ybus matrix in CSC format
:param V: Voltages vector
:param pvpq: array of pv|pq bus indices
:param pq: array of pq indices
:param pvpq_lookup: array of pv|pq lookup indices
:param npv: number of pv buses
:param npq: number of pq buses
:return: Jacobian Matrix in CSR format
"""
Ibus = zeros(len(V), dtype=complex128)
# create Jacobian from fast calc of dS_dV
dS_dVm, dS_dVa = deriv.dSbus_dV_numba_sparse_csr(Ybus.data, Ybus.indptr,
Ybus.indices, V,
V / abs(V), Ibus)
# data in J, space pre-allocated is bigger than actual Jx -> will be reduced later on
Jx = empty(len(dS_dVm) * 4, dtype=float64)
# row pointer, dimension = pvpq.shape[0] + pq.shape[0] + 1
Jp = zeros(pvpq.shape[0] + pq.shape[0] + 1, dtype=int32)
# indices, same with the pre-allocated space (see Jx)
Jj = empty(len(dS_dVm) * 4, dtype=int32)
# fill Jx, Jj and Jp in CSR order
if len(pvpq) == len(pq):
create_J_no_pv(dS_dVm, dS_dVa, Ybus.indptr, Ybus.indices, pvpq_lookup,
pvpq, Jx, Jj, Jp)
else:
create_J(dS_dVm, dS_dVa, Ybus.indptr, Ybus.indices, pvpq_lookup, pvpq,
pq, Jx, Jj, Jp)
# resize before generating the scipy sparse matrix
Jx.resize(Jp[-1], refcheck=False)
Jj.resize(Jp[-1], refcheck=False)
# generate scipy sparse matrix
nj = npv + npq + npq
return csr_matrix((Jx, Jj, Jp), shape=(nj, nj))
def auto_norm(data_set: ndarray) -> (ndarray, ndarray, ndarray):
# 每列的最小值
min_values: ndarray = data_set.min(axis=0)
max_values: ndarray = data_set.max(axis=0)
ranges: ndarray = max_values - min_values
norm_data_set = zeros(shape(data_set))
m = data_set.shape[0]
norm_data_set = data_set - tile(min_values, (m, 1))
# 在numpy中， /表示值相除，而不是矩阵相除
norm_data_set = norm_data_set / tile(ranges, (m, 1))
return norm_data_set, ranges, min_values
def _pauli_basis(nq=1):
# NOTE: This is slow as can be.
# TODO: Make this sparse. CSR format was causing problems for the [idx, :]
# slicing below.
B = zeros((4**nq, 4**nq), dtype=complex)
dims = [[[2]*nq]*2]*2
for idx, op in enumerate(starmap(tensor, product(_SINGLE_QUBIT_PAULI_BASIS, repeat=nq))):
B[:, idx] = operator_to_vector(op).dag().data.todense()
return Qobj(B, dims=dims)
def __init__(self, Neq, blocksize):
assert Neq > 0 and blocksize > 0
self.eqset = []
self.V = []
self.C = 0
self.N = Neq
self.blocksize = blocksize
for i in xrange(self.N):
e = Equation([0] * self.N, ma.zeros(self.blocksize, numpy.uint8))
self.eqset.append(e)
self.V.append(False)
def _pauli_basis(nq=1):
# NOTE: This is slow as can be.
# TODO: Make this sparse. CSR format was causing problems for the [idx, :]
# slicing below.
B = zeros((4**nq, 4**nq), dtype=complex)
dims = [[[2] * nq] * 2] * 2
for idx, op in enumerate(
starmap(tensor, product(_SINGLE_QUBIT_PAULI_BASIS, repeat=nq))):
B[:, idx] = operator_to_vector(op).dag().full()
return Qobj(B, dims=dims)
def dSbus_dV_numba_sparse(Yx, Yp, Yj, V, Vnorm, Ibus): # pragma: no cover
"""
Computes partial derivatives of power injection w.r.t. voltage.
Calculates faster with numba and sparse matrices.
Input: Ybus in CSR sparse form (Yx = data, Yp = indptr, Yj = indices), V and Vnorm (= V / abs(V))
OUTPUT: data from CSR form of dS_dVm, dS_dVa
(index pointer and indices are the same as the ones from Ybus)
Translation of: dS_dVm = dS_dVm = diagV * conj(Ybus * diagVnorm) + conj(diagIbus) * diagVnorm
dS_dVa = 1j * diagV * conj(diagIbus - Ybus * diagV)
"""
# transform input
# init buffer vector
buffer = zeros(len(V), dtype=complex128)
dS_dVm = Yx.copy()
dS_dVa = Yx.copy()
# iterate through sparse matrix
for r in range(len(Yp) - 1):
for k in range(Yp[r], Yp[r + 1]):
# Ibus = Ybus * V
buffer[r] += Yx[k] * V[Yj[k]]
# Ybus * diag(Vnorm)
dS_dVm[k] *= Vnorm[Yj[k]]
# Ybus * diag(V)
dS_dVa[k] *= V[Yj[k]]
Ibus[r] += buffer[r]
# conj(diagIbus) * diagVnorm
buffer[r] = conj(buffer[r]) * Vnorm[r]
for r in range(len(Yp) - 1):
for k in range(Yp[r], Yp[r + 1]):
# diag(V) * conj(Ybus * diagVnorm)
dS_dVm[k] = conj(dS_dVm[k]) * V[r]
if r == Yj[k]:
# diagonal elements
dS_dVa[k] = -Ibus[r] + dS_dVa[k]
dS_dVm[k] += buffer[r]
# 1j * diagV * conj(diagIbus - Ybus * diagV)
dS_dVa[k] = conj(-dS_dVa[k]) * (1j * V[r])
return dS_dVm, dS_dVa
def relu(
feature_map
): # Activation function, normalize of what is passed from the convolution stage
shape = feature_map.shape
output = zeros(shape)
for channel_number in range(shape[-1]):
for row in arange(0, shape[0]):
for column in arange(0, shape[1]):
output[row, column, channel_number] = numpy.max(
[0, feature_map[row, column, channel_number]])
return output
def _use_raptor_block(self, seqnum, rblock):
self.C += 1
e = Equation(LTlist(seqnum,self.K, self.L, self.L1),rblock)
self.es.puteq(e)
if self.C == self.K:
block = ma.zeros(self.blocksize,numpy.uint8)
for i in xrange(self.S):
e = Equation(self.raptorSmtx.getrow(i)[:self.L],block)
self.es.puteq(e)
for i in xrange(self.H):
e = Equation(self.raptorHmtx.getrow(i)[:self.L],block)
self.es.puteq(e)
return self.es.done()
def file2matrix(filename: str) -> (ndarray, List[int]):
with open(filename, 'r') as fr:
lines = fr.readlines()
number_of_lines: int = len(lines)
return_matrix: ndarray = zeros((number_of_lines, 3))
class_label_vector: List[int] = []
index = 0
for line in lines:
line = line.strip()
return_matrix[index, :] = line.split('\t')[:3]
class_label_vector.append(int(line.split('\t')[3]))
index += 1
return return_matrix, class_label_vector
def _use_raptor_block(self, seqnum, rblock):
self.C += 1
e = Equation(LTlist(seqnum, self.K, self.L, self.L1), rblock)
self.es.puteq(e)
if self.C == self.K:
block = ma.zeros(self.blocksize, numpy.uint8)
for i in xrange(self.S):
e = Equation(self.raptorSmtx.getrow(i)[:self.L], block)
self.es.puteq(e)
for i in xrange(self.H):
e = Equation(self.raptorHmtx.getrow(i)[:self.L], block)
self.es.puteq(e)
return self.es.done()
def from_sampler(cls, n: int, sequence_sampler: Callable[[], Tuple[array, array]]) -> 'LabeledSequences':
"""
Create training data for a sequence-to-sequence labeling model.
The features are an array of size samples * time steps * 1.
The labels are a one-hot encoding of time step labels of size samples * time steps * number of labels.
:param n: number of sequence pairs to generate
:param sequence_sampler: a function that returns two numeric sequences of equal length
:return: feature and label sequences
"""
from keras.utils import to_categorical
xs, ys = sequence_sampler()
assert len(xs) == len(ys)
x = zeros((n, len(xs)), int)
y = zeros((n, len(ys)), int)
for i in range(n):
xs, ys = sequence_sampler()
x[i] = xs
y[i] = ys
x = x[:, :, newaxis]
y = to_categorical(y).astype(int)
return cls(x, y)
def digits_with_repetition_labels() -> Tuple[array, array]:
"""
Return a random list of 10 digits from 0 to 9. Two of the digits will be repeated. The rest will be unique.
Along with this list, return a list of 10 labels, where the label is 0 if the corresponding digit is unique and 1
if it is repeated.
:return: digits and labels
"""
n = 10
xs = arange(n)
ys = zeros(n, int)
shuffle(xs)
i, j = sample(range(n), 2)
xs[i] = xs[j]
ys[i] = ys[j] = 1
return xs, ys
def _raptor_precode(self, piece):
assert len(piece) % self.blocksize == 0
es = EquationSet(self.L, self.blocksize)
for i in xrange(0, self.K, 1):
block = ma.fromstring(piece[i*self.blocksize:i*self.blocksize+self.blocksize],numpy.uint8)
e = Equation(LTlist(i,self.K,self.L,self.L1),block)
es.puteq(e)
block = ma.zeros(self.blocksize,numpy.uint8)
for i in xrange(0, self.S, 1):
e = Equation(self.raptorSmtx.getrow(i)[:self.L],block)
es.puteq(e)
for i in xrange(0, self.H, 1):
e = Equation(self.raptorHmtx.getrow(i)[:self.L],block)
es.puteq(e)
assert es.done()
return es.getdata()
def _raptor_precode(self, piece):
assert len(piece) % self.blocksize == 0
es = EquationSet(self.L, self.blocksize)
for i in xrange(0, self.K, 1):
block = ma.fromstring(
piece[i * self.blocksize:i * self.blocksize + self.blocksize],
numpy.uint8)
e = Equation(LTlist(i, self.K, self.L, self.L1), block)
es.puteq(e)
block = ma.zeros(self.blocksize, numpy.uint8)
for i in xrange(0, self.S, 1):
e = Equation(self.raptorSmtx.getrow(i)[:self.L], block)
es.puteq(e)
for i in xrange(0, self.H, 1):
e = Equation(self.raptorHmtx.getrow(i)[:self.L], block)
es.puteq(e)
assert es.done()
return es.getdata()
def __init__ (self, worldfile):
with open (worldfile) as world:
reader = csv.reader (world)
names = {}
for k, line in enumerate (reader):
if not "#" in line [0]:
names [line [0]] = k
data = loadtxt (worldfile, delimiter = ',', usecols = range (1, 7), dtype = float64)
self.names = names
self.radii = data [:, 0]
self.masses = data [:, 1]
self.positions = data [:, 2:4]
self.velocities = data [:, 4:]
self.accelerations = zeros ( (len (self.names),) + self.positions.shape, dtype = float64)
self.mm = outer (self.masses, self.masses)
self.diagind = tuple (range (0, len (self.accelerations)))
self.count = len (self.names)
self.time = 0
plt.clf()
l1, l2, l3, l4 = plt.plot(x1, y1, 'bo', x2, y2, 'r*', x3, y3, 'gD', x4, y4, 'c^')
plt.plot(x1_new, y1_new, 'b-', x2_new, y2_new, 'r-', x3_new, y3_new, 'g-', x4_new, y4_new, 'c-', linewidth=3)
plt.legend((l1, l2, l3, l4), ('$R_F = R_D$', '$R_F = 2 R_D$', '$R_F = 3 R_D$', '$R_F = 4 R_D$'), 'upper right')
plt.axis([0, 100, 0, 10])
plt.xlabel("Number of Sessions per ONU ($n$)")
plt.ylabel("ECR [Mbps]")
plt.grid(linestyle='-')
plt.minorticks_on()
plt.show()
plt.savefig(base1 + "_" + base2 + ".ecr.new.png", format='png')
raw_input("Press ENTER to continue ...")
# plot multiplication factor to achieve ECR of 10 Mbps
mf = ma.zeros(len(x1_new))
for i in range(len(x1_new)):
if y1_new[i] >= 10:
mf[i] = 1
elif y2_new[i] >= 10:
mf[i] = 2
elif y3_new[i] >= 10:
mf[i] = 3
elif y4_new[i] >= 10:
mf[i] = 4
else:
mf[i] = 0
plt.clf()
plt.plot(x1_new, mf, linewidth=3)
plt.axis([0, 19, 0, 5])
from numpy import *
from numpy.linalg import inv
import pandas as pd
from numpy.core.multiarray import zeros
from numpy.core.numeric import newaxis
file = pd.read_excel(r"C:/Users/eulle/OneDrive - cefet-rj.br/Cefet Eng Eletrica/6°periodo/Computação Aplicada/Lista 2/DadosQ2.xlsx", engine="openpyxl")
print("\n \n Digite sua matriz A e b no arquivo excel, na primeira coluna vc pode começar a digitar a matriz A\n")
print(file)
while True:
try:
n = file.shape[0] - 1
A = zeros((n,n))
for i in range(n):
for j in range(n):
A[j][i] = file[i+1][j+1]
print("\n \n Sua matriz A é: \n\n {}\n\n".format(A))
c = zeros((n))
b = c[:,newaxis]
for i in range(n):
b[i] = file['b'][i+1]
print("\n \n Sua matriz b é: \n\n {}\n\n".format(b))
x = inv(A).dot(b)
linewidth=3)
plt.legend((l1, l2, l3, l4),
('$R_F = R_D$', '$R_F = 2 R_D$', '$R_F = 3 R_D$', '$R_F = 4 R_D$'),
'upper right')
plt.axis([0, 100, 0, 10])
plt.xlabel("Number of Sessions per ONU ($n$)")
plt.ylabel("ECR [Mbps]")
plt.grid(linestyle='-')
plt.minorticks_on()
plt.show()
plt.savefig(base1 + "_" + base2 + ".ecr.new.png", format='png')
raw_input("Press ENTER to continue ...")
# plot multiplication factor to achieve ECR of 10 Mbps
mf = ma.zeros(len(x1_new))
for i in range(len(x1_new)):
if y1_new[i] >= 10:
mf[i] = 1
elif y2_new[i] >= 10:
mf[i] = 2
elif y3_new[i] >= 10:
mf[i] = 3
elif y4_new[i] >= 10:
mf[i] = 4
else:
mf[i] = 0
plt.clf()
plt.plot(x1_new, mf, linewidth=3)
plt.axis([0, 19, 0, 5])
from numpy.core.multiarray import zeros, arange
tmax = 1000
dt = 0.5
a = 0.02
b = 0.2
c = -65
d = 8
iapp = 10
tr = [200 / dt, 700 / dt]
T = ceil(tmax / dt)
print(T)
v = zeros(int(T))
print(v)
u = zeros(int(T))
print(u)
v[0] = -70
u[0] = -14
for t in arange(T - 1):
if t > tr[0] and t < tr[1]:
i = iapp
else:
i = 0
if v[int(t)] < 35:
dv = (0.04 * v[int(t)] + 5) * v[int(t)] + 140 - u[int(t)]
v[int(t) + 1] = v[int(t)] + (dv + i) * dt
__author__ = 'KOL'
from numpy.core.multiarray import zeros
import re
daysChoose = zeros(7, dtype=int)
file = open("redata.txt", "r")
lines = file.readlines()
file.close()
matcher = re.compile(r"[MTWSF][a-z]{2}")
for i in lines:
day = matcher.findall(i)[0]
if day == "Mon":
daysChoose[0] += 1
elif day == "Thu":
daysChoose[1] += 1
elif day == "Wed":
daysChoose[2] += 1
elif day == "Tue":
daysChoose[3] += 1
elif day == "Fri":
daysChoose[4] += 1
elif day == "Sat":
daysChoose[5] += 1
elif day == "Sun":
daysChoose[6] += 1
print(daysChoose)
import numpy as np
from numpy.core.multiarray import zeros
from scipy import linalg
import time
start_time = time.clock()
Theano = False
porfolio=1000
fee=1
reader = csv.reader(open("C:\s980.csv", "rb"), delimiter=',')
S = np.matrix(list(reader)).astype('double')
[T, N] = S.shape
G = np.cov(S, rowvar=False)
A = zeros((N, N))
for t in range(1, T): # sum 2 to T
STMinusOneTranspose = S[t-1, :].T
A = A + (linalg.pinv2((S[t-1,:].T).dot(S[t-1,:]))).dot((S[t-1,:].T).dot(S[t,:]));
pingv = linalg.sqrtm(linalg.pinv2(G))
X = (pingv.T).dot(A).dot(G).dot((A.T)).dot(pingv)
[maxEigenValue, maxEigenVector] = linalg.eigh(X, eigvals_only=False, eigvals=(N-1, N-1))
w = pingv.real.dot(maxEigenVector.real)
if w.dot(A[:,N-1])>pandas.stats.moments.ewma(A[:,N-1], span=10):
portfolio=porfolio+porftolio*w.dot(A[:,N-1])-fee
else
portfolio=porfolio+porftolio*-w.dot(A[:,N-1])-fee
end_time = time.clock()
print end_time-start_time
numthetas = 2 # number of latent proficiency variables
# toggle the following to switch between generating from/learning latent variables
# are we generating responses(1), or learning latent vars from pre-generated responses(0)?
# (note that when not generating, "correct.npy" must have been generated with the same counts as above)
generating = 0
if generating:
# two ability params, one which alternates between -1 and 1 (across people)
# and another which moves smoothly from -1 to 1
abilities = array([linspace(-1,1,numpeople), [1,-1] * (numpeople/2)]) #, list(linspace(-1,1,numpeople/2))+list(linspace(1,-1,numpeople/2))])
# abilities = array([linspace(-1,1,numpeople), linspace(1,-1,numpeople), linspace(0,0,numpeople)])
# abilities = array([[1]*(numpeople/3)+[0]*(numpeople/3)+[0]*(numpeople/3), [0]*(numpeople/3)+[1]*(numpeople/3)+[0]*(numpeople/3), [1]*(numpeople/3)+[0]*(numpeople/3)+[1]*(numpeople/3)])
numpy.save("abilities", abilities)
theta_initial = abilities
correctness = zeros((numquestions, numpeople))
else:
# abilities is a 2d ndarray of float64. each column represents a person, each row a proficiency. values are proficiency between -1 and 1
abilities = numpy.load("abilities.npy")
# theta initial is an array the same size as abilities, populated with zeroes
theta_initial = zeros((numthetas, numpeople))
# correctness is a 2d array of bool. columns are questions, rows are people. values are whether the person answered the question correctly
correctness = numpy.load("correct.npy")
# theta (proficiency params) are sampled from a normal distribution
theta = pymc.Normal("theta", mu=0, tau=1, value=theta_initial, observed=generating)
from matplotlib.lines import Line2D
from matplotlib.ticker import AutoMinorLocator
from numpy.core.multiarray import zeros
from spatiotemporal.temporal_events.trapezium import TemporalEventTrapezium
from spatiotemporal.time_intervals import TimeInterval
from matplotlib import pyplot as plt
from matplotlib import animation
__author__ = 'keyvan'
x_axis = xrange(13)
zeros_13 = zeros(13)
class Animation(object):
def __init__(self, event_a, event_b, event_c, plt=plt):
self.event_a = event_a
self.event_c = event_c
self.event_b_length_beginning = event_b.beginning - event_b.a
self.event_b_length_middle = self.event_b_length_beginning + event_b.ending - event_b.beginning
self.event_b_length_total = event_b.b - event_b.ending
self.plt = plt
self.fig = plt.figure(1)
self.ax_a_b = self.fig.add_subplot(4, 1, 1)
self.ax_b_c = self.fig.add_subplot(4, 1, 2)
self.ax_a_c = self.fig.add_subplot(4, 1, 3)
self.ax_relations = self.fig.add_subplot(4, 1, 4)
self.ax_a_b.set_xlim(0, 13)
self.ax_a_b.set_ylim(0, 1)
def joint_matrix(sites):
"""takes as input a filename and returns the joint Rate matrix
for the list of sequences contained in that file
Joint rates R(X;Y_ are defined as
R(X;Y) = - sum over X,Y p(x,y) * I(X;Y)
I(X;y) = - sum over X,Y p(x,y) * log2[p(x,y)/(p(x)p(y))]
"""
bases = ['A','C','G','T']
indexDictionary = {} # the index dictionary
for i in range(4):
for j in range(4):
ssPair = bases[i] + bases[j]
indexDictionary[ssPair]=i,j
site_length = len(sites[0])
# initialize the matrix
di_counts = zeros([site_length,site_length],dtype='(4,4)int')
def add_seq(m,s,n,b):
"""adds the dinucleotide counts from one sequence to the mm_matrix (an array, passed by refence). requires the length n"""
for i in range(n):
for j in range(n):
m[i,j][ b[s[i]+s[j]] ] += 1
# count pairs over every sequence
for site in sites:
add_seq(di_counts,site.upper(),site_length,indexDictionary)
# convert to probabilities
di_probs = zeros([site_length,site_length],dtype='(4,4)float')
total_seqs = di_counts[0,0].sum()
for i in range(site_length):
for j in range(site_length):
for ii in range(4):
for jj in range(4):
di_probs[i,j][ii,jj] = di_counts[i,j][ii,jj] / float(total_seqs)
mm_matrix = zeros([site_length,site_length],dtype='float')
for i in range(site_length):
for j in range(site_length):
# sum over all dinucleotide combinations
pM = di_probs[i,j]
# Determine Iij
Iij = 0.0
for x in range(4):
for y in range(4):
px = pM[x,:].sum()
py = pM[:,y].sum()
pxy = pM[x,y]
if any([pxy==0, py==0, px==0]): continue
Iij += pxy * math.log(pxy/px/py, 2)
# Determine Rij
Rij = 0.0
for x in range(4):
for y in range(4):
pxy = pM[x, y]
Rij -= pxy * Iij
mm_matrix[i][j] = Rij
return (di_counts, di_probs, mm_matrix)
def zeros(shape, typecode='l', savespace=0, dtype=None):
"""zeros(shape, dtype=int) returns an array of the given
dimensions which is initialized to all zeros
"""
dtype = convtypecode(typecode, dtype)
return mu.zeros(shape, dtype)
from matplotlib.lines import Line2D
from matplotlib.ticker import AutoMinorLocator
from numpy.core.multiarray import zeros
from spatiotemporal.temporal_events.trapezium import TemporalEventTrapezium
from spatiotemporal.time_intervals import TimeInterval
from matplotlib import pyplot as plt
from matplotlib import animation
__author__ = 'keyvan'
x_axis = xrange(13)
zeros_13 = zeros(13)
class Animation(object):
def __init__(self, event_a, event_b, event_c, plt=plt):
self.event_a = event_a
self.event_c = event_c
self.event_b_length_beginning = event_b.beginning - event_b.a
self.event_b_length_middle = self.event_b_length_beginning + event_b.ending - event_b.beginning
self.event_b_length_total = event_b.b - event_b.ending
self.plt = plt
self.fig = plt.figure(1)
self.ax_a_b = self.fig.add_subplot(4, 1, 1)
self.ax_b_c = self.fig.add_subplot(4, 1, 2)
self.ax_a_c = self.fig.add_subplot(4, 1, 3)
self.ax_relations = self.fig.add_subplot(4, 1, 4)
self.ax_a_b.set_xlim(0, 13)
self.ax_a_b.set_ylim(0, 1)
def cameraIntrinsicCalibration(path, checkerBoardSize=[6, 7], secondPassSearch=False, display=False):
""" Camera calibration searches through all the images (jpg or png) located
in _path_ for matches to a checkerboard pattern of size checkboardSize.
These images should all be of the same camera with the same resolution.
For best results, use an asymetric board and ensure that the image has
very high contrast, including the background. Suitable checkerboard:
http://ftp.isr.ist.utl.pt/pub/roswiki/attachments/camera_calibration(2f)Tutorials(2f)StereoCalibration/check-108.png
The code below is based off of:
https://opencv-python-tutroals.readthedocs.org/en/latest/py_tutorials/py_calib3d/py_calibration/py_calibration.html
Modified by Paul St-Aubin
"""
from numpy import zeros, mgrid, float32, savetxt
import glob, os
# termination criteria
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
# prepare object points, like (0,0,0), (1,0,0), (2,0,0) ....,(6,5,0)
objp = zeros((checkerBoardSize[0] * checkerBoardSize[1], 3), float32)
objp[:, :2] = mgrid[0 : checkerBoardSize[1], 0 : checkerBoardSize[0]].T.reshape(-1, 2)
# Arrays to store object points and image points from all the images.
objpoints = [] # 3d point in real world space
imgpoints = [] # 2d points in image plane.
## Loop throuhg all images in _path_
images = (
glob.glob(os.path.join(path, "*.[jJ][pP][gG]"))
+ glob.glob(os.path.join(path, "*.[jJ][pP][eE][gG]"))
+ glob.glob(os.path.join(path, "*.[pP][nN][gG]"))
)
for fname in images:
img = cv2.imread(fname)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Find the chess board corners
ret, corners = cv2.findChessboardCorners(gray, (checkerBoardSize[1], checkerBoardSize[0]), None)
# If found, add object points, image points (after refining them)
if ret:
print "Found pattern in " + fname
if secondPassSearch:
corners = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria)
objpoints.append(objp)
imgpoints.append(corners)
# Draw and display the corners
if display:
img = cv2.drawChessboardCorners(img, (checkerBoardSize[1], checkerBoardSize[0]), corners, ret)
if img:
cv2.imshow("img", img)
cv2.waitKey(0)
## Close up image loading and calibrate
cv2.destroyAllWindows()
if len(objpoints) == 0 or len(imgpoints) == 0:
return False
try:
ret, camera_matrix, dist_coeffs, rvecs, tvecs = cv2.calibrateCamera(
objpoints, imgpoints, gray.shape[::-1], None, None
)
except NameError:
return False
savetxt("intrinsic-camera.txt", camera_matrix)
return camera_matrix, dist_coeffs
def setAtomTypeNum(self, atomTypeNum): self.atomTypeNum = atomTypeNum; #self.atomList = [[] for x in range(atomTypeNum)] self.atomList = [self.QList() for x in range(atomTypeNum)] self.atomNumMap = zeros((self.atomTypeNum, self.dimX, self.dimY), int)