# Python numpy.matrix() 使用实例

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 transformation_from_points(points1, points2):
points1 = points1.astype(np.float64)
points2 = points2.astype(np.float64)

c1 = np.mean(points1, axis=0)
c2 = np.mean(points2, axis=0)
points1 -= c1
points2 -= c2

s1 = np.std(points1)
s2 = np.std(points2)
points1 /= s1
points2 /= s2

U, S, Vt = np.linalg.svd(points1.T * points2)
R = (U * Vt).T

return np.vstack([np.hstack(((s2 / s1) * R,
c2.T - (s2 / s1) * R * c1.T)),
np.matrix([0., 0., 1.])]) ```

Example 2

```def KeyGen(n, m, k, d, q):
'''
input:
q : polynomial size prime number
n, m, k : dimensions specifiers
d : SIS parameter, hardest instances are where d ~ q^(n/m)

output:
Signing Key S :  Matrix of dimension mxk with coefficients in [-d.d]
Verification Key A : Matrix of dimension nxm with coefficients from [-(q-1)/2,(q-1)/2]
T : the matrix AS ,it is used in the Verification of the signature

'''
S = crypt_secure_matrix(d, m, k)
A = crypt_secure_matrix((q-1)/2, n, m)
T = np.matmul(A, S)
return S, A, T ```

Example 3

```def test_calculate_slopes_no_mask():
mat = np.matrix([[1, 5, 7, 0, 12, 14],
[12, 5, 7, 18, 0, 0],
[6, 2, 9, 17, 0, 5]])
tp = np.array([0, 5, 7, 11, 15, 19])
mask = np.array(['1', '1', '1', '1', '1', '1'])
true_res = np.matrix([[0.8, 1, -1.75, 3, 0.5],
[-1.4, 1, 2.75, -4.5, 0],
[-0.8, 3.5, 2, -4.25, 1.25]])
assert (res - true_res).sum() <= 10e-10

#def test_generate_STS_distance_matrix():
#    pass

#def sts_matrix_generator(ind, slope_matrix)
#def test_sts_matrix_generator():
#    pass

#def cluster_dbscan(dist_matrix, eps=1, distance_measure="sts")
#def test_cluster_dbscan():
#    pass

#def zscore(x) ```

Example 4

```def timeseriesdata_constructor_existing_file():
"""Tests the TimeSeriesData class constructor when the file exists. Tests
that the data are as expected, and that the filled data flag is set."""
tsd = TimeSeriesData("./tests/data/small.h5")
assert tsd.filled_data
#Validate that the time-series matrix data are correct
dat = np.matrix([[0, 2, 0, 0],
[2, 1, 3, 4],
[1, 1, 1, 1],
[0, 0, 1, 0]])
assert (dat == tsd.get_sparse_matrix().todense()).all()
assert (tsd.get_time_points() == [0, 4, 10, 12]).all()
sequence_ids = np.array([b'9247ec5fd33e99387d41e8fc0d7ee278',
b'7f97b4991342bf629966aeac0708c94f'])
assert (sequence_ids == tsd.get_array_by_chunks("genes/sequenceids")).all()
sample_names = np.array([b'72c', b'29', b'qpa', b'15'])
assert (sample_names == tsd.get_array_by_chunks("samples/names")).all()

# __del__(self)
#Test if HDF5 file closed ```

Example 5

```def gradientDescent(X, y, theta, alpha, iters):
temp = np.matrix(np.zeros(theta.shape))
params = int(theta.ravel().shape[1]) #flattens
cost = np.zeros(iters)

for i in range(iters):
err = (X * theta.T) - y

for j in range(params):
term = np.multiply(err, X[:,j])
temp[0, j] = theta[0, j] - ((alpha / len(X)) * np.sum(term))

theta = temp
cost[i] = computeCost(X, y, theta)

return theta, cost ```

Example 6

```def computeCost(X, y, theta):
inner = np.power(((X * theta.T) - y), 2)
return np.sum(inner) / (2 * len(X))

#def gradientDescent(X, y, theta, alpha, iters):
#    temp = np.matrix(np.zeros(theta.shape))
#    params = int(theta.ravel().shape[1]) #flattens
#    cost = np.zeros(iters)
#
#    for i in range(iters):
#        err = (X * theta.T) - y
#
#        for j in range(params):
#            term = np.multiply(err, X[:,j])
#            temp[0, j] = theta[0, j] - ((alpha / len(X)) * np.sum(term))
#
#        theta = temp
#        cost[i] = computeCost(X, y, theta)
#
#    return theta, cost ```

Example 7

```def adapt_z_state(self,main_rdd, cinfo,beta):
ainv = cinfo
def Updatez(tpl):
tt=[]
for ((tx,lam,state,z),index) in tpl:
random.setstate(state)
p = random.random()
state = random.getstate()
if p<self.ptr:
znew=float(-np.matrix(tx)*ainv*np.matrix(tx).T)
else:
znew=0.0
z=(1-beta)*z+beta*znew
tt.append(((tx,lam,state,z),index))
return tt
main_rdd = main_rdd.mapValues(Updatez).cache()
return main_rdd ```

Example 8

