# Python numpy.dot() Examples

The following are 30 code examples of numpy.dot(). 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 also want to check out all available functions/classes of the module , or try the search function .
Example #1
 Source File: NLP.py    From Financial-NLP with Apache License 2.0 7 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
 Source File: point_cloud.py    From FRIDA with 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
 Source File: point_cloud.py    From FRIDA with 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
 Source File: generators.py    From FRIDA with 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
 Source File: doa.py    From FRIDA with 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
 Source File: tools_fri_doa_plane.py    From FRIDA with 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
 Source File: tools_fri_doa_plane.py    From FRIDA with 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
 Source File: display_graph.py    From gated-graph-transformer-network with 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
 Source File: dynamic.py    From StructEngPy with 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
 Source File: dynamic.py    From StructEngPy with 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
 Source File: __init__.py    From StructEngPy with 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
 Source File: element.py    From StructEngPy with 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
 Source File: csys.py    From StructEngPy with 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
 Source File: csys.py    From StructEngPy with 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
 Source File: kalman_filter.py    From kalman_filter_multi_object_tracking with 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
 Source File: nn.py    From deep-learning-note with 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
 Source File: kde.py    From svviz with 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
 Source File: util.py    From libTLDA with 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
 Source File: suba.py    From libTLDA with 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
 Source File: suba.py    From libTLDA with 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
 Source File: suba.py    From libTLDA with 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
 Source File: flda.py    From libTLDA with 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
 Source File: rba.py    From libTLDA with 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
 Source File: scl.py    From libTLDA with 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
 Source File: scl.py    From libTLDA with 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
 Source File: tca.py    From libTLDA with 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
 Source File: test_suba.py    From libTLDA with 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
 Source File: viz.py    From libTLDA with 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
 Source File: test_xrft.py    From xrft with 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
 Source File: point_cloud.py    From FRIDA with 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)) ```