Handling File IO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## File I/O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Filesystem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Print working directory\n",
    "pwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Get files and directories in current directory\n",
    "readdir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Get home directory\n",
    "ENV[\"HOME\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Another way of getting the home directory\n",
    "homedir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create a string holding the full path to ~/tmp/julia\n",
    "JULIATMPDIR = joinpath(homedir(), \"tmp/julia\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# If ~/tmp/julia directory doesn't exist, then create it\n",
    "if !isdir(JULIATMPDIR)\n",
    "  mkpath(JULIATMPDIR)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create the directory ~/tmp/julia/dir01/dir02\n",
    "mkpath(joinpath(JULIATMPDIR, \"dir01/dir02\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Delete the directory ~/tmp/julia/dir01/dir02\n",
    "rm(joinpath(JULIATMPDIR, \"dir01\"), recursive=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data I/O\n",
    "\n",
    "####  write (and read) a vector to (and from) a file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Define a vector\n",
    "x = [2.5, 3.0, 1.0]\n",
    "\n",
    "# Create a string holding the full path to ~/tmp/julia\n",
    "JULIATMPDIR = joinpath(homedir(), \"tmp/julia\")\n",
    "\n",
    "# If ~/tmp/julia directory doesn't exist, then create it\n",
    "if !isdir(JULIATMPDIR)\n",
    "  mkpath(JULIATMPDIR)\n",
    "end\n",
    "\n",
    "# Create a string holding the filename on which to operate\n",
    "DATAFILE = joinpath(JULIATMPDIR, \"out01.txt\")\n",
    "\n",
    "# Write x to one-column DATAFILE\n",
    "writedlm(DATAFILE, x)\n",
    "\n",
    "# Read one-column DATAFILE into vector y\n",
    "y = readdlm(DATAFILE, ' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### write (and read) a vector to (and from) a file line by line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Define a vector\n",
    "x = [2.5, 3.0, 1.0]\n",
    "\n",
    "# Create a string holding the full path to ~/tmp/julia\n",
    "JULIATMPDIR = joinpath(homedir(), \"tmp/julia\")\n",
    "\n",
    "# If ~/tmp/julia directory doesn't exist, then create it\n",
    "if !isdir(JULIATMPDIR)\n",
    "  mkpath(JULIATMPDIR)\n",
    "end\n",
    "\n",
    "# Create a string holding the filename on which to operate\n",
    "DATAFILE = joinpath(JULIATMPDIR, \"out02.txt\")\n",
    "\n",
    "# Write x to one-column DATAFILE line by line\n",
    "outstream = open(DATAFILE, \"w+\")\n",
    "\n",
    "for i = 1:length(x)\n",
    "  write(outstream, string(x[i], \"\\n\"))\n",
    "end\n",
    "\n",
    "close(outstream)\n",
    "\n",
    "# Read one-column DATAFILE line by line into vector y\n",
    "instream = open(DATAFILE, \"r\")\n",
    "\n",
    "y = Array(Float64, countlines(DATAFILE))\n",
    "i = 0\n",
    "\n",
    "while !eof(instream)\n",
    "    y[i+=1] = parse(Float64, readline(instream))\n",
    "end\n",
    "\n",
    "close(instream)\n",
    "\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### JLD - To save julia objects to file and retrieve back"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you just want to save a few variables and don't care to use the more advanced features, then a simple syntax is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "using JLD\n",
    "t = 15\n",
    "z = [1,3]\n",
    "save(\"/tmp/myfile.jld\", \"t\", t, \"arr\", z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we're explicitly saving t and z as \"t\" and \"arr\" within myfile.jld."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To load back the variables, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String,Any} with 2 entries:\n",
       "  \"arr\" => [1,3]\n",
       "  \"t\"   => 15"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = load(\"/tmp/myfile.jld\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Int64,1}:\n",
       " 1\n",
       " 3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[\"arr\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or you can be more specific and just request particular variables of interest. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Int64,1}:\n",
       " 1\n",
       " 3"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = load(\"/tmp/myfile.jld\", \"arr\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "There are some convenience macros like `@save` and `@load` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "@save \"/tmp/myfile1.jld\" t z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "@save \"/tmp/myfile2.jld\" # will save all the variables in global scope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Symbol,1}:\n",
       " :d\n",
       " :t\n",
       " :z"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@load \"/tmp/myfile2.jld\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The limitation of the above macros is that they cannot be used inside functions, since the functions are compiled to machine code before evaluation, no new variables can be introduced during runtime."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More fine-grained control can be obtained using functional syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "UndefVarError: A not defined",
     "output_type": "error",
     "traceback": [
      "UndefVarError: A not defined",
      "",
      " in #jldopen#11(::Array{Any,1}, ::Function, ::##1#2, ::String, ::Vararg{String,N}) at /Applications/JuliaPro-0.5.0.4.app/Contents/Resources/pkgs-0.5.0.4/v0.5/JLD/src/JLD.jl:260",
      " in jldopen(::Function, ::String, ::String) at /Applications/JuliaPro-0.5.0.4.app/Contents/Resources/pkgs-0.5.0.4/v0.5/JLD/src/JLD.jl:258"
     ]
    }
   ],
   "source": [
    "jldopen(\"mydata.jld\", \"w\") do file\n",
    "    write(file, \"A\", A)  # alternatively, say \"@write file A\"\n",
    "end\n",
    "\n",
    "c = jldopen(\"mydata.jld\", \"r\") do file\n",
    "    read(file, \"A\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.5.0",
   "language": "julia",
   "name": "julia-0.5"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}