```def update_lam_z(self, main_rdd, cinfo,iStar,Gamma):
ainv = cinfo
def update(t, ainv):
p=[]
[tpl, gen] = t
for ((tx,lam,z),index) in tpl:
znew=0.0
if gen.random()<self.ptr:
znew=-(np.matrix(tx)*ainv*np.matrix(tx).T)[0,0]
else:
znew= 0.0
zupdtd = (1.0-self.beta)*z + self.beta*znew
if index != iStar:
lamupdt = (1-Gamma)*lam
else:
lamupdt = (1-Gamma)*lam +lam
p.append(((tx,lamupdt,zupdtd),index))
out = [p,gen]
return out

main_rdd = main_rdd.mapValues(lambda t:update(t,ainv)).persist()
return main_rdd ```

Example 9

```def update_lam_z(self, main_rdd, cinfo,iStar,Gamma):
ainv,ainv2 = cinfo
def update(t, ainv2):
p=[]
[tpl, gen] = t
for ((tx,lam,z),index) in tpl:
znew=0.0
if gen.random()<self.ptr:
znew=-(np.matrix(tx)*ainv2*np.matrix(tx).T)[0,0]
else:
znew= 0.0
zupdtd = (1.0-self.beta)*z + self.beta*znew
if index != iStar:
lamupdt = (1-Gamma)*lam
else:
lamupdt = (1-Gamma)*lam +lam
p.append(((tx,lamupdt,zupdtd),index))
out = [p,gen]
return out

main_rdd = main_rdd.mapValues(lambda t:update(t,ainv2)).persist()
return main_rdd ```

Example 10

```def update_comm_info(self,cinfo,iStar,mingrad,txmin,Gamma):
def UpdateAinv2(binv2,u,v,UVT,Denom,alpha,Xi):
return binv2-alpha*UVT/Denom-alpha*UVT.T/Denom+alpha**2*UVT*Xi*u.T/Denom**2
def UpdateAinv3(binv3,U1,U2,U3,D,Xi,Gamma):
return binv3-Gamma*U2*U2.T/D-Gamma*U1*U3.T/D-Gamma*U3*U1.T/D+Gamma**2*U1*U2.T*Xi*U2.T/D**2+Gamma**2*U2*U2.T*Xi*U1.T/D**2+Gamma**2*U1*U3.T*Xi*U1.T/D**2-Gamma**3*U1*U2.T*Xi*U2.T*Xi*U1.T/D**3
ainv,ainv2,ainv3=cinfo
binv=1.0/(1.0-Gamma)*ainv
binv2=1.0/(1.0-Gamma)**2*ainv2
binv3=1.0/(1.0-Gamma)**3*ainv3
u1=binv*np.matrix(txmin).T
u2=binv2*np.matrix(txmin).T
u3=binv3*np.matrix(txmin).T
UVT=u1*u2.T
Denom=1+Gamma*u1.T*np.matrix(txmin).T
ainv=rankOneInvUpdate(binv,Gamma*np.matrix(txmin).T,np.matrix(txmin).T)
ainv2=UpdateAinv2(binv2,u1,u2,UVT,Denom,Gamma,np.matrix(txmin).T)
ainv3=UpdateAinv3(binv3,u1,u2,u3,Denom,np.matrix(txmin).T,Gamma)
return ainv,ainv2,ainv3 ```

Example 11

```def compute_mingrad_l1(self,main_rdd,cinfo,K):
R = cinfo
def maxmin_l1(tpl1,tpl2):
(z1,x1,lam1,i1)=tpl1
(z2,x2,lam2,i2)=tpl2
zt = max(abs(z1),abs(z2))
if zt>abs(z2):
out = (z1,x1,lam1,i1)
else:
out = (z2,x2,lam2,i2)
return out

p=[]
for ((tx,lam),index) in tpl:
p.append(((np.matrix(tx)*R)[0,0],tx,lam,index))

return p

Example 12

```def update_lam_z(self, main_rdd, cinfo,iStar,Gamma):
R = cinfo
def update(t, R):
p=[]
[tpl, gen] = t
for ((tx,lam,z),index) in tpl:
znew=0.0
if gen.random()<self.ptr:
znew=(2*np.matrix(tx)*R)[0,0]
else:
znew= 0.0
zupdtd = (1.0-self.beta)*z + self.beta*znew
if index != iStar:
lamupdt = (1-Gamma)*lam
else:
lamupdt = (1-Gamma)*lam +lam
p.append(((tx,lamupdt,zupdtd),index))
out = [p,gen]
return out

main_rdd = main_rdd.mapValues(lambda t:update(t,R)).persist()
return main_rdd ```

Example 13

```def  gen_comm_info(self,main_rdd):
def cominfo(tpl):
p=[]
for ((tx,lam),index) in tpl:
p.append(np.matrix(tx).T*lam)
return p
def findDim(tpl):
for ((tx,lam),index) in tpl:
d = len(tx)
return d
d = main_rdd.mapValues(findDim).values().reduce(lambda x,y:x)
c=main_rdd.flatMapValues(cominfo).map(lambda (key,value):value).reduce(lambda x,y:x+y)
V=matrix(0.0,(d,1))
for j in range(d):
V[j]=math.exp(-self.C*self.r[j]*c[j,0])
return d,V ```

Example 14

```def computegap(self,cinfo,main_rdd,iStar,mingrad,lambdaMin):
d,V = cinfo
z=matrix(0.0,(d,1))
vSum=float(np.sum(V))
for j in range(d):
z[j]=-V[j]*self.C*self.r[j]/vSum
p=[]
for ((tx,lam),index) in tpl:
if index!=iStar:
p.append((np.matrix(tx)*np.matrix(z))[0,0]*lam)
else:
return p
return gap ```

Example 15

```def get_landmarks(self,im,fname,n=2):
'''
??????????????????????????????
im:
???numpy??
fname:
????????
???:
????(x,y)?????
'''
rects = self.detector(im, 1)

