# Python numpy.dot() Examples

The following are 30 code examples for showing how to use numpy.dot(). These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example.

You may check out the related API usage on the sidebar.

You may also want to check out all available functions/classes of the module , or try the search function .

Example 1
 Project: Financial-NLP   Author: Coldog2333   File: NLP.py    License: Apache License 2.0 6 votes  ```def similarity_label(self, words, normalization=True):
"""
you can calculate more than one word at the same time.
"""
if self.model==None:
raise Exception('no model.')
if isinstance(words, string_types):
words=[words]
vectors=np.transpose(self.model.wv.__getitem__(words))
if normalization:
unit_vector=unitvec(vectors,ax=0) # 这样写比原来那样速度提升一倍
#unit_vector=np.zeros((len(vectors),len(words)))
#for i in range(len(words)):
#    unit_vector[:,i]=matutils.unitvec(vectors[:,i])
dists=np.dot(self.Label_vec_u, unit_vector)
else:
dists=np.dot(self.Label_vec, vectors)
return dists ```
Example 2
 Project: FRIDA   Author: LCAV   File: point_cloud.py    License: MIT License 6 votes  ```def classical_mds(self, D):
'''
Classical multidimensional scaling

Parameters
----------
D : square 2D ndarray
Euclidean Distance Matrix (matrix containing squared distances between points
'''

# Apply MDS algorithm for denoising
n = D.shape
J = np.eye(n) - np.ones((n,n))/float(n)
G = -0.5*np.dot(J, np.dot(D, J))

s, U = np.linalg.eig(G)

# we need to sort the eigenvalues in decreasing order
s = np.real(s)
o = np.argsort(s)
s = s[o[::-1]]
U = U[:,o[::-1]]

S = np.diag(s)[0:self.dim,:]
self.X = np.dot(np.sqrt(S),U.T) ```
Example 3
 Project: FRIDA   Author: LCAV   File: point_cloud.py    License: MIT License 6 votes  ```def flatten(self, ind):
'''
Transform the set of points so that the subset of markers given as argument is
as close as flat (wrt z-axis) as possible.

Parameters
----------
ind : list of bools
Lists of marker indices that should be all in the same subspace
'''

# Transform references to indices if needed
ind = [self.key2ind(s) for s in ind]

# center point cloud around the group of indices
centroid = self.X[:,ind].mean(axis=1, keepdims=True)
X_centered = self.X - centroid

# The rotation is given by left matrix of SVD
U,S,V = la.svd(X_centered[:,ind], full_matrices=False)

self.X = np.dot(U.T, X_centered) + centroid ```
Example 4
 Project: FRIDA   Author: LCAV   File: generators.py    License: MIT License 6 votes  ```def gen_visibility(alphak, phi_k, pos_mic_x, pos_mic_y):
"""
generate visibility from the Dirac parameter and microphone array layout
:param alphak: Diracs' amplitudes
:param phi_k: azimuths
:param pos_mic_x: a vector that contains microphones' x coordinates
:param pos_mic_y: a vector that contains microphones' y coordinates
:return:
"""
xk, yk = polar2cart(1, phi_k)
num_mic = pos_mic_x.size
visi = np.zeros((num_mic, num_mic), dtype=complex)
for q in xrange(num_mic):
p_x_outer = pos_mic_x[q]
p_y_outer = pos_mic_y[q]
for qp in xrange(num_mic):
p_x_qqp = p_x_outer - pos_mic_x[qp]  # a scalar
p_y_qqp = p_y_outer - pos_mic_y[qp]  # a scalar
visi[qp, q] = np.dot(np.exp(-1j * (xk * p_x_qqp + yk * p_y_qqp)), alphak)
return visi ```
Example 5
 Project: FRIDA   Author: LCAV   File: doa.py    License: MIT License 6 votes  ```def compute_mode(self):
"""
Pre-compute mode vectors from candidate locations (in spherical
coordinates).
"""
if self.num_loc is None:
raise ValueError('Lookup table appears to be empty. \
Run build_lookup().')
self.mode_vec = np.zeros((self.max_bin,self.M,self.num_loc),
dtype='complex64')
if (self.nfft % 2 == 1):
raise ValueError('Signal length must be even.')
f = 1.0 / self.nfft * np.linspace(0, self.nfft / 2, self.max_bin) \
* 1j * 2 * np.pi
for i in range(self.num_loc):
p_s = self.loc[:, i]
for m in range(self.M):
p_m = self.L[:, m]
if (self.mode == 'near'):
dist = np.linalg.norm(p_m - p_s, axis=1)
if (self.mode == 'far'):
dist = np.dot(p_s, p_m)
# tau = np.round(self.fs*dist/self.c) # discrete - jagged
tau = self.fs * dist / self.c  # "continuous" - smoother
self.mode_vec[:, m, i] = np.exp(f * tau) ```
Example 6
 Project: FRIDA   Author: LCAV   File: tools_fri_doa_plane.py    License: MIT License 6 votes  ```def cov_mtx_est(y_mic):
"""
estimate covariance matrix
:param y_mic: received signal (complex based band representation) at microphones
:return:
"""
# Q: total number of microphones
# num_snapshot: number of snapshots used to estimate the covariance matrix
Q, num_snapshot = y_mic.shape
cov_mtx = np.zeros((Q, Q), dtype=complex, order='F')
for q in range(Q):
y_mic_outer = y_mic[q, :]
for qp in range(Q):
y_mic_inner = y_mic[qp, :]
cov_mtx[qp, q] = np.dot(y_mic_outer, y_mic_inner.T.conj())
return cov_mtx / num_snapshot ```
Example 7
 Project: FRIDA   Author: LCAV   File: tools_fri_doa_plane.py    License: MIT License 6 votes  ```def mtx_updated_G(phi_recon, M, mtx_amp2visi_ri, mtx_fri2visi_ri):
"""
Update the linear transformation matrix that links the FRI sequence to the
visibilities by using the reconstructed Dirac locations.
:param phi_recon: the reconstructed Dirac locations (azimuths)
:param M: the Fourier series expansion is between -M to M
:param p_mic_x: a vector that contains microphones' x-coordinates
:param p_mic_y: a vector that contains microphones' y-coordinates
:param mtx_freq2visi: the linear mapping from Fourier series to visibilities
:return:
"""
L = 2 * M + 1
ms_half = np.reshape(np.arange(-M, 1, step=1), (-1, 1), order='F')
phi_recon = np.reshape(phi_recon, (1, -1), order='F')
mtx_amp2freq = np.exp(-1j * ms_half * phi_recon)  # size: (M + 1) x K
mtx_amp2freq_ri = np.vstack((mtx_amp2freq.real, mtx_amp2freq.imag[:-1, :]))  # size: (2M + 1) x K
mtx_fri2amp_ri = linalg.lstsq(mtx_amp2freq_ri, np.eye(L))
# projection mtx_freq2visi to the null space of mtx_fri2amp
mtx_null_proj = np.eye(L) - np.dot(mtx_fri2amp_ri.T,
linalg.lstsq(mtx_fri2amp_ri.T, np.eye(L)))
G_updated = np.dot(mtx_amp2visi_ri, mtx_fri2amp_ri) + \
np.dot(mtx_fri2visi_ri, mtx_null_proj)
return G_updated ```
Example 8
 Project: gated-graph-transformer-network   Author: hexahedria   File: display_graph.py    License: MIT License 6 votes  ```def prep_graph_display(states, options={}):
clean_states = [x.tolist() for x in states]
nstr, nid, nstate, estr = states
flat_nid = nid.reshape([-1,nid.shape[-1]])
flat_estr = estr.reshape([-1,estr.shape[-1]])
flat_estr = flat_estr / (np.linalg.norm(flat_estr, axis=1, keepdims=True) + 1e-8)

num_unique_colors = nid.shape[-1] + estr.shape[-1]
id_denom = max(nid.shape[-1] - 1, 1)
id_project_mat = np.array([list(cm_rainbow(i/id_denom)[:3]) for i in range(0,nid.shape[-1])])
estr_denom = estr.shape[-1]
estr_project_mat = np.array([list(cm_rainbow((i+0.37)/estr_denom)[:3]) for i in range(estr.shape[-1])])
node_colors = np.dot(flat_nid, id_project_mat)
edge_colors = np.dot(flat_estr, estr_project_mat)

colormap = {
"node_id": node_colors.reshape(nid.shape[:-1] + (3,)).tolist(),
"edge_type": edge_colors.reshape(estr.shape[:-1] + (3,)).tolist(),
}

return json.dumps({
"states":clean_states,
"colormap":colormap,
"options":options
}) ```
Example 9
 Project: StructEngPy   Author: zhuoju36   File: dynamic.py    License: MIT License 6 votes  ```def Riz_mode(model:Model,n,F):
"""
Solve the Riz mode of the MDOF system\n
n: number of modes to extract\n
"""
#            alpha=np.array(mode).T
#            #Grum-Schmidt procedure
#            beta=[]
#            for i in range(len(mode)):
#                beta_i=alpha[i]
#                for j in range(i):
#                    beta_i-=np.dot(alpha[i],beta[j])/np.dot(alpha[j],alpha[j])*beta[j]
#                beta.append(beta_i)
#            mode_=np.array(beta).T
pass ```
Example 10
 Project: StructEngPy   Author: zhuoju36   File: dynamic.py    License: MIT License 6 votes  ```def spectrum_analysis(model,n,spec):
"""
sepctrum analysis

params:
n: number of modes to use\n
spec: a list of tuples (period,acceleration response)
"""
freq,mode=eigen_mode(model,n)
M_=np.dot(mode.T,model.M)
M_=np.dot(M_,mode)
K_=np.dot(mode.T,model.K)
K_=np.dot(K_,mode)
C_=np.dot(mode.T,model.C)
C_=np.dot(C_,mode)
d_=[]
for (m_,k_,c_) in zip(M_.diag(),K_.diag(),C_.diag()):
sdof=SDOFSystem(m_,k_)
T=sdof.omega_d()
d_.append(np.interp(T,spec,spec*m_))
d=np.dot(d_,mode)
#CQC
return d ```
Example 11
 Project: StructEngPy   Author: zhuoju36   File: __init__.py    License: MIT License 6 votes  ```def resolve_modal_displacement(self,node_id,k):
"""
resolve modal node displacement.

params:
node_id: int.
k: order of vibration mode.
return:
6-array of local nodal displacement.
"""
if not self.is_solved:
raise Exception('The model has to be solved first.')
if node_id in self.__nodes.keys():
node=self.__nodes[node_id]
T=node.transform_matrix
return T.dot(self.mode_[node_id*6:node_id*6+6,k-1]).reshape(6)
else:
raise Exception("The node doesn't exists.") ```
Example 12
 Project: StructEngPy   Author: zhuoju36   File: element.py    License: MIT License 6 votes  ```def _BtDB(self,s,r):
"""
dot product of B^T, D, B
params:
s,r:natural position of evalue point.2-array.
returns:
3x3 matrix.
"""
print(self._B(s,r).transpose(2,0,1).shape)
print(
np.matmul(
np.dot(self._B(s,r).T,self._D),
self._B(s,r).transpose(2,0,1)).shape
)
print(self._D.shape)

return np.matmul(np.dot(self._B(s,r).T,self._D),self._B(s,r).transpose(2,0,1)).transpose(1,2,0) ```
Example 13
 Project: StructEngPy   Author: zhuoju36   File: csys.py    License: MIT License 6 votes  ```def __init__(self,origin, pt1, pt2, name=None):
"""
origin: 3x1 vector
pt1: 3x1 vector
pt2: 3x1 vector
"""
self.__origin=origin
vec1 = np.array([pt1 - origin , pt1 - origin , pt1 - origin])
vec2 = np.array([pt2 - origin , pt2 - origin , pt2 - origin])
cos = np.dot(vec1, vec2)/np.linalg.norm(vec1)/np.linalg.norm(vec2)
if  cos == 1 or cos == -1:
raise Exception("Three points should not in a line!!")
self.__x = vec1/np.linalg.norm(vec1)
z = np.cross(vec1, vec2)
self.__z = z/np.linalg.norm(z)
self.__y = np.cross(self.z, self.x)
self.__name=uuid.uuid1() if name==None else name ```
Example 14
 Project: StructEngPy   Author: zhuoju36   File: csys.py    License: MIT License 6 votes  ```def set_by_3pts(self,origin, pt1, pt2):
"""
origin: tuple 3
pt1: tuple 3
pt2: tuple 3
"""
self.origin=origin
vec1 = np.array([pt1 - origin , pt1 - origin , pt1 - origin])
vec2 = np.array([pt2 - origin , pt2 - origin , pt2 - origin])
cos = np.dot(vec1, vec2)/np.linalg.norm(vec1)/np.linalg.norm(vec2)
if  cos == 1 or cos == -1:
raise Exception("Three points should not in a line!!")
self.x = vec1/np.linalg.norm(vec1)
z = np.cross(vec1, vec2)
self.z = z/np.linalg.norm(z)
self.y = np.cross(self.z, self.x) ```
Example 15
 Project: kalman_filter_multi_object_tracking   Author: srianant   File: kalman_filter.py    License: MIT License 6 votes  ```def predict(self):
"""Predict state vector u and variance of uncertainty P (covariance).
where,
u: previous state vector
P: previous covariance matrix
F: state transition matrix
Q: process noise matrix
Equations:
u'_{k|k-1} = Fu'_{k-1|k-1}
P_{k|k-1} = FP_{k-1|k-1} F.T + Q
where,
F.T is F transpose
Args:
None
Return:
vector of predicted state estimate
"""
# Predicted state estimate
self.u = np.round(np.dot(self.F, self.u))
# Predicted estimate covariance
self.P = np.dot(self.F, np.dot(self.P, self.F.T)) + self.Q
self.lastResult = self.u  # same last predicted result
return self.u ```
Example 16
 Project: deep-learning-note   Author: wdxtub   File: nn.py    License: MIT License 6 votes  ```def train(self, inputs_list, targets_list):
inputs = np.array(inputs_list, ndmin=2).T
targets = np.array(targets_list, ndmin=2).T

hidden_inputs = np.dot(self.wih, inputs)
hidden_outputs = self.activation_function(hidden_inputs)

final_inputs = np.dot(self.who, hidden_outputs)
final_outputs = self.activation_function(final_inputs)

output_errors = targets - final_outputs
hidden_errors = np.dot(self.who.T, output_errors)

self.who += self.lr * np.dot((output_errors *
final_outputs *
(1.0 - final_outputs)), np.transpose(hidden_outputs))
self.wih += self.lr * np.dot((hidden_errors *
hidden_outputs *
(1.0 - hidden_outputs)), np.transpose(inputs))

pass

# query ```
Example 17
 Project: svviz   Author: svviz   File: kde.py    License: MIT License 5 votes  ```def evaluate(self, points):
points = atleast_2d(points)

d, m = points.shape
if d != self.d:
if d == 1 and m == self.d:
# points was passed in as a row vector
points = reshape(points, (self.d, 1))
m = 1
else:
msg = "points have dimension %s, dataset has dimension %s" % (d,
self.d)
raise ValueError(msg)

result = zeros((m,), dtype=np.float)

if m >= self.n:
# there are more points than data, so loop over data
for i in range(self.n):
diff = self.dataset[:, i, newaxis] - points
tdiff = dot(self.inv_cov, diff)
energy = sum(diff*tdiff,axis=0) / 2.0
result = result + exp(-energy)
else:
# loop over points
for i in range(m):
diff = self.dataset - points[:, i, newaxis]
tdiff = dot(self.inv_cov, diff)
energy = sum(diff * tdiff, axis=0) / 2.0
result[i] = sum(exp(-energy), axis=0)

result = result / self._norm_factor

return result ```
Example 18
 Project: libTLDA   Author: wmkouw   File: util.py    License: MIT License 5 votes  ```def nullspace(A, atol=1e-13, rtol=0):
"""
Compute an approximate basis for the nullspace of A.

INPUT   (1) array 'A': 1-D array with length k will be treated
as a 2-D with shape (1, k).
(2) float 'atol': the absolute tolerance for a zero singular value.
Singular values smaller than `atol` are considered to be zero.
(3) float 'rtol': relative tolerance. Singular values less than
rtol*smax are considered to be zero, where smax is the largest
singular value.

If both `atol` and `rtol` are positive, the combined tolerance
is the maximum of the two; tol = max(atol, rtol * smax)
Singular values smaller than `tol` are considered to be zero.
OUTPUT  (1) array 'B': if A is an array with shape (m, k), then B will be
an array with shape (k, n), where n is the estimated dimension
of the nullspace of A.  The columns of B are a basis for the
nullspace; each element in np.dot(A, B) will be
approximately zero.
"""
# Expand A to a matrix
A = np.atleast_2d(A)

# Singular value decomposition
u, s, vh = al.svd(A)

# Set tolerance
tol = max(atol, rtol * s)

# Compute the number of non-zero entries
nnz = (s >= tol).sum()

# Conjugate and transpose to ensure real numbers
ns = vh[nnz:].conj().T

return ns ```
Example 19
 Project: libTLDA   Author: wmkouw   File: suba.py    License: MIT License 5 votes  ```def zca_whiten(self, X):
"""
Perform ZCA whitening (aka Mahalanobis whitening).

Parameters
----------
X : array (M samples x D features)
data matrix.

Returns
-------
X : array (M samples x D features)
whitened data.

"""
# Covariance matrix
Sigma = np.cov(X.T)

# Singular value decomposition
U, S, V = svd(Sigma)

# Whitening constant to prevent division by zero
epsilon = 1e-5

# ZCA whitening matrix
W = np.dot(U, np.dot(np.diag(1.0 / np.sqrt(S + epsilon)), V))

# Apply whitening matrix
return np.dot(X, W) ```
Example 20
 Project: libTLDA   Author: wmkouw   File: suba.py    License: MIT License 5 votes  ```def align_data(self, X, Z, CX, CZ, V):
"""
Align data to components and transform source.

Parameters
----------
X : array
source data set (N samples x D features)
Z : array
target data set (M samples x D features)
CX : array
source principal components (D features x d subspaces)
CZ : array
target principal component (D features x d subspaces)
V : array
transformation matrix (d subspaces x d subspaces)

Returns
-------
X : array
transformed source data (N samples x d subspaces)
Z : array
projected target data (M samples x d subspaces)

"""
# Map source data onto source principal components
XC = np.dot(X, CX)

# Align projected source data to target components
XV = np.dot(XC, V)

# Map target data onto target principal components
ZC = np.dot(Z, CZ)

return XV, ZC ```
Example 21
 Project: libTLDA   Author: wmkouw   File: suba.py    License: MIT License 5 votes  ```def reg_cov(self, X):
"""
Regularize covariance matrix until non-singular.

Parameters
----------
C : array
square symmetric covariance matrix.

Returns
-------
C : array
regularized covariance matrix.

"""
# Number of data points
N = X.shape

# Compute mean of data
muX = np.mean(X, axis=0, keepdims=1)

# Compute covariance matrix without regularization
SX = np.dot((X - muX).T, (X - muX)) / N

# Initialize regularization parameter
reg = 1e-6

# Keep going until non-singular
while not self.is_pos_def(SX):

# Compute covariance matrix with regularization
SX = np.dot((X - muX).T, (X - muX)) / N + reg*np.eye(X.shape)

# Increment reg
reg *= 10

# Report regularization
print('Final regularization parameter = {}'.format(reg))

return SX ```
Example 22
 Project: libTLDA   Author: wmkouw   File: flda.py    License: MIT License 5 votes  ```def predict(self, Z_):
"""
Make predictions on new dataset.

Parameters
----------
Z : array
new data set (M samples by D features)

Returns
-------
preds : array
label predictions (M samples by 1)

"""
# Data shape
M, D = Z_.shape

# If classifier is trained, check for same dimensionality
if self.is_trained:
if not self.train_data_dim == D:
raise ValueError('''Test data is of different dimensionality
than training data.''')

# Predict target labels
preds = np.argmax(np.dot(Z_, self.theta), axis=1)

# Map predictions back to labels
preds = self.classes[preds]

# Return predictions array
return preds ```
Example 23
 Project: libTLDA   Author: wmkouw   File: rba.py    License: MIT License 5 votes  ```def psi(self, X, theta, w, K=2):
"""
Compute psi function.

Parameters
----------
X : array
data set (N samples by D features)
theta : array
classifier parameters (D features by 1)
w : array
importance-weights (N samples by 1)
K : int
number of classes (def: 2)

Returns
-------
psi : array
array with psi function values (N samples by K classes)

"""
# Number of samples
N = X.shape

# Preallocate psi array
psi = np.zeros((N, K))

# Loop over classes
for k in range(K):
# Compute feature statistics
Xk = self.feature_stats(X, k*np.ones((N, 1)))

# Compute psi function
psi[:, k] = (w*np.dot(Xk, theta))[:, 0]

return psi ```
Example 24
 Project: libTLDA   Author: wmkouw   File: scl.py    License: MIT License 5 votes  ```def Huber_loss(self, theta, X, y, l2=0.0):
"""
Huber loss function.

Reference: Ando & Zhang (2005a). A framework for learning predictive
structures from multiple tasks and unlabeled data. JMLR.

Parameters
----------
theta : array
classifier parameters (D features by 1)
X : array
data (N samples by D features)
y : array
label vector (N samples by 1)
l2 : float
l2-regularization parameter (def= 0.0)

Returns
-------
array
Objective function value.

"""
# Precompute terms
Xy = (X.T*y.T).T
Xyt = np.dot(Xy, theta)

# Indices of discontinuity
ix = (Xyt >= -1)

# Loss function
return np.sum(np.clip(1 - Xyt[ix], 0, None)**2, axis=0) \
+ np.sum(-4*Xyt[~ix], axis=0) + l2*np.sum(theta**2, axis=0) ```
Example 25
 Project: libTLDA   Author: wmkouw   File: scl.py    License: MIT License 5 votes  ```def predict(self, Z):
"""
Make predictions on new dataset.

Parameters
----------
Z : array
new data set (M samples by D features)

Returns
-------
preds : array
label predictions (M samples by 1)

"""
# Data shape
M, D = Z.shape

# If classifier is trained, check for same dimensionality
if self.is_trained:
if not self.train_data_dim == D:
raise ValueError('''Test data is of different dimensionality
than training data.''')

# Check for augmentation
if not self.train_data_dim == D:
Z = np.concatenate((np.dot(Z, self.C), Z), axis=1)

# Call scikit's predict function
preds = self.clf.predict(Z)

# For quadratic loss function, correct predictions
preds = (np.sign(preds)+1)/2.

# Return predictions array
return preds ```
Example 26
 Project: libTLDA   Author: wmkouw   File: tca.py    License: MIT License 5 votes  ```def predict(self, Z):
"""
Make predictions on new dataset.

Parameters
----------
Z : array
new data set (M samples by D features)

Returns
-------
preds : array
label predictions (M samples by 1)

"""
# Data shape
M, D = Z.shape

# If classifier is trained, check for same dimensionality
if self.is_trained:
if not self.train_data_dim == D:
raise ValueError('''Test data is of different dimensionality
than training data.''')

# Compute kernel for new data
K = self.kernel(Z, self.XZ, type=self.kernel_type,
bandwidth=self.bandwidth, order=self.order)

# Map new data onto transfer components
Z = np.dot(K, self.C)

# Call scikit's predict function
preds = self.clf.predict(Z)

# For quadratic loss function, correct predictions
preds = (np.sign(preds)+1)/2.

# Return predictions array
return preds ```
Example 27
 Project: libTLDA   Author: wmkouw   File: test_suba.py    License: MIT License 5 votes  ```def test_subspace_alignment():
"""Test the alignment between datasets."""
X = rnd.randn(100, 10)
Z = np.dot(rnd.randn(100, 10), np.diag(np.arange(1, 11)))
clf = SubspaceAlignedClassifier()
V, CX, CZ = clf.subspace_alignment(X, Z, subspace_dim=3)
assert not np.any(np.isnan(V))
assert CX.shape == 3
assert CZ.shape == 3 ```
Example 28
 Project: libTLDA   Author: wmkouw   File: viz.py    License: MIT License 5 votes  ```def plotc(parameters, ax=[], color='k', gridsize=(101, 101)):
"""
Plot a linear classifier in a 2D scatterplot.

INPUT   (1) tuple 'parameters': consists of a list of class proportions
(1 by K classes), an array of class means (K classes by
D features), an array of class-covariance matrices (D features
by D features by K classes)
(2) object 'ax': axes of a pyplot figure or subject (def: empty)
(3) str 'colors': colors of the contours in the plot (def: 'k')
(4) tuple 'gridsize': number of points in the grid
(def: (101, 101))
OUTPUT  None
"""
# Check for figure object
if fig:
ax = fig.gca()
else:
fig, ax = plt.subplots()

# Get axes limits
xl = ax.get_xlim()
yl = ax.get_ylim()

# Define grid
gx = np.linspace(xl, xl, gridsize)
gy = np.linspace(yl, yl, gridsize)
x, y = np.meshgrid(gx, gy)
xy = np.vstack((x.ravel(), y.ravel())).T

# Values of grid
z = np.dot(xy, parameters[:-1, :]) + parameters[-1, :]
z = np.reshape(z[:, 0] - z[:, 1], gridsize)

# Plot grid
ax.contour(x, y, z, levels=0, colors=colors) ```
Example 29
 Project: xrft   Author: xgcm   File: test_xrft.py    License: MIT License 5 votes  ```def numpy_detrend(da):
"""
Detrend a 2D field by subtracting out the least-square plane fit.

Parameters
----------
da : `numpy.array`
The data to be detrended

Returns
-------
da : `numpy.array`
The detrended input data
"""
N = da.shape

G = np.ones((N*N,3))
for i in range(N):
G[N*i:N*i+N, 1] = i+1
G[N*i:N*i+N, 2] = np.arange(1, N+1)

d_obs = np.reshape(da.copy(), (N*N,1))
m_est = np.dot(np.dot(spl.inv(np.dot(G.T, G)), G.T), d_obs)
d_est = np.dot(G, m_est)

lin_trend = np.reshape(d_est, N)

return da - lin_trend ```
Example 30
 Project: FRIDA   Author: LCAV   File: point_cloud.py    License: MIT License 5 votes  ```def EDM(self):
''' Computes the EDM corresponding to the marker set '''
if self.X is None:
raise ValueError('No marker set')

G = np.dot(self.X.T, self.X)
return np.outer(np.ones(self.m), np.diag(G)) \
- 2*G + np.outer(np.diag(G), np.ones(self.m)) ```