{
"cells": [
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"execution": {
"iopub.execute_input": "2024-01-05T15:04:47.670882Z",
"iopub.status.busy": "2024-01-05T15:04:47.669914Z",
"iopub.status.idle": "2024-01-05T15:04:47.695946Z",
"shell.execute_reply": "2024-01-05T15:04:47.693955Z",
"shell.execute_reply.started": "2024-01-05T15:04:47.670803Z"
},
"tags": []
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n"
],
"text/plain": [
""
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"%run ../../common_functions/import_all.py\n",
"\n",
"from scipy import optimize\n",
"from scipy.integrate import quad, odeint\n",
"from scipy.interpolate import interp1d\n",
"from scipy.signal import detrend\n",
"from scipy.spatial import distance\n",
"from matplotlib.legend_handler import HandlerLine2D\n",
"\n",
"from functools import partial \n",
"from ipywidgets import interact\n",
"\n",
"from common_functions.setup_notebook import set_css_style, setup_matplotlib, config_ipython\n",
"config_ipython()\n",
"setup_matplotlib()\n",
"set_css_style()\n",
"\n",
"dataset = '../../datasets/oldfaithful.txt'"
]
},
{
"cell_type": "markdown",
"metadata": {
"tags": []
},
"source": [
"# Scientific Python: Numpy and Scipy, and some more\n",
"\n",
"Some high-level notes to these two libraries, not intended to be comprehensive, plus some function divertissements.\n",
"\n",
"[**Numpy**](#Numpy)\n",
"* [Arrays and Matrices](#Arrays-and-Matrices)\n",
"* [Linear Algebra](#Some-linear-Algebra)\n",
"* [Playing with Polynomials](#Playing-with-polynomials)\n",
"* [Various](#Numpy-various)\n",
" \n",
"---\n",
"\n",
"[**Scipy**](#Scipy)\n",
"* [Using `optimize`: fit and solve equations](#Using-optimize)\n",
"* [The `stats` module: statistical computation](#The-stats-module)\n",
"* [The `interpolate` module: ](#The-interpolate-module)\n",
"* [Integrate](#The-integrate-module)\n",
"* [Signal and noise](#The-signal-module)\n",
"* [Mathematical distances](#Mathematical-distances)\n",
"\n",
"*Note: some of the stuff presented here comes from the Scipy lectures http://www.scipy-lectures.org/index.html*\n",
"\n",
"--- \n",
"\n",
"[**Divertissements with functions**](#Divertissements-with-functions)\n",
"\n",
"Using the `interact` widget to visualise how a function can change with parameters."
]
},
{
"cell_type": "markdown",
"metadata": {
"jp-MarkdownHeadingCollapsed": true,
"tags": []
},
"source": [
"## Numpy\n",
"\n",
"\"Num\" stands for \"numerical\", this is a library devoted to numerical computation and it's a building block of many other projects."
]
},
{
"cell_type": "markdown",
"metadata": {
"jp-MarkdownHeadingCollapsed": true,
"tags": []
},
"source": [
"### Arrays and Matrices\n",
"\n",
"These objects constitute the basic blocks for manipulation"
]
},