if len(rects) >=5:
raise TooManyFaces('Too many faces in '+fname)
if len(rects) <2:
raise NoFace('No enough face in' +fname)
return [np.matrix([[p.x, p.y] for p in self.predictor(im, rect).parts()]) for rect in rects] ```

Example 16

```def get_landmarks(self,im,fname,n=1):
'''
??????????????????????????????
im:
???numpy??
fname:
????????
???:
????(x,y)?????
'''
rects = self.detector(im, 1)

if len(rects) > n:
raise TooManyFaces('No face in '+fname)
if len(rects) < 0:
raise NoFace('Too many faces in '+fname)
return np.matrix([[p.x, p.y] for p in self.predictor(im, rects[0]).parts()]) ```

Example 17

```def __init__(self, originFilename):
self._originFilename = originFilename
if originFilename is None:
self._name = 'None'
else:
self._name = os.path.basename(originFilename)
if '.' in self._name:
self._name = os.path.splitext(self._name)[0]
self._meshList = []
self._position = numpy.array([0.0, 0.0])
self._matrix = numpy.matrix([[1,0,0],[0,1,0],[0,0,1]], numpy.float64)
self._transformedMin = None
self._transformedMax = None
self._transformedSize = None
self._boundaryCircleSize = None
self._drawOffset = None
self._boundaryHull = None
self._printAreaExtend = numpy.array([[-1,-1],[ 1,-1],[ 1, 1],[-1, 1]], numpy.float32)
self._headAreaExtend = numpy.array([[-1,-1],[ 1,-1],[ 1, 1],[-1, 1]], numpy.float32)
self._printAreaHull = None

Example 18

```def test_iter_allocate_output_subtype():
# Make sure that the subtype with priority wins

# matrix vs ndarray
a = np.matrix([[1, 2], [3, 4]])
b = np.arange(4).reshape(2, 2).T
i = nditer([a, b, None], [],
assert_equal(type(a), type(i.operands[2]))
assert_(type(b) != type(i.operands[2]))
assert_equal(i.operands[2].shape, (2, 2))

# matrix always wants things to be 2D
b = np.arange(4).reshape(1, 2, 2)
assert_raises(RuntimeError, nditer, [a, b, None], [],
# but if subtypes are disabled, the result can still work
i = nditer([a, b, None], [],
assert_equal(type(b), type(i.operands[2]))
assert_(type(a) != type(i.operands[2]))
assert_equal(i.operands[2].shape, (1, 2, 2)) ```

Example 19

```def test_shapes(self):
dims = [
((1, 1), (2, 1, 1)),     # broadcast first argument
((2, 1, 1), (1, 1)),     # broadcast second argument
((2, 1, 1), (2, 1, 1)),  # matrix stack sizes match
]

for dt, (dm1, dm2) in itertools.product(self.types, dims):
a = np.ones(dm1, dtype=dt)
b = np.ones(dm2, dtype=dt)
res = self.matmul(a, b)
assert_(res.shape == (2, 1, 1))

# vector vector returns scalars.
for dt in self.types:
a = np.ones((2,), dtype=dt)
b = np.ones((2,), dtype=dt)
c = self.matmul(a, b)
assert_(np.array(c).shape == ()) ```

Example 20

```def test_inner_product_with_various_contiguities(self):
# github issue 6532
for dt in np.typecodes['AllInteger'] + np.typecodes['AllFloat'] + '?':
# check an inner product involving a matrix transpose
A = np.array([[1, 2], [3, 4]], dtype=dt)
B = np.array([[1, 3], [2, 4]], dtype=dt)
C = np.array([1, 1], dtype=dt)
desired = np.array([4, 6], dtype=dt)
assert_equal(np.inner(A.T, C), desired)
assert_equal(np.inner(C, A.T), desired)
assert_equal(np.inner(B, C), desired)
assert_equal(np.inner(C, B), desired)
# check a matrix product
desired = np.array([[7, 10], [15, 22]], dtype=dt)
assert_equal(np.inner(A, B), desired)
# check the syrk vs. gemm paths
desired = np.array([[5, 11], [11, 25]], dtype=dt)
assert_equal(np.inner(A, A), desired)
assert_equal(np.inner(A, A.copy()), desired)
# check an inner product involving an aliased and reversed view
a = np.arange(5).astype(dt)
b = a[::-1]
desired = np.array(10, dtype=dt).item()
assert_equal(np.inner(b, a), desired) ```

Example 21

