CH1/templates/11_matrix_operations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  `NumPy`: матрицы и операции над ними\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В этом ноутбуке из сторонних библиотек нам понадобится только `NumPy`. Для удобства импортируем ее под более коротким именем:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Создание матриц"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Приведем несколько способов создания матриц в `NumPy`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Самый простой способ — с помощью функции __`numpy.array(list, dtype=None, ...)`__.\n",
    "\n",
    "В качестве первого аргумента ей надо передать итерируемый объект, элементами которого являются другие итерируемые объекты одинаковой длины и содержащие данные одинакового типа.\n",
    "\n",
    "Второй аргумент является опциональным и определяет тип данных матрицы. Его можно не задавать, тогда тип данных будет определен из типа элементов первого аргумента. При задании этого параметра будет произведена попытка приведения типов.\n",
    "\n",
    "Например, матрицу из списка списков целых чисел можно создать следующим образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица:\n",
      "[[1 2 3]\n",
      " [2 5 6]\n",
      " [6 7 4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3], [2, 5, 6], [6, 7, 4]])\n",
    "print \"Матрица:\\n\", a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Второй способ создания — с помощью встроенных функций __`numpy.eye(N, M=None, ...)`__, __`numpy.zeros(shape, ...)`__, __`numpy.ones(shape, ...)`__.\n",
    "\n",
    "Первая функция создает единичную матрицу размера $N \\times M$; если $M$ не задан, то $M = N$. \n",
    "\n",
    "Вторая и третья функции создают матрицы, состоящие целиком из нулей или единиц соответственно. В качестве первого аргумента необходимо задать размерность массива — кортеж целых чисел. В двумерном случае это набор из двух чисел: количество строк и столбцов матрицы.\n",
    "\n",
    "__Примеры:__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Единичная матрица:\n",
      "[[ 1.  0.  0.  0.  0.]\n",
      " [ 0.  1.  0.  0.  0.]\n",
      " [ 0.  0.  1.  0.  0.]\n",
      " [ 0.  0.  0.  1.  0.]\n",
      " [ 0.  0.  0.  0.  1.]]\n"
     ]
    }
   ],
   "source": [
    "b = np.eye(5)\n",
    "print \"Единичная матрица:\\n\", b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица, состоящая из одних единиц:\n",
      "[[ 1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.]]\n"
     ]
    }
   ],
   "source": [
    "c = np.ones((7, 5))\n",
    "print \"Матрица, состоящая из одних единиц:\\n\", c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Обратите внимание: размерность массива задается не двумя аргументами функции, а одним — кортежем!__ \n",
    "\n",
    "Вот так —  __`np.ones(7, 5)`__ — создать массив не получится, так как функции в качестве параметра `shape` передается `7`, а не кортеж `(7, 5)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "И, наконец, третий способ — с помощью функции __`numpy.arange([start, ]stop, [step, ], ...)`__, которая создает одномерный массив последовательных чисел из промежутка __`[start, stop)`__ с заданным шагом __`step`__, и _метода_ __`array.reshape(shape)`__. \n",
    "\n",
    "Параметр __`shape`__, как и в предыдущем примере, задает размерность матрицы (кортеж чисел). Логика работы метода ясна из следующего примера:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор-столбец:\n",
      "[ 0  2  4  6  8 10 12 14 16 18 20 22]\n"
     ]
    }
   ],
   "source": [
    "v = np.arange(0, 24, 2)\n",
    "print \"Вектор-столбец:\\n\", v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица:\n",
      "[[ 0  2  4  6]\n",
      " [ 8 10 12 14]\n",
      " [16 18 20 22]]\n"
     ]
    }
   ],
   "source": [
    "d = v.reshape((3, 4))\n",
    "print \"Матрица:\\n\", d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Более подробно о том, как создавать массивы в `NumPy`, \n",
    "см. [документацию](http://docs.scipy.org/doc/numpy-1.10.1/user/basics.creation.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Индексирование "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для получения элементов матрицы можно использовать несколько способов. Рассмотрим самые простые из них."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для удобства напомним, как выглядит матрица __d__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица:\n",
      "[[ 0  2  4  6]\n",
      " [ 8 10 12 14]\n",
      " [16 18 20 22]]\n"
     ]
    }
   ],
   "source": [
    "print \"Матрица:\\n\", d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Элемент на пересечении строки __`i`__ и столбца __`j`__ можно получить с помощью выражения __`array[i, j]`__. \n",
    "\n",
    "__Обратите внимание:__ строки и столбцы нумеруются с нуля!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Второй элемент третьей строки матрицы: 18\n"
     ]
    }
   ],
   "source": [
    "print \"Второй элемент третьей строки матрицы:\", d[2, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Из матрицы можно получать целые строки или столбцы с помощью выражений __`array[i, :]`__ или __`array[:, j]`__ соответственно:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вторая строка матрицы d:\n",
      "[ 8 10 12 14]\n",
      "Четвертый столбец матрицы d:\n",
      "[ 6 14 22]\n"
     ]
    }
   ],
   "source": [
    "print \"Вторая строка матрицы d:\\n\", d[1, :]\n",
    "print \"Четвертый столбец матрицы d:\\n\", d[:, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Еще один способ получения элементов — с помощью выражения __`array[list1, list2]`__, где __`list1`__, __`list2`__ — некоторые списки целых чисел. При такой адресации одновременно просматриваются оба списка и возвращаются элементы матрицы с соответствующими координатами. Следующий пример более понятно объясняет механизм работы такого индексирования:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Элементы матрицы d с координатами (1, 2) и (0, 3):\n",
      "[12  6]\n"
     ]
    }
   ],
   "source": [
    "print \"Элементы матрицы d с координатами (1, 2) и (0, 3):\\n\", d[[1, 0], [2, 3]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Более подробно о различных способах индексирования в массивах\n",
    "см. [документацию](http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Векторы, вектор-строки и вектор-столбцы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Следующие два способа задания массива кажутся одинаковыми: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "b = np.array([[1], [2], [3]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Однако, на самом деле, это задание одномерного массива (то есть _вектора_) и двумерного массива:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор:\n",
      "[1 2 3]\n",
      "Его размерность:\n",
      "(3,)\n",
      "Двумерный массив:\n",
      "[[1]\n",
      " [2]\n",
      " [3]]\n",
      "Его размерность:\n",
      "(3, 1)\n"
     ]
    }
   ],
   "source": [
    "print \"Вектор:\\n\", a\n",
    "print \"Его размерность:\\n\", a.shape\n",
    "print \"Двумерный массив:\\n\", b\n",
    "print \"Его размерность:\\n\", b.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Обратите внимание:__ _вектор_ (одномерный массив) и _вектор-столбец_ или _вектор-строка_ (двумерные массивы) являются различными объектами в `NumPy`, хотя математически задают один и тот же объект. В случае одномерного массива кортеж __`shape`__ состоит из одного числа и имеет вид __`(n,)`__, где __`n`__ — длина вектора. В случае двумерных векторов в __`shape`__ присутствует еще одна размерность, равная единице. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В большинстве случаев неважно, какое представление использовать, потому что часто срабатывает приведение типов. Но некоторые операции не работают для одномерных массивов. Например, транспонирование (о нем пойдет речь ниже):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = a.T\n",
    "b = b.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор не изменился:\n",
      "[1 2 3]\n",
      "Его размерность также не изменилась:\n",
      "(3,)\n",
      "Транспонированный двумерный массив:\n",
      "[[1 2 3]]\n",
      "Его размерность изменилась:\n",
      "(1, 3)\n"
     ]
    }
   ],
   "source": [
    "print \"Вектор не изменился:\\n\", a\n",
    "print \"Его размерность также не изменилась:\\n\", a.shape\n",
    "print \"Транспонированный двумерный массив:\\n\", b\n",
    "print \"Его размерность изменилась:\\n\", b.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Умножение матриц и столбцов"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Напоминание теории.__ Операция __умножения__ определена для двух матриц, таких что число столбцов первой равно числу строк второй. \n",
    "\n",
    "Пусть матрицы $A$ и $B$ таковы, что $A \\in \\mathbb{R}^{n \\times k}$ и $B \\in \\mathbb{R}^{k \\times m}$. __Произведением__ матриц $A$ и $B$ называется матрица $C$, такая что $c_{ij} = \\sum_{r=1}^{k} a_{ir}b_{rj}$, где $c_{ij}$ — элемент матрицы $C$, стоящий на пересечении строки с номером $i$ и столбца с номером $j$.\n",
    "\n",
    "В `NumPy` произведение матриц вычисляется с помощью функции __`numpy.dot(a, b, ...)`__ или с помощью _метода_ __`array1.dot(array2)`__, где __`array1`__ и __`array2`__ — перемножаемые матрицы."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = np.array([[1, 0], [0, 1]])\n",
    "b = np.array([[4, 1], [2, 2]])\n",
    "r1 = np.dot(a, b)\n",
    "r2 = a.dot(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица A:\n",
      "[[1 0]\n",
      " [0 1]]\n",
      "Матрица B:\n",
      "[[4 1]\n",
      " [2 2]]\n",
      "Результат умножения функцией:\n",
      "[[4 1]\n",
      " [2 2]]\n",
      "Результат умножения методом:\n",
      "[[4 1]\n",
      " [2 2]]\n"
     ]
    }
   ],
   "source": [
    "print \"Матрица A:\\n\", a\n",
    "print \"Матрица B:\\n\", b\n",
    "print \"Результат умножения функцией:\\n\", r1\n",
    "print \"Результат умножения методом:\\n\", r2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Матрицы в `NumPy` можно умножать и на векторы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "c = np.array([1, 2])\n",
    "r3 = b.dot(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица:\n",
      "[[4 1]\n",
      " [2 2]]\n",
      "Вектор:\n",
      "[1 2]\n",
      "Результат умножения:\n",
      "[6 6]\n"
     ]
    }
   ],
   "source": [
    "print \"Матрица:\\n\", b\n",
    "print \"Вектор:\\n\", c\n",
    "print \"Результат умножения:\\n\", r3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Обратите внимание:__ операция __`*`__ производит над матрицами покоординатное умножение, а не матричное!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "r = a * b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица A:\n",
      "[[1 0]\n",
      " [0 1]]\n",
      "Матрица B:\n",
      "[[4 1]\n",
      " [2 2]]\n",
      "Результат покоординатного умножения через операцию *:\n",
      "[[4 0]\n",
      " [0 2]]\n"
     ]
    }
   ],
   "source": [
    "print \"Матрица A:\\n\", a\n",
    "print \"Матрица B:\\n\", b\n",
    "print \"Результат покоординатного умножения через операцию *:\\n\", r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Более подробно о матричном умножении в `NumPy`\n",
    "см. [документацию](http://docs.scipy.org/doc/numpy-1.10.0/reference/routines.linalg.html#matrix-and-vector-products)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Транспонирование матриц"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Напоминание теории.__ __Транспонированной матрицей__ $A^{T}$ называется матрица, полученная из исходной матрицы $A$ заменой строк на столбцы. Формально: элементы матрицы $A^{T}$ определяются как $a^{T}_{ij} = a_{ji}$, где $a^{T}_{ij}$ — элемент матрицы $A^{T}$, стоящий на пересечении строки с номером $i$ и столбца с номером $j$.\n",
    "\n",
    "В `NumPy` транспонированная матрица вычисляется с помощью функции __`numpy.transpose()`__ или с помощью _метода_ __`array.T`__, где __`array`__ — нужный двумерный массив.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.array([[1, 2], [3, 4]])\n",
    "b = np.transpose(a)\n",
    "c = a.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица:\n",
      "[[1 2]\n",
      " [3 4]]\n",
      "Транспонирование функцией:\n",
      "[[1 3]\n",
      " [2 4]]\n",
      "Транспонирование методом:\n",
      "[[1 3]\n",
      " [2 4]]\n"
     ]
    }
   ],
   "source": [
    "print \"Матрица:\\n\", a\n",
    "print \"Транспонирование функцией:\\n\", b\n",
    "print \"Транспонирование методом:\\n\",  c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "См. более подробно о \n",
    "[numpy.transpose()](http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.transpose.html) и \n",
    "[array.T](http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.ndarray.T.html) в `NumPy`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В следующих разделах активно используется модуль __`numpy.linalg`__, реализующий некоторые приложения линейной алгебры. Более подробно о функциях, описанных ниже, и различных других функциях этого модуля можно посмотреть в его [документации](http://docs.scipy.org/doc/numpy-1.10.0/reference/routines.linalg.html#linear-algebra-numpy-linalg)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Определитель матрицы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Напоминание теории.__ Для квадратных матриц существует понятие __определителя__.\n",
    "\n",
    "Пусть $A$ — квадратная матрица. __Определителем__ (или __детерминантом__) матрицы $A \\in \\mathbb{R}^{n \\times n}$ назовем число \n",
    "\n",
    "$$\\det A = \\sum_{\\alpha_{1}, \\alpha_{2}, \\dots, \\alpha_{n}} (-1)^{N(\\alpha_{1}, \\alpha_{2}, \\dots, \\alpha_{n})} \\cdot a_{\\alpha_{1} 1} \\cdot \\cdot \\cdot a_{\\alpha_{n} n},\n",
    "$$\n",
    "где $\\alpha_{1}, \\alpha_{2}, \\dots, \\alpha_{n}$ — перестановка чисел от $1$ до $n$, $N(\\alpha_{1}, \\alpha_{2}, \\dots, \\alpha_{n})$ — число инверсий в перестановке, суммирование ведется по всем возможным перестановкам длины $n$.\n",
    "\n",
    "_Не стоит расстраиваться, если это определение понятно не до конца — в дальнейшем в таком виде оно не понадобится._\n",
    "\n",
    "Например, для матрицы размера $2 \\times 2$ получается:\n",
    "\n",
    "$$\\det \\left( \\begin{array}{cc} a_{11} & a_{12} \\\\ a_{21} & a_{22}  \\end{array} \\right) = a_{11} a_{22} - a_{12} a_{21}\n",
    "$$\n",
    "\n",
    "\n",
    "Вычисление определителя матрицы по определению требует порядка $n!$ операций, поэтому разработаны методы, которые позволяют вычислять его быстро и эффективно.\n",
    "\n",
    "В `NumPy` определитель матрицы вычисляется с помощью функции __`numpy.linalg.det(a)`__, где __`a`__ — исходная матрица."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = np.array([[1, 2, 1], [1, 1, 4], [2, 3, 6]], dtype=np.float32)\n",
    "det = np.linalg.det(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица:\n",
      "[[ 1.  2.  1.]\n",
      " [ 1.  1.  4.]\n",
      " [ 2.  3.  6.]]\n",
      "Определитель:\n",
      "-1.0\n"
     ]
    }
   ],
   "source": [
    "print \"Матрица:\\n\", a\n",
    "print \"Определитель:\\n\", det"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Рассмотрим одно интересное свойство определителя. Пусть у нас есть параллелограмм с углами в точках $(0, 0), (c,d), (a+c, b+d), (a, b)$ (углы даны в порядке обхода по часовой стрелке). Тогда площадь этого параллелограмма можно вычислить как модуль определителя матрицы $\\left( \\begin{array}{cc} a & c \\\\ b & d  \\end{array} \\right)$. Похожим образом можно выразить и объем параллелепипеда через определитель матрицы размера $3 \\times 3$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Ранг матрицы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Напоминание теории.__ __Рангом матрицы__ $A$ называется максимальное число линейно независимых строк (столбцов) этой матрицы.\n",
    "\n",
    "В `NumPy` ранг матрицы вычисляется с помощью функции __`numpy.linalg.matrix_rank(M, tol=None)`__, где __`M`__ — матрица, __`tol`__ — параметр, отвечающий за некоторую точность вычисления. В простом случае можно его не задавать, и функция сама определит подходящее значение этого параметра."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.array([[1, 2, 3], [1, 1, 1], [2, 2, 2]])\n",
    "r = np.linalg.matrix_rank(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица:\n",
      "[[1 2 3]\n",
      " [1 1 1]\n",
      " [2 2 2]]\n",
      "Ранг матрицы: 2\n"
     ]
    }
   ],
   "source": [
    "print \"Матрица:\\n\", a\n",
    "print \"Ранг матрицы:\", r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С помощью вычисления ранга матрицы можно проверять линейную независимость системы векторов.\n",
    "\n",
    "Допустим, у нас есть несколько векторов. Составим из них матрицу, где наши векторы будут являться строками. Понятно, что векторы линейно независимы тогда и только тогда, когда ранг полученной матрицы совпадает с числом векторов. Приведем пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "b = np.array([1, 1, 1])\n",
    "c = np.array([2, 3, 5])\n",
    "m = np.array([a, b, c])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print np.linalg.matrix_rank(m) == m.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Системы линейных уравнений"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Напоминание теории.__ __Системой линейных алгебраических уравнений__ называется система вида $Ax = b$, где $A \\in \\mathbb{R}^{n \\times m}, x \\in \\mathbb{R}^{m \\times 1}, b \\in \\mathbb{R}^{n \\times 1}$. В случае квадратной невырожденной матрицы $A$ решение системы единственно.\n",
    "\n",
    "В `NumPy` решение такой системы можно найти с помощью функции __`numpy.linalg.solve(a, b)`__, где первый аргумент — матрица $A$, второй — столбец $b$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.array([[3, 1], [1, 2]])\n",
    "b = np.array([9, 8])\n",
    "x = np.linalg.solve(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица A:\n",
      "[[3 1]\n",
      " [1 2]]\n",
      "Вектор b:\n",
      "[9 8]\n",
      "Решение системы:\n",
      "[ 2.  3.]\n"
     ]
    }
   ],
   "source": [
    "print \"Матрица A:\\n\", a\n",
    "print \"Вектор b:\\n\", b\n",
    "print \"Решение системы:\\n\", x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Убедимся, что вектор __x__ действительно является решением системы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 9.  8.]\n"
     ]
    }
   ],
   "source": [
    "print a.dot(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Бывают случаи, когда решение системы не существует. Но хотелось бы все равно \"решить\" такую систему. Логичным кажется искать такой вектор $x$, который минимизирует выражение $\\left\\Vert Ax - b\\right\\Vert^{2}$ — так мы приблизим выражение $Ax$ к $b$.\n",
    "\n",
    "В `NumPy` такое псевдорешение можно искать с помощью функции __`numpy.linalg.lstsq(a, b, ...)`__, где первые два аргумента такие же, как и для функции __`numpy.linalg.solve()`__. \n",
    "Помимо решения функция возвращает еще три значения, которые нам сейчас не понадобятся."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = np.array([[0, 1], [1, 1], [2, 1], [3, 1]])\n",
    "b = np.array([-1, 0.2, 0.9, 2.1])\n",
    "x, res, r, s = np.linalg.lstsq(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица A:\n",
      "[[0 1]\n",
      " [1 1]\n",
      " [2 1]\n",
      " [3 1]]\n",
      "Вектор b:\n",
      "[-1.   0.2  0.9  2.1]\n",
      "Псевдорешение системы:\n",
      "[ 1.   -0.95]\n"
     ]
    }
   ],
   "source": [
    "print \"Матрица A:\\n\", a\n",
    "print \"Вектор b:\\n\", b\n",
    "print \"Псевдорешение системы:\\n\", x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Обращение матриц"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Напоминание теории.__  Для квадратных невырожденных матриц определено понятие __обратной__ матрицы. \n",
    "\n",
    "Пусть $A$ — квадратная невырожденная матрица. Матрица $A^{-1}$ называется __обратной матрицей__ к $A$, если \n",
    "\n",
    "$$AA^{-1} = A^{-1}A = I,\n",
    "$$ \n",
    "\n",
    "где $I$ — единичная матрица.\n",
    "\n",
    "В `NumPy` обратные матрицы вычисляются с помощью функции __`numpy.linalg.inv(a)`__, где __`a`__ — исходная матрица."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = np.array([[1, 2, 1], [1, 1, 4], [2, 3, 6]], dtype=np.float32)\n",
    "b = np.linalg.inv(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица A:\n",
      "[[ 1.  2.  1.]\n",
      " [ 1.  1.  4.]\n",
      " [ 2.  3.  6.]]\n",
      "Обратная матрица к A:\n",
      "[[ 6.  9. -7.]\n",
      " [-2. -4.  3.]\n",
      " [-1. -1.  1.]]\n",
      "Произведение A на обратную должна быть единичной:\n",
      "[[ 1.  0.  0.]\n",
      " [ 0.  1.  0.]\n",
      " [ 0.  0.  1.]]\n"
     ]
    }
   ],
   "source": [
    "print \"Матрица A:\\n\", a\n",
    "print \"Обратная матрица к A:\\n\", b\n",
    "print \"Произведение A на обратную должна быть единичной:\\n\", a.dot(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. Собственные числа и собственные вектора матрицы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Напоминание теории.__ Для квадратных матриц определены понятия __собственного вектора__ и __собственного числа__.\n",
    "\n",
    "Пусть $A$ — квадратная матрица и $A \\in \\mathbb{R}^{n \\times n}$. __Собственным вектором__ матрицы $A$ называется такой ненулевой вектор $x \\in \\mathbb{R}^{n}$, что для некоторого $\\lambda \\in \\mathbb{R}$ выполняется равенство $Ax = \\lambda x$. При этом $\\lambda$ называется __собственным числом__ матрицы $A$. Собственные числа и собственные векторы матрицы играют важную роль в теории линейной алгебры и ее практических приложениях.\n",
    "\n",
    "В `NumPy` собственные числа и собственные векторы матрицы вычисляются с помощью функции __`numpy.linalg.eig(a)`__, где __`a`__ — исходная матрица. В качестве результата эта функция выдает одномерный массив __`v`__ собственных чисел и двумерный массив __`w`__, в котором по столбцам записаны собственные вектора, так что вектор __`w[:, i]`__ соотвествует собственному числу __`v[i]`__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = np.array([[-1, -6], [2, 6]])\n",
    "w, v = np.linalg.eig(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица A:\n",
      "[[-1 -6]\n",
      " [ 2  6]]\n",
      "Собственные числа:\n",
      "[ 2.  3.]\n",
      "Собственные векторы:\n",
      "[[-0.89442719  0.83205029]\n",
      " [ 0.4472136  -0.5547002 ]]\n"
     ]
    }
   ],
   "source": [
    "print \"Матрица A:\\n\", a\n",
    "print \"Собственные числа:\\n\", w\n",
    "print \"Собственные векторы:\\n\", v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Обратите внимание:__ у вещественной матрицы собственные значения или собственные векторы могут быть комплексными."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11. Комплексные числа в питоне"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Внимание: данный материал является дополнительным — его изучение не является необходимым для выполнения тестов.__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Напоминание теории.__ __Комплексными числами__ называются числа вида $x + iy$, где $x$ и $y$ — вещественные числа, а $i$ — мнимая единица (величина, для которой выполняется равенство $i^{2} = -1$). Множество всех комплексных чисел обозначается буквой $\\mathbb{C}$ (подробнее про комплексные числа см. [википедию](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D0%BB%D0%B5%D0%BA%D1%81%D0%BD%D0%BE%D0%B5_%D1%87%D0%B8%D1%81%D0%BB%D0%BE))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В питоне комплескные числа можно задать следующим образом (__j__ обозначает мнимую единицу):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = 3 + 2j\n",
    "b = 1j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Комплексное число a:\n",
      "(3+2j)\n",
      "Комплексное число b:\n",
      "1j\n"
     ]
    }
   ],
   "source": [
    "print \"Комплексное число a:\\n\", a\n",
    "print \"Комплексное число b:\\n\", b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С комплексными числами в питоне можно производить базовые арифметические операции так же, как и с вещественными числами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "c = a * a\n",
    "d = a / (4 - 5j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Комплексное число c:\n",
      "(5+12j)\n",
      "Комплексное число d:\n",
      "(0.0487804878049+0.560975609756j)\n"
     ]
    }
   ],
   "source": [
    "print \"Комплексное число c:\\n\", c\n",
    "print \"Комплексное число d:\\n\", d"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}