documentation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "                                                                  \n",
    ".---.                                                             \n",
    "|   |.--.              __.....__     /|                           \n",
    "|   ||__|  .--./)  .-''         '.   ||                           \n",
    "|   |.--. /.''\\\\  /     .-''\"'-.  `. ||        .-,.--.            \n",
    "|   ||  || |  | |/     /________\\   \\||  __    |  .-. |    __     \n",
    "|   ||  | \\`-' / |                  |||/'__ '. | |  | | .:--.'.   \n",
    "|   ||  | /(\"'`  \\    .-------------'|:/`  '. '| |  | |/ |   \\ |  \n",
    "|   ||  | \\ '---. \\    '-.____...---.||     | || |  '- `\" __ | |  \n",
    "|   ||__|  /'\"\"'.\\ `.             .' ||\\    / '| |      .'.''| |  \n",
    "'---'     ||     ||  `''-...... -'   |/\\'..' / | |     / /   | |_ \n",
    "          \\'. __//                   '  `'-'`  |_|     \\ \\._,\\ '/ \n",
    "           `'---'                                       `--'  `\"  \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [],
    "vscode": {
     "languageId": "cpp"
    }
   },
   "outputs": [],
   "source": [
    "#pragma cling load(\"libligebra\") // ignore this line if you are not using Jupyter Notebook\n",
    "#include \"src/SquareMatrix.h\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Matrix construction\n",
    "\n",
    "The `SquareMatrix` class is used to declare matrices. As the name suggests, only square matrices and augmented matrices with square coefficient matrices can be declared.\n",
    "    \n",
    "The constructor has 2 parameters `initMatrix` and `_isAugmented`:\n",
    "\n",
    "Parameter | Data type | Meaning\n",
    "---|---|---\n",
    "`initMatrix` | 2D vector of double| initial matrix\n",
    "`_isAugmented` | Boolean | Indicates whether matrix is augmented or not. Has a default value of `false`.\n",
    "\n",
    "> [Definition](https://en.wikipedia.org/wiki/Augmented_matrix): In linear algebra, an augmented matrix is a matrix obtained by appending the columns of two given matrices, usually for the purpose of performing the same elementary row operations on each of the given matrices.\n",
    "\n",
    "```cpp\n",
    "SquareMatrix A({{2, 10}, {0, 0}}); ✅\n",
    "\n",
    "SquareMatrix B({{2, 6, -1, 85}, {6, 15, 2, 72}, {1, 1, 54, 110}}, true); ✅\n",
    "\n",
    "SquareMatrix C({{2, 6, -1, 85, 11, 12}, {6, 15, 2, 72, 15, 16}, {1, 1, 54, 110, 2, 1}}, true); ✅\n",
    "\n",
    "SquareMatrix D({{2, 10, 1}, {0, 0, 2}}, false); ❌ \n",
    "```\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matrix output\n",
    "\n",
    "Method | Description\n",
    "---|---\n",
    "`.stringify(dp)` | Returns a stringified version of the matrix. The number of decimal places `dp` can be specified.\n",
    "\n",
    "**WARNING:** `stringify()` uses some special characters (`┌`, `┐`, `└`, `┘`) which may not render properly on some terminals. You might have to configure your terminal to display these characters or replace these special characters with other ones which are supported by your terminal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "vscode": {
     "languageId": "cpp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "┌                        ┐\n",
      "|    2.000     10.000    |      \n",
      "|    0.000     0.000     |      \n",
      "└                        ┘\n",
      "┌                                                 ┐\n",
      "|    2.000     6.000     -1.000    |    85.000    |      \n",
      "|    6.000     15.000    2.000     |    72.000    |      \n",
      "|    1.000     1.000     54.000    |    110.000   |      \n",
      "└                                                 ┘\n",
      "┌                                                                     ┐\n",
      "|    2.000     6.000     -1.000    |    85.000    11.000    12.000    |      \n",
      "|    6.000     15.000    2.000     |    72.000    15.000    16.000    |      \n",
      "|    1.000     1.000     54.000    |    110.000   2.000     1.000     |      \n",
      "└                                                                     ┘\n"
     ]
    }
   ],
   "source": [
    "SquareMatrix A({{2, 10}, {0, 0}});\n",
    "std::cout << (A.stringify());\n",
    "\n",
    "SquareMatrix B({{2, 6, -1, 85}, {6, 15, 2, 72}, {1, 1, 54, 110}}, true); // augmented matrix\n",
    "std::cout << (B.stringify());\n",
    "\n",
    "SquareMatrix C({{2, 6, -1, 85, 11, 12}, {6, 15, 2, 72, 15, 16}, {1, 1, 54, 110, 2, 1}}, true); // augmented matrix\n",
    "std::cout << (C.stringify());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matrix manipulation methods\n",
    "\n",
    "Method | Description\n",
    "---|---\n",
    "`.transpose()` | Transposes matrix.\n",
    "`.add_rows(row1, row2, k)` | Performs `row1 = row1 + k*row2`. \n",
    "`.scale_row(row, k)` | Divides each element in a row by `k`.\n",
    "`.swap_col(col1, col2)` |  Swaps two columns.\n",
    "`.swap_row(row1, row2)` | Swaps two rows.\n",
    "`.at(i, j)` | Returns matrix element at row `i` and column `j`.\n",
    "`.set_val(i, j, x)` | Sets matrix element at row `i` and column `j` to `k`.\n",
    "`.to_diag()` | Transforms matrix into non-strict diagonally dominant form. This can be used together with `solve_approx()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matrix operations\n",
    "Operations between two matrices like addition, division, and multiplication, require both matrices to have compatible shapes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "vscode": {
     "languageId": "cpp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "┌                        ┐\n",
      "|    2.000     9.000     |      \n",
      "|    1.000     0.000     |      \n",
      "└                        ┘\n"
     ]
    }
   ],
   "source": [
    "SquareMatrix A({{2, 10}, {0, 0}});\n",
    "SquareMatrix B({{0, -1}, {1, 0}});\n",
    "SquareMatrix Sum = A + B;\n",
    "std::cout << (Sum.stringify());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matrix properties\n",
    "\n",
    "Method | Description\n",
    "---|---\n",
    "`.det()` | Returns determinant of matrix. If matrix is augmented, return determinant of coefficient matrix.\n",
    "`.rank()` | Returns rank of matrix.\n",
    "`.trace()` | Returns trace of matrix.\n",
    "`.is_diag_dominant(strict)` | Returns true if matrix is diagonally dominant. To check for strict dominance, set `strict` to true."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given the matrix\n",
    "\n",
    "\\begin{pmatrix}\n",
    "    25 & 125 & 35\\\\\n",
    "    3 & 4 & 1\\\\ 0 & 1 & 6\n",
    "\\end{pmatrix}\n",
    "\n",
    "the properties can be calculated as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "vscode": {
     "languageId": "cpp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1570\n",
      "3\n",
      "35\n",
      "0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "SquareMatrix A({{25, 125, 35}, {3, 4, 1}, {0, 1, 6}});\n",
    "std::cout << (A.det()) << std::endl;\n",
    "std::cout << (A.rank()) << std::endl;\n",
    "std::cout << (A.trace()) << std::endl;\n",
    "std::cout << (A.is_diag_dominant()) << std::endl;\n",
    "std::cout << (A.is_diag_dominant(true)) << std::endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Outputting calculations\n",
    "Calculations can be performed on a matrix in a sequence and corresponding step-by-step calculations can be ouputted.\n",
    " \n",
    "Method | Description\n",
    "---|---\n",
    "`.calc_cout()` | Outputs **all** calculations performed on the matrix to the **console**.\n",
    "\n",
    "`calc_cout()` will not output anything for basic operations like tranpose and arithmetic operations. In that case, use `stringify()` to view matrix .\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converting matrix below to row echelon form\n",
      "┌                                                                     ┐\n",
      "|    5.000     6.000     -1.000    |    1.000     0.000     0.000     |      \n",
      "|    1.000     4.000     2.000     |    0.000     1.000     0.000     |      \n",
      "|    1.000     -2.000    5.000     |    0.000     0.000     1.000     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R1 / 5\n",
      "┌                                                                     ┐\n",
      "|    1.000     1.200     -0.200    |    0.200     0.000     0.000     |      \n",
      "|    1.000     4.000     2.000     |    0.000     1.000     0.000     |      \n",
      "|    1.000     -2.000    5.000     |    0.000     0.000     1.000     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R2  - R1\n",
      "┌                                                                     ┐\n",
      "|    1.000     1.200     -0.200    |    0.200     0.000     0.000     |      \n",
      "|    0.000     2.800     2.200     |    -0.200    1.000     0.000     |      \n",
      "|    1.000     -2.000    5.000     |    0.000     0.000     1.000     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R3  - R1\n",
      "┌                                                                     ┐\n",
      "|    1.000     1.200     -0.200    |    0.200     0.000     0.000     |      \n",
      "|    0.000     2.800     2.200     |    -0.200    1.000     0.000     |      \n",
      "|    0.000     -3.200    5.200     |    -0.200    0.000     1.000     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R2 / 2.8\n",
      "┌                                                                     ┐\n",
      "|    1.000     1.200     -0.200    |    0.200     0.000     0.000     |      \n",
      "|    0.000     1.000     0.786     |    -0.071    0.357     0.000     |      \n",
      "|    0.000     -3.200    5.200     |    -0.200    0.000     1.000     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R3  - R2 * -3.2\n",
      "┌                                                                     ┐\n",
      "|    1.000     1.200     -0.200    |    0.200     0.000     0.000     |      \n",
      "|    0.000     1.000     0.786     |    -0.071    0.357     0.000     |      \n",
      "|    0.000     0.000     7.714     |    -0.429    1.143     1.000     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R3 / 7.71429\n",
      "┌                                                                     ┐\n",
      "|    1.000     1.200     -0.200    |    0.200     0.000     0.000     |      \n",
      "|    0.000     1.000     0.786     |    -0.071    0.357     0.000     |      \n",
      "|    0.000     0.000     1.000     |    -0.056    0.148     0.130     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "Matrix is in Row Echelon Form\n",
      "┌                                                                     ┐\n",
      "|    1.000     1.200     -0.200    |    0.200     0.000     0.000     |      \n",
      "|    0.000     1.000     0.786     |    -0.071    0.357     0.000     |      \n",
      "|    0.000     0.000     1.000     |    -0.056    0.148     0.130     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R2  - R3 * 0.785714\n",
      "\n",
      "┌                                                                     ┐\n",
      "|    1.000     1.200     -0.200    |    0.200     0.000     0.000     |      \n",
      "|    0.000     1.000     0.000     |    -0.028    0.241     -0.102    |      \n",
      "|    0.000     0.000     1.000     |    -0.056    0.148     0.130     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R1  - R3 * -0.2\n",
      "\n",
      "┌                                                                     ┐\n",
      "|    1.000     1.200     0.000     |    0.189     0.030     0.026     |      \n",
      "|    0.000     1.000     0.000     |    -0.028    0.241     -0.102    |      \n",
      "|    0.000     0.000     1.000     |    -0.056    0.148     0.130     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R1  - R2 * 1.2\n",
      "\n",
      "┌                                                                     ┐\n",
      "|    1.000     0.000     0.000     |    0.222     -0.259    0.148     |      \n",
      "|    0.000     1.000     0.000     |    -0.028    0.241     -0.102    |      \n",
      "|    0.000     0.000     1.000     |    -0.056    0.148     0.130     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "Inverse matrix:\n",
      "┌                                  ┐\n",
      "|    0.222     -0.259    0.148     |      \n",
      "|    -0.028    0.241     -0.102    |      \n",
      "|    -0.056    0.148     0.130     |      \n",
      "└                                  ┘\n",
      "\n",
      "Determinant of matrix: \n",
      "0.00925926\n",
      "\n",
      "Cofactor matrix: \n",
      "┌                                  ┐\n",
      "|    0.046     0.009     0.009     |      \n",
      "|    0.056     0.037     -0.019    |      \n",
      "|    -0.009    0.019     0.046     |      \n",
      "└                                  ┘\n",
      "\n",
      "Adjoint matrix: \n",
      "┌                                  ┐\n",
      "|    0.046     0.056     -0.009    |      \n",
      "|    0.009     0.037     0.019     |      \n",
      "|    0.009     -0.019    0.046     |      \n",
      "└                                  ┘\n",
      "\n",
      "Inverse matrix: \n",
      "┌                                  ┐\n",
      "|    5.000     6.000     -1.000    |      \n",
      "|    1.000     4.000     2.000     |      \n",
      "|    1.000     -2.000    5.000     |      \n",
      "└                                  ┘\n"
     ]
    }
   ],
   "source": [
    "SquareMatrix A({{5, 6, -1}, {1, 4, 2}, {1, -2, 5}});\n",
    "A.gauss_inv(); // inverse matrix using row operations\n",
    "A.leb_inv(); // inverse result from previous calculation using Leibniz method\n",
    "A.calc_cout(); // output calculations for both steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solving system of linear equations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To solve a system of linear equations the following methods are available:\n",
    "\n",
    "Method | Description\n",
    "---|---\n",
    "`.solve_approx(useSeidelMethod, initial_approx, iterations, dp)` | Uses either Gauss-Jacobi or Gauss-Seidel method.\n",
    "`.solve_cramer()` | Uses Cramer's rule to find exact solution.\n",
    "`.to_rref()` | Uses Gaussian elimination.\n",
    "`.solve_plu()` | Uses LU/PLU decomposition method with partial pivoting.\n",
    "\n",
    "Suppose we need to solve the following system of equations:\n",
    "\n",
    "\\begin{align}\n",
    "10x_1 + x_2 + 2x_3 + 3x_4 = 30\\\\\n",
    "x_1 + 15x_2 + 2x_3 -5x_4 = 17\\\\\n",
    "x_2 +20x_3 + 3x_4 = 74\\\\\n",
    "3x_1 -10x_2 -x_3 +25x_4 = 80\n",
    "\\end{align}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gauss-Jacobi / Gauss-Seidel\n",
    "\n",
    "`solve_approx()` takes a **diagonally dominant matrix** as parameter. To guarantee convergence, ensure that your matrix is strictly diagonally dominant by first calling `to_diag()`.\n",
    "\n",
    "Let our initial approximation for $(x_1, x_2, x_3, x_4) = (0,0,0,0)$ and let's calculate 6 iterations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "vscode": {
     "languageId": "cpp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gauss-seidel method\n",
      "Iteration      x1             x2             x3             x4             \n",
      "0              0.0000         0.0000         0.0000         0.0000         \n",
      "1              3.0000         0.9333         3.6533         3.3595         \n",
      "2              1.1682         1.6882         3.1117         3.8596         \n",
      "3              1.0510         1.9349         3.0243         3.9688         \n",
      "4              1.0110         1.9856         3.0054         3.9931         \n",
      "5              1.0024         1.9968         3.0012         3.9985         \n",
      "6              1.0005         1.9993         3.0003         3.9997         \n"
     ]
    }
   ],
   "source": [
    "SquareMatrix A({{10, 1, 2, 3, 30},\n",
    "                {1, 15, 2, -5, 17},\n",
    "                {0, 1, 20, 3, 74},\n",
    "                {3, -10, -1, 25, 80}},\n",
    "                true);\n",
    "A.solve_approx(true, {0, 0, 0, 0}, 6, 4); // 6 iterations with 4 decimal places\n",
    "A.calc_cout(); // output calculations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use Gauss-Jacobi method, the first argument of `solve_approx` should be `false` or `0`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "vscode": {
     "languageId": "cpp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gauss-jacobi method\n",
      "Iteration      x1             x2             x3             x4             \n",
      "0              0.0000         0.0000         0.0000         0.0000         \n",
      "1              3.0000         1.1333         3.7000         3.2000         \n",
      "2              1.1867         1.5067         3.1633         3.4413         \n",
      "3              1.1843         1.7796         3.1085         3.7868         \n",
      "4              1.0643         1.9022         3.0430         3.8940         \n",
      "5              1.0330         1.9547         3.0208         3.9549         \n",
      "6              1.0139         1.9800         3.0090         3.9787         \n"
     ]
    }
   ],
   "source": [
    "SquareMatrix A({{10, 1, 2, 3, 30},\n",
    "                {1, 15, 2, -5, 17},\n",
    "                {0, 1, 20, 3, 74},\n",
    "                {3, -10, -1, 25, 80}},\n",
    "                true);\n",
    "A.solve_approx(0, {0, 0, 0, 0}, 6, 4); \n",
    "A.calc_cout();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cramer's rule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true,
    "vscode": {
     "languageId": "cpp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original matrix: \n",
      "\n",
      "┌                                                           ┐\n",
      "|    10.000    1.000     2.000     3.000     |    30.000    |      \n",
      "|    1.000     15.000    2.000     -5.000    |    17.000    |      \n",
      "|    0.000     1.000     20.000    3.000     |    74.000    |      \n",
      "|    3.000     -10.000   -1.000    25.000    |    80.000    |      \n",
      "└                                                           ┘\n",
      "\n",
      "Coefficient matrix: \n",
      "\n",
      "┌                                            ┐\n",
      "|    10.000    1.000     2.000     3.000     |      \n",
      "|    1.000     15.000    2.000     -5.000    |      \n",
      "|    0.000     1.000     20.000    3.000     |      \n",
      "|    3.000     -10.000   -1.000    25.000    |      \n",
      "└                                            ┘\n",
      "\n",
      "Determinant = 60710\n",
      "\n",
      "Swap column 1 and column 5 in original matrix\n",
      "\n",
      "┌                                                           ┐\n",
      "|    30.000    1.000     2.000     3.000     |    10.000    |      \n",
      "|    17.000    15.000    2.000     -5.000    |    1.000     |      \n",
      "|    74.000    1.000     20.000    3.000     |    0.000     |      \n",
      "|    80.000    -10.000   -1.000    25.000    |    3.000     |      \n",
      "└                                                           ┘\n",
      "\n",
      "New determinant: 60710\n",
      "x1 = 60710 / 60710 = 1\n",
      "\n",
      "Swap column 2 and column 5 in original matrix\n",
      "\n",
      "┌                                                           ┐\n",
      "|    10.000    30.000    2.000     3.000     |    1.000     |      \n",
      "|    1.000     17.000    2.000     -5.000    |    15.000    |      \n",
      "|    0.000     74.000    20.000    3.000     |    1.000     |      \n",
      "|    3.000     80.000    -1.000    25.000    |    -10.000   |      \n",
      "└                                                           ┘\n",
      "\n",
      "New determinant: 121420\n",
      "x2 = 121420 / 60710 = 2\n",
      "\n",
      "Swap column 3 and column 5 in original matrix\n",
      "\n",
      "┌                                                           ┐\n",
      "|    10.000    1.000     30.000    3.000     |    2.000     |      \n",
      "|    1.000     15.000    17.000    -5.000    |    2.000     |      \n",
      "|    0.000     1.000     74.000    3.000     |    20.000    |      \n",
      "|    3.000     -10.000   80.000    25.000    |    -1.000    |      \n",
      "└                                                           ┘\n",
      "\n",
      "New determinant: 182130\n",
      "x3 = 182130 / 60710 = 3\n",
      "\n",
      "Swap column 4 and column 5 in original matrix\n",
      "\n",
      "┌                                                           ┐\n",
      "|    10.000    1.000     2.000     30.000    |    3.000     |      \n",
      "|    1.000     15.000    2.000     17.000    |    -5.000    |      \n",
      "|    0.000     1.000     20.000    74.000    |    3.000     |      \n",
      "|    3.000     -10.000   -1.000    80.000    |    25.000    |      \n",
      "└                                                           ┘\n",
      "\n",
      "New determinant: 242840\n",
      "x4 = 242840 / 60710 = 4\n",
      "\n"
     ]
    }
   ],
   "source": [
    "SquareMatrix A({{10, 1, 2, 3, 30},\n",
    "                {1, 15, 2, -5, 17},\n",
    "                {0, 1, 20, 3, 74},\n",
    "                {3, -10, -1, 25, 80}},\n",
    "                true);\n",
    "A.solve_cramer(); \n",
    "A.calc_cout();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "vscode": {
     "languageId": "cpp"
    }
   },
   "source": [
    "# Other matrix methods\n",
    "\n",
    "Method | Description\n",
    "---|---\n",
    "`.to_ref()` | Converts matrix to row-echelon form.\n",
    "`.to_rref()` | Converts matrix to reduced-row echelon form.\n",
    "`.gauss_inv()`| Inverts matrix using Gauss-Jordan elimination method. \n",
    "`.leb_inv()` | Inverts matrix using Leibniz method. \n",
    "`.get_PLU()`| Returns the PLU decomposition of a matrix.\n",
    " `.is_diag_dominant(strict)`| Returns true if matrix is diagonally dominant. Set `strict` to true to test for strict diagonal dominance. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true,
    "vscode": {
     "languageId": "cpp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converting matrix below to row echelon form\n",
      "┌                                  ┐\n",
      "|    5.000     6.000     -1.000    |      \n",
      "|    1.000     4.000     2.000     |      \n",
      "|    1.000     -2.000    5.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "R1 / 5\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    1.000     4.000     2.000     |      \n",
      "|    1.000     -2.000    5.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "R2  - R1\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     2.800     2.200     |      \n",
      "|    1.000     -2.000    5.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "R3  - R1\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     2.800     2.200     |      \n",
      "|    0.000     -3.200    5.200     |      \n",
      "└                                  ┘\n",
      "\n",
      "R2 / 2.8\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     1.000     0.786     |      \n",
      "|    0.000     -3.200    5.200     |      \n",
      "└                                  ┘\n",
      "\n",
      "R3  - R2 * -3.2\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     1.000     0.786     |      \n",
      "|    0.000     0.000     7.714     |      \n",
      "└                                  ┘\n",
      "\n",
      "R3 / 7.71429\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     1.000     0.786     |      \n",
      "|    0.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "R2  - R3 * 0.785714\n",
      "\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     1.000     0.000     |      \n",
      "|    0.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "R1  - R3 * -0.2\n",
      "\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     0.000     |      \n",
      "|    0.000     1.000     0.000     |      \n",
      "|    0.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "R1  - R2 * 1.2\n",
      "\n",
      "┌                                  ┐\n",
      "|    1.000     0.000     0.000     |      \n",
      "|    0.000     1.000     0.000     |      \n",
      "|    0.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n"
     ]
    }
   ],
   "source": [
    "SquareMatrix A({{5, 6, -1}, {1, 4, 2}, {1, -2, 5}});\n",
    "A.to_rref();\n",
    "A.calc_cout();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true,
    "tags": [],
    "vscode": {
     "languageId": "cpp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialise matrix U:\n",
      "┌                                  ┐\n",
      "|    5.000     6.000     -1.000    |      \n",
      "|    1.000     4.000     2.000     |      \n",
      "|    1.000     -2.000    5.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "Matrix U: R1 / 5\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    1.000     4.000     2.000     |      \n",
      "|    1.000     -2.000    5.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "Update Matrix L\n",
      "┌                                  ┐\n",
      "|    5.000     0.000     0.000     |      \n",
      "|    0.000     1.000     0.000     |      \n",
      "|    0.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "Matrix U: R2  - R1\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     2.800     2.200     |      \n",
      "|    1.000     -2.000    5.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "Update Matrix L\n",
      "┌                                  ┐\n",
      "|    5.000     0.000     0.000     |      \n",
      "|    1.000     1.000     0.000     |      \n",
      "|    0.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "Matrix U: R3  - R1\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     2.800     2.200     |      \n",
      "|    0.000     -3.200    5.200     |      \n",
      "└                                  ┘\n",
      "\n",
      "Update Matrix L\n",
      "┌                                  ┐\n",
      "|    5.000     0.000     0.000     |      \n",
      "|    1.000     1.000     0.000     |      \n",
      "|    1.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "Matrix U: R2 / 2.8\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     1.000     0.786     |      \n",
      "|    0.000     -3.200    5.200     |      \n",
      "└                                  ┘\n",
      "\n",
      "Update Matrix L\n",
      "┌                                  ┐\n",
      "|    5.000     0.000     0.000     |      \n",
      "|    1.000     2.800     0.000     |      \n",
      "|    1.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "Matrix U: R3  - R2 * -3.2\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     1.000     0.786     |      \n",
      "|    0.000     0.000     7.714     |      \n",
      "└                                  ┘\n",
      "\n",
      "Update Matrix L\n",
      "┌                                  ┐\n",
      "|    5.000     0.000     0.000     |      \n",
      "|    1.000     2.800     0.000     |      \n",
      "|    1.000     -3.200    1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "Matrix U: R3 / 7.71429\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     1.000     0.786     |      \n",
      "|    0.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "Update Matrix L\n",
      "┌                                  ┐\n",
      "|    5.000     0.000     0.000     |      \n",
      "|    1.000     2.800     0.000     |      \n",
      "|    1.000     -3.200    7.714     |      \n",
      "└                                  ┘\n",
      "\n",
      "Final Matrix P:\n",
      "┌                                  ┐\n",
      "|    1.000     0.000     0.000     |      \n",
      "|    0.000     1.000     0.000     |      \n",
      "|    0.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "Final Matrix L:\n",
      "┌                                  ┐\n",
      "|    5.000     0.000     0.000     |      \n",
      "|    1.000     2.800     0.000     |      \n",
      "|    1.000     -3.200    7.714     |      \n",
      "└                                  ┘\n",
      "\n",
      "Final Matrix U:\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     1.000     0.786     |      \n",
      "|    0.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n"
     ]
    }
   ],
   "source": [
    "SquareMatrix A({{5, 6, -1}, {1, 4, 2}, {1, -2, 5}});\n",
    "A.get_PLU();\n",
    "A.calc_cout();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true,
    "tags": [],
    "vscode": {
     "languageId": "cpp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converting matrix below to row echelon form\n",
      "┌                                  ┐\n",
      "|    5.000     6.000     -1.000    |      \n",
      "|    1.000     4.000     2.000     |      \n",
      "|    1.000     -2.000    5.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "R1 / 5\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    1.000     4.000     2.000     |      \n",
      "|    1.000     -2.000    5.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "R2  - R1\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     2.800     2.200     |      \n",
      "|    1.000     -2.000    5.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "R3  - R1\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     2.800     2.200     |      \n",
      "|    0.000     -3.200    5.200     |      \n",
      "└                                  ┘\n",
      "\n",
      "R2 / 2.8\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     1.000     0.786     |      \n",
      "|    0.000     -3.200    5.200     |      \n",
      "└                                  ┘\n",
      "\n",
      "R3  - R2 * -3.2\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     1.000     0.786     |      \n",
      "|    0.000     0.000     7.714     |      \n",
      "└                                  ┘\n",
      "\n",
      "R3 / 7.71429\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     1.000     0.786     |      \n",
      "|    0.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "R2  - R3 * 0.785714\n",
      "\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     -0.200    |      \n",
      "|    0.000     1.000     0.000     |      \n",
      "|    0.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "R1  - R3 * -0.2\n",
      "\n",
      "┌                                  ┐\n",
      "|    1.000     1.200     0.000     |      \n",
      "|    0.000     1.000     0.000     |      \n",
      "|    0.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "R1  - R2 * 1.2\n",
      "\n",
      "┌                                  ┐\n",
      "|    1.000     0.000     0.000     |      \n",
      "|    0.000     1.000     0.000     |      \n",
      "|    0.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "Making matrix diagonally dominant\n",
      "R0 + 0.5 * R1\n",
      "┌                                  ┐\n",
      "|    1.000     0.500     0.000     |      \n",
      "|    0.000     1.000     0.000     |      \n",
      "|    0.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "R1 + 0.5 * R2\n",
      "┌                                  ┐\n",
      "|    1.000     0.500     0.000     |      \n",
      "|    0.000     1.000     0.500     |      \n",
      "|    0.000     0.000     1.000     |      \n",
      "└                                  ┘\n",
      "\n",
      "R2 + 0.5 * R1\n",
      "┌                                  ┐\n",
      "|    1.000     0.500     0.000     |      \n",
      "|    0.000     1.000     0.500     |      \n",
      "|    0.000     0.500     1.250     |      \n",
      "└                                  ┘\n",
      "\n",
      "R1 + 0.5 * R0\n",
      "┌                                  ┐\n",
      "|    1.000     0.500     0.000     |      \n",
      "|    0.500     1.250     0.500     |      \n",
      "|    0.000     0.500     1.250     |      \n",
      "└                                  ┘\n",
      "\n"
     ]
    }
   ],
   "source": [
    "SquareMatrix A({{5, 6, -1}, {1, 4, 2}, {1, -2, 5}});\n",
    "A.to_diag();\n",
    "A.calc_cout();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true,
    "tags": [],
    "vscode": {
     "languageId": "cpp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converting matrix below to row echelon form\n",
      "┌                                                                     ┐\n",
      "|    25.000    125.000   35.000    |    1.000     0.000     0.000     |      \n",
      "|    3.000     4.000     1.000     |    0.000     1.000     0.000     |      \n",
      "|    0.000     1.000     6.000     |    0.000     0.000     1.000     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R1 / 25\n",
      "┌                                                                     ┐\n",
      "|    1.000     5.000     1.400     |    0.040     0.000     0.000     |      \n",
      "|    3.000     4.000     1.000     |    0.000     1.000     0.000     |      \n",
      "|    0.000     1.000     6.000     |    0.000     0.000     1.000     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R2  - R1 * 3\n",
      "┌                                                                     ┐\n",
      "|    1.000     5.000     1.400     |    0.040     0.000     0.000     |      \n",
      "|    0.000     -11.000   -3.200    |    -0.120    1.000     0.000     |      \n",
      "|    0.000     1.000     6.000     |    0.000     0.000     1.000     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R2 / -11\n",
      "┌                                                                     ┐\n",
      "|    1.000     5.000     1.400     |    0.040     0.000     0.000     |      \n",
      "|    -0.000    1.000     0.291     |    0.011     -0.091    -0.000    |      \n",
      "|    0.000     1.000     6.000     |    0.000     0.000     1.000     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R3  - R2\n",
      "┌                                                                     ┐\n",
      "|    1.000     5.000     1.400     |    0.040     0.000     0.000     |      \n",
      "|    -0.000    1.000     0.291     |    0.011     -0.091    -0.000    |      \n",
      "|    0.000     0.000     5.709     |    -0.011    0.091     1.000     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R3 / 5.70909\n",
      "┌                                                                     ┐\n",
      "|    1.000     5.000     1.400     |    0.040     0.000     0.000     |      \n",
      "|    -0.000    1.000     0.291     |    0.011     -0.091    -0.000    |      \n",
      "|    0.000     0.000     1.000     |    -0.002    0.016     0.175     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "Matrix is in Row Echelon Form\n",
      "┌                                                                     ┐\n",
      "|    1.000     5.000     1.400     |    0.040     0.000     0.000     |      \n",
      "|    -0.000    1.000     0.291     |    0.011     -0.091    -0.000    |      \n",
      "|    0.000     0.000     1.000     |    -0.002    0.016     0.175     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R2  - R3 * 0.290909\n",
      "\n",
      "┌                                                                     ┐\n",
      "|    1.000     5.000     1.400     |    0.040     0.000     0.000     |      \n",
      "|    -0.000    1.000     0.000     |    0.011     -0.096    -0.051    |      \n",
      "|    0.000     0.000     1.000     |    -0.002    0.016     0.175     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R1  - R3 * 1.4\n",
      "\n",
      "┌                                                                     ┐\n",
      "|    1.000     5.000     0.000     |    0.043     -0.022    -0.245    |      \n",
      "|    -0.000    1.000     0.000     |    0.011     -0.096    -0.051    |      \n",
      "|    0.000     0.000     1.000     |    -0.002    0.016     0.175     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "R1  - R2 * 5\n",
      "\n",
      "┌                                                                     ┐\n",
      "|    1.000     0.000     0.000     |    -0.015    0.455     0.010     |      \n",
      "|    -0.000    1.000     0.000     |    0.011     -0.096    -0.051    |      \n",
      "|    0.000     0.000     1.000     |    -0.002    0.016     0.175     |      \n",
      "└                                                                     ┘\n",
      "\n",
      "Inverse matrix:\n",
      "┌                                  ┐\n",
      "|    -0.015    0.455     0.010     |      \n",
      "|    0.011     -0.096    -0.051    |      \n",
      "|    -0.002    0.016     0.175     |      \n",
      "└                                  ┘\n",
      "\n"
     ]
    }
   ],
   "source": [
    "SquareMatrix A({{25, 125, 35}, {3, 4, 1}, {0, 1, 6}});\n",
    "A.gauss_inv();\n",
    "A.calc_cout();"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "C++17",
   "language": "C++17",
   "name": "xcpp17"
  },
  "language_info": {
   "codemirror_mode": "text/x-c++src",
   "file_extension": ".cpp",
   "mimetype": "text/x-c++src",
   "name": "c++",
   "version": "17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}