```def test_basic(self):
y1 = np.array([1, 2, 3])
assert_(average(y1, axis=0) == 2.)
y2 = np.array([1., 2., 3.])
assert_(average(y2, axis=0) == 2.)
y3 = [0., 0., 0.]
assert_(average(y3, axis=0) == 0.)

y4 = np.ones((4, 4))
y4[0, 1] = 0
y4[1, 0] = 2
assert_almost_equal(y4.mean(0), average(y4, 0))
assert_almost_equal(y4.mean(1), average(y4, 1))

y5 = rand(5, 5)
assert_almost_equal(y5.mean(0), average(y5, 0))
assert_almost_equal(y5.mean(1), average(y5, 1))

y6 = np.matrix(rand(5, 5))
assert_array_equal(y6.mean(0), average(y6, 0)) ```

Example 22

```def test_return_type(self):
a = np.ones([2, 2])
m = np.asmatrix(a)
assert_equal(type(kron(a, a)), np.ndarray)
assert_equal(type(kron(m, m)), np.matrix)
assert_equal(type(kron(a, m)), np.matrix)
assert_equal(type(kron(m, a)), np.matrix)

class myarray(np.ndarray):
__array_priority__ = 0.0

ma = myarray(a.shape, a.dtype, a.data)
assert_equal(type(kron(a, a)), np.ndarray)
assert_equal(type(kron(ma, ma)), myarray)
assert_equal(type(kron(a, ma)), np.ndarray)
assert_equal(type(kron(ma, a)), myarray) ```

Example 23

```def test_allany_onmatrices(self):
x = np.array([[0.13, 0.26, 0.90],
[0.28, 0.33, 0.63],
[0.31, 0.87, 0.70]])
X = np.matrix(x)
m = np.array([[True, False, False],
[False, False, False],
[True, True, False]], dtype=np.bool_)
mXbig = (mX > 0.5)
mXsmall = (mX < 0.5)

self.assertFalse(mXbig.all())
self.assertTrue(mXbig.any())
assert_equal(mXbig.all(0), np.matrix([False, False, True]))
assert_equal(mXbig.all(1), np.matrix([False, False, True]).T)
assert_equal(mXbig.any(0), np.matrix([False, False, True]))
assert_equal(mXbig.any(1), np.matrix([True, True, True]).T)

self.assertFalse(mXsmall.all())
self.assertTrue(mXsmall.any())
assert_equal(mXsmall.all(0), np.matrix([True, True, False]))
assert_equal(mXsmall.all(1), np.matrix([False, False, False]).T)
assert_equal(mXsmall.any(0), np.matrix([True, True, False]))
assert_equal(mXsmall.any(1), np.matrix([True, True, False]).T) ```

Example 24

```def test_compressed(self):
# Tests compressed
a = array([1, 2, 3, 4], mask=[0, 0, 0, 0])
b = a.compressed()
assert_equal(b, a)
b = a.compressed()
assert_equal(b, [2, 3, 4])

a = array(np.matrix([1, 2, 3, 4]), mask=[0, 0, 0, 0])
b = a.compressed()
assert_equal(b, a)
self.assertTrue(isinstance(b, np.matrix))
b = a.compressed()
assert_equal(b, [[2, 3, 4]]) ```

Example 25

```def test_ravel(self):
# Tests ravel
a = array([[1, 2, 3, 4, 5]], mask=[[0, 1, 0, 0, 0]])
aravel = a.ravel()
a = array([0, 0], mask=[1, 1])
aravel = a.ravel()
a = array(np.matrix([1, 2, 3, 4, 5]), mask=[[0, 1, 0, 0, 0]])
aravel = a.ravel()
assert_equal(aravel.shape, (1, 5))
# Checks that small_mask is preserved
a = array([1, 2, 3, 4], mask=[0, 0, 0, 0], shrink=False)
# Test that the fill_value is preserved
a.fill_value = -99
a.shape = (2, 2)
ar = a.ravel()
assert_equal(ar._data, [1, 2, 3, 4])
assert_equal(ar.fill_value, -99)
# Test index ordering
assert_equal(a.ravel(order='C'), [1, 2, 3, 4])
assert_equal(a.ravel(order='F'), [1, 3, 2, 4]) ```

Example 26

```def test_view(self):
# Test view w/ flexible dtype
iterator = list(zip(np.arange(10), np.random.rand(10)))
data = np.array(iterator)
a = array(iterator, dtype=[('a', float), ('b', float)])
controlmask = np.array([1] + 19 * [0], dtype=bool)
# Transform globally to simple dtype
test = a.view(float)
assert_equal(test, data.ravel())
# Transform globally to dty
test = a.view((float, 2))
assert_equal(test, data)

test = a.view((float, 2), np.matrix)
assert_equal(test, data)
self.assertTrue(isinstance(test, np.matrix)) ```

Example 27

```def dot_generalized(a, b):
a = asarray(a)
if a.ndim >= 3:
if a.ndim == b.ndim:
# matrix x matrix
new_shape = a.shape[:-1] + b.shape[-1:]
elif a.ndim == b.ndim + 1:
# matrix x vector
new_shape = a.shape[:-1]
else:
raise ValueError("Not implemented...")
r = np.empty(new_shape, dtype=np.common_type(a, b))
for c in itertools.product(*map(range, a.shape[:-2])):
r[c] = dot(a[c], b[c])
return r
else:
return dot(a, b) ```

