meeting_02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Things you should know about Julia\n",
    "\n",
    "Julia is high-level and easy to write (dynamically typed, for instance). At the same time it aims to be such that, when written carefully, it can be as fast as the fastest languages (C, Fortran). The secret ingredient? Just-in-time compilation (read up on it if you care).\n",
    "\n",
    "Julia is specifically geared towards scientific and technical computing.\n",
    "\n",
    "Julia is new. It doesn't have a huge number of libraries and a wide user base (yet).\n",
    "\n",
    "Julia is not done. v0.6 came out in June and introduced several breaking changes.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basics of Julia, and IJulia notebooks, for the purpose of tensor networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is xxx\n"
     ]
    }
   ],
   "source": [
    "# This is a comment  \n",
    "println(\"My name is xxx\") # replace xxx with your name and press Shift+Enter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Int64\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "println(typeof(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Float64\n"
     ]
    }
   ],
   "source": [
    "b = 2.3\n",
    "println(typeof(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.3\n",
      "Float64\n"
     ]
    }
   ],
   "source": [
    "c = a+b  # Beware of performance gotchas!\n",
    "println(c)\n",
    "println(typeof(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z2 = a + b*im  # complex numbers\n",
    "z1 = complex(a, b)\n",
    "z1 == z2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[1mc\u001b[22m\u001b[1mo\u001b[22m\u001b[1mm\u001b[22m\u001b[1mp\u001b[22m\u001b[1ml\u001b[22m\u001b[1me\u001b[22m\u001b[1mx\u001b[22m \u001b[1mC\u001b[22m\u001b[1mo\u001b[22m\u001b[1mm\u001b[22m\u001b[1mp\u001b[22m\u001b[1ml\u001b[22m\u001b[1me\u001b[22m\u001b[1mx\u001b[22m \u001b[1mC\u001b[22m\u001b[1mo\u001b[22m\u001b[1mm\u001b[22m\u001b[1mp\u001b[22m\u001b[1ml\u001b[22m\u001b[1me\u001b[22m\u001b[1mx\u001b[22m64 \u001b[1mC\u001b[22m\u001b[1mo\u001b[22m\u001b[1mm\u001b[22m\u001b[1mp\u001b[22m\u001b[1ml\u001b[22m\u001b[1me\u001b[22m\u001b[1mx\u001b[22m32 \u001b[1mC\u001b[22m\u001b[1mo\u001b[22m\u001b[1mm\u001b[22m\u001b[1mp\u001b[22m\u001b[1ml\u001b[22m\u001b[1me\u001b[22m\u001b[1mx\u001b[22m128 pre\u001b[1mc\u001b[22m\u001b[1mo\u001b[22m\u001b[1mm\u001b[22m\u001b[1mp\u001b[22mi\u001b[1ml\u001b[22m\u001b[1me\u001b[22m __pre\u001b[1mc\u001b[22m\u001b[1mo\u001b[22m\u001b[1mm\u001b[22m\u001b[1mp\u001b[22mi\u001b[1ml\u001b[22m\u001b[1me\u001b[22m__\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "```\n",
       "complex(r, [i])\n",
       "```\n",
       "\n",
       "Convert real numbers or arrays to complex. `i` defaults to zero.\n",
       "\n",
       "```\n",
       "complex(T::Type)\n",
       "```\n",
       "\n",
       "Returns an appropriate type which can represent a value of type `T` as a complex number. Equivalent to `typeof(complex(zero(T)))`.\n",
       "\n",
       "```jldoctest\n",
       "julia> complex(Complex{Int})\n",
       "Complex{Int64}\n",
       "\n",
       "julia> complex(Int)\n",
       "Complex{Int64}\n",
       "```\n"
      ],
      "text/plain": [
       "```\n",
       "complex(r, [i])\n",
       "```\n",
       "\n",
       "Convert real numbers or arrays to complex. `i` defaults to zero.\n",
       "\n",
       "```\n",
       "complex(T::Type)\n",
       "```\n",
       "\n",
       "Returns an appropriate type which can represent a value of type `T` as a complex number. Equivalent to `typeof(complex(zero(T)))`.\n",
       "\n",
       "```jldoctest\n",
       "julia> complex(Complex{Int})\n",
       "Complex{Int64}\n",
       "\n",
       "julia> complex(Int)\n",
       "Complex{Int64}\n",
       "```\n"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?complex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1×4 Array{Float64,2}:\n",
       " 1.0  2.0  0.0  0.2"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = [1.0 2 0 0.2]  # row vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Float64,1}:\n",
       " 0.3\n",
       " 0.0\n",
       " 2.0\n",
       " 1.2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w = [0.3; 0; 2; 1.2]  # column vector  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×1 Array{Complex{Float64},2}:\n",
       "   0.637736-1.07667im\n",
       "  -0.301651+0.47722im\n",
       "    1.34004-1.71412im\n",
       " -0.0786585-1.12504im"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w = complex.(randn(4,1), randn(4,1))  # random column vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.30165094757918903 + 0.47722042912882806im"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w[2]  # access 2nd component of the vector w. Numbering starts from 1!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1×1 Array{Complex{Float64},2}:\n",
       " 0.0187026-0.347234im"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v*w  # scalar product as a 1x1 array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.018702635587533403 - 0.34723368405873706im"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(v*w)[1]  # scalar product as a single number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1×4 Array{Complex{Float64},2}:\n",
       " 0.637736+1.07667im  -0.301651-0.47722im  …  -0.0786585+1.12504im"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w'  # Conjugate transpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt((w'*w)[1]) == vecnorm(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×4 Array{Complex{Float64},2}:\n",
       "   1.56592+0.0im        -0.706181+0.0204369im  …    1.16113+0.802166im\n",
       " -0.706181-0.0204369im   0.318733+0.0im           -0.513163-0.376906im\n",
       "   2.70013+0.349614im    -1.22224-0.122425im        1.82305+1.64242im \n",
       "   1.16113-0.802166im   -0.513163+0.376906im         1.2719+0.0im     "
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w*w'  # Outer product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Array{Float64,2}:\n",
       " 0.585952  0.665325  0.889817\n",
       " 0.5905    0.20737   0.353809\n",
       " 0.013864  0.777706  0.979527"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 3\n",
    "M = rand(n, n)  # nxn random matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Array{Float64,2}:\n",
       " 0.585952  0.627912  0.45184 \n",
       " 0.627912  0.20737   0.565757\n",
       " 0.45184   0.565757  0.979527"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = (M + M')/2  # Let's make M Hermitian"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eigenvalues and vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([-0.296521, 0.344115, 1.72526], [0.499306 -0.678199 -0.539203; -0.843673 -0.238888 -0.48078; 0.197255 0.694967 -0.691456])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D, U = eig(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D = [-0.296521, 0.344115, 1.72526]\n",
      "U = [0.499306 -0.678199 -0.539203; -0.843673 -0.238888 -0.48078; 0.197255 0.694967 -0.691456]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3×3 Array{Float64,2}:\n",
       "  0.499306  -0.678199  -0.539203\n",
       " -0.843673  -0.238888  -0.48078 \n",
       "  0.197255   0.694967  -0.691456"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@show D  # eigenvalues\n",
    "@show U  # eigenvectors as rows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Is it true that $M = U \\cdot D \\cdot U^{\\dagger}$? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = U*diagm(D)*U'  # let's build UDU'\n",
    "M == N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M ≈ N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.6304897551986876e-15"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "norm(M - N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Float64,1}:\n",
       "  0.499306\n",
       " -0.843673\n",
       "  0.197255"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = D[1]    # first eigenvalue of matrix M\n",
    "u1 = U[:,1]  # first eigenvector of matrix M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Is it true that $M\\cdot\\vec{u}_1 = d_1 \\vec{u}_1$? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M*u1 ≈ d1*u1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2×3 Array{Float64,3}:\n",
       "[:, :, 1] =\n",
       " 0.776811  0.570522\n",
       " 0.946886  0.578174\n",
       "\n",
       "[:, :, 2] =\n",
       " 0.418961   0.184617\n",
       " 0.0273454  0.210723\n",
       "\n",
       "[:, :, 3] =\n",
       " 0.436116  0.992994\n",
       " 0.997976  0.985715"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_tensor = rand(2,2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2×2×3 Array{Float64,3}:\n",
       "[:, :, 1] =\n",
       " 0.776811  0.946886\n",
       " 0.570522  0.578174\n",
       "\n",
       "[:, :, 2] =\n",
       " 0.418961  0.0273454\n",
       " 0.184617  0.210723 \n",
       "\n",
       "[:, :, 3] =\n",
       " 0.436116  0.997976\n",
       " 0.992994  0.985715"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "permutedims(A_tensor, (2,1,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×3 Array{Float64,2}:\n",
       " 0.776811  0.418961   0.436116\n",
       " 0.946886  0.0273454  0.997976\n",
       " 0.570522  0.184617   0.992994\n",
       " 0.578174  0.210723   0.985715"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_matrix = reshape(A_tensor, (4,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "true\n",
      "true\n",
      "true\n",
      "true\n",
      "true\n",
      "true\n",
      "true\n",
      "true\n",
      "true\n",
      "true\n",
      "true\n"
     ]
    }
   ],
   "source": [
    "for i in 1:2\n",
    "    for j in 1:2\n",
    "        for k in 1:3\n",
    "            println(A_tensor[i,j,k] == A_matrix[i + (j-1)*2, k])  # (i,j) -> i + (j-1)*2 is a bijection!\n",
    "        end\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_tensor == reshape(A_matrix, (2,2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$C_{ij} = A_{ikm} B_{jkn} x_{mn}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8×8 Array{Float64,2}:\n",
       "   1.95282  -14.1955      7.05945  …    0.685361   -6.67212   13.307  \n",
       " -13.2314     0.561873    3.12435       0.441828   -1.25748    6.50263\n",
       "  -2.70632    7.56017    -8.64605       0.884867    4.29495    4.2028 \n",
       "  17.829     -2.63609    19.0705        6.37398     5.17074   12.8566 \n",
       "  -8.19021   -8.33132     9.92002       0.37438    -9.24423   -3.98531\n",
       " -17.2215   -29.279      15.5893   …    0.398753   -7.64186    4.43791\n",
       "  -1.41482  -10.406     -12.5167      -12.4666    -13.419      2.73614\n",
       "   1.25496    2.46992    -6.01213      -4.12705     0.312403   5.40517"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = 8\n",
    "d = 2\n",
    "A=randn(D, d, D)\n",
    "B=randn(D, d, D)\n",
    "x=randn(D, D)\n",
    "\n",
    "C = zeros(eltype(A), (D, D))\n",
    "for i in 1:D\n",
    "    for j in 1:D\n",
    "        for k in 1:d\n",
    "            for m in 1:D\n",
    "                for n in 1:D\n",
    "                    C[i,j] += A[i,k,m] * B[j,k,n] * x[m,n]\n",
    "                end\n",
    "            end\n",
    "        end\n",
    "    end\n",
    "end\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "using TensorOperations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@tensor C2[i,j] := A[i,k,m] * (B[j,k,n] * x[m,n])\n",
    "C2 ≈ C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions and types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Array{Float64,2}"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(C)  # Parametric types!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Array{T,3} where T"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MPSTensor{T} = Array{T,3}  # Define a new type, MPSTensor{T}, for every type T."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = randn(3,3,3)\n",
    "typeof(A) == MPSTensor{Float64}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Define a composite type, that can hold several things as fields.\n",
    "mutable struct UMPS{T}\n",
    "    A::MPSTensor{T}\n",
    "    # There could also be more fields, if for instance the MPS was of finite length:\n",
    "    #lb::Vector{T}\n",
    "    #rb::Vector{T}\n",
    "    #length::Int32\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×2×4 Array{Float64,3}:\n",
       "[:, :, 1] =\n",
       " -0.624711   0.81219 \n",
       " -0.274045   1.58016 \n",
       "  0.304923   0.091567\n",
       " -0.324495  -1.14701 \n",
       "\n",
       "[:, :, 2] =\n",
       "  1.61509   -1.15443 \n",
       " -0.781988  -0.913507\n",
       "  1.42486    0.242666\n",
       " -0.721004  -0.821166\n",
       "\n",
       "[:, :, 3] =\n",
       "  0.783997   1.87251 \n",
       " -1.25609    0.136086\n",
       "  0.969948  -0.383294\n",
       " -0.303481  -0.6856  \n",
       "\n",
       "[:, :, 4] =\n",
       "  1.34294   -0.063962\n",
       "  0.245558   1.56128 \n",
       " -0.830528   1.00754 \n",
       " -0.709913   0.225044"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = UMPS(randn(4,2,4))  # Create a new instance of UMPS.\n",
    "M.A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "UMPS{Float64}([-0.846168 -1.41074; -1.05757 -0.586876; … ; 0.312067 -1.64696; -0.378433 0.242243]\n",
       "\n",
       "[0.2704 2.35381; 0.241059 0.710148; … ; 0.618658 1.01747; 0.249869 -0.0999388]\n",
       "\n",
       "[-0.473256 0.976609; 0.00953401 -0.457308; … ; 0.570835 -2.50081; 0.0329324 0.351769]\n",
       "\n",
       "[2.19616 -2.25986; -1.07877 0.705594; … ; 1.55647 -2.29203; 0.648942 0.911258]\n",
       "\n",
       "[-0.810223 0.797905; 0.584915 2.12501; … ; -0.697768 -0.560918; -1.98353 0.403346]\n",
       "\n",
       "[-0.793436 -0.0985046; 1.16135 -0.108438; … ; -0.478436 0.889807; 0.987962 -1.17988]\n",
       "\n",
       "[-0.220849 -0.281321; -0.171815 -0.611377; … ; -0.416637 -1.69347; 0.453566 -0.435341]\n",
       "\n",
       "[1.10113 0.55644; 1.16726 0.58958; … ; 0.0132259 1.94401; -0.977716 -0.469378]\n",
       "\n",
       "[0.646013 1.1265; -0.79689 1.59958; … ; 0.988167 0.479808; 0.917322 -0.807249]\n",
       "\n",
       "[-1.68409 0.223433; 2.59853 -0.112798; … ; -2.55285 0.549835; 0.538366 -0.0637573])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function rand_UMPS(d::Int, D::Int)  # Specify that the arguments of rand_UMPS must be Ints.\n",
    "    shp = (D, d, D)\n",
    "    A = randn(shp)\n",
    "    return UMPS{Float64}(A)\n",
    "end\n",
    "\n",
    "# Try modifying the above function so that it can take in a third argument,\n",
    "# that would be the element type of the UMPS (above it's just always Float64).\n",
    "\n",
    "rumps = rand_UMPS(2, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Two different methods for the function bond_dim.\n",
    "# Every time bond_dim is called, Julia looks at the type of the argument.\n",
    "# If the argument is an MPSTensor, the first method is executed.\n",
    "# If the argument is a UMPS, the second method is executed.\n",
    "bond_dim(A::MPSTensor) = size(A, 1)\n",
    "bond_dim(M::UMPS) = bond_dim(M.A)\n",
    "\n",
    "bond_dim(rumps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "UMPS{Float64}([0.522837 1.00385; 0.805443 -1.41565; 0.0202699 0.842224]\n",
       "\n",
       "[0.542974 -0.196122; 0.112067 1.24749; 0.396193 -2.39049]\n",
       "\n",
       "[1.5308 -0.356433; -0.0432526 -1.26136; -1.49503 0.00949274])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Whenever a function modifies its arguments, the name should end in a \"!\".\n",
    "# This is not syntax of the language, but just a convention.\n",
    "# Please follow it though.\n",
    "set_mps_tensor!{T}(M::UMPS{T}, A::MPSTensor{T}) = M.A = A\n",
    "\n",
    "set_mps_tensor!(rumps, randn(3,2,3))\n",
    "rumps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.6.0",
   "language": "julia",
   "name": "julia-0.6"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}