SciPy builds directly on NumPy arrays. This snippet shows how to create NumPy arrays of different dimensionality and dtype, including 1-D, 2-D, and complex-valued arrays:
```python
import numpy as np
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)]])
```

Michigan State University

Google

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

```
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

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

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

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

SciPy Documentation

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).

Computer Vision in Scipy (ndimage)

The `scipy.ndimage` module provides functions for multidimensional image processing in Python. It includes operations for filtering, mathematical morphology, interpolation, object measurements, and feature extraction on NumPy arrays that represent n-dimensional images.

SciPy ndimage Module

```python
# Return the angle of the complex argument
np.angle(b, deg=True)

# Create an array of evenly spaced values (number of samples below)
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)
```

Learn Before

Related