Example 28

```def do(self, a, b):
arr = np.asarray(a)
m, n = arr.shape
u, s, vt = linalg.svd(a, 0)
x, residuals, rank, sv = linalg.lstsq(a, b)
if m <= n:
assert_almost_equal(b, dot(a, x))
assert_equal(rank, m)
else:
assert_equal(rank, n)
assert_almost_equal(sv, sv.__array_wrap__(s))
if rank == n and m > n:
expect_resids = (
np.asarray(abs(np.dot(a, x) - b)) ** 2).sum(axis=0)
expect_resids = np.asarray(expect_resids)
if len(np.asarray(b).shape) == 1:
expect_resids.shape = (1,)
assert_equal(residuals.shape, expect_resids.shape)
else:
expect_resids = np.array([]).view(type(x))
assert_almost_equal(residuals, expect_resids)
assert_(np.issubdtype(residuals.dtype, np.floating))
assert_(imply(isinstance(b, matrix), isinstance(x, matrix)))
assert_(imply(isinstance(b, matrix), isinstance(residuals, matrix))) ```

Example 29

```def test_bad_args(self):
# Check that bad arguments raise the appropriate exceptions.

A = array([[1, 2, 3], [4, 5, 6]], dtype=self.dt)
B = np.arange(1, 25, dtype=self.dt).reshape(2, 3, 4)

# Using `axis=<integer>` or passing in a 1-D array implies vector
# norms are being computed, so also using `ord='fro'`
# or `ord='nuc'` raises a ValueError.
assert_raises(ValueError, norm, A, 'fro', 0)
assert_raises(ValueError, norm, A, 'nuc', 0)
assert_raises(ValueError, norm, [3, 4], 'fro', None)
assert_raises(ValueError, norm, [3, 4], 'nuc', None)

# Similarly, norm should raise an exception when ord is any finite
# number other than 1, 2, -1 or -2 when computing matrix norms.
for order in [0, 3]:
assert_raises(ValueError, norm, A, order, None)
assert_raises(ValueError, norm, A, order, (0, 1))
assert_raises(ValueError, norm, B, order, (1, 2))

# Invalid axis
assert_raises(ValueError, norm, B, None, 3)
assert_raises(ValueError, norm, B, None, (2, 3))
assert_raises(ValueError, norm, B, None, (0, 1, 2)) ```

Example 30

```def test_matrix_rank(self):
# Full rank matrix
yield assert_equal, 4, matrix_rank(np.eye(4))
# rank deficient matrix
I = np.eye(4)
I[-1, -1] = 0.
yield assert_equal, matrix_rank(I), 3
# All zeros - zero rank
yield assert_equal, matrix_rank(np.zeros((4, 4))), 0
# 1 dimension - rank 1 unless all 0
yield assert_equal, matrix_rank([1, 0, 0, 0]), 1
yield assert_equal, matrix_rank(np.zeros((4,))), 0
# accepts array-like
yield assert_equal, matrix_rank([1]), 1
# greater than 2 dimensions raises error
yield assert_raises, TypeError, matrix_rank, np.zeros((2, 2, 2))
# works on scalar
yield assert_equal, matrix_rank(1), 1 ```

Example 31

```def test_mode_all_but_economic(self):
a = array([[1, 2], [3, 4]])
b = array([[1, 2], [3, 4], [5, 6]])
for dt in "fd":
m1 = a.astype(dt)
m2 = b.astype(dt)
self.check_qr(m1)
self.check_qr(m2)
self.check_qr(m2.T)
self.check_qr(matrix(m1))
for dt in "fd":
m1 = 1 + 1j * a.astype(dt)
m2 = 1 + 1j * b.astype(dt)
self.check_qr(m1)
self.check_qr(m2)
self.check_qr(m2.T)
self.check_qr(matrix(m1)) ```

Example 32

```def test_basic(self):
A = np.array([[1, 2], [3, 4]])
mA = matrix(A)
assert_(np.all(mA.A == A))

B = bmat("A,A;A,A")
C = bmat([[A, A], [A, A]])
D = np.array([[1, 2, 1, 2],
[3, 4, 3, 4],
[1, 2, 1, 2],
[3, 4, 3, 4]])
assert_(np.all(B.A == D))
assert_(np.all(C.A == D))

E = np.array([[5, 6], [7, 8]])
AEresult = matrix([[1, 2, 5, 6], [3, 4, 7, 8]])
assert_(np.all(bmat([A, E]) == AEresult))

vec = np.arange(5)
mvec = matrix(vec)
assert_(mvec.shape == (1, 5)) ```

Example 33

```def test_sum(self):
"""Test whether matrix.sum(axis=1) preserves orientation.
Fails in NumPy <= 0.9.6.2127.
"""
M = matrix([[1, 2, 0, 0],
[3, 4, 0, 0],
[1, 2, 1, 2],
[3, 4, 3, 4]])
sum0 = matrix([8, 12, 4, 6])
sum1 = matrix([3, 7, 6, 14]).T
sumall = 30
assert_array_equal(sum0, M.sum(axis=0))
assert_array_equal(sum1, M.sum(axis=1))
assert_equal(sumall, M.sum())

assert_array_equal(sum0, np.sum(M, axis=0))
assert_array_equal(sum1, np.sum(M, axis=1))
assert_equal(sumall, np.sum(M)) ```

