02. Numpy a a maticové operácie.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Numpy a a maticové operácie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na vytvorenie matice v Pythone použijeme knižnicu numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1, 2], [3, 4]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrix/ Matica: [[1 2]\n",
    " [3 4]]\n",
    " \n",
    "Maticu sme zadefinovali pomocou dvoch vektorov [1,2] a [3,4] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "v_row = np.array([1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Row vector / Riadkovy vektor:  [1 2 3 4]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "v_column = np.array([[1, 2, 3, 4]]).T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stĺpcovy vektor dostaneme jednoduchou úpravou (transpose) riadkového vektora.\n",
    "\n",
    "Column vector / Stlpcovy vektor:  [[1]\n",
    "[2]\n",
    "[3]\n",
    "[4]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "trans_2_v_row = v_column.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transpose / Transponuje sa cez atribut T (Vymena riadkov a stlpcov):  [[1 2 3 4]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "lin_spaced_vector = np.linspace(0, 9, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operacia linspace vrati x prvkov (10) od pociatku 0 po cislo 9. Tieto prvky su rovnomerne rozmiestnene cez dany interval (0-9)\n",
    "\n",
    "Linearly spaced vector / Vektor s linearnym rastom: [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "v_empty = np.array([])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Empty vector / Prazdny vector:  []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Špeciálne inicializácie matíc:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "mat_zeros = np.zeros((3, 3))  # tuple as input param\n",
    "print(mat_zeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operacia np.zeros vrati maticu s danym rozmerom, ktora je vyplnena nulami"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ones matrix: \n",
      " [[[1. 1.]\n",
      "  [1. 1.]\n",
      "  [1. 1.]]\n",
      "\n",
      " [[1. 1.]\n",
      "  [1. 1.]\n",
      "  [1. 1.]]]\n"
     ]
    }
   ],
   "source": [
    "mat_ones = np.ones((2, 3, 2))\n",
    "print(\"Ones matrix: \\n\", mat_ones)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podobna operacia je np.ones, ktora ale vracia maticu vyplnenu jednotkami."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Diagional matrix / Diagonalna matica:\n",
      " [[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "mat_eye = np.eye(3)\n",
    "print(\"Diagional matrix / Diagonalna matica:\\n\", mat_eye)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Np.eye vrati diagonalnu maticu s danym rozmerom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random matrix / Matica nahodnych cisel:\n",
      " [[0.40343779 0.67785879 0.98585484]\n",
      " [0.27987432 0.75698085 0.01405531]]\n"
     ]
    }
   ],
   "source": [
    "mat_rand = np.random.rand(2, 3)\n",
    "print(\"Random matrix / Matica nahodnych cisel:\\n\", mat_rand)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pri vytvoreni nahdonych matic si mozeme pomoct kniznicou random pomocou ktorej si vieme priamo vytvorit maticu s danym rozmerom naplnenu nahodnymi cislami. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "vec = np.array([3, 2, 1])\n",
    "print(vec[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pri vybere specifickeho prvka z vektora alebo matice pracujeme s indexom. Nesmieme zabudnut, ze v pythone sa indexuje od 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pristup k matici:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Acessing matrix / Pristup k matici\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "mat = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "print(\"Acessing matrix / Pristup k matici\")\n",
    "print(mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(\"Accessing  element at (2,3) / Pristup k elementu (2,3)\", mat[1][2])\n",
    "#print(\"Accesing different elements through sequences:/ Dynamicky pristup k elementom matic\")\n",
    "#print(mat[0][:])  # vrati prvy riadok ako riadkovy vektor\n",
    "#print(\"\")\n",
    "#print(mat[:][1])  # vrati druhy stlpec ako riadkovy vektor !!!\n",
    "#print(\"\")\n",
    "#print(mat[1:3, 1:3])  # submatica zacinajuca na 2,2\n",
    "#print(\"\")\n",
    "#print(mat[1:, 1:])  # (2,2) + till end\n",
    "#print(\"\")\n",
    "#print(mat[:3, :3])  # od [] -> to index [3 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Z matice vieme vybrat samostatne stlpce alebo riadky pomocou roznych indexov. Ak chceme vypisat prvy riadok matice ako riadkovy vektor pouzijeme mat[0][:]  co nam vrati vystup [1 2 3]\n",
    "Obdobne to funguje pri vybere stlpca, kde indexy vymenime mat[:][1] : [4 5 6]\n",
    "\n",
    "Jednotlive prikazy si mozete vyskusat v okne vyssie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of the matrix/ Rozmery matice:  (3, 3)\n",
      "Shape of the matrix/ Rozmery matice:  3\n",
      "Shape of the matrix/ Rozmery matice:  3\n"
     ]
    }
   ],
   "source": [
    "print(\"Shape of the matrix/ Rozmery matice: \", mat.shape)\n",
    "print(\"Shape of the matrix/ Rozmery matice: \", mat.shape[0])\n",
    "print(\"Shape of the matrix/ Rozmery matice: \", mat.shape[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jednoduché operácie s vektormi a maticam:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "S maticami mozeme vykonavat rozne vypoctove operacie od scitania a odcitania po SVD dekompoziciu. Vsetky operacie su sprostredkovane kniznicou Numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]\n",
      " [2]\n",
      " [3]\n",
      " [4]]\n"
     ]
    }
   ],
   "source": [
    "vec_a = np.array([[1, 2, 3, 4]]).T\n",
    "print(vec_a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]\n",
      " [2]\n",
      " [3]\n",
      " [4]]\n"
     ]
    }
   ],
   "source": [
    "vec_b = np.array([[1, 2, 3, 4]]).T\n",
    "print(vec_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(2 * vec_a)\n",
    "#print(\"\")\n",
    "#print(vec_a / 2)\n",
    "#print(\"\")\n",
    "#print(vec_a ** 3)\n",
    "\n",
    "#print(vec_a * vec_b)\n",
    "#print(\"\")\n",
    "#print(vec_a / vec_b)\n",
    "#print(\"\")\n",
    "#print(vec_a - vec_b)\n",
    "#print(\"\")\n",
    "#print(np.log(vec_a))\n",
    "#print(\"\")\n",
    "#print(np.round(np.log(vec_a)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # Skalarne operacie na vektore -> vystup je skalar:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nasledujuce prikazy nam vratia uzitocne informacie o matici na ktoru boli pouzite. \n",
    "\n",
    "-Operacia sum nam vrati sucet vsetkych prvkov v matici\n",
    "\n",
    "-Operacia mean vyrata aritmeticky priemer na specifikovanej osi. Ak sme os nespecifikovali tak sa vyrata priemer vsetkych prvkov.\n",
    "\n",
    "-Var nam vrati rozptyl prvkov v matici. \n",
    "\n",
    "-Std vyrata smerodajnu odchylku.\n",
    "\n",
    "-Operacie np.min a np.max vratia najmensi a najväcsi prvok v matici"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "\n",
      "2.5\n",
      "\n",
      "1.25\n",
      "\n",
      "1.118033988749895\n",
      "\n",
      "1 4\n"
     ]
    }
   ],
   "source": [
    "print(np.sum(vec_a))\n",
    "print(\"\")\n",
    "print(np.mean(vec_a))\n",
    "print(\"\")\n",
    "print(np.var(vec_a))\n",
    "print(\"\")\n",
    "print(np.std(vec_a))\n",
    "print(\"\")\n",
    "print(np.min(vec_a), np.max(vec_a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operacie na matici -> vystup je vektor:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Velmi dolezitymi operaciami s maticami su vypocty skalarnych a vektorovych sucinov. Tieto operacie si je potrebne osvojit a vediet sa orientovat v roznych zapisoch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "#print(np.mean(mat, 0))\n",
    "#print(\"Max of mat along axis 0: \", np.max(mat, 0))\n",
    "#print(\"Max of mat alojng axis 1: \", np.max(mat, 1))\n",
    "#print(np.max(mat))\n",
    "#print(mat[0] * mat[1])  # elementwise\n",
    "#print(mat[0].T * mat[1])    # vektorovy sucin\n",
    "#print(mat[0] * mat[1].T)  # vektorovy sucin\n",
    "#print(mat[0].T @ mat[1])  # skalarny sucin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operacie na matici:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat_1 = np.random.rand(3, 2)\n",
    "mat_2 = np.random.rand(2, 4)\n",
    "vec_1 = np.array([[1, 2, 3]]).T\n",
    "vec_2 = np.array([1, 2])\n",
    "#print(np.matmul(mat_1, mat_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(np.matmul(vec_1.T, mat_1)) # 1x3 * 3x2 = 1x2\n",
    "#print(np.matmul(mat_1, vec_2)) # 3x2 * 2x1 = 3x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(\"Inverse matrix: \\n\", np.linalg.inv(np.random.rand(3, 3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(\"Eigen values: \\n\", np.linalg.eigvals(np.random.rand(3, 3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linearna algebra:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eigen values: \n",
      " [1.23638316 0.43417129 0.01201218] \n",
      " Eigen matrix\n",
      " [[-0.08433031 -0.62897725 -0.34588098]\n",
      " [-0.95695945  0.76109156 -0.39536061]\n",
      " [-0.2776995  -0.15851578  0.850915  ]]\n"
     ]
    }
   ],
   "source": [
    "V, D = np.linalg.eig(np.random.rand(3, 3))\n",
    "print(\"Eigen values: \\n\",V,\"\\n Eigen matrix\\n\",D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVD single value decomposition: \n",
      " [[-0.50475886  0.86283199  0.02719278]\n",
      " [-0.71160683 -0.39804595 -0.57894313]\n",
      " [-0.48870668 -0.31157724  0.81491435]] \n",
      " Eigen matrix\n",
      " [1.84402584 0.53036126 0.47574497] \n",
      " Eigen matrix\n",
      " [[-0.71443827 -0.54048218 -0.4443613 ]\n",
      " [ 0.55778164 -0.82336123  0.10467051]\n",
      " [ 0.42244241  0.17307596 -0.88971182]]\n"
     ]
    }
   ],
   "source": [
    "U, S, V = np.linalg.svd(np.random.rand(3, 3))\n",
    "print(\"SVD single value decomposition: \\n\", U,\"\\n Eigen matrix\\n\",S,\"\\n Eigen matrix\\n\",V) # a = U * S * V'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.32606342 0.89051006]\n",
      " [0.53351575 0.91198193]\n",
      " [0.88005695 0.21590958]\n",
      " [0.25623601 0.84964013]\n",
      " [0.98817016 0.01050342]\n",
      " [0.55545406 0.22084121]\n",
      " [0.39058538 0.74963682]\n",
      " [0.81521112 0.34429125]]\n"
     ]
    }
   ],
   "source": [
    "B = np.random.rand(4, 4)\n",
    "np.linalg.det(B)\n",
    "np.sum(B)\n",
    "print(B.reshape((8,2)))\n",
    "vec_a = np.array([[1, 2, 3]])\n",
    "vec_b = np.array([[4, 5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec_c = np.concatenate((vec_a, vec_b), 0)\n",
    "#print(vec_c)\n",
    "vec_c = np.array((vec_a, vec_b))\n",
    "vec_c = np.squeeze(vec_c)\n",
    "#print(vec_c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Concatenate spoji dve matice pozdlz danej osi.\n",
    "Prikaz squeeze odstrani z matice osy s rozmerom 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "\n",
      "[[1 2]\n",
      " [1 2]\n",
      " [3 4]\n",
      " [3 4]]\n",
      "\n",
      "[0.32606342 0.21590958 0.55545406 0.34429125]\n"
     ]
    }
   ],
   "source": [
    "print(A)\n",
    "print(\"\")\n",
    "print(np.repeat(A, 2,axis=0))\n",
    "print(\"\")\n",
    "print(np.diag(B))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operacia repeat opakuje prvky matice. Pocet opakovani si zvolime my, tak isto aj os pozdlz ktorej sa prvky duplikuju. \n",
    "Nasledne vykoname operaciu diag, ktora nam vypise z danej matice len tie prvky, ktore lezia na hlavnej diagonale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}