Tutorial_11_Printing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Printing\n",
    "\n",
    "This notebook is focused on how to print (arrays of) numbers with formatting (width, number of digits shown, etc)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Packages and Extra Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Printf\n",
    "\n",
    "include(\"src/printmat.jl\")\n",
    "include(\"src/printTeXTable.jl\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Printing\n",
    "\n",
    "is done with `println()` or `display()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11.111 12.12; 21.0 22.0]\n"
     ]
    }
   ],
   "source": [
    "x = [11.111 12.12;21 22]        #a matrix to print\n",
    "\n",
    "println(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2 Matrix{Float64}:\n",
       " 11.111  12.12\n",
       " 21.0    22.0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(x)                     #gives basic formatting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `printmat()` and `printTeXTable`\n",
    "\n",
    "My simple function `printmat()` allows basic formatting and `printTeXTable()` prints a simple LaTeX table.\n",
    "\n",
    "These functions use keyword arguments, for instance, `colNames=[\"A\",\"B\"]`. But, if you already have a variable `colNames` defined in the notebook, then using just `colNames` works fine.\n",
    "\n",
    "`printTeXTable()` is somewhat similar, but creates a string that can be used for a LaTeX table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      A      B\n",
      "  11.11  12.12\n",
      "  21.00  22.00\n",
      "\n"
     ]
    }
   ],
   "source": [
    "printmat(x;colNames=[\"A\",\"B\"],width=7,prec=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           A      B\n",
      "row 1  11.11  12.12\n",
      "row 2  21.00  22.00\n",
      "\n"
     ]
    }
   ],
   "source": [
    "colNames = [\"A\",\"B\"]\n",
    "rowNames = [\"row 1\",\"row 2\"]\n",
    "printmat(x;colNames,rowNames,width=7,prec=2)                      #notice the ;\n",
    "#printmat(x;colNames=colNames,rowNames=rowNames,width=7,prec=2)   #this works too"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{table}\n",
      "  \\begin{tabular}{lrr}\n",
      "     & A & B \\\\ \\hline \n",
      "   row 1 &   11.11 &   12.12 \\\\ \n",
      "   row 2 &   21.00 &   22.00 \\\\ \n",
      "  \\hline\n",
      "  \\end{tabular}\n",
      "\\end{table}\n"
     ]
    }
   ],
   "source": [
    "str = printTeXTable(x;colNames,rowNames,width=7,prec=2);   #str can be printed to a file, see below)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The PrettyTables.jl Package\n",
    "\n",
    "The [PrettyTables.jl](https://github.com/ronisbr/PrettyTables.jl) package provides powerful methods for formatted printing, including printing LaTeX tables.\n",
    "\n",
    "The lines around/in the table are defined by the `tf` keyword. \n",
    "\n",
    "The formatting is defined by the `formatters` keyword. For instance, to print a decimal floating point number with a width of 5 and 2 digits after the decimal point, use `ft_printf(\"%5.2f\")`. (See `@printf` in the manual.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "┌───────┬────────┬───────┐\n",
      "│\u001b[1m       \u001b[0m│\u001b[1m      A \u001b[0m│\u001b[1m     B \u001b[0m│\n",
      "├───────┼────────┼───────┤\n",
      "│\u001b[1m row 1 \u001b[0m│ 11.111 │ 12.12 │\n",
      "│\u001b[1m row 2 \u001b[0m│   21.0 │  22.0 │\n",
      "└───────┴────────┴───────┘\n",
      " \u001b[1m       \u001b[0m \u001b[1m     A \u001b[0m \u001b[1m     B \u001b[0m\n",
      "\n",
      " \u001b[1m row 1 \u001b[0m  11.11   12.12\n",
      " \u001b[1m row 2 \u001b[0m  21.00   22.00\n",
      "...................................\n",
      ":\u001b[1m       \u001b[0m:\u001b[1m          A \u001b[0m:\u001b[1m          B \u001b[0m:\n",
      ":.......:............:............:\n",
      ":\u001b[1m row 1 \u001b[0m:    11.1110 :    12.1200 :\n",
      ":\u001b[1m row 2 \u001b[0m:    21.0000 :    22.0000 :\n",
      ":.......:............:............:\n"
     ]
    }
   ],
   "source": [
    "using PrettyTables\n",
    "\n",
    "pretty_table(x;header=colNames,row_labels=rowNames)\n",
    "\n",
    "pretty_table(x;header=colNames,row_labels=rowNames,tf=tf_borderless,formatters=ft_printf(\"%5.2f\"))\n",
    "\n",
    "pretty_table(x;header=colNames,row_labels=rowNames,tf=tf_ascii_dots,formatters=ft_printf(\"%10.4f\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{tabular}{rr}\n",
      "  \\hline\n",
      "  \\textbf{A} & \\textbf{B} \\\\\\hline\n",
      "  11.11 & 12.12 \\\\\n",
      "  21.00 & 22.00 \\\\\\hline\n",
      "\\end{tabular}\n"
     ]
    }
   ],
   "source": [
    "pretty_table(x;header=colNames,formatters=ft_printf(\"%5.2f\"),backend=Val(:latex))   #LaTeX table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Printing Output to a Text File\n",
    "\n",
    "is simple. You `open()` the file, write to it and then `close()` it. The next cells demonstrate this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "fh = open(\"Results/NewTxtFile.txt\", \"w\")     #open the file, \"w\" for writing\n",
    "\n",
    "println(fh,\"Dogs are \")                      #printing to the file, notice the fh\n",
    "println(fh,\"nicer than cats.\\n\")\n",
    "\n",
    "printmat(fh,x,prec=2)\n",
    "printmat(fh,x,colNames=colNames,rowNames=rowNames,prec=2)\n",
    "printTeXTable(fh,x,colNames=colNames,rowNames=rowNames,prec=2)\n",
    "\n",
    "pretty_table(fh,x,header=colNames,row_labels=rowNames,formatters=ft_printf(\"%5.2f\"))\n",
    "\n",
    "close(fh)                                    #close the file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mResults/NewTxtFile.txt has been closed. Check it out. The raw contents are:\u001b[22m\u001b[39m\n",
      "\n",
      "Dogs are \n",
      "nicer than cats.\n",
      "\n",
      "     11.11     12.12\n",
      "     21.00     22.00\n",
      "\n",
      "              A         B\n",
      "row 1     11.11     12.12\n",
      "row 2     21.00     22.00\n",
      "\n",
      "\\begin{table}\n",
      "  \\begin{tabular}{lrr}\n",
      "     & A & B \\\\ \\hline \n",
      "   row 1 &        11.11 &        12.12 \\\\ \n",
      "   row 2 &        21.00 &        22.00 \\\\ \n",
      "  \\hline\n",
      "  \\end{tabular}\n",
      "\\end{table}\n",
      "┌───────┬───────┬───────┐\n",
      "│       │     A │     B │\n",
      "├───────┼───────┼───────┤\n",
      "│ row 1 │ 11.11 │ 12.12 │\n",
      "│ row 2 │ 21.00 │ 22.00 │\n",
      "└───────┴───────┴───────┘\n",
      "\n"
     ]
    }
   ],
   "source": [
    "printblue(\"Results/NewTxtFile.txt has been closed. Check it out. The raw contents are:\\n\")\n",
    "println(read(\"Results/NewTxtFile.txt\",String))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Redirecting the Output (extra)\n",
    "\n",
    "You can also *redirect* the output from the screen to a file. This gives an simple mechanism for dumping all outputs to a file without having to insert the IO stream (called `fh` above) in all print statements.\n",
    "\n",
    "To do that, use something like the next cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mResults/NewTxtFile2.txt has been closed. Check it out. The raw contents are:\u001b[22m\u001b[39m\n",
      "\n",
      "NewTxtFile2.txt should contain this string and the next table\n",
      "     11.11     12.12\n",
      "     21.00     22.00\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "redirect_stdio(stdout=\"Results/NewTxtFile2.txt\") do     #redirect the output to a file\n",
    "  println(\"NewTxtFile2.txt should contain this string and the next table\")\n",
    "  printmat(x,prec=2)\n",
    "end  #end redirection\n",
    "\n",
    "printblue(\"Results/NewTxtFile2.txt has been closed. Check it out. The raw contents are:\\n\")\n",
    "println(read(\"Results/NewTxtFile2.txt\",String))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Formatted Printing (extra)\n",
    "\n",
    "by using the `Printf` libary. \n",
    "\n",
    "`@printf()` prints to a file or to the screen (and IOBuffers etc), while `@sprintf()` prints to a string. \n",
    "\n",
    "To print with dynamic formatting (that is, where the format is decided at run-time), use `Printf.format()`. The second cell below illustrates by drawing the width and precision randomly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      3.14\n",
      "my string is just this:  1828 2.71828\n"
     ]
    }
   ],
   "source": [
    "z = 3.14159\n",
    "                                         #the format string is constant\n",
    "@printf(\"%10.2f\\n\",z)                    #width 10, 2 digits, floating point\n",
    "\n",
    "str = @sprintf(\"%5d %g\",1828,exp(1))     #width 5 and integer, compact floating point\n",
    "println(\"my string is just this: \",str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1       3.1\n",
      "2      3.14\n",
      "3     3.142\n",
      "4    3.1416\n",
      "5   3.14159\n",
      "6  3.141590\n"
     ]
    }
   ],
   "source": [
    "n = 6\n",
    "(width,prec) = (10,1:n)\n",
    "for i = 1:n\n",
    "    #local fmt,str            #only needed in script\n",
    "    fmt = Printf.Format(\"%$(width).$(prec[i])f\")\n",
    "    str = Printf.format(fmt,z)\n",
    "    println(i,str)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Julia 1.11.1",
   "language": "julia",
   "name": "julia-1.11"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.11.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}