Example 34

```def test_basic(self):
import numpy.linalg as linalg

A = np.array([[1., 2.],
[3., 4.]])
mA = matrix(A)
assert_(np.allclose(linalg.inv(A), mA.I))
assert_(np.all(np.array(np.transpose(A) == mA.T)))
assert_(np.all(np.array(np.transpose(A) == mA.H)))
assert_(np.all(A == mA.A))

B = A + 2j*A
mB = matrix(B)
assert_(np.allclose(linalg.inv(B), mB.I))
assert_(np.all(np.array(np.transpose(B) == mB.T)))
assert_(np.all(np.array(np.transpose(B).conj() == mB.H))) ```

Example 35

```def skew(v):
return np.matrix([[0,-v[2,0],v[1,0]], [v[2,0],0,-v[0,0]], [-v[1,0],v[0,0],0]]) ```

Example 36

```def vector3(x, y, z):
return np.matrix([[x],[y],[z]]) ```

Example 37

```def vector6(a, b, c, x, y, z):
return np.matrix([[a],[b],[c],[x],[y],[z]]) ```

Example 38

```def col(v):
col = [[x] for x in v]
return np.matrix(col) ```

Example 39

```def build_2D_cov_matrix(sigmax,sigmay,angle,verbose=True):
"""
Build a covariance matrix for a 2D multivariate Gaussian

--- INPUT ---
sigmax          Standard deviation of the x-compoent of the multivariate Gaussian
sigmay          Standard deviation of the y-compoent of the multivariate Gaussian
angle           Angle to rotate matrix by in degrees (clockwise) to populate covariance cross terms
verbose         Toggle verbosity
--- EXAMPLE OF USE ---
import tdose_utilities as tu
covmatrix = tu.build_2D_cov_matrix(3,1,35)

"""
if verbose: print ' - Build 2D covariance matrix with varinaces (x,y)=('+str(sigmax)+','+str(sigmay)+\
') and then rotated '+str(angle)+' degrees'
cov_orig      = np.zeros([2,2])
cov_orig[0,0] = sigmay**2.0
cov_orig[1,1] = sigmax**2.0

angle_rad     = (180.0-angle) * np.pi/180.0 # The (90-angle) makes sure the same convention as DS9 is used
rotmatrix     = np.matrix([[c, -s], [s, c]])

cov_rot       = np.dot(np.dot(rotmatrix,cov_orig),np.transpose(rotmatrix))  # performing rot * cov * rot^T

return cov_rot
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ```

Example 40

```def normalize_2D_cov_matrix(covmatrix,verbose=True):
"""
Calculate the normalization foctor for a multivariate gaussian from it's covariance matrix
However, not that gaussian returned by tu.gen_2Dgauss() is normalized for scale=1

--- INPUT ---
covmatrix       covariance matrix to normaliz
verbose         Toggle verbosity

"""
detcov  = np.linalg.det(covmatrix)
normfac = 1.0 / (2.0 * np.pi * np.sqrt(detcov) )

return normfac
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ```

Example 41

```def analytic_convolution_gaussian(mu1,covar1,mu2,covar2):
"""
The analytic vconvolution of two Gaussians is simply the sum of the two mean vectors
and the two convariance matrixes

--- INPUT ---
mu1         The mean of the first gaussian
covar1      The covariance matrix of of the first gaussian
mu2         The mean of the second gaussian
covar2      The covariance matrix of of the second gaussian

"""
muconv    = mu1+mu2
covarconv = covar1+covar2
return muconv, covarconv

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ```

Example 42

```def get_facial_landmarks_from_mask(img, pts):
rect = cv2.boundingRect(pts)
rect = dlib.rectangle(rect[0], rect[1], rect[0] + rect[2], rect[1] + rect[3])
return np.matrix([list(pt) for pt in pts]), rect ```

Example 43

```def get_facial_landmarks(img):
# No need to upsample
rects = face_detector(img, 0)

if len(rects) == 0:
print "No faces"
return None

rect = rects[0]
shape = shape_predictor(img, rect)
return np.matrix([[pt.x, pt.y] for pt in shape.parts()]), rect ```

Example 44

```def get_tm_opp(pts1, pts2):
# Transformation matrix - ( Translation + Scaling + Rotation )
# using Procuster analysis
pts1 = np.float64(pts1)
pts2 = np.float64(pts2)

m1 = np.mean(pts1, axis = 0)
m2 = np.mean(pts2, axis = 0)

# Removing translation
pts1 -= m1
pts2 -= m2

std1 = np.std(pts1)
std2 = np.std(pts2)
std_r = std2/std1

# Removing scaling
pts1 /= std1
pts2 /= std2

U, S, V = np.linalg.svd(np.transpose(pts1) * pts2)

# Finding the rotation matrix
R = np.transpose(U * V)

return np.vstack([np.hstack((std_r * R,
np.transpose(m2) - std_r * R * np.transpose(m1))), np.matrix([0.0, 0.0, 1.0])]) ```

Example 45

