Tutorial_06c_ArrayFunctions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions of Arrays\n",
    "\n",
    "This notebook illustrates how to apply a function to arrays and how to iterate over array elements. How to create/reshuffle arrays and matrix algebra are covered in other notebooks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Packages and Extra Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Printf\n",
    "\n",
    "include(\"jlFiles/printmat.jl\");   #a function for prettier matrix printing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Elementwise Functions of Arrays: The Dot (.)\n",
    "\n",
    "Let `X` be an array, and `a` and `b` be scalars. Then, `y = fn.(X,a,b)` generates an array `y` where `y[i,j] = fn(X[i,j],a,b)`\n",
    "\n",
    "(You would achieve the same thing with `map(xi->fn(xi,a,b),x)`.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   110.000    60.000\n",
      "       Inf    20.000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "fn(x,a,b) = a/x + b             #x has to be a scalar for this to work\n",
    "\n",
    "X = [1 2;\n",
    "     0 10]\n",
    "\n",
    "printmat(fn.(X,100,10))         #notice the dot (.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Looping over Elements of an Array\n",
    "\n",
    "There are several ways of looping over all elements in an array. The next cell summarises some of them. We cover\n",
    "`for z in x`, `for i in 1:length(x)` and `for i in eachindex(x)`. `The enumerate()` approach is discussed further below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1melements of x\u001b[22m\u001b[39m\n",
      "11\n",
      "21\n",
      "12\n",
      "22\n",
      "\n",
      "\u001b[34m\u001b[1my:\u001b[22m\u001b[39m\n",
      "   111       312    \n",
      "   221       422    \n",
      "\n",
      "\u001b[34m\u001b[1my calculated in another way:\u001b[22m\u001b[39m\n",
      "   111       312    \n",
      "   221       422    \n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = [11 12; 21 22]\n",
    "\n",
    "printblue(\"elements of x\")\n",
    "for z in x                     #when we do not need the index\n",
    "    println(z)\n",
    "end\n",
    "println()\n",
    "\n",
    "y = similar(x)\n",
    "for i in 1:length(x)           #when we want to use the index i for an output\n",
    "    y[i] = x[i] + i*100        #works only with traditional arrays (first index is 1)\n",
    "end                            #`for i = 1:length(x)` is the same\n",
    "printblue(\"y:\")\n",
    "printmat(y)\n",
    "\n",
    "y = similar(x)\n",
    "for i in eachindex(x)          #again when we want to use the index i for an output\n",
    "    y[i] = x[i] + i*100        #more general and would work with non-traditional arrays\n",
    "end\n",
    "printblue(\"y calculated in another way:\")\n",
    "printmat(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Looping over Columns or Rows\n",
    "\n",
    "Suppose you want to calculate the sum of each row of a matrix. The classical way of doing that is to loop and extract each row as `X[i,:]`\n",
    "\n",
    "But, there is also a direct way to loop over all rows by using `for r in eachrow(X)`. To also get the row number `i`, we use `for (i,row) in enumerate(eachrow(X))`. For looping over columns, use `eachcol()`.\n",
    "\n",
    "To change `X` in such a loop, use `row .= new_vector`. Notice the dot in the assignment (`.=`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mX:\u001b[22m\u001b[39m\n",
      "     1         2    \n",
      "     0        10    \n",
      "\n",
      "\u001b[34m\u001b[1msum of each row:\u001b[22m\u001b[39m\n",
      "     3    \n",
      "    10    \n",
      "\n",
      "\u001b[34m\u001b[1msum of each row:\u001b[22m\u001b[39m\n",
      "     3    \n",
      "    10    \n",
      "\n",
      "\u001b[34m\u001b[1mchanging rows by using `eachrow()` \u001b[22m\u001b[39m\n",
      "    11        12    \n",
      "    21        22    \n",
      "\n"
     ]
    }
   ],
   "source": [
    "X = [1 2;\n",
    "     0 10]\n",
    "printblue(\"X:\")\n",
    "printmat(X)\n",
    "\n",
    "m = size(X,1)\n",
    "\n",
    "z = zeros(Int,m)               #to fill with results, zeros(Int,m) to get Int\n",
    "for i in 1:m                   #traditional loop over rows\n",
    "    z[i] = sum(X[i,:])         #or sum(view(X,i,:)) to save memory\n",
    "end\n",
    "printblue(\"sum of each row:\")\n",
    "printmat(z)\n",
    "\n",
    "z = zeros(Int,m)\n",
    "for (i,row) in enumerate(eachrow(X))   #enumerate to get both index and value\n",
    "    z[i] = sum(row)\n",
    "end\n",
    "printblue(\"sum of each row:\")\n",
    "printmat(z)\n",
    "\n",
    "Xb = copy(X) \n",
    "for (i,row) in enumerate(eachrow(Xb))   #enumerate to get both index and value\n",
    "    row .= [i*10+1,i*10+2]              #need .= to change Xb\n",
    "end\n",
    "printblue(\"changing rows by using `eachrow()` \")\n",
    "printmat(Xb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions with Built-in `dims` Argument\n",
    "\n",
    "May functions have a `dims` argument that allows you to avoid looping, for instance, `sum`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     3    \n",
      "    10    \n",
      "\n"
     ]
    }
   ],
   "source": [
    "printmat(sum(X,dims=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions with Inside Functions (Predicates)\n",
    "\n",
    "Several functions allow you to also apply an elementwise function to `X` before doing the rest of the calculations, for instance, `any`, `all`, `sum`, `prod`, `maximum`, and `minimum`. This speeds up things since it avoids creating intermediate/temporary arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×1 Matrix{Int64}:\n",
       "   5\n",
       " 100"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(abs2,X,dims=2)           #same as sum(abs2.(X),dims=2) but faster"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Apply Your Own Function on Each Column: mapslices (extra)\n",
    "\n",
    "...or each row (or some other dimension)\n",
    "\n",
    "The `mapslices(fun,x,dims=1)` applies `fun(x[:,i])` to each column of a matrix `x`. This is a flexible alternative to looping over the columns, since it easily allows you to change the dimension over which too loop.\n",
    "\n",
    "The cell below illustrates this by calling a function which calculates the moving average of `x[t]` and `x[t-1]` for each column (or row) of a matrix `X`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mY and MA(1) of X:\u001b[22m\u001b[39m\n",
      "        x₁        x₂    MA(x₁)    MA(x₂)\n",
      "     1.000   101.000       NaN       NaN\n",
      "     2.000   102.000     1.500   101.500\n",
      "     3.000   103.000     2.500   102.500\n",
      "     4.000   104.000     3.500   103.500\n",
      "     5.000   105.000     4.500   104.500\n",
      "\n"
     ]
    }
   ],
   "source": [
    "function MovingAvg2(x)             #moving average of t and t-1\n",
    "    T = length(x)\n",
    "    y = fill(NaN,T)\n",
    "    for t = 2:T\n",
    "        y[t] = (x[t] + x[t-1])/2\n",
    "    end\n",
    "    return y\n",
    "end\n",
    "\n",
    "X = [1:5 101:105]\n",
    "Y = mapslices(MovingAvg2,X,dims=1)          #could change to dims=2\n",
    "printblue(\"Y and MA(1) of X:\")\n",
    "printmat([X Y],colNames=[\"x₁\",\"x₂\",\"MA(x₁)\",\"MA(x₂)\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Julia 1.10.3",
   "language": "julia",
   "name": "julia-1.10"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.10.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}