{ "cells": [ { "cell_type": "markdown", "id": "fc55193f-f621-4e44-b680-26bf630b5b7b", "metadata": {}, "source": [ "This notebook illustrates some aspects of computing with Julia." ] }, { "cell_type": "markdown", "id": "ccd2e3a8", "metadata": {}, "source": [ "# 1. the spectrum of a random matrix" ] }, { "cell_type": "markdown", "id": "0ebfff1f", "metadata": {}, "source": [ "This notebook illustrates the plotting all eigenvalues of a matrix, with entries generated at random, following a normal distribution." ] }, { "cell_type": "code", "execution_count": 1, "id": "da55714e", "metadata": {}, "outputs": [], "source": [ "using LinearAlgebra" ] }, { "cell_type": "code", "execution_count": 2, "id": "f5e27a10", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "100-element Vector{ComplexF64}:\n", " -10.734317700261316 + 0.0im\n", " -8.966158672738377 - 3.1830003658573105im\n", " -8.966158672738377 + 3.1830003658573105im\n", " -8.564445410644723 - 2.219934553398658im\n", " -8.564445410644723 + 2.219934553398658im\n", " -8.072091882178295 - 5.611898861175635im\n", " -8.072091882178295 + 5.611898861175635im\n", " -7.954604530880103 + 0.0im\n", " -7.852762277158398 - 1.6111170690067307im\n", " -7.852762277158398 + 1.6111170690067307im\n", " -6.7682511357949355 + 0.0im\n", " -5.955305850985741 + 0.0im\n", " -5.851750247746129 - 6.0179689285042155im\n", " ⋮\n", " 6.626392208903317 + 5.9599398550561915im\n", " 6.735843879081541 - 4.128214530006378im\n", " 6.735843879081541 + 4.128214530006378im\n", " 7.063186661568286 + 0.0im\n", " 7.935311672378672 - 2.9356117197983758im\n", " 7.935311672378672 + 2.9356117197983758im\n", " 8.123260207571338 + 0.0im\n", " 8.123500160041784 - 4.787097043364829im\n", " 8.123500160041784 + 4.787097043364829im\n", " 8.668429339321815 - 2.357458832010454im\n", " 8.668429339321815 + 2.357458832010454im\n", " 10.859699715086618 + 0.0im" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A = randn(100,100)\n", "L = eigvals(A)" ] }, { "cell_type": "code", "execution_count": 3, "id": "c01aa725", "metadata": {}, "outputs": [], "source": [ "using Plots" ] }, { "cell_type": "code", "execution_count": 4, "id": "3dec2c1c", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "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", "\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", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n" ], "text/html": [ "\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", "\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" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Lre = [real(x) for x in L]\n", "Lim = [imag(x) for x in L]\n", "scatter(Lre, Lim, label=\"\", title=\"eigenvalues of a normal matrix\")" ] }, { "cell_type": "code", "execution_count": 5, "id": "99fa60a8", "metadata": {}, "outputs": [], "source": [ "# savefig(\"specplot.png\")" ] }, { "cell_type": "markdown", "id": "691b7731-632b-4451-8e04-0bc8b7ace142", "metadata": {}, "source": [ "# 2. the modified Gram-Schmidt method" ] }, { "cell_type": "markdown", "id": "00ec4a8c-d8b6-43cd-af27-49245a650995", "metadata": {}, "source": [ "The functions below define a simple implementation of the\n", "Gram-Schmidt method for the QR factorization." ] }, { "cell_type": "code", "execution_count": 6, "id": "2aee7f3b-9d22-413e-87b2-94915cbc9481", "metadata": {}, "outputs": [], "source": [ "using Printf\n", "Base.show(io::IO, f::Float64) = @printf(io, \"%.3e\", f)" ] }, { "cell_type": "code", "execution_count": 7, "id": "105e976f-5665-4e42-bb94-517d650df3c9", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "gsqr" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"\"\"\n", " gsqr(A::Array{Float64,2})\n", "\n", "Gram-Schmidt orthogonalization for a QR decomposition:\n", "\n", " Q, R = gsqr(A) returns a QR decomposition of A,\n", "computed with 64-bit floating-point arithmetic.\n", "\n", "ON ENTRY :\n", "\n", " A an n-by-k Float64 matrix, n >= k.\n", "\n", "ON RETURN :\n", "\n", " Q an orthogonal matrix: Q'Q = I, whose column span \n", " is the same as the column span of A;\n", "\n", " R an upper triangular matrix: Q*R = A.\n", "\n", "EXAMPLE :\n", "\n", " a = rand(4,3); # a random 4-by-3 matrix\n", " q, r = gsqr(a);\n", " a - q*r # check residual\n", " transpose(q)*q # check orthogonality\n", "\"\"\"\n", "function gsqr(A::Array{Float64,2})\n", " k = size(A,2)\n", " Q = deepcopy(A)\n", " R = zeros(k,k)\n", " for j = 1:k\n", " p = A[:,j]\n", " for i = 1:j-1\n", " R[i,j] = transpose(Q[:,i])*A[:,j]\n", " p = p - Q[:,i]*R[i,j]\n", " end\n", " Q[:,j] = p/norm(p,2);\n", " R[j,j] = transpose(Q[:,j])*A[:,j]\n", " end\n", " return Q, R\n", "end" ] }, { "cell_type": "code", "execution_count": 8, "id": "51a8eb3d-f61d-4e23-a5b4-8a687a80a1ea", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "testFloat64" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"\"\"\n", "Generates a random 4-by-3 matrix\n", "and tests the gsqr function\n", "with 64-bit floating-point numbers.\n", "\"\"\"\n", "function testFloat64()\n", " println(\"Testing the 64-bit version ...\")\n", " a = rand(4, 3)\n", " q, r = gsqr(a)\n", " res = norm(a - q*r)\n", " stres = @sprintf(\"%.2e\", res)\n", " println(\"The residual : $stres\")\n", " println(\"Testing orthogonality, Q^T*Q is\")\n", " show(stdout, \"text/plain\", transpose(q)*q); println(\"\");\n", "end" ] }, { "cell_type": "code", "execution_count": 9, "id": "a9683d40-e2f6-4cd7-bbf7-412005a0eb08", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Testing the 64-bit version ...\n", "The residual : 3.28e-15\n", "Testing orthogonality, Q^T*Q is\n", "3×3 Matrix{Float64}:\n", " 1.000e+00 -2.442e-15 -1.110e-16\n", " -2.442e-15 1.000e+00 2.276e-15\n", " -1.110e-16 2.276e-15 1.000e+00\n" ] } ], "source": [ "testFloat64()" ] }, { "cell_type": "code", "execution_count": 10, "id": "1e0be71b-cebf-411d-bf1d-2aea7c9ea2f3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "gsqr" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"\"\"\n", " gsqr(A::Array{BigFloat,2})\n", "\n", "Gram-Schmidt orthogonalization for a QR decomposition:\n", "\n", " Q, R = gsqr(A) returns a QR decomposition of A,\n", "computed with multiprecision floating-point arithmetic.\n", "\n", "ON ENTRY :\n", "\n", " A an n-by-k BigFloat matrix, n >= k.\n", "\n", "ON RETURN :\n", "\n", " Q an orthogonal matrix: Q'Q = I, whose column span \n", " is the same as the column span of A;\n", " R an upper triangular matrix: Q*R = A.\n", "\n", "EXAMPLE :\n", "\n", " a = rand(4,3); # a random 4-by-3 matrix\n", " A = Array{BigFloat,2}(a) # convert to BigFloat\n", " q, r = gsqr(a);\n", " a - q*r # check residual\n", " transpose(q)*q # check orthogonality\n", "\"\"\"\n", "function gsqr(A::Array{BigFloat,2})\n", " k = size(A,2)\n", " Q = deepcopy(A)\n", " R = Array{BigFloat,2}(zeros(k,k))\n", " for j = 1:k\n", " p = A[:,j]\n", " for i = 1:j-1\n", " R[i,j] = transpose(Q[:,i])*A[:,j]\n", " p = p - Q[:,i]*R[i,j]\n", " end\n", " Q[:,j] = p/norm(p,2);\n", " R[j,j] = transpose(Q[:,j])*A[:,j]\n", " end\n", " return Q, R\n", "end" ] }, { "cell_type": "code", "execution_count": 11, "id": "f3995052-5807-494f-a41c-2c0eecb02fc5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "testBigFloat" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"\"\"\n", "Generates a random 4-by-3 matrix\n", "and tests the gsqr function\n", "with 64-bit floating-point numbers.\n", "\"\"\"\n", "function testBigFloat()\n", " println(\"Testing the BigFloat version ...\")\n", " a = rand(4, 3)\n", " A = Array{BigFloat,2}(a)\n", " q, r = gsqr(A)\n", " res = norm(A - q*r)\n", " stres = @sprintf(\"%.2e\", res)\n", " println(\"The residual : $stres\")\n", " println(\"Testing orthogonality, Q^T*Q is\")\n", " show(stdout, \"text/plain\", transpose(q)*q); println(\"\");\n", "end" ] }, { "cell_type": "code", "execution_count": 12, "id": "ae2c8e82-a6dc-47b0-8c05-d60f6c895014", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Testing the BigFloat version ...\n", "The residual : 2.77e-77\n", "Testing orthogonality, Q^T*Q is\n", "3×3 Matrix{BigFloat}:\n", " 1.0 -9.71569e-78 4.11567e-78\n", " -9.71569e-78 1.0 1.8082e-77\n", " 4.11567e-78 1.8082e-77 1.0\n" ] } ], "source": [ "testBigFloat()" ] }, { "cell_type": "markdown", "id": "c0979bee-1a83-45f6-af9c-416cd5e28199", "metadata": {}, "source": [ "# 3. Cobweb diagrams" ] }, { "cell_type": "code", "execution_count": 13, "id": "f17d2043-ef60-495a-a532-c45c90e36feb", "metadata": {}, "outputs": [], "source": [ "using Plots" ] }, { "cell_type": "code", "execution_count": 14, "id": "8b1976fe-7230-43e4-b812-44f5b16df8dc", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "cobweb" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"\"\"\n", "Applies the fixed-point iteration to a given function g\n", "and makes a cobweb plot.\n", "\n", "ON ENTRY :\n", " g a function in one variable\n", " x0 initial guess for the fixed-point iteration\n", " maxit upper bound on the number of iterations\n", " tol tolerance on the abs(g(x) - x) where x is\n", " the current approximation for the fixed point\n", " a left bound for the range of the plot\n", " b right bound for the range of the plot\n", "\n", "ON RETURN :\n", " x the current approximation for the fixed point\n", " numit the number of iterations done\n", " fail true if the accuracy requirement was not met,\n", " false otherwise;\n", " plt a plot of the cobweb diagram.\n", "\n", "EXAMPLE :\n", " g(x) = 1-x^3\n", " (x, numit, fail, plt) = cobweb(g,0.5,10,1.0e-4,-0.1,1.1)\n", "\"\"\"\n", "function cobweb(g::Function,x0::Float64,maxit::Int,tol::Float64, \n", " a::Float64,b::Float64)\n", " r = a:0.01:b\n", " plt = plot(g, r, label=\"g\")\n", " ylims!((a, b))\n", " diagonal(x) = x\n", " plot!(diagonal, r, label=\"\")\n", " println(\"running a fixed-point iteration ...\")\n", " strit = @sprintf(\"%3d\", 0)\n", " strx0 = @sprintf(\"%.4e\", x0)\n", " println(\"$strit : $strx0\")\n", " xprevious = x0\n", " xnext = xprevious\n", " for i=1:maxit\n", " xnext = g(xprevious)\n", " if i == 1\n", " plot!([xprevious], [xnext], line=(:sticks, :black), label=\"\")\n", " else\n", " if xprevious < xnext\n", " rng = xprevious:0.01:xnext; xr = [xprevious for i in rng]\n", " plot!(xr, rng, line=(:black), label=\"\")\n", " else\n", " rng = xnext:0.01:xprevious; xr = [xprevious for i in rng]\n", " plot!(xr, rng, line=(:black), label=\"\")\n", " end\n", " end\n", " if xprevious < xnext\n", " rng = xprevious:0.01:xnext; yr = [xnext for i in rng]\n", " plot!(rng, yr, line=(:black), label=\"\")\n", " else\n", " rng = xnext:0.01:xprevious; yr = [xnext for i in rng]\n", " plot!(rng, yr, line=(:black), label=\"\")\n", " end\n", " strit = @sprintf(\"%3d\", i)\n", " strxi = @sprintf(\"%.4e\", xnext)\n", " error = abs(xnext - xprevious)\n", " strerr = @sprintf(\"%.2e\", error)\n", " println(\"$strit : $strxi : $strerr\" )\n", " if error < tol\n", " return (xnext, i, false, plt)\n", " end\n", " xprevious = xnext\n", " end\n", " return (xnext, maxit, true, plt)\n", "end" ] }, { "cell_type": "markdown", "id": "a17265b3-a336-44cc-87fc-e1d05ca552b6", "metadata": {}, "source": [ "Let us run the example." ] }, { "cell_type": "code", "execution_count": 15, "id": "8f276d1d-23cb-424f-9523-692aaad74c77", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "running a fixed-point iteration ...\n", " 0 : 5.0000e-01\n", " 1 : 8.7500e-01 : 3.75e-01\n", " 2 : 3.3008e-01 : 5.45e-01\n", " 3 : 9.6404e-01 : 6.34e-01\n", " 4 : 1.0405e-01 : 8.60e-01\n", " 5 : 9.9887e-01 : 8.95e-01\n", " 6 : 3.3761e-03 : 9.95e-01\n", " 7 : 1.0000e+00 : 9.97e-01\n", " 8 : 1.1544e-07 : 1.00e+00\n", " 9 : 1.0000e+00 : 1.00e+00\n", " 10 : 0.0000e+00 : 1.00e+00\n" ] }, { "data": { "text/plain": [ "(0.000e+00, 10, true, Plot{Plots.GRBackend() n=22})" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "g(x) = 1-x^3\n", "(x, numit, fail, plt) = cobweb(g,0.5,10,1.0e-4,-0.1,1.1)" ] }, { "cell_type": "code", "execution_count": 16, "id": "9eada1ed-9346-4061-bc3c-dee5ec9f1f4b", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "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", "\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" ], "text/html": [ "\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" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "display(plt)" ] }, { "cell_type": "markdown", "id": "3c3b46f4-4eaf-41f8-97d8-91cfb7b40da6", "metadata": {}, "source": [ "# 4. the method of Laguerre" ] }, { "cell_type": "markdown", "id": "22f12fa4-c349-42e7-b977-3ef10f428af4", "metadata": {}, "source": [ "This code below illustrates the method of Laguerre\n", "to approximate roots of polynomials in one variable." ] }, { "cell_type": "markdown", "id": "b323f9ef-54cb-47c7-b6fe-687c6f70a06b", "metadata": {}, "source": [ "To evaluate polynomials, we use `evalpoly(x, p)`,\n", "where `x` is the value for the input and `p[1]`, `p[2]`, ...\n", "are the coefficients of the polynomial `p`,\n", "in ascending order of the power of `x`. \n", " \n", "The `evalpoly(x, p)` returns \n", "\n", " p[1] + p[2]*x + p[3]*x^2 + ... + p[d+1]*x^d,\n", " \n", "where d is the degree of `p`, `d = size(p, 1) - 1`." ] }, { "cell_type": "code", "execution_count": 17, "id": "0e0e87ef-7e5d-4b24-bdac-ff4592c9825a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "diffpoly" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"\"\"\n", "The function diffpoly returns the coefficients of the derivative\n", "of the polynomial with coefficients in c. \\\\\n", "The zero polynomial is represented as an array of one zero.\n", "\n", "EXAMPLE : \\\\\n", " c = Array([Complex{Float64}(i,i) for i = 1:3]) \\\\\n", " diffpoly(c)\n", "\"\"\"\n", "function diffpoly(c::Array{Complex{Float64},1})\n", " sz = size(c, 1)\n", " if sz < 2\n", " result = Array([Complex{Float64}(0)])\n", " else\n", " result = Array([Complex{Float64}(0) for _ = 1:sz-1])\n", " for i=2:sz\n", " result[i-1] = (i-1)*c[i]\n", " end\n", " end\n", " return result\n", "end" ] }, { "cell_type": "code", "execution_count": 18, "id": "5a71bb4a-3899-4850-ba13-ee862d5f7249", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "laguerre" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"\"\"\n", "The function laguerre applies the method of Laguerre.\n", "\n", "ON ENTRY : (p, d1p, d2p, z0, dxtol, pxtol, maxit, verbose) \\\\\n", " p are the coefficients of a polynomial in one variable \\\\\n", " d1p are the coefficients of the first derivative of p \\\\\n", " d2p are the coefficients of the second derivative of p \\\\\n", " z0 is an approximation for the root \\\\\n", " dxtol is the tolerance on the forward error \\\\\n", " pxtol is the tolerance on the backward error \\\\\n", " maxit is the maximum number of iterations \\\\\n", " verbose is the verbose flag, if true, writes one line each step\n", " \n", "ON RETURN : (root, absdx, abspx, nbrit, fail) \\\\\n", " root is an approximation for the root \\\\\n", " absdx is the estimated forward error \\\\\n", " abspx is the estimated backward error \\\\\n", " nbrit is the number of iterations \\\\\n", " fail is true if tolerances not reached, \\\\\n", " false otherwise.\n", "\"\"\"\n", "function laguerre(p::Array{Complex{Float64},1},\n", " d1p::Array{Complex{Float64},1},\n", " d2p::Array{Complex{Float64},1},\n", " z0::Complex{Float64},\n", " dxtol::Float64=1.0e-8,\n", " pxtol::Float64=1.0e-8,\n", " maxit::Int64=20,\n", " verbose::Bool=true)\n", " root = z0; dx = 1; pval = 1\n", " degm1 = size(p, 1) - 2 # degree of p minus one\n", " deg = degm1 + 1\n", " if verbose\n", " title = \" real(root) imag(root)\"\n", " println(\"step : $title |dx| |p(x)|\")\n", " stri = @sprintf(\"%3d\", 0)\n", " strx = @sprintf(\"%.16e %.16e\", real(root), imag(root))\n", " println(\"$stri : $strx\")\n", " end\n", " pval = evalpoly(root, p)\n", " for i=1:maxit\n", " if abs(pval) < pxtol\n", " if verbose\n", " stri = string(i-1)\n", " println(\"succeeded after $stri step(s)\")\n", " end\n", " return (root, abs(dx), abs(pval), i, false)\n", " end\n", " d1val = evalpoly(root, d1p)\n", " d2val = evalpoly(root, d2p)\n", " Lroot = d1val/pval\n", " Mroot = Lroot^2 - d2val/pval\n", " valsqrt = sqrt(degm1*(deg*Mroot - Lroot^2))\n", " yplus = Lroot + valsqrt\n", " yminus = Lroot - valsqrt\n", " if abs(yplus) > abs(yminus)\n", " dx = deg/yplus\n", " else\n", " dx = deg/yminus\n", " end\n", " root = root - dx\n", " pval = evalpoly(root, p)\n", " if verbose\n", " stri = @sprintf(\"%3d\", i)\n", " strx = @sprintf(\"%.16e %.16e\", real(root), imag(root))\n", " strdx = @sprintf(\"%.2e\", abs(dx))\n", " strpx = @sprintf(\"%.2e\", abs(pval))\n", " println(\"$stri : $strx $strdx $strpx\")\n", " end\n", " if abs(dx) < dxtol\n", " if verbose\n", " stri = string(i)\n", " println(\"succeeded after $stri step(s)\")\n", " end\n", " return (root, abs(dx), abs(pval), i, false)\n", " end\n", " end\n", " strN = string(maxit)\n", " if verbose\n", " println(\"failed requirements after $strN step(s)\")\n", " end\n", " return (root, abs(dx), abs(pval), maxit, true)\n", "end" ] }, { "cell_type": "code", "execution_count": 19, "id": "6ad98041-4631-4747-8fc7-0f68555f068e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "rank" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"\"\"\n", "Returns the index of the root in roots that is within tol of point.\n", "\"\"\"\n", "function rank(roots::Array{Complex{Float64},1},\n", " point::Complex{Float64},\n", " tol::Float64=1.0e-4)\n", " for i=1:size(roots, 1)\n", " if(abs(roots[i] - point) < tol)\n", " return i\n", " end\n", " end\n", " return 0\n", "end" ] }, { "cell_type": "code", "execution_count": 20, "id": "aae589c5-c0be-4f5d-8c85-1745d263c465", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "runlaguerre" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"\"\"\n", "The function runlaguerre demonstrates the method of Laguerre\n", "on the polynomial (x-1)*(x-2) = x^2 - 3*x + 2.\n", "\"\"\"\n", "function runlaguerre()\n", " c1 = Complex{Float64}(2)\n", " c2 = Complex{Float64}(-3)\n", " c3 = Complex{Float64}(1)\n", " p = [c1, c2, c3]\n", " d1p = diffpoly(p)\n", " d2p = diffpoly(d1p)\n", " roots = [Complex{Float64}(1.0), Complex{Float64}(2.0)]\n", " z0 = Complex{Float64}(rand(),rand())\n", " rnd = rand()\n", " if(rnd > 0.5)\n", " z0 = 3*z0\n", " end\n", " println(z0)\n", " println(\"running on x^2 - 3*x + 2 ...\")\n", " result = laguerre(p,d1p,d2p,z0)\n", " srnk = string(rank(roots, result[1]))\n", " println(\"the rank : $srnk\")\n", "end" ] }, { "cell_type": "code", "execution_count": 21, "id": "6a702a37-8e55-41aa-8a0d-40838938e079", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5.445e-01 + 3.490e-01im\n", "running on x^2 - 3*x + 2 ...\n", "step : real(root) imag(root) |dx| |p(x)|\n", " 0 : 5.4447598011273368e-01 3.4902880896465882e-01\n", " 1 : 1.0000000000000000e+00 1.1102230246251565e-16 5.74e-01 1.11e-16\n", "succeeded after 1 step(s)\n", "the rank : 1\n" ] } ], "source": [ "runlaguerre()" ] }, { "cell_type": "code", "execution_count": 22, "id": "65cd75d1-829c-4ec6-b4a1-6b010eda9f55", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "rankmatrix" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"\"\"\n", " function rankmatrix(dim::Int)\n", "\n", "returns the square matrix of dimension dim with integers.\n", "The integer in the matrix corresponds to the label of the 8-th root of unity\n", "the initial solution converged to with Laguerre's method.\n", "\"\"\"\n", "function rankmatrix(dim::Int)\n", " p = [Complex{Float64}(-1.0), Complex{Float64}(0.0), Complex{Float64}(0.0),\n", " Complex{Float64}(0.0), Complex{Float64}(0.0), Complex{Float64}(0.0),\n", " Complex{Float64}(0.0), Complex{Float64}(0.0), Complex{Float64}(1.0)]\n", " d1p = diffpoly(p)\n", " d2p = diffpoly(d1p)\n", " sq2 = sqrt(2.0)/2.0\n", " roots = [complex(1), complex(sq2, sq2), complex(0, 1), \n", " complex(-sq2, sq2), complex(-1), complex(-sq2, -sq2),\n", " complex(0, -1), complex(sq2, -sq2)]\n", " #dim = 10001\n", " left = -1.1\n", " right = 1.1\n", " dz = (right - left)/(dim-1)\n", " mat = zeros(Int8, dim, dim)\n", " for i=1:dim\n", " for j=1:dim\n", " z0 = complex(left + (i-1)*dz, left + (j-1)*dz)\n", " if(rank(roots, z0, 0.01) != 0)\n", " mat[i,j] = size(roots, 1)\n", " else\n", " result = laguerre(p, d1p, d2p, z0, 1.0e-8, 1.0e-8, 20, false)\n", " mat[i,j] = rank(roots, result[1]) - 1\n", " end\n", " end\n", " end\n", " #println(dim)\n", " #for i=1:dim\n", " # print(mat[i,1])\n", " # for j=2:dim\n", " # print(\",\", mat[i,j])\n", " # end\n", " # println()\n", " #end\n", " return mat\n", "end" ] }, { "cell_type": "code", "execution_count": 23, "id": "d920bb88-57b0-4e22-a6f6-fe97a4dd3169", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "100×100 Matrix{Int8}:\n", " 5 5 5 5 5 5 5 5 5 5 5 5 5 … 3 3 3 3 3 3 3 3 3 3 3 3\n", " 5 5 5 5 5 5 5 5 5 5 5 5 5 3 3 3 3 3 3 3 3 3 3 3 3\n", " 5 5 5 5 5 5 5 5 5 5 5 5 5 3 3 3 3 3 3 3 3 3 3 3 3\n", " 5 5 5 5 5 5 5 5 5 5 5 5 5 3 3 3 3 3 3 3 3 3 3 3 3\n", " 5 5 5 5 5 5 5 5 5 5 5 5 5 3 3 3 3 3 3 3 3 3 3 3 3\n", " 5 5 5 5 5 5 5 5 5 5 5 5 5 … 3 3 3 3 3 3 3 3 3 3 3 3\n", " 5 5 5 5 5 5 5 5 5 5 5 5 5 3 3 3 3 3 3 3 3 3 3 3 3\n", " 5 5 5 5 5 5 5 5 5 5 5 5 5 3 3 3 3 3 3 3 3 3 3 3 3\n", " 5 5 5 5 5 5 5 5 5 5 5 5 5 3 3 3 3 3 3 3 3 3 3 3 3\n", " 5 5 5 5 5 5 5 5 5 5 5 5 5 3 3 3 3 3 3 3 3 3 3 3 3\n", " 5 5 5 5 5 5 5 5 5 5 5 5 5 … 3 3 3 3 3 3 3 3 3 3 3 3\n", " 5 5 5 5 5 5 5 5 5 5 5 5 5 3 3 3 3 3 3 3 3 3 3 3 3\n", " 5 5 5 5 5 5 5 5 5 5 5 5 5 3 3 3 3 3 3 3 3 3 3 3 3\n", " ⋮ ⋮ ⋮ ⋱ ⋮ ⋮ \n", " 7 7 7 7 7 7 7 7 7 7 7 7 7 1 1 1 1 1 1 1 1 1 1 1 1\n", " 7 7 7 7 7 7 7 7 7 7 7 7 7 1 1 1 1 1 1 1 1 1 1 1 1\n", " 7 7 7 7 7 7 7 7 7 7 7 7 7 … 1 1 1 1 1 1 1 1 1 1 1 1\n", " 7 7 7 7 7 7 7 7 7 7 7 7 7 1 1 1 1 1 1 1 1 1 1 1 1\n", " 7 7 7 7 7 7 7 7 7 7 7 7 7 1 1 1 1 1 1 1 1 1 1 1 1\n", " 7 7 7 7 7 7 7 7 7 7 7 7 7 1 1 1 1 1 1 1 1 1 1 1 1\n", " 7 7 7 7 7 7 7 7 7 7 7 7 7 1 1 1 1 1 1 1 1 1 1 1 1\n", " 7 7 7 7 7 7 7 7 7 7 7 7 7 … 1 1 1 1 1 1 1 1 1 1 1 1\n", " 7 7 7 7 7 7 7 7 7 7 7 7 7 1 1 1 1 1 1 1 1 1 1 1 1\n", " 7 7 7 7 7 7 7 7 7 7 7 7 7 1 1 1 1 1 1 1 1 1 1 1 1\n", " 7 7 7 7 7 7 7 7 7 7 7 7 7 1 1 1 1 1 1 1 1 1 1 1 1\n", " 7 7 7 7 7 7 7 7 7 7 7 7 7 1 1 1 1 1 1 1 1 1 1 1 1" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A = rankmatrix(100)" ] }, { "cell_type": "code", "execution_count": 24, "id": "1dda4ecb-49eb-4e54-955c-0fc122c9e622", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "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", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n" ], "text/html": [ "\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" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "heatmap(A)" ] }, { "cell_type": "code", "execution_count": null, "id": "88ba3070-cb0f-4139-81e5-cb99ca6d6faf", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Julia 1.9.1", "language": "julia", "name": "julia-1.9" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "1.9.1" } }, "nbformat": 4, "nbformat_minor": 5 }