
{
"cell_type": "markdown",
"metadata": {
"jp-MarkdownHeadingCollapsed": true,
"tags": []
},
"source": [
"#### Attributes, slicing reshaping/resizing/flattening"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* A vector\n",
" Dimension 1 and shape (5,): [1 2 3 4 5]\n",
" Slice of vector: [3 4]\n",
" Slice of vector with step: [2 4]\n",
" Slice with newaxis on column: [[1]\n",
" [2]\n",
" [3]\n",
" [4]\n",
" [5]]\n",
" Slice with newaxis on row: [[1 2 3 4 5]]\n"
]
}
],
"source": [
"# NOTE: np.array is function to create an ndarray (n-dimensional array), ndarray not to be used to create\n",
"\n",
"# Vector: an array\n",
"\n",
"print('* A vector')\n",
"vec = np.array([1, 2, 3, 4, 5]) \n",
"print(' Dimension %d and shape %s: %s' %(vec.ndim, vec.shape, vec))\n",
"print(' Slice of vector: ', vec[2:4])\n",
"print(' Slice of vector with step: ', vec[1:4:2])\n",
"print(' Slice with newaxis on column: ', vec[:, np.newaxis])\n",
"print(' Slice with newaxis on row: ', vec[np.newaxis, :])"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"execution": {
"iopub.execute_input": "2024-01-05T14:24:46.935973Z",
"iopub.status.busy": "2024-01-05T14:24:46.934618Z",
"iopub.status.idle": "2024-01-05T14:24:46.953686Z",
"shell.execute_reply": "2024-01-05T14:24:46.952184Z",
"shell.execute_reply.started": "2024-01-05T14:24:46.935889Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* A matrix\n",
" This is an ndarray of dimension 2 and shape (3, 4):\n",
" [[1 2 3 0]\n",
" [2 3 4 1]\n",
" [4 0 1 0]]\n",
" It contains 12 elements (size)\n",
" Its element on row 2, col 3 is 4\n",
" A slice of it is (second column) [2 3 0]\n"
]
}
],
"source": [
"# Matrix, a 2D array\n",
"\n",
"print('* A matrix')\n",
"mat = np.array([[1,2,3, 0], [2,3,4, 1], [4, 0, 1, 0]])\n",
"print(' This is an ndarray of dimension %d and shape %s:\\n %s' %(mat.ndim, mat.shape, mat))\n",
"print(' It contains %d elements (size)' %mat.size)\n",
"print(' Its element on row 2, col 3 is %d' %mat[1,2])\n",
"print(' A slice of it is (second column)', mat[:,1])"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* Reshaping and resizing ['t_red']\n",
" Original vector: [0 1 2 3 4 5]\n",
" Reshaping vector to shape (2, 3) (change shape, return reshaped ndarray): \n"
]
},
{
"data": {
"text/plain": [
"array([[0, 1, 2],\n",
" [3, 4, 5]])"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" Resizing vector to shape (2, 2) (change shape and size, do in place and return None): \n"
]
},
{
"data": {
"text/plain": [
"array([0, 1, 2, 3, 4, 5])"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
" Original matrix: [[1 2 3 0]\n",
" [2 3 4 1]\n",
" [4 0 1 0]]\n",
" Flattened matrix: [1 2 3 0 2 3 4 1 4 0 1 0]\n"
]
}
],
"source": [
"# Reshaping, resizing and flattening\n",
"\n",
"print('* Reshaping and resizing', ['t_red'])\n",
"a = np.arange(6)\n",
"print(' Original vector: ', a)\n",
"print(' Reshaping vector to shape (2, 3) (change shape, return reshaped ndarray): ')\n",
"a.reshape((2, 3))\n",
"print(' Resizing vector to shape (2, 2) (change shape and size, do in place and return None): ')\n",
"a\n",
"print(' Original matrix: ', mat)\n",
"print(' Flattened matrix: ', mat.ravel())"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* Matrices of zeros and ones ['t_red']\n"
]
},
{
"data": {
"text/plain": [
"array([[0., 0., 0., 0.],\n",
" [0., 0., 0., 0.],\n",
" [0., 0., 0., 0.]])"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
"array([[1., 1., 1., 1., 1.]])"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Matrices of zeros and ones\n",
"\n",
"print('* Matrices of zeros and ones', ['t_red'])\n",
"np.zeros((3, 4))\n",
"np.ones((1, 5))"
]
},
{
"cell_type": "markdown",
"metadata": {
"jp-MarkdownHeadingCollapsed": true,
"tags": []
},
"source": [
"#### Operations on arrays/matrices"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* Vectors and matrices to use\n",
" vector v is [1 2 3]\n",
" Matrix A is\n",
"[[1 2 0]\n",
" [2 3 4]]\n",
" Matrix B is\n",
"[[0 1]\n",
" [2 0]\n",
" [1 1]]\n",
" Matrix C is\n",
"[[3 5 1]\n",
" [0 0 2]]\n"
]
}
],
"source": [
"# Setting the vars to use\n",
"\n",
"print('* Vectors and matrices to use')\n",
"v = np.array([1, 2, 3])\n",
"A = np.array([[1,2, 0], [2,3,4]])\n",
"B = np.array([[0, 1], [2, 0], [1, 1]])\n",
"C = np.array([[3, 5, 1], [0, 0, 2]])\n",
"print(' vector v is', v)\n",
"print(' Matrix A is')\n",
"print(A)\n",
"print(' Matrix B is')\n",
"print(B)\n",
"print(' Matrix C is')\n",
"print(C)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* Matrix and transpose\n",
" Transpose of A is\n",
" [[1 2]\n",
" [2 3]\n",
" [0 4]]\n"
]
}
],
"source": [
"# matrix transpose\n",
"\n",
"print('* Matrix and transpose')\n",
"print(' Transpose of A is\\n', A.T)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* Properties of matrix elements\n",
" Sum, mean, std of elements: 12 2.0 1.2909944487358056\n",
" Sum of A on axis 0: [3 5 4]\n",
" Sum of A on axis 1: [3 9]\n"
]
}
],
"source": [
"# Some Matrix properties of elements\n",
"\n",
"print('* Properties of matrix elements')\n",
"print(' Sum, mean, std of elements: ', A.sum(), A.mean(), A.std())\n",
"print(' Sum of A on axis 0: ', A.sum(axis=0))\n",
"print(' Sum of A on axis 1: ', A.sum(axis=1))"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* Matrix product\n",
" Product A * B is\n",
"[[ 4 1]\n",
" [10 6]]\n"
]
}
],
"source": [
"# Product of matrices\n",
"\n",
"print('* Matrix product')\n",
"print(' Product A * B is')\n",
"print(np.dot(A, B))"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* Multiplication and sum with scalar (v and A)\n",
" 2 * v: [2 4 6]\n",
" 2 * A: [[2 4 0]\n",
" [4 6 8]]\n",
" v + 1: [2 3 4]\n",
" A + 1: [[2 3 1]\n",
" [3 4 5]]\n"
]
}
],
"source": [
"# scalar * vector; scalar * matrix\n",
"\n",
"print('* Multiplication and sum with scalar (v and A)')\n",
"print(' 2 * v: ', 2 * v)\n",
"print(' 2 * A: ', 2 * A)\n",
"print(' v + 1: ', v + 1)\n",
"print(' A + 1: ', A + 1)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* Arithmetics with matrices\n",
" Summing A and C\n",
"[[4 7 1]\n",
" [2 3 6]]\n",
" Subtracting C from A\n",
"[[-2 -3 -1]\n",
" [ 2 3 2]]\n"
]
}
],
"source": [
"# Matrix arithmetics\n",
"\n",
"print('* Arithmetics with matrices')\n",
"print(' Summing A and C')\n",
"print(A + C)\n",
"print(' Subtracting C from A')\n",
"print(A - C)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* Sorting matrix\n",
" Sorting A: [[0 1 2]\n",
" [2 3 4]]\n",
" Sorting A on axis 0 [[1 2 0]\n",
" [2 3 4]]\n",
" Sorting A on axis 1 [[0 1 2]\n",
" [2 3 4]]\n"
]
}
],
"source": [
"# sorting a matrix\n",
"\n",
"print('* Sorting matrix')\n",
"A_copy = A.copy()\n",
"A.sort()\n",
"print(' Sorting A: ', A)\n",
"A = A_copy.copy()\n",
"A.sort(axis=0)\n",
"print(' Sorting A on axis 0', A)\n",
"A = A_copy.copy()\n",
"A.sort(axis=1)\n",
"print(' Sorting A on axis 1', A)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* Randomly shuffling array:\n",
"[3 2 1]\n"
]
}
],
"source": [
"# array shuffling at random\n",
"\n",
"print('* Randomly shuffling array:')\n",
"np.random.shuffle(v) # shuffles and returns None\n",
"print(v)"
]
},