From edb72fa77407b41e477527084b19c5e9ffbf2e28 Mon Sep 17 00:00:00 2001 From: Manvitha Ponnapati Date: Sun, 18 Feb 2018 14:43:41 -0500 Subject: [PATCH 1/8] chapter 1 files --- textbook/chapter1/code11_bellcurve.jl | 0 textbook/chapter1/code12_semicircle.jl | 0 textbook/chapter1/code13_tracywidom.jl | 0 textbook/chapter1/code14_largeeig.jl | 0 4 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 textbook/chapter1/code11_bellcurve.jl create mode 100644 textbook/chapter1/code12_semicircle.jl create mode 100644 textbook/chapter1/code13_tracywidom.jl create mode 100644 textbook/chapter1/code14_largeeig.jl diff --git a/textbook/chapter1/code11_bellcurve.jl b/textbook/chapter1/code11_bellcurve.jl new file mode 100644 index 0000000..e69de29 diff --git a/textbook/chapter1/code12_semicircle.jl b/textbook/chapter1/code12_semicircle.jl new file mode 100644 index 0000000..e69de29 diff --git a/textbook/chapter1/code13_tracywidom.jl b/textbook/chapter1/code13_tracywidom.jl new file mode 100644 index 0000000..e69de29 diff --git a/textbook/chapter1/code14_largeeig.jl b/textbook/chapter1/code14_largeeig.jl new file mode 100644 index 0000000..e69de29 From 5f54bf0d108310c64eb7177a421ebd692e2505f5 Mon Sep 17 00:00:00 2001 From: Manvitha Ponnapati Date: Sun, 18 Feb 2018 15:33:34 -0500 Subject: [PATCH 2/8] code11 --- textbook/chapter1/code11_bellcurve.jl | 32 +++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/textbook/chapter1/code11_bellcurve.jl b/textbook/chapter1/code11_bellcurve.jl index e69de29..bf60cdc 100644 --- a/textbook/chapter1/code11_bellcurve.jl +++ b/textbook/chapter1/code11_bellcurve.jl @@ -0,0 +1,32 @@ +#= +bellcurve.jl + +ALGORITHM 1.1 of Random Eigenvalues by Alan Edelman + +EXPERIMENT : Generate random samples from the normal distribution +PLOT : Histogram of random samples +THEORY : The normal distribution curve +=# + +# ------------ # +# EXPERIMENT +# ------------ # +t = 10000 #trials +dx = .2 #binsize +v = randn(t); #randn - Generate a normally-distributed random number with mean 0 and standard deviation 1. + +# ------------ # +# PLOT +# ------------ # +# Install package with +# Pkg.clone("https://github.com/plotly/Plotly.jl") +using Plotly +plotly() + +x = -4:dx:4 +histogram(v, xlim=(-4,4), nbins=length(x), normed=true ) + +# ------------ # +# THEORY +# ------------ # +plot!(x,exp.(-x.^2/2)/sqrt(2*pi)) From 1f9df49b30775cbaa4085d1df84988a0eeb07164 Mon Sep 17 00:00:00 2001 From: Manvitha Ponnapati Date: Sun, 18 Feb 2018 15:50:11 -0500 Subject: [PATCH 3/8] Code 12 --- textbook/chapter1/code11_bellcurve.jl | 14 ++++++--- textbook/chapter1/code12_semicircle.jl | 43 ++++++++++++++++++++++++++ 2 files changed, 52 insertions(+), 5 deletions(-) diff --git a/textbook/chapter1/code11_bellcurve.jl b/textbook/chapter1/code11_bellcurve.jl index bf60cdc..42cc14c 100644 --- a/textbook/chapter1/code11_bellcurve.jl +++ b/textbook/chapter1/code11_bellcurve.jl @@ -8,18 +8,22 @@ PLOT : Histogram of random samples THEORY : The normal distribution curve =# +# ------------ # +# PARAMETERS +# ------------ # +t = 10000 # trials +dx = .2 # binsize + # ------------ # # EXPERIMENT # ------------ # -t = 10000 #trials -dx = .2 #binsize -v = randn(t); #randn - Generate a normally-distributed random number with mean 0 and standard deviation 1. +v = randn(t); # randn - Generate a normally-distributed random number with mean 0 and standard deviation 1. # ------------ # # PLOT # ------------ # -# Install package with -# Pkg.clone("https://github.com/plotly/Plotly.jl") +# Install package with Pkg.add("Plots") +Pkg.clone("https://github.com/plotly/Plotly.jl") using Plotly plotly() diff --git a/textbook/chapter1/code12_semicircle.jl b/textbook/chapter1/code12_semicircle.jl index e69de29..19c9cc1 100644 --- a/textbook/chapter1/code12_semicircle.jl +++ b/textbook/chapter1/code12_semicircle.jl @@ -0,0 +1,43 @@ +#= +semicircle.jl + +ALGORITHM 1.2 of Random Eigenvalues by Alan Edelman + +EXPERIMENT : Sample random symmetric Gaussian matrices +PLOT : Histogram of the eigenvalues +THEORY : Semicircle as n -> infinity +=# + +# ------------ # +# PARAMETERS +# ------------ # +n = 100 # matrix size +t = 25 # trials +v = Float64[] # eigenvalue samples +dx = .2 # binsize + +# ------------ # +# EXPERIMENT +# ------------ # +for i=1:t + A = randn(n,n) # n by n matrix of random Gaussians + S = (A+A')/2 # symmetrize matrix + v = append!(v, eigvals(S)) # eigenvalues +end +v = v/√(n/2) # normalize eigenvalues + +# ------------ # +# PLOT +# ------------ # +# Install package with Pkg.add("Plots") +# Pkg.clone("https://github.com/plotly/Plotly.jl") +using Plotly +plotly() + +x = -2:dx:2 +histogram(v, xlim=(-2,2), nbins=length(x), normed=true ) + +# ------------ # +# THEORY +# ------------ # +plot!(x,sqrt.(4 - x.^2)/(2*π)) From e315060c578f74ca2933f2289c733b1ebbab592b Mon Sep 17 00:00:00 2001 From: Manvitha Ponnapati Date: Sun, 18 Feb 2018 18:16:34 -0500 Subject: [PATCH 4/8] code12 code 14 --- textbook/chapter1/code11_bellcurve.jl | 2 +- textbook/chapter1/code13_tracywidom.jl | 40 ++++++++++++++++++++++++ textbook/chapter1/code14_largeeig.jl | 43 ++++++++++++++++++++++++++ 3 files changed, 84 insertions(+), 1 deletion(-) diff --git a/textbook/chapter1/code11_bellcurve.jl b/textbook/chapter1/code11_bellcurve.jl index 42cc14c..4d80cf3 100644 --- a/textbook/chapter1/code11_bellcurve.jl +++ b/textbook/chapter1/code11_bellcurve.jl @@ -23,7 +23,7 @@ v = randn(t); # randn - Generate a normally-distributed random number with mean # PLOT # ------------ # # Install package with Pkg.add("Plots") -Pkg.clone("https://github.com/plotly/Plotly.jl") +# Pkg.clone("https://github.com/plotly/Plotly.jl") using Plotly plotly() diff --git a/textbook/chapter1/code13_tracywidom.jl b/textbook/chapter1/code13_tracywidom.jl index e69de29..dc20384 100644 --- a/textbook/chapter1/code13_tracywidom.jl +++ b/textbook/chapter1/code13_tracywidom.jl @@ -0,0 +1,40 @@ +#= +tracywidom.jl + +ALGORITHM 1.3 of Random Eigenvalues by Alan Edelman + +EXPERIMENT : ~ +PLOT : Tracy widom distribution +THEORY : Compute tracy-widom distribution +=# + +# ------------ # +# PARAMETERS +# ------------ # +t0 = 5.0 # right endpoint +tn = -8.0 # left endpoint +dx = 0.005 # discretization + +# ------------ # +# THEORY +# ------------ # +# Install the differential equations solver package with +# Pkg.add("DifferentialEquations") + +using DifferentialEquations + +# System of differential equations described in Eq.(1.6) +function tw_diff_eq_system(dy,y,t) + dy[1] = y[2] + dy[2] = t*y[1]+2*y[1]^3 + dy[3] = y[4] + dy[4] = y[1] ^ 2 +end + +# To use airy opterator +# Pkg.add("SpecialFunctions") +using SpecialFunctions +y0 = [airyai.(t0);airyai.([1,t0]);0;(airyai.(t0))^2] +tspan = (tn,t0) +prob = ODEProblem(tw_diff_eq_system,y0,tspan) +sol = solve(prob,reltol=1e-12,abstol=1e-15) diff --git a/textbook/chapter1/code14_largeeig.jl b/textbook/chapter1/code14_largeeig.jl index e69de29..3a314f4 100644 --- a/textbook/chapter1/code14_largeeig.jl +++ b/textbook/chapter1/code14_largeeig.jl @@ -0,0 +1,43 @@ +#= +largeeig.jl + +ALGORITHM 1.4 of Random Eigenvalues by Alan Edelman + +EXPERIMENT : Largest eigenvalue of random Hermitian matrices +PLOT : Histogram of the normalized eigenvalues +THEORY : Tracy-widom as n-> infinity +=# + +# ------------ # +# PARAMETERS +# ------------ # +n = 100 # matrix size +t = 5000 # trials +v = Float64[] # eigenvalue samples +dx = .2 # binsize + +# ------------ # +# EXPERIMENT +# ------------ # +for i=1:t + A = randn(n,n)+im*randn(n,n) # n by n matrix of random Gaussians + S = (A+A')/2 # symmetrize matrix + v = append!(v, maximum(eigvals(S))) # eigenvalues +end +v = n^(1/6)*(v-2*√n) # normalize eigenvalues + +# ------------ # +# PLOT +# ------------ # +# Install package with Pkg.add("Plots") +# Pkg.clone("https://github.com/plotly/Plotly.jl") +using Plotly +plotly() + +x = -5:dx:2 +histogram(v, xlim=(-5,2), nbins=length(x), normed=true ) + +# ------------ # +# THEORY +# ------------ # +# Plot tracy widom From a70d9050d4f8dca7dd2af67b0e8cb60a4510647d Mon Sep 17 00:00:00 2001 From: Manvitha Ponnapati Date: Fri, 4 May 2018 04:55:54 -0400 Subject: [PATCH 5/8] save --- textbook/chapter4/Chapter4.ipynb | 246 +++++++++++++++++++++++++++++++ 1 file changed, 246 insertions(+) create mode 100644 textbook/chapter4/Chapter4.ipynb diff --git a/textbook/chapter4/Chapter4.ipynb b/textbook/chapter4/Chapter4.ipynb new file mode 100644 index 0000000..00dd435 --- /dev/null +++ b/textbook/chapter4/Chapter4.ipynb @@ -0,0 +1,246 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Code 4.1 Marˇcenko–Pastur Singular Value Formulation (r = 0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Experiment : Gaussian Random\n", + "# Plot : Histogram of the eigenvalues of X’X/m\n", + "# Theory : Marcenko−Pastur as n−>infinity\n", + "\n", + "## Definition of Parameters\n", + "t = 1 # Number of trials\n", + "r = 0.1 #aspect ratio n/m -->r <= 1\n", + "n = 2000 #column width of matrix\n", + "m = Int64.(n/r) \n", + "v = [] #eigenvalues\n", + "dx = 0.1 #binsize\n", + "\n", + "## Experiment\n", + "for i = 1:t\n", + " X = randn(m,n) # n-by-n matrix of random Gaussians\n", + " s = X'*X # symmetrize positive definite matrix\n", + " v = append!(v,eigvals(s)) # eigenvalues\n", + "end\n", + "\n", + "## Normalized Eigenvalues\n", + "v = v/m\n", + "a = (1-sqrt.(r))^2\n", + "b = (1+sqrt.(r))^2\n", + "\n", + "## Plot\n", + "using StatsBase, Plots #Install using Pkg.add(\"Plots\") and install a pyplot backend using Pkg.add(\"PyPlot\")\n", + "v_hist = fit(Histogram,v,closed=:left,a:dx:b)\n", + "bar(v_hist.edges,v_hist.weights/(t*dx*n))\n", + "\n", + "## Theory\n", + "x = linspace(a,b)\n", + "plot!(x,(sqrt.((x-a).*(b-x)))./(2*pi*r*x),linewidth=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Code 4.2 Numerical check of the Cauchy transform of the Marˇcenko–Pastur Law" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1×2 Array{Float64,2}:\n", + " 0.668628 0.666667" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Experiment : Calculate Cauchy transform as trace of resolvent of wishart matrix\n", + "# Theory : Marˇcenko–Pastur Law¶\n", + "\n", + "m = 2000\n", + "n = 1000\n", + "r = n/m # Remeber n/m <= 1 as m -> infinity\n", + "\n", + "a = (1-sqrt.(r))^2\n", + "b = (1+sqrt.(r))^2\n", + "\n", + "z = 3 # Should be outside [a,b]\n", + "X = randn(m,n) \n", + "W = (X'*X)/m # Wishart Matrix\n", + "[trace(inv(z*eye(n)-W))/n (z-1+r-sqrt.((z-a)*(z-b)))/(2*r*z)]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Code 4.3 Wachter Law in cosine squared format (a = 5, b = 10)" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "execution_count": 133, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Experiment : Gaussian Random\n", + "# Plot : Histogram of the eigenvalues of (AA’ + BB’ ) ˆ{−1}(AA’)\n", + "# Theory : Watcher Law as n−>infinity\n", + "\n", + "## Parameters\n", + "t =1000 #trials\n", + "a = 5\n", + "b = 10 \n", + "n=100\n", + "m1=round(a*n)\n", + "m2=round(b*n) \n", + "m = m1 + m2;\n", + "v = [] \n", + "dx = 0.05\n", + "\n", + "## Experiment\n", + "for i = 1:t\n", + " # MANOVA the naive format\n", + " A = randn(m1,n)\n", + " B = randn(m2,n)\n", + " AA = A'*A\n", + " BB = B'*B\n", + " s = (AA+BB)\\AA\n", + " v = append!(v,eigvals(s)) \n", + " #TODO: Do this with gsvd\n", + "end\n", + "\n", + "c = sqrt.(a/(a+b)*(1-1/(a+b))) \n", + "d = sqrt.(1/(a+b)*(1-a/(a+b))) \n", + "\n", + "lmax = (c+d).^2\n", + "lmin = (c-d).^2\n", + "\n", + "## Plot\n", + "using StatsBase, Plots #Install using Pkg.add(\"Plots\") and install a pyplot backend using Pkg.add(\"PyPlot\")\n", + "v_hist = fit(Histogram,v,closed=:left,0:dx:1)\n", + "bar(v_hist.edges,v_hist.weights/(t*dx*n))\n", + "\n", + "## Theory\n", + "x = linspace(lmin,lmax)\n", + "plot!(x,(a+b)*(sqrt.((x-lmin).*(lmax-x)))./(2*pi*x.*(1-x)),linewidth=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Code 4.4 Marˇcenko–Pastur Law used in applications" + ] + }, + { + "cell_type": "code", + "execution_count": 174, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "execution_count": 174, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Experiment : Marcenko−Pastur for application\n", + "# Plot : Histogram of the covariance matrix\n", + "# Theory : Marcenko−Pastur as n−>infinity\n", + "\n", + "\n", + "## Parameters\n", + "t = 100 # trials\n", + "r = 1 # aspect ratio\n", + "n = 100 # matrix columns\n", + "m = Int64.(n/ r)\n", + "v = [] \n", + "dx = 0.1\n", + "\n", + "## Experiment\n", + "for i = 1:t\n", + " a = 1:n\n", + " A = randn(m,n)+4*sqrt.(n)*Diagonal((1:n).<10)\n", + " A = A+sqrt.(n)*Diagonal((1:n).>(n-1))*3\n", + " v = append!(v,svd(A)[2])\n", + "end\n", + "\n", + "## Normalized Eigenvalues\n", + "v = v/(sqrt.(m))\n", + "a = (1-sqrt.(r))\n", + "b = 10\n", + "\n", + "## Plot\n", + "using StatsBase, Plots #Install using Pkg.add(\"Plots\") and install a pyplot backend using Pkg.add(\"PyPlot\")\n", + "v_hist = fit(Histogram,v,closed=:left,(a-dx/2):dx:b)\n", + "bar(v_hist.edges,v_hist.weights/(t*dx*n))\n", + "\n", + "## Theory\n", + "x = linspace(a,b)\n", + "plot!(x,real(sqrt.(((x.^2-a^2).*(2^2-x.^2))+0im))./(pi*x*r),linewidth=2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 0.6.2", + "language": "julia", + "name": "julia-0.6" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "0.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 2bf29eb61f638c7f7d50df99e74e10e1a5e04819 Mon Sep 17 00:00:00 2001 From: Manvitha Ponnapati Date: Fri, 4 May 2018 04:56:15 -0400 Subject: [PATCH 6/8] remove other chapters and add things one by one --- textbook/chapter1/code11_bellcurve.jl | 36 --------------------- textbook/chapter1/code12_semicircle.jl | 43 -------------------------- textbook/chapter1/code13_tracywidom.jl | 40 ------------------------ textbook/chapter1/code14_largeeig.jl | 43 -------------------------- 4 files changed, 162 deletions(-) delete mode 100644 textbook/chapter1/code11_bellcurve.jl delete mode 100644 textbook/chapter1/code12_semicircle.jl delete mode 100644 textbook/chapter1/code13_tracywidom.jl delete mode 100644 textbook/chapter1/code14_largeeig.jl diff --git a/textbook/chapter1/code11_bellcurve.jl b/textbook/chapter1/code11_bellcurve.jl deleted file mode 100644 index 4d80cf3..0000000 --- a/textbook/chapter1/code11_bellcurve.jl +++ /dev/null @@ -1,36 +0,0 @@ -#= -bellcurve.jl - -ALGORITHM 1.1 of Random Eigenvalues by Alan Edelman - -EXPERIMENT : Generate random samples from the normal distribution -PLOT : Histogram of random samples -THEORY : The normal distribution curve -=# - -# ------------ # -# PARAMETERS -# ------------ # -t = 10000 # trials -dx = .2 # binsize - -# ------------ # -# EXPERIMENT -# ------------ # -v = randn(t); # randn - Generate a normally-distributed random number with mean 0 and standard deviation 1. - -# ------------ # -# PLOT -# ------------ # -# Install package with Pkg.add("Plots") -# Pkg.clone("https://github.com/plotly/Plotly.jl") -using Plotly -plotly() - -x = -4:dx:4 -histogram(v, xlim=(-4,4), nbins=length(x), normed=true ) - -# ------------ # -# THEORY -# ------------ # -plot!(x,exp.(-x.^2/2)/sqrt(2*pi)) diff --git a/textbook/chapter1/code12_semicircle.jl b/textbook/chapter1/code12_semicircle.jl deleted file mode 100644 index 19c9cc1..0000000 --- a/textbook/chapter1/code12_semicircle.jl +++ /dev/null @@ -1,43 +0,0 @@ -#= -semicircle.jl - -ALGORITHM 1.2 of Random Eigenvalues by Alan Edelman - -EXPERIMENT : Sample random symmetric Gaussian matrices -PLOT : Histogram of the eigenvalues -THEORY : Semicircle as n -> infinity -=# - -# ------------ # -# PARAMETERS -# ------------ # -n = 100 # matrix size -t = 25 # trials -v = Float64[] # eigenvalue samples -dx = .2 # binsize - -# ------------ # -# EXPERIMENT -# ------------ # -for i=1:t - A = randn(n,n) # n by n matrix of random Gaussians - S = (A+A')/2 # symmetrize matrix - v = append!(v, eigvals(S)) # eigenvalues -end -v = v/√(n/2) # normalize eigenvalues - -# ------------ # -# PLOT -# ------------ # -# Install package with Pkg.add("Plots") -# Pkg.clone("https://github.com/plotly/Plotly.jl") -using Plotly -plotly() - -x = -2:dx:2 -histogram(v, xlim=(-2,2), nbins=length(x), normed=true ) - -# ------------ # -# THEORY -# ------------ # -plot!(x,sqrt.(4 - x.^2)/(2*π)) diff --git a/textbook/chapter1/code13_tracywidom.jl b/textbook/chapter1/code13_tracywidom.jl deleted file mode 100644 index dc20384..0000000 --- a/textbook/chapter1/code13_tracywidom.jl +++ /dev/null @@ -1,40 +0,0 @@ -#= -tracywidom.jl - -ALGORITHM 1.3 of Random Eigenvalues by Alan Edelman - -EXPERIMENT : ~ -PLOT : Tracy widom distribution -THEORY : Compute tracy-widom distribution -=# - -# ------------ # -# PARAMETERS -# ------------ # -t0 = 5.0 # right endpoint -tn = -8.0 # left endpoint -dx = 0.005 # discretization - -# ------------ # -# THEORY -# ------------ # -# Install the differential equations solver package with -# Pkg.add("DifferentialEquations") - -using DifferentialEquations - -# System of differential equations described in Eq.(1.6) -function tw_diff_eq_system(dy,y,t) - dy[1] = y[2] - dy[2] = t*y[1]+2*y[1]^3 - dy[3] = y[4] - dy[4] = y[1] ^ 2 -end - -# To use airy opterator -# Pkg.add("SpecialFunctions") -using SpecialFunctions -y0 = [airyai.(t0);airyai.([1,t0]);0;(airyai.(t0))^2] -tspan = (tn,t0) -prob = ODEProblem(tw_diff_eq_system,y0,tspan) -sol = solve(prob,reltol=1e-12,abstol=1e-15) diff --git a/textbook/chapter1/code14_largeeig.jl b/textbook/chapter1/code14_largeeig.jl deleted file mode 100644 index 3a314f4..0000000 --- a/textbook/chapter1/code14_largeeig.jl +++ /dev/null @@ -1,43 +0,0 @@ -#= -largeeig.jl - -ALGORITHM 1.4 of Random Eigenvalues by Alan Edelman - -EXPERIMENT : Largest eigenvalue of random Hermitian matrices -PLOT : Histogram of the normalized eigenvalues -THEORY : Tracy-widom as n-> infinity -=# - -# ------------ # -# PARAMETERS -# ------------ # -n = 100 # matrix size -t = 5000 # trials -v = Float64[] # eigenvalue samples -dx = .2 # binsize - -# ------------ # -# EXPERIMENT -# ------------ # -for i=1:t - A = randn(n,n)+im*randn(n,n) # n by n matrix of random Gaussians - S = (A+A')/2 # symmetrize matrix - v = append!(v, maximum(eigvals(S))) # eigenvalues -end -v = n^(1/6)*(v-2*√n) # normalize eigenvalues - -# ------------ # -# PLOT -# ------------ # -# Install package with Pkg.add("Plots") -# Pkg.clone("https://github.com/plotly/Plotly.jl") -using Plotly -plotly() - -x = -5:dx:2 -histogram(v, xlim=(-5,2), nbins=length(x), normed=true ) - -# ------------ # -# THEORY -# ------------ # -# Plot tracy widom From 344cc2fd6d1ec328380730b65d8f78a9f40ef9f1 Mon Sep 17 00:00:00 2001 From: Manvitha Ponnapati Date: Fri, 4 May 2018 12:00:17 -0400 Subject: [PATCH 7/8] save chapter 1 --- textbook/chapter1/Chapter1.ipynb | 1215 ++++++++++++++++++++++++++++++ 1 file changed, 1215 insertions(+) create mode 100644 textbook/chapter1/Chapter1.ipynb diff --git a/textbook/chapter1/Chapter1.ipynb b/textbook/chapter1/Chapter1.ipynb new file mode 100644 index 0000000..c0e0f5d --- /dev/null +++ b/textbook/chapter1/Chapter1.ipynb @@ -0,0 +1,1215 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Code 1.1 Plot of the Bell curve (the normal distribution)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "-4\n", + "\n", + "\n", + "-2\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "2\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "0.0\n", + "\n", + "\n", + "0.1\n", + "\n", + "\n", + "0.2\n", + "\n", + "\n", + "0.3\n", + "\n", + "\n", + "0.4\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "y1\n", + "\n", + "\n", + "\n", + "y2\n", + "\n", + "\n" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Experiment : Generate random samples from the normal distribution\n", + "# Plot : Histogram of random samples\n", + "# Theory : The normal distribution curve\n", + "\n", + "## Experiment\n", + "t = 100000 # trials\n", + "dx = 0.2 \n", + "v = randn(t)\n", + "\n", + "## Plot\n", + "using StatsBase, Plots #Install using Pkg.add(\"Plots\") and install a pyplot backend using Pkg.add(\"PyPlot\")\n", + "v_hist = fit(Histogram,v,closed=:left,-4:dx:4)\n", + "bar(v_hist.edges,v_hist.weights/(t*dx))\n", + "\n", + "## Theory\n", + "x = linspace(-4,4)\n", + "plot!(x,exp.(-x.^2/2)/sqrt.(2*pi),linewidth=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Code 1.2 Semicircle law (Random symmetric matrix eigenvalues)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "-2\n", + "\n", + "\n", + "-1\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "2\n", + "\n", + "\n", + "0.0\n", + "\n", + "\n", + "0.1\n", + "\n", + "\n", + "0.2\n", + "\n", + "\n", + "0.3\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "y1\n", + "\n", + "\n", + "\n", + "y2\n", + "\n", + "\n" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Experiment : Sample random symmetric Gaussian matrices\n", + "# Plot : Histogram of eigenvalues\n", + "# Theory : Semicircle as n --> infinity\n", + "\n", + "\n", + "## Parameters\n", + "\n", + "n = 1000 # matrix size\n", + "t = 1 # trials\n", + "v = [] # eigenvalue samples\n", + "dx = 0.2 # bin size\n", + "\n", + "\n", + "## Experiment\n", + "for i = 1:t\n", + " X = randn(n,n) # n-by-n matrix of random Gaussians\n", + " s = (X+X')/2 # symmetrize matrix\n", + " v = append!(v,eigvals(s)) # eigenvalues\n", + "end\n", + "v=v/sqrt.(n/2)\n", + "\n", + "## Plot\n", + "using StatsBase, Plots #Install using Pkg.add(\"Plots\") and install a pyplot backend using Pkg.add(\"PyPlot\")\n", + "v_hist = fit(Histogram,v,closed=:left,-2:dx:2)\n", + "bar(v_hist.edges,v_hist.weights/(t*dx*n))\n", + "\n", + "\n", + "## Theory\n", + "x = linspace(-2,2)\n", + "plot!(x,sqrt.(4-x.^2)/(2*pi),linewidth=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Code 1.3 Compute and plot the Tracy-Widom (β = 2) distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Theory : Compute and plot the tracy widom distribution\n", + "\n", + "## Parameters\n", + "t0 = 5.0 # right endpoint\n", + "tn = -8.0 # left endpoint\n", + "dx = 0.005 # discretization\n", + "\n", + "## Theory : The differential equation solver\n", + "# Install the differential equations solver package with\n", + "# Pkg.add(\"DifferentialEquations\")\n", + "\n", + "using DifferentialEquations\n", + "\n", + "# System of differential equations described in Eq.(1.6)\n", + "function tw_diff_eq_system(dy,y,p,t)\n", + " dy[1] = y[2]\n", + " dy[2] = t*y[1]+2*y[1]^3\n", + " dy[3] = y[4]\n", + " dy[4] = y[1] ^ 2\n", + "end\n", + "\n", + "# To use airy opterator\n", + "# Pkg.add(\"SpecialFunctions\")\n", + "using SpecialFunctions\n", + "y0 = [airyai.(t0);airyaiprime.(t0);0;(airyai.(t0))^2]\n", + "tspan = (t0,tn)\n", + "prob = ODEProblem(tw_diff_eq_system,y0,tspan)\n", + "sol = solve(prob,Vern8(),reltol=1e-12,abstol=1e-12)\n", + "F2 = exp.(-sol.u[:][3])\n", + "f2 = gradient(F2,sol.t)\n", + "\n", + "## Plot\n", + "using StatsBase, Plots #Install using Pkg.add(\"Plots\") and install a pyplot backend using Pkg.add(\"PyPlot\")\n", + "x = linspace(-2,2)\n", + "plot(sol.t,f2,xlims=(-2,2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Code 1.4 The largest eigenvalue of a random symmetric matrix of Gaussians." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "-4\n", + "\n", + "\n", + "-2\n", + "\n", + "\n", + "0\n", + "\n", + "\n", + "2\n", + "\n", + "\n", + "0.0\n", + "\n", + "\n", + "0.1\n", + "\n", + "\n", + "0.2\n", + "\n", + "\n", + "0.3\n", + "\n", + "\n", + "0.4\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "y1\n", + "\n", + "\n" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Experiment : Largest eigenvalue of random Hermitian matrices\n", + "# Plot : Histogram of the normalized eigenvalues\n", + "# Theory : Tracy-widom as n-> infinity\n", + "\n", + "\n", + "## Parameters\n", + "n = 100 # matrix size\n", + "t = 5000 # trials\n", + "v = Float64[] # eigenvalue samples\n", + "dx = .2 # binsize\n", + "\n", + "## Experiment\n", + "for i=1:t\n", + " A = randn(n,n)+im*randn(n,n) # n by n matrix of random Gaussians\n", + " S = (A+A')/2 # symmetrize matrix\n", + " v = append!(v, maximum(eigvals(S))) # eigenvalues\n", + "end\n", + "v = n^(1/6)*(v-2*√n) # normalize eigenvalues\n", + "\n", + "## Plot\n", + "using StatsBase, Plots #Install using Pkg.add(\"Plots\") and install a pyplot backend using Pkg.add(\"PyPlot\")\n", + "v_hist = fit(Histogram,v,closed=:left,-5:dx:2)\n", + "bar(v_hist.edges,v_hist.weights/(t*dx))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 0.6.2", + "language": "julia", + "name": "julia-0.6" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "0.6.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 4eaf813ec5b5fd45ac6ce227576ad46809575a70 Mon Sep 17 00:00:00 2001 From: Manvitha Ponnapati Date: Tue, 14 Apr 2020 09:56:06 -0400 Subject: [PATCH 8/8] Created using Colaboratory --- notebooks/SemiCircleLaw.ipynb | 207 +++++++++++++++++++++------------- 1 file changed, 127 insertions(+), 80 deletions(-) diff --git a/notebooks/SemiCircleLaw.ipynb b/notebooks/SemiCircleLaw.ipynb index f8532a4..6b33fbe 100644 --- a/notebooks/SemiCircleLaw.ipynb +++ b/notebooks/SemiCircleLaw.ipynb @@ -1,85 +1,132 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "using RandomMatrices" - ] + "nbformat": 4, + "nbformat_minor": 0, + "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" + }, + "colab": { + "name": "SemiCircleLaw.ipynb", + "provenance": [] + } }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ + "cells": [ + { + "cell_type": "code", + "metadata": { + "id": "9nKXerOM9_p_", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 130 + }, + "outputId": "fb35f8b0-f49b-4979-a8b3-2530cd1b7504" + }, + "source": [ + "using RandomMatrices" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "error", + "ename": "SyntaxError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m using RandomMatrices\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" + ] + } + ] + }, { - "data": { - "text/html": [ - "
\n", - " \n" + "cell_type": "code", + "metadata": { + "id": "Rm2dA00r9_qN", + "colab_type": "code", + "colab": {}, + "outputId": "469becf9-834d-445e-a369-59a05d4cd706" + }, + "source": [ + "#semicircle.jl\n", + "#Algorithm 1.2 of Random Eigenvalues by Alan Edelman\n", + "\n", + "#Experiment: Sample random symmetric Gaussian matrices\n", + "#Plot: Histogram of the eigenvalues\n", + "#Theory: Semicircle as n->infinity\n", + "\n", + "using Plots\n", + "plotly()\n", + "\n", + "## Parameters\n", + "n = 1000\n", + "t = 1\n", + "\n", + "## Experiment\n", + "vals = Float64[] # initialize result vector\n", + "for i = 1:t\n", + " A = randn(n, n) # draw n by n matrix with idependent gaussians\n", + " S = (A + A')/2 # symmetrize matrix\n", + " vals = append!(vals, eigvals(S)) # calculate eigenvalues and append to result vector\n", + "end\n", + "vals /= √(n/2) # scale eigenvalues\n", + "\n", + " # set limits for x axis in plot\n", + "histogram(vals, xlim=(-2,2), nbins=50, normed=true ) # make histogram\n", + "xvals = -2:.1:2\n", + "plot!(xvals, sqrt.(4 - xvals.^2)/(2*π),color=:red) # plot semi circle" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/html": [ + "
\n", + " \n" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 32 + } ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" + }, + { + "cell_type": "code", + "metadata": { + "id": "X4f5pRnA-DF5", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "MTgZpHZ49_qj", + "colab_type": "code", + "colab": {} + }, + "source": [ + "import numpy" + ], + "execution_count": 0, + "outputs": [] } - ], - "source": [ - "#semicircle.jl\n", - "#Algorithm 1.2 of Random Eigenvalues by Alan Edelman\n", - "\n", - "#Experiment: Sample random symmetric Gaussian matrices\n", - "#Plot: Histogram of the eigenvalues\n", - "#Theory: Semicircle as n->infinity\n", - "\n", - "using Plots\n", - "plotly()\n", - "\n", - "## Parameters\n", - "n = 1000\n", - "t = 1\n", - "\n", - "## Experiment\n", - "vals = Float64[] # initialize result vector\n", - "for i = 1:t\n", - " A = randn(n, n) # draw n by n matrix with idependent gaussians\n", - " S = (A + A')/2 # symmetrize matrix\n", - " vals = append!(vals, eigvals(S)) # calculate eigenvalues and append to result vector\n", - "end\n", - "vals /= √(n/2) # scale eigenvalues\n", - "\n", - " # set limits for x axis in plot\n", - "histogram(vals, xlim=(-2,2), nbins=50, normed=true ) # make histogram\n", - "xvals = -2:.1:2\n", - "plot!(xvals, sqrt.(4 - xvals.^2)/(2*π),color=:red) # plot semi circle" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "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": 2 -} + ] +} \ No newline at end of file