```def as_float_array(X, copy=True, force_all_finite=True):
"""Converts an array-like to an array of floats
The new dtype will be np.float32 or np.float64, depending on the original
type. The function can create a copy or modify the argument depending
on the argument copy.
Parameters
----------
X : {array-like, sparse matrix}
copy : bool, optional
If True, a copy of X will be created. If False, a copy may still be
returned if X's dtype is not a floating point type.
force_all_finite : boolean (default=True)
Whether to raise an error on np.inf and np.nan in X.
Returns
-------
XT : {array, sparse matrix}
An array of type np.float
"""
if isinstance(X, np.matrix) or (not isinstance(X, np.ndarray)
and not sp.issparse(X)):
return check_array(X, ['csr', 'csc', 'coo'], dtype=np.float64,
copy=copy, force_all_finite=force_all_finite,
ensure_2d=False)
elif sp.issparse(X) and X.dtype in [np.float32, np.float64]:
return X.copy() if copy else X
elif X.dtype in [np.float32, np.float64]:  # is numpy array
return X.copy('F' if X.flags['F_CONTIGUOUS'] else 'C') if copy else X
else:
return X.astype(np.float32 if X.dtype == np.int32 else np.float64) ```

Example 46

```def get_precision(self):
"""Compute data precision matrix with the generative model.
Equals the inverse of the covariance but computed with
the matrix inversion lemma for efficiency.
Returns
-------
precision : array, shape=(n_features, n_features)
Estimated precision of data.
"""
n_features = self.components_.shape[1]

# handle corner cases first
if self.n_components_ == 0:
return np.eye(n_features) / self.noise_variance_
if self.n_components_ == n_features:
return linalg.inv(self.get_covariance())

# Get precision using matrix inversion lemma
components_ = self.components_
exp_var = self.explained_variance_
exp_var_diff = np.maximum(exp_var - self.noise_variance_, 0.)
precision = np.dot(components_, components_.T) / self.noise_variance_
precision.flat[::len(precision) + 1] += 1. / exp_var_diff
precision = np.dot(components_.T,
np.dot(linalg.inv(precision), components_))
precision /= -(self.noise_variance_ ** 2)
precision.flat[::len(precision) + 1] += 1. / self.noise_variance_
return precision ```

Example 47

```def diffD1D2(Flags):
# To check if the difference between D1 and D2 amplifies downstream
# First decide which model to use
delay = 1
if Flags == "Allsym":
(d1,d2,fsi,ti,ta,stn,gpi,ipctx,A,B,params) = calcRates(Flags,delay)
# D = Direct pathway, ID = Indirect pathway, HD = Hyperdirect pathway
# Reducing a full recurrent matrix leads to postive and negative contributions in ID and HD instead of pure just positive contributions
D = params['gpid1']
print "Direct",D

de1 = 1. + (params['d1d1']*params['fsifsi']) - (params['stnti']*params['stnstn'])
Ex1 = (params['stnti']*params['d1d1']*params['fsifsi']*params['gpistn'])/de1
Ex2 = (params['gpid1']*params['stnstn']*params['d1ta']*params['fsifsi'])/de1
IDpos = params['stnti']*params['tid2']*(params['d1ta']*params['gpid1']*params['tistn']+ Ex1 + Ex2)

print "IDpos",IDpos

Ex3 = (params['d1ta']+params['d1ta']*params['tata']+((params['stnta']*params['fsiti']*params['d1fsi'])/de1))
IDneg = params['gpid1']+params['gpiti']*params['tid2']+params['gpid1']*params['stnstn']*params['tid2']*Ex3
print "IDneg",IDneg

HDpos = (params['jstnctx']*params['gpid1']*params['stnstn']*params['fsiti']*params['d1fsi'])/de1
print "HDpos",HDpos
Ex4 = params['jstnctx']*params['d1d1']*params['fsifsi']*params['stnti']*params['gpistn']
Ex5 = params['jstnctx']*params['gpid1']*params['stnstn']*params['d1ta']*params['fsifsi']
HDneg = (Ex4 + Ex5)/de1
print "HDneg",HDneg

d1fix = np.mean(d1[:-10])
d2fix = np.mean(d2[:-10])
DelMSN = d1fix - d2fix
DelGpi = (D*d1fix) + ((IDpos - IDneg)*d2fix)

return (DelMSN,DelGpi) ```

Example 48

