{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Testing Julia - first steps using linear algebra" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "At the beginning of the file, we have to load the packages that we want in this notebook. Here \"LinearAlgebra\" and \"Plots\"." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "using LinearAlgebra" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "using Plots" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the computing lab on tensor network renormalization, we will define tensors as multidimensional arrays. Here is 4-dimensional example." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "That way we also see how to define a function." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "define_array (generic function with 1 method)" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function define_array()\n", " \n", " result = zeros(Int,4,4,4,4) #This command creates a 4-dim array with a range of 4 each.\n", " #The entries are all zero and Integer.\n", " \n", " # As a next step, we change its values. We go through the entries using for loops.\n", " \n", " count = 0\n", " \n", " for i in 1:4, j in 1:4, k in 1:4, l in 1:4 #This is a short hand version for mulitple for loops\n", " \n", " # 1:4 just gives a vector with the entries 1,2,3,4\n", " \n", " count += 1 # Here we increase the value of the (local) variable count by 1.\n", " \n", " result[i,j,k,l] = count\n", " \n", " end\n", " \n", " result #As a last statement for end of the function means that we return the array result.\n", " \n", "end" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4×4×4×4 Array{Int64,4}:\n", "[:, :, 1, 1] =\n", " 1 17 33 49\n", " 65 81 97 113\n", " 129 145 161 177\n", " 193 209 225 241\n", "\n", "[:, :, 2, 1] =\n", " 5 21 37 53\n", " 69 85 101 117\n", " 133 149 165 181\n", " 197 213 229 245\n", "\n", "[:, :, 3, 1] =\n", " 9 25 41 57\n", " 73 89 105 121\n", " 137 153 169 185\n", " 201 217 233 249\n", "\n", "[:, :, 4, 1] =\n", " 13 29 45 61\n", " 77 93 109 125\n", " 141 157 173 189\n", " 205 221 237 253\n", "\n", "[:, :, 1, 2] =\n", " 2 18 34 50\n", " 66 82 98 114\n", " 130 146 162 178\n", " 194 210 226 242\n", "\n", "[:, :, 2, 2] =\n", " 6 22 38 54\n", " 70 86 102 118\n", " 134 150 166 182\n", " 198 214 230 246\n", "\n", "[:, :, 3, 2] =\n", " 10 26 42 58\n", " 74 90 106 122\n", " 138 154 170 186\n", " 202 218 234 250\n", "\n", "[:, :, 4, 2] =\n", " 14 30 46 62\n", " 78 94 110 126\n", " 142 158 174 190\n", " 206 222 238 254\n", "\n", "[:, :, 1, 3] =\n", " 3 19 35 51\n", " 67 83 99 115\n", " 131 147 163 179\n", " 195 211 227 243\n", "\n", "[:, :, 2, 3] =\n", " 7 23 39 55\n", " 71 87 103 119\n", " 135 151 167 183\n", " 199 215 231 247\n", "\n", "[:, :, 3, 3] =\n", " 11 27 43 59\n", " 75 91 107 123\n", " 139 155 171 187\n", " 203 219 235 251\n", "\n", "[:, :, 4, 3] =\n", " 15 31 47 63\n", " 79 95 111 127\n", " 143 159 175 191\n", " 207 223 239 255\n", "\n", "[:, :, 1, 4] =\n", " 4 20 36 52\n", " 68 84 100 116\n", " 132 148 164 180\n", " 196 212 228 244\n", "\n", "[:, :, 2, 4] =\n", " 8 24 40 56\n", " 72 88 104 120\n", " 136 152 168 184\n", " 200 216 232 248\n", "\n", "[:, :, 3, 4] =\n", " 12 28 44 60\n", " 76 92 108 124\n", " 140 156 172 188\n", " 204 220 236 252\n", "\n", "[:, :, 4, 4] =\n", " 16 32 48 64\n", " 80 96 112 128\n", " 144 160 176 192\n", " 208 224 240 256" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "test_array = define_array()" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# The notation array[:,:,1,1] means all entries in the first two indices, which gives a matrix." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Tensor network renormalization algorithms employ a singular value decomposition at some point in order to split a tensor into two parts." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A singular value decomposition is a decomposition of a matrix $M$, similar to the eigenvalue decomposition. The singular value decomposition is more general and can be applied to all matrices, e.g. with different numbers of rows and columns." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$M_{AB} = \\sum_{i=1}^N U_{Ai} \\lambda_i (V^\\dagger)_{iB}$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Each matrix is split into two matrices of singular vectors, with a diagonal matrix of singular values $\\lambda_i$. The matrices $U$ and $V$ are unitary. The singular values $\\lambda_i$ are ordered in size $\\lambda_1 \\geq \\lambda_2 \\geq \\dots \\geq \\lambda_N$ and always greater or equal to zero." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will use the latter fact to approximate a matrix, by a matrix of smaller rank by truncating the number of singular values. In fact this is the best possible approximation." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "length(test_array[:,1,1,1]) # This returns the index range of the first index of test_array" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "define_matrix (generic function with 1 method)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function define_matrix(array::Array{Int64,4}) # We can pass objects to functions.\n", " # These objects can be of different type, Int, Float, etc. They need not be specified.\n", " # Here I pass an array with 4 entries.\n", " \n", " # Here we will simply combine two indices of the array into one index of the matrix.\n", " \n", " len = 4^2 #Length of the combined index, simply squared\n", " \n", " mat = zeros(Int,len,len) #Initialize a 2-dim array with index lengths len\n", " \n", " index1 = 0 \n", " \n", " for i in 1:4, j in 1:4 # We combine the indices i and j into index1\n", " \n", " index1 += 1\n", " \n", " index2 = 0\n", " \n", " for k in 1:4, l in 1:4 # We combine the indices k and l into index2\n", " \n", " index2 += 1\n", " \n", " mat[index1,index2] = array[i,j,k,l] # i is first index of array, j second etc.\n", " \n", " end\n", " \n", " end\n", " \n", " return mat\n", " \n", "end" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "16×16 Array{Int64,2}:\n", " 1 2 3 4 5 6 7 8 … 10 11 12 13 14 15 16\n", " 17 18 19 20 21 22 23 24 26 27 28 29 30 31 32\n", " 33 34 35 36 37 38 39 40 42 43 44 45 46 47 48\n", " 49 50 51 52 53 54 55 56 58 59 60 61 62 63 64\n", " 65 66 67 68 69 70 71 72 74 75 76 77 78 79 80\n", " 81 82 83 84 85 86 87 88 … 90 91 92 93 94 95 96\n", " 97 98 99 100 101 102 103 104 106 107 108 109 110 111 112\n", " 113 114 115 116 117 118 119 120 122 123 124 125 126 127 128\n", " 129 130 131 132 133 134 135 136 138 139 140 141 142 143 144\n", " 145 146 147 148 149 150 151 152 154 155 156 157 158 159 160\n", " 161 162 163 164 165 166 167 168 … 170 171 172 173 174 175 176\n", " 177 178 179 180 181 182 183 184 186 187 188 189 190 191 192\n", " 193 194 195 196 197 198 199 200 202 203 204 205 206 207 208\n", " 209 210 211 212 213 214 215 216 218 219 220 221 222 223 224\n", " 225 226 227 228 229 230 231 232 234 235 236 237 238 239 240\n", " 241 242 243 244 245 246 247 248 … 250 251 252 253 254 255 256" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "test_matrix = define_matrix(test_array)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we will split this matrix via a SVD. The algorithm is called svd()" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "SVD{Float64,Float64,Array{Float64,2}}([-0.0145417 -0.47721 … 0.00063215 -8.11381e-5; -0.0415193 -0.430164 … -0.0439117 -0.0379026; … ; -0.392229 0.181442 … -0.121057 -0.151787; -0.419207 0.228489 … -0.0897977 -0.019227], [2371.47, 36.703, 2.18744e-13, 1.93229e-14, 4.85062e-15, 3.31781e-15, 1.9195e-15, 1.7607e-15, 6.68182e-16, 6.27723e-16, 4.50312e-16, 4.33696e-16, 2.03852e-16, 9.1788e-17, 3.14262e-17, 2.0601e-17], [-0.238935 -0.240398 … -0.25942 -0.260883; 0.413342 0.359129 … -0.345639 -0.399851; … ; -0.00283039 -0.0439496 … -0.24737 -0.0517477; -0.00369406 -0.022683 … 0.348603 0.0407458])" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "decomp = svd(test_matrix)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It returns a particular type, called SVD object. It contains two matrices, $U$ and $V$, and a vector for the singular values." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can access these separate objects as follows" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "16×16 Array{Float64,2}:\n", " -0.0145417 -0.47721 0.877905 0.0356598 … 0.00063215 -8.11381e-5\n", " -0.0415193 -0.430164 -0.228047 0.0126223 -0.0439117 -0.0379026 \n", " -0.068497 -0.383117 -0.206071 -0.0760275 -0.014234 0.0355871 \n", " -0.0954746 -0.336071 -0.182284 -0.0945369 0.0340277 -0.0358852 \n", " -0.122452 -0.289024 -0.155852 -0.141728 -0.076995 -0.0513588 \n", " -0.14943 -0.241977 -0.130402 -0.113568 … -0.337539 -0.0636851 \n", " -0.176408 -0.194931 -0.116926 0.174946 -0.0371312 0.302407 \n", " -0.203385 -0.147884 -0.0790673 -0.150308 0.150812 0.0396611 \n", " -0.230363 -0.100838 -0.066389 0.16775 0.628319 -0.628628 \n", " -0.257341 -0.053791 -0.053389 0.485636 0.191314 0.494272 \n", " -0.284318 -0.00674436 -0.0147308 0.147165 … -0.281549 0.0328115 \n", " -0.311296 0.0403022 0.0207945 -0.15108 -0.355723 -0.245003 \n", " -0.338274 0.0873488 0.0610389 -0.497359 0.431925 0.407556 \n", " -0.365251 0.134395 0.0471186 0.495459 -0.0790922 -0.0787365 \n", " -0.392229 0.181442 0.0918594 0.0153997 -0.121057 -0.151787 \n", " -0.419207 0.228489 0.134442 -0.310033 … -0.0897977 -0.019227 " ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "decomp.U # returns U / matrix of left singular vectors" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "16-element Array{Float64,1}:\n", " 2371.4697745275225 \n", " 36.70297675092284 \n", " 2.1874358375259716e-13\n", " 1.932294941733821e-14 \n", " 4.850616525069149e-15 \n", " 3.3178076368202656e-15\n", " 1.919497668944498e-15 \n", " 1.7607048654808919e-15\n", " 6.681818928924322e-16 \n", " 6.277226289603507e-16 \n", " 4.503119525393135e-16 \n", " 4.3369600867093563e-16\n", " 2.038519082565345e-16 \n", " 9.178801237252475e-17 \n", " 3.1426202195463304e-17\n", " 2.0600971023587986e-17" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "decomp.S # returns S / vector of singular values\n", "# It drops off quickly!" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "16×16 Adjoint{Float64,Array{Float64,2}}:\n", " -0.238935 0.413342 0.343374 -0.807026 … -0.00283039 -0.00369406\n", " -0.240398 0.359129 -0.231413 0.190344 -0.0439496 -0.022683 \n", " -0.241861 0.304916 -0.196348 0.144926 -0.0219273 0.0622751 \n", " -0.243324 0.250703 0.28938 0.324441 -0.0964564 0.431118 \n", " -0.244788 0.19649 -0.128931 0.0992181 -0.167156 0.353492 \n", " -0.246251 0.142277 -0.551504 -0.119508 … -0.0743893 -0.266536 \n", " -0.247714 0.0880644 0.39336 0.26818 -0.0882288 -0.485153 \n", " -0.249177 0.0338516 -0.0264645 0.0919665 0.617871 -0.0679058 \n", " -0.250641 -0.0203613 0.00899613 0.0714037 -0.174363 -0.341855 \n", " -0.252104 -0.0745742 0.0406676 0.0675812 -0.022053 -0.131256 \n", " -0.253567 -0.128787 0.0759195 0.0171444 … 0.479403 0.299421 \n", " -0.25503 -0.183 0.109032 0.0196721 0.191193 -0.081055 \n", " -0.256493 -0.237213 0.144965 0.0290439 -0.431585 0.00662741\n", " -0.257957 -0.291426 -0.271707 -0.167327 0.133589 -0.142144 \n", " -0.25942 -0.345639 -0.2403 -0.204626 -0.24737 0.348603 \n", " -0.260883 -0.399851 0.240972 -0.0254334 … -0.0517477 0.0407458 " ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "decomp.V # returns V / matrix of right singular vectors" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "16×16 Array{Float64,2}:\n", " -0.238935 -0.240398 -0.241861 … -0.257957 -0.25942 -0.260883 \n", " 0.413342 0.359129 0.304916 -0.291426 -0.345639 -0.399851 \n", " 0.343374 -0.231413 -0.196348 -0.271707 -0.2403 0.240972 \n", " -0.807026 0.190344 0.144926 -0.167327 -0.204626 -0.0254334\n", " -0.0279483 -0.79002 0.281199 0.131557 0.0594036 -0.346012 \n", " -0.0366584 -0.232357 -0.0114917 … -0.459962 -0.295669 0.433644 \n", " 0.011879 -0.0633875 0.179315 0.00193742 0.0972702 0.51369 \n", " 0.0138198 0.0259141 -0.128892 0.414475 -0.553956 -0.0195393\n", " -0.00910297 0.134537 0.24255 0.272738 -0.0255526 0.227439 \n", " 0.00869267 -0.0785152 0.352167 0.31024 -0.125884 0.113255 \n", " -0.0113125 0.101279 -0.0247876 … -0.00320121 0.183981 -0.0556296\n", " -0.00386241 0.0369098 -0.315139 -0.145062 0.21606 -0.103957 \n", " 0.00903117 -0.0058126 0.595635 -0.300471 -0.0170939 0.0298413\n", " -0.000599737 -0.0477117 -0.13814 0.161308 -0.16218 0.240058 \n", " -0.00283039 -0.0439496 -0.0219273 0.133589 -0.24737 -0.0517477\n", " -0.00369406 -0.022683 0.0622751 … -0.142144 0.348603 0.0407458" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "decomp.V' # return V^\\dagger" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can reconstruct the matrix test_matrix from the SVD data" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "16×16 Array{Float64,2}:\n", " 1.0 2.0 3.0 4.0 5.0 … 12.0 13.0 14.0 15.0 16.0\n", " 17.0 18.0 19.0 20.0 21.0 28.0 29.0 30.0 31.0 32.0\n", " 33.0 34.0 35.0 36.0 37.0 44.0 45.0 46.0 47.0 48.0\n", " 49.0 50.0 51.0 52.0 53.0 60.0 61.0 62.0 63.0 64.0\n", " 65.0 66.0 67.0 68.0 69.0 76.0 77.0 78.0 79.0 80.0\n", " 81.0 82.0 83.0 84.0 85.0 … 92.0 93.0 94.0 95.0 96.0\n", " 97.0 98.0 99.0 100.0 101.0 108.0 109.0 110.0 111.0 112.0\n", " 113.0 114.0 115.0 116.0 117.0 124.0 125.0 126.0 127.0 128.0\n", " 129.0 130.0 131.0 132.0 133.0 140.0 141.0 142.0 143.0 144.0\n", " 145.0 146.0 147.0 148.0 149.0 156.0 157.0 158.0 159.0 160.0\n", " 161.0 162.0 163.0 164.0 165.0 … 172.0 173.0 174.0 175.0 176.0\n", " 177.0 178.0 179.0 180.0 181.0 188.0 189.0 190.0 191.0 192.0\n", " 193.0 194.0 195.0 196.0 197.0 204.0 205.0 206.0 207.0 208.0\n", " 209.0 210.0 211.0 212.0 213.0 220.0 221.0 222.0 223.0 224.0\n", " 225.0 226.0 227.0 228.0 229.0 236.0 237.0 238.0 239.0 240.0\n", " 241.0 242.0 243.0 244.0 245.0 … 252.0 253.0 254.0 255.0 256.0" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "decomp.U * Diagonal(decomp.S) * decomp.V' # Notice that the type of the object has changed." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let us try to approximate the matrix by another matrix of lower rank." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let us start with rank 1." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "16×16 Array{Float64,2}:\n", " 8.2397 8.29016 8.34061 … 8.89567 8.94613 8.99659\n", " 23.526 23.67 23.8141 25.3989 25.543 25.687 \n", " 38.8122 39.0499 39.2876 41.9021 42.1398 42.3775 \n", " 54.0985 54.4298 54.7611 58.4053 58.7366 59.0679 \n", " 69.3847 69.8097 70.2346 74.9085 75.3335 75.7584 \n", " 84.671 85.1895 85.708 … 91.4118 91.9303 92.4488 \n", " 99.9573 100.569 101.182 107.915 108.527 109.139 \n", " 115.244 115.949 116.655 124.418 125.124 125.83 \n", " 130.53 131.329 132.129 140.921 141.721 142.52 \n", " 145.816 146.709 147.602 157.425 158.318 159.211 \n", " 161.102 162.089 163.075 … 173.928 174.914 175.901 \n", " 176.389 177.469 178.549 190.431 191.511 192.591 \n", " 191.675 192.849 194.022 206.934 208.108 209.282 \n", " 206.961 208.229 209.496 223.438 224.705 225.972 \n", " 222.247 223.608 224.969 239.941 241.302 242.663 \n", " 237.534 238.988 240.443 … 256.444 257.899 259.353 " ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "decomp.U[:,1] * decomp.S[1] * transpose(decomp.V'[1,:]) # Notation is always a bit subtle\n", "# the transpose is necessary to create a matrix" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "16×16 Array{Float64,2}:\n", " 8.2397 8.29016 8.34061 … 8.89567 8.94613 8.99659\n", " 23.526 23.67 23.8141 25.3989 25.543 25.687 \n", " 38.8122 39.0499 39.2876 41.9021 42.1398 42.3775 \n", " 54.0985 54.4298 54.7611 58.4053 58.7366 59.0679 \n", " 69.3847 69.8097 70.2346 74.9085 75.3335 75.7584 \n", " 84.671 85.1895 85.708 … 91.4118 91.9303 92.4488 \n", " 99.9573 100.569 101.182 107.915 108.527 109.139 \n", " 115.244 115.949 116.655 124.418 125.124 125.83 \n", " 130.53 131.329 132.129 140.921 141.721 142.52 \n", " 145.816 146.709 147.602 157.425 158.318 159.211 \n", " 161.102 162.089 163.075 … 173.928 174.914 175.901 \n", " 176.389 177.469 178.549 190.431 191.511 192.591 \n", " 191.675 192.849 194.022 206.934 208.108 209.282 \n", " 206.961 208.229 209.496 223.438 224.705 225.972 \n", " 222.247 223.608 224.969 239.941 241.302 242.663 \n", " 237.534 238.988 240.443 … 256.444 257.899 259.353 " ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "decomp.U[:,1] * decomp.S[1] * transpose(decomp.V[:,1]) # Notation is always a bit subtle\n", "# This is an alternative way to write it. V is real, so we can do not need to conjugate." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The approximation is not too bad. Let us improve it by taking the second singular value into account." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "16×16 Array{Float64,2}:\n", " 1.0 2.0 3.0 4.0 5.0 … 12.0 13.0 14.0 15.0 16.0\n", " 17.0 18.0 19.0 20.0 21.0 28.0 29.0 30.0 31.0 32.0\n", " 33.0 34.0 35.0 36.0 37.0 44.0 45.0 46.0 47.0 48.0\n", " 49.0 50.0 51.0 52.0 53.0 60.0 61.0 62.0 63.0 64.0\n", " 65.0 66.0 67.0 68.0 69.0 76.0 77.0 78.0 79.0 80.0\n", " 81.0 82.0 83.0 84.0 85.0 … 92.0 93.0 94.0 95.0 96.0\n", " 97.0 98.0 99.0 100.0 101.0 108.0 109.0 110.0 111.0 112.0\n", " 113.0 114.0 115.0 116.0 117.0 124.0 125.0 126.0 127.0 128.0\n", " 129.0 130.0 131.0 132.0 133.0 140.0 141.0 142.0 143.0 144.0\n", " 145.0 146.0 147.0 148.0 149.0 156.0 157.0 158.0 159.0 160.0\n", " 161.0 162.0 163.0 164.0 165.0 … 172.0 173.0 174.0 175.0 176.0\n", " 177.0 178.0 179.0 180.0 181.0 188.0 189.0 190.0 191.0 192.0\n", " 193.0 194.0 195.0 196.0 197.0 204.0 205.0 206.0 207.0 208.0\n", " 209.0 210.0 211.0 212.0 213.0 220.0 221.0 222.0 223.0 224.0\n", " 225.0 226.0 227.0 228.0 229.0 236.0 237.0 238.0 239.0 240.0\n", " 241.0 242.0 243.0 244.0 245.0 … 252.0 253.0 254.0 255.0 256.0" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "decomp.U[:,1] * decomp.S[1] * transpose(decomp.V'[1,:]) +\n", "decomp.U[:,2] * decomp.S[2] * transpose(decomp.V'[2,:]) # Julia understand that you want to add two matrices" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The approximation is perfect, since all other singular values are tiny in comparison." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simple plot" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As a last step, let us plot something to test whether plot is working." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let us just plot 10 random numbers" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "plot(1:10,rand(10))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first vector describes the entries on the x-axis, the second vector for the y-axis." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also plot multiple functions." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "plot(pi/50*(0:100),[cos.(pi/50*(0:100)),sin.(pi/50*(0:100))]) # cos. just means that cos is applied\n", "# to each entry of the vector" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Julia 1.0.1", "language": "julia", "name": "julia-1.0" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "1.0.1" } }, "nbformat": 4, "nbformat_minor": 2 }