
{
"cell_type": "markdown",
"metadata": {
"jp-MarkdownHeadingCollapsed": true,
"tags": []
},
"source": [
"### Some linear Algebra"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"# set the vars to use\n",
"\n",
"v = np.array([1, 2, 1, 1])\n",
"A = np.array([[1, 2, 3], [0, 1, 0], [0, 2, 1]])"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* Determinant, trace, inverse, norm\n",
" Determinant of matrix A: 1.0\n",
" Trace of matrix A: 3\n",
" Inverse of matrix A: [[ 1. 4. -3.]\n",
" [ 0. 1. 0.]\n",
" [-0. -2. 1.]]\n",
" Norm of vector v and of matrix A: 2.6457513110645907 4.47213595499958\n"
]
}
],
"source": [
"# determinant & co\n",
"\n",
"print('* Determinant, trace, inverse, norm')\n",
"print(' Determinant of matrix A: ', np.linalg.det(A))\n",
"print(' Trace of matrix A:', np.trace(A))\n",
"print(' Inverse of matrix A: ', np.linalg.inv(A))\n",
"print(' Norm of vector v and of matrix A:', np.linalg.norm(v), np.linalg.norm(A))"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* Eigenvalues/Eigenvectors\n",
" Eigenvalues and eigenvectors of matrix A: (array([1., 1., 1.]), array([[ 1.00000000e+00, -1.00000000e+00, 1.00000000e+00],\n",
" [ 0.00000000e+00, 0.00000000e+00, 8.21730110e-33],\n",
" [ 0.00000000e+00, 7.40148683e-17, -7.40148683e-17]]))\n"
]
}
],
"source": [
"# eigenthings\n",
"\n",
"print('* Eigenvalues/Eigenvectors')\n",
"print(' Eigenvalues and eigenvectors of matrix A:', np.linalg.eig(A))"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* Single Value Decomposition\n",
" SVD of matrix A: (array([[ 0.86349489, 0.47752005, -0.16233045],\n",
" [ 0.15573818, -0.55857386, -0.81470293],\n",
" [ 0.47971053, -0.67821077, 0.55669378]]), array([4.27194722, 1.3109472 , 0.17856195]), array([[ 0.20213145, 0.66530528, 0.71868753],\n",
" [ 0.36425575, -0.73226084, 0.57542317],\n",
" [-0.9090988 , -0.14547494, 0.39035422]]))\n"
]
}
],
"source": [
"# SVD\n",
"\n",
"print('* Single Value Decomposition')\n",
"print(' SVD of matrix A:', np.linalg.svd(A))"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"* Linear systems\n",
" Solving linear system Ax = b: [ 0.4 -0.2]\n",
" Least Square solution for Ax = b: (array([ 0.4, -0.2]), array([], dtype=float64), 2, array([3.61803399, 1.38196601]))\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/Users/martina/Desktop/Mallzee/repos/plantation/venv/lib/python3.7/site-packages/ipykernel_launcher.py:7: FutureWarning: `rcond` parameter will change to the default of machine precision times ``max(M, N)`` where M and N are the input matrix dimensions.\n",
"To use the future default and silence this warning we advise to pass `rcond=None`, to keep using the old, explicitly pass `rcond=-1`.\n",
" import sys\n"
]
}
],
"source": [
"# System of linear equations\n",
"\n",
"A = np.array([[1, 2], [3, 1]])\n",
"b = np.array([0, 1])\n",
"print('* Linear systems')\n",
"print(' Solving linear system Ax = b:', np.linalg.solve(A, b))\n",
"print(' Least Square solution for Ax = b: ', np.linalg.lstsq(A, b))"
]
},
{
"cell_type": "markdown",
"metadata": {
"jp-MarkdownHeadingCollapsed": true,
"tags": []
},
"source": [
"### Playing with polynomials"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Basics"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"y = x^2 -2x + 1\n",
"* Order of polynomial is 2\n",
"* y(2) = 1\n",
"* Roots of polynomial are [1. 1.]\n"
]
}
],
"source": [
"print('y = x^2 -2x + 1')\n",
"y = np.poly1d([1, -2, 1])\n",
"print('* Order of polynomial is ', y.order)\n",
"print('* y(2) = ', y(2))\n",
"print('* Roots of polynomial are ', y.roots)"
]
},
{
"cell_type": "markdown",
"metadata": {
"tags": []
},
"source": [
"#### A polynomial fit to points"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"