```def diffD1D2(Flags):
# To check if the difference between D1 and D2 amplifies downstream
# First decide which model to use
delay = 1
if Flags == "Allsym":
(d1,d2,fsi,ti,ta,stn,gpi,ipctx,A,B,params) = calcRates(Flags,delay)
# D = Direct pathway, ID = Indirect pathway, HD = Hyperdirect pathway
# Reducing a full recurrent matrix leads to postive and negative contributions in ID and HD instead of pure just positive contributions
D = params['gpid1']
print "Direct",D

de1 = 1. + (params['d1d1']*params['fsifsi']) - (params['stnti']*params['stnstn'])
Ex1 = (params['stnti']*params['d1d1']*params['fsifsi']*params['gpistn'])/de1
Ex2 = (params['gpid1']*params['stnstn']*params['d1ta']*params['fsifsi'])/de1
IDpos = params['stnti']*params['tid2']*(params['d1ta']*params['gpid1']*params['tistn']+ Ex1 + Ex2)

print "IDpos",IDpos

Ex3 = (params['d1ta']+params['d1ta']*params['tata']+((params['stnta']*params['fsiti']*params['d1fsi'])/de1))
IDneg = params['gpid1']+params['gpiti']*params['tid2']+params['gpid1']*params['stnstn']*params['tid2']*Ex3
print "IDneg",IDneg

HDpos = (params['jstnctx']*params['gpid1']*params['stnstn']*params['fsiti']*params['d1fsi'])/de1
print "HDpos",HDpos
Ex4 = params['jstnctx']*params['d1d1']*params['fsifsi']*params['stnti']*params['gpistn']
Ex5 = params['jstnctx']*params['gpid1']*params['stnstn']*params['d1ta']*params['fsifsi']
HDneg = (Ex4 + Ex5)/de1
print "HDneg",HDneg

d1fix = np.mean(d1[:-10])
d2fix = np.mean(d2[:-10])
DelMSN = d1fix - d2fix
DelGpi = (D*d1fix) + ((IDpos - IDneg)*d2fix)

return (DelMSN,DelGpi) ```

Example 49

```def diffD1D2(Flags):
# To check if the difference between D1 and D2 amplifies downstream
# First decide which model to use
delay = 1
if Flags == "Allsym":
(d1,d2,fsi,ti,ta,stn,gpi,ipctx,A,B,params) = calcRates(Flags,delay)
# D = Direct pathway, ID = Indirect pathway, HD = Hyperdirect pathway
# Reducing a full recurrent matrix leads to postive and negative contributions in ID and HD instead of pure just positive contributions
D = params['gpid1']
print "Direct",D

de1 = 1. + (params['d1d1']*params['fsifsi']) - (params['stnti']*params['stnstn'])
Ex1 = (params['stnti']*params['d1d1']*params['fsifsi']*params['gpistn'])/de1
Ex2 = (params['gpid1']*params['stnstn']*params['d1ta']*params['fsifsi'])/de1
IDpos = params['stnti']*params['tid2']*(params['d1ta']*params['gpid1']*params['tistn']+ Ex1 + Ex2)

print "IDpos",IDpos

Ex3 = (params['d1ta']+params['d1ta']*params['tata']+((params['stnta']*params['fsiti']*params['d1fsi'])/de1))
IDneg = params['gpid1']+params['gpiti']*params['tid2']+params['gpid1']*params['stnstn']*params['tid2']*Ex3
print "IDneg",IDneg

HDpos = (params['jstnctx']*params['gpid1']*params['stnstn']*params['fsiti']*params['d1fsi'])/de1
print "HDpos",HDpos
Ex4 = params['jstnctx']*params['d1d1']*params['fsifsi']*params['stnti']*params['gpistn']
Ex5 = params['jstnctx']*params['gpid1']*params['stnstn']*params['d1ta']*params['fsifsi']
HDneg = (Ex4 + Ex5)/de1
print "HDneg",HDneg

d1fix = np.mean(d1[:-10])
d2fix = np.mean(d2[:-10])
DelMSN = d1fix - d2fix
DelGpi = (D*d1fix) + ((IDpos - IDneg)*d2fix)

return (DelMSN,DelGpi) ```

Example 50

```def diffD1D2(Flags):
# To check if the difference between D1 and D2 amplifies downstream
# First decide which model to use
delay = 1
if Flags == "Allsym":
(d1,d2,fsi,ti,ta,stn,gpi,ipctx,A,B,params) = calcRates(Flags,delay)
# D = Direct pathway, ID = Indirect pathway, HD = Hyperdirect pathway
# Reducing a full recurrent matrix leads to postive and negative contributions in ID and HD instead of pure just positive contributions
D = params['gpid1']
print "Direct",D

de1 = 1. + (params['d1d1']*params['fsifsi']) - (params['stnti']*params['stnstn'])
Ex1 = (params['stnti']*params['d1d1']*params['fsifsi']*params['gpistn'])/de1
Ex2 = (params['gpid1']*params['stnstn']*params['d1ta']*params['fsifsi'])/de1
IDpos = params['stnti']*params['tid2']*(params['d1ta']*params['gpid1']*params['tistn']+ Ex1 + Ex2)

print "IDpos",IDpos

Ex3 = (params['d1ta']+params['d1ta']*params['tata']+((params['stnta']*params['fsiti']*params['d1fsi'])/de1))
IDneg = params['gpid1']+params['gpiti']*params['tid2']+params['gpid1']*params['stnstn']*params['tid2']*Ex3
print "IDneg",IDneg

HDpos = (params['jstnctx']*params['gpid1']*params['stnstn']*params['fsiti']*params['d1fsi'])/de1
print "HDpos",HDpos
Ex4 = params['jstnctx']*params['d1d1']*params['fsifsi']*params['stnti']*params['gpistn']
Ex5 = params['jstnctx']*params['gpid1']*params['stnstn']*params['d1ta']*params['fsifsi']
HDneg = (Ex4 + Ex5)/de1
print "HDneg",HDneg

d1fix = np.mean(d1[:-10])
d2fix = np.mean(d2[:-10])
DelMSN = d1fix - d2fix
DelGpi = (D*d1fix) + ((IDpos - IDneg)*d2fix)

return (DelMSN,DelGpi) ```