```
A = np.matrix(np.random.random((2,2)))

B = np.asmatrix(b)

C = np.mat(np.random.random((10,5)))

D = np.mat([[3,4], [5,6]])
```

Creating Matrix

•INVERSE
```
A.I #inverse

linalg.inv(A) #inverse
```
•TRANSPOSE and CONJUGATE
```
A.T #transpose matrix

A.H #conjugate
```
•TRACE
```
np.trace(A) #trace
```
•NORM
```
linalg.norm(A) #Frobenius norm

linalg.norm(A,1) #L1 Norm (max column sum)

linalg.norm(A,np.inf) #L inf Norm (max row sum)
```
•RANK
```
np.linalg.matrix_rank(C) #matrix rank
```
•DETERMINANT 
```
linalg.det(A) #determinant
```
•SOLVING LINEAR EQUATIONS
```
linalg.solve(A,b) #solver for dense matrices

E = np.mat(a).T #solver for dense matrices

linalg.lstsq(F,E) #least-squares solution to linear matrix equation
```

•GENERALIZED INVERSE
```
linalg.pinv(C) #Compute the pseudo-inverse of a matrix (least-squares solver)

linalg.pinv2(C) #Compute the pseudo-inverse of a matrix
(SVD)
```

Basic Matrix Routines

 F = np.eye(3, k=1) #Create a 2X2 identity matrix

G = np.mat(np.identity(2)) #Create a 2x2 identity matrix

C[[C > 0.5]] = 0

H = sparse.csr_matrix(C) #Compressed Sparse Row matrix

I = sparse.csc_matrix(D) #Compressed Sparse Column matrix

J = sparse.dok_matrix(A) #Dictionary Of Keys matrix

E.todense() #Sparse matrix to full matrix

sparse.isspmatrix_csc(A) #Identify sparse matrix

Creating Sparse Matrices

•INVERSE
```
sparse.linalg.inv(I) #inverse
```
•NORM
```
sparse.linalg.norm(I) #norm
```
•SOLVING LINEAR EQUATIONS
```
sparse.linalg.spsolve(H,I) #solver for sparse matrices
```

Sparse Matrix Routines

```
sparse.linalg.expm(I) #Sparse matrix exponential
```

Sparse Matrix Functions

•EIGENVALUES AND EIGENVECTORS
```
la, v = linalg.eig(A) #Solve ordinary or generalized eigenvalue problem for square matrix

l1, l2 = la #Unpack eigenvalues

v[:,0] #First eigenvector

v[:,1] #Second eigenvector

linalg.eigvals(A) #Unpack eigenvalues 
```
•SINGULAR VALUE DECOMPOSITION
```
U,s,Vh = linalg.svd(B) #Singular Value Decomposition (SVD)

M,N = B.shape

Sig = linalg.diagsvd(s,M,N) #Construct sigma matrix in SVD
```
•LU DECOMPOSITION
```
P,L,U = linalg.lu(C) #LU Decomposition
```

Decompositions

```
la, v = sparse.linalg.eigs(F,1) #Eigenvalues and eigenvectors

sparse.linalg.svds(H, 2) #SVD```

Sparse Matrix Decomposition

The numpy (np) and scipy.linalg modules provide a variety of functions for matrix operations:

- Addition & Subtraction: np.add(A, D), np.subtract(A, D)
- Division: np.divide(A, D)
- Multiplication: A @ D (matrix multiplication operator), np.multiply(D, A) (element-wise), np.dot(A, D) (dot product), np.vdot(A, D) (vector dot product), np.inner(A, D) (inner product), np.outer(A, D) (outer product), np.tensordot(A, D) (tensor dot product), np.kron(A, D) (Kronecker product)
- Exponential: linalg.expm(A) (matrix exponential), linalg.expm2(A) (Taylor series), linalg.expm3(D) (eigenvalue decomposition)
- Logarithmic: linalg.logm(A)
- Trigonometric: linalg.sinm(D), linalg.cosm(D), linalg.tanm(A)
- Hyperbolic: linalg.sinhm(D), linalg.coshm(D), linalg.tanhm(A)
- Sign: np.signm(A)
- Square Root: linalg.sqrtm(A)
- Arbitrary: linalg.funm(A, lambda x: x*x)

NumPy and SciPy Matrix Functions

Vectorization is a computational technique used to replace explicit, element-by-element loops (such as Python for-loops) with optimized operations on entire data structures simultaneously. In machine learning, vectorization leverages highly optimized linear algebra libraries to perform mathematical operations—like calculating the elementwise sum of vectors or processing whole minibatches of examples—at once. This approach dramatically reduces execution time by yielding order-of-magnitude speedups, simplifies code, reduces the potential for bugs, and increases portability by offloading mathematics to underlying libraries.

Vectorization

You’ll use the linalg and sparse modules. Note that scipy.linalg contains and expands on numpy.linalg. 
```
from scipy import linalg, sparse
```

Michigan State University

University of Michigan - Ann Arbor

The SciPy library is one of the core packages that make up the SciPy stack. It provides many user-friendly and efficient numerical routines, such as routines for numerical integration, interpolation, optimization, linear algebra, and statistics. SciPy is NumPy extension of Python.

-Interacting with NumPy
-Linear Algebra with SciPy

SciPy Library

https://docs.scipy.org/doc/scipy/tutorial/index.html

SciPy Documentation

```
import numpy as np #importing numpy library

a = np.array([1,2,3]) 

b = np.array([(1+5j,2j,3j), (4j,5j,6j)]) 

c = np.array([[(1.5,2,3), (4,5,6)], [(3,2,1), (4,5,6)]])

```

interacting with NumPy

```
np.transpose(b) #Permute array dimensions a.k.a transpose

b.flatten() #Flatten the array

np.hstack((b,c)) #Stack arrays horizontally (column-wise) 

np.vstack((a,b)) #Stack arrays vertically (row-wise)

np.hsplit(c,2) #Split the array horizontally at the 2nd index

np.vpslit(d,2) #Split the array vertically at the 2nd index
```

Index Tricks

```
from numpy import poly1d

p = poly1d([3,4,5]) #Create a polynomial object
```

Polynomials

def myfunc(a): #vectorize functions

      if a < 0:

           return a*2

      else:

           return a/2

np.vectorize(myfunc)

Vectorizing Functions

```
np.real(b) #Return the real part of the array elements

np.imag(b) #Return the imaginary part of the array elements

np.real_if_close(c,tol=1000) #Return a real array if complex parts close to 0

np.cast['f'](np.pi) #Cast object to a data type
```

Type Handling

```
#Return the angle of the complex argument Create an array of evenly spaced values (number of samples below)

 np.angle(b,deg=True)

ex)

g = np.linspace(0,np.pi,num=5

g [3:] += np.pi


 #Unwrap

 np.unwrap(g)


#Create an array of evenly spaced values (log scale)

np.logspace(0,10,3)


#Return values from a list of arrays depending on conditions

np.select([c<4],[c*2])


#Factorial

misc.factorial(a)


#Combine N things taken at k time

misc.comb(10,3,exact=True)


#Weights for Np-point central derivative

misc.central_diff_weights(3) 


#Find the n-th derivative of a function at a point

misc.derivative(myfunc,1.0)
```

Other useful functions

Linear Algebra

```
help(scipy.linalg.diagsvd)
np.info(np.matrix)
```

Asking for help

SciPy is a great tool for reading certain kinds of files into Python or passing SciPy/NumPy variables into a program such as MATLAB. 

File IO with SciPy

SciPy contains signal processing functions for

- B-splines

- Filtering

- Spectral Analysis

- Detrend

Signal Processing using SciPy

Fourier transform is a mathematical tool which helps to break up  any kind of function or waveform existing in the universe into sinusoids. Discrete Fourier Transform ( DFT) is the main tool used in digital signal processing and Fast Fourier Transform(FFT) algorithms helps to  compute DFT efficiently..

- 1-D discrete Fourier transforms
- 2- and N-D discrete Fourier transforms

Fourier Transform using SciPy

This library contains a number of images used for image processing and analysis that is abstract to work with "n" dimensions. Useful computer vision methods such as convolutions, filters, gradients, etc are all available. It's a less applied version of OpenCV (more barebone functionality).

Learn Before

Related

Learn After