18fall/mathematical_packages/octave1-matrices-index.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Indexing matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing allows referencing separate matrix elements or submatrices. We will use the following matrices throughout all the examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =\n",
      "\n",
      "    10    20    30    40    50\n",
      "    60    70    80    90   100\n",
      "   110   120   130   140   150\n",
      "   160   170   180   190   200\n",
      "   210   220   230   240   250\n",
      "\n",
      "b =\n",
      "\n",
      "   10   20   30   40   50   60\n",
      "\n",
      "c =\n",
      "\n",
      "   10\n",
      "   20\n",
      "   30\n",
      "   40\n",
      "   50\n",
      "   60\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = 10 * ((1:5) + (0:5:20)')\n",
    "b = 10 * (1:6)\n",
    "c = 10 * (1:6)'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ans =  81\n",
      "ans =  250\n",
      "a =\n",
      "\n",
      "    10    20    30    40    50\n",
      "    60    70    81    90   100\n",
      "   110   120   130   140   150\n",
      "   160   170   180   190   200\n",
      "   210   220   230   240   250\n",
      "\n",
      "ans =  30\n",
      "ans =  40\n",
      "ans =  40\n"
     ]
    }
   ],
   "source": [
    "a(2, 3) # element of the 2nd row, the 3rd column\n",
    "a(5, 5) # element of the 5th row, the 5th column\n",
    "a(2, 3) = 81 # you can either read element, or assign to them\n",
    "b(3) # b and c are one-dimentional matrices, we may use only one index \n",
    "c(4)\n",
    "c(4, 1) # but we still can use both indices: 4th row, 1st column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Althogh, $a$ is a two dimentional matrix, you can anyway use one index to access its elements. The elements are counted from the leftmost topmost element down column by column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ans =  110\n",
      "ans =  120\n",
      "a =\n",
      "\n",
      "    10    20    30    40    50\n",
      "    60    70    81    90   100\n",
      "   110   122   130   140   150\n",
      "   160   170   180   190   200\n",
      "   210   220   230   240   250\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a(3)\n",
    "a(8)\n",
    "a(8) = 122"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Submatrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexes are not restricted to be only numbers. They may be matrices by themselves. In this case we select several lines and columns and get a submatrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ans =  140\n",
      "ans =\n",
      "\n",
      "   130   140   150\n",
      "   180   190   200\n",
      "\n",
      "ans =\n",
      "\n",
      "   110   120\n",
      "   160   170\n",
      "   110   120\n",
      "\n"
     ]
    }
   ],
   "source": [
    "row = 3;\n",
    "col = 4;\n",
    "a(row, col) # a usual way to index elements\n",
    "rows = [3, 4];\n",
    "cols = [3, 4, 5];\n",
    "a(rows, cols) # selecting a submatrix\n",
    "a([3, 4, 3], [1, 2]) # it is possible to select some row or column several times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A very common usecase is to select a whole row or a whole column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ans =\n",
      "\n",
      "   10   20   30   40   50\n",
      "\n",
      "ans =\n",
      "\n",
      "   10   20   30   40   50\n",
      "\n",
      "ans =\n",
      "\n",
      "   10   20   30   40   50\n",
      "\n",
      "ans =\n",
      "\n",
      "   10   20   30   40\n",
      "\n",
      "ans =\n",
      "\n",
      "   30   40   50\n",
      "\n",
      "ans =\n",
      "\n",
      "   10   20   30   40   50\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a(1, [1, 2, 3, 4, 5]) # we select the whole 1st row, because we mention all the columns\n",
    "a(1, 1:5) # the same may be achived by the range operator. 1:5 just equals [1 2 3 4 5]\n",
    "a(1, 1:end) # there is a magical word `end`, that always means \"the last element\"\n",
    "a(1, 1:end-1) # we may do evaluations with `end`, e.g. take all but the last element\n",
    "a(1, (end+1)/2:end) # we may take the second half of the row\n",
    "a(1, :) # there is a special syntax for the `1:end` range. Just write :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is actually a very common code, to select rows and columns with the : symbol:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ans =\n",
      "\n",
      "    60    70    81    90   100\n",
      "\n",
      "ans =\n",
      "\n",
      "    30\n",
      "    81\n",
      "   130\n",
      "   180\n",
      "   230\n",
      "\n",
      "ans =\n",
      "\n",
      "    10    20    30    40    50\n",
      "    60    70    81    90   100\n",
      "   110   120   130   140   150\n",
      "   160   170   180   190   200\n",
      "   210   220   230   240   250\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a(2, :) # the second row\n",
    "a(:, 3) # the third column\n",
    "a(:, :) # select everything (not very usefull, because this is the same as `a`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing submatrices may be used to assignments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ans =\n",
      "\n",
      "   31   41\n",
      "   82   91\n",
      "\n",
      "a =\n",
      "\n",
      "    10    20    31    41    50\n",
      "    60    70    82    91   100\n",
      "   110   120   130   140   150\n",
      "   160   170   180   200   200\n",
      "   210   220   230   200   200\n",
      "\n",
      "ans =\n",
      "\n",
      "   200   200\n",
      "   200   200\n",
      "\n",
      "a =\n",
      "\n",
      "    10    20    31    41    50\n",
      "    60    70    82    91   100\n",
      "   110   120   130   140   150\n",
      "   160   170   180   200   200\n",
      "   210   220   230   200   200\n",
      "\n",
      "aa =\n",
      "\n",
      "    10    20    31    41    50\n",
      "    60    70    82    91   100\n",
      "   110   120   130   140   150\n",
      "   160   170   180   200   200\n",
      "   210   220   230   200   200\n",
      "\n",
      "aa =\n",
      "\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",
      "\n"
     ]
    }
   ],
   "source": [
    "a([1, 2], [3, 4]) # a 2 by 2 submatrix\n",
    "a([1, 2], [3, 4]) = [31 41; 82 91] # we may assign a matrix of the same size\n",
    "a(4:5, 4:5) # again we have a 2 by 2 submatrix\n",
    "a(4:5, 4:5) = 200 # and it is possible to assign one number, in this case it is copied to all the cells\n",
    "aa = a # we will do the next operation on the copy of the matrix: \n",
    "aa(:, :) = 1 # copy 1 to all elements of the matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next example is a litle bit complicated, but remember what is the effect of indexing a two-dimentional matrix with only one index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ans =\n",
      "\n",
      "    10\n",
      "    60\n",
      "   110\n",
      "   160\n",
      "   210\n",
      "    20\n",
      "    70\n",
      "   120\n",
      "   170\n",
      "   220\n",
      "    31\n",
      "    82\n",
      "   130\n",
      "   180\n",
      "   230\n",
      "    41\n",
      "    91\n",
      "   140\n",
      "   200\n",
      "   200\n",
      "    50\n",
      "   100\n",
      "   150\n",
      "   200\n",
      "   200\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a(:)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Octave",
   "language": "octave",
   "name": "octave"
  },
  "language_info": {
   "file_extension": ".m",
   "help_links": [
    {
     "text": "GNU Octave",
     "url": "https://www.gnu.org/software/octave/support.html"
    },
    {
     "text": "Octave Kernel",
     "url": "https://github.com/Calysto/octave_kernel"
    },
    {
     "text": "MetaKernel Magics",
     "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md"
    }
   ],
   "mimetype": "text/x-octave",
   "name": "octave",
   "version": "4.2.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}