polylog.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b5fe6158-813a-450a-a960-05c02fea1d6c",
   "metadata": {},
   "source": [
    "## A Julia Package for numerical evaluation of the dilogarithm function\n",
    "\n",
    "This package \n",
    "\n",
    "This Julia package defines a function `polylog2` that numericaly evaluates the dilogarithm function in the entire complex plane. The input can be any floating point type  (`Float16`, `Float32`, `Float64`, and `BigFloat`), including complex.\n",
    "\n",
    "### Installation\n",
    "\n",
    "To use this package, you will need to copy the files `polylog.jl`, `polylog_test.jl`, and `tests.jl` into a folder that Julia can locate. \n",
    "\n",
    "\n",
    "### Usage\n",
    "\n",
    "Once the files are in place, you can load the package using the `using` command; for example\n",
    "\n",
    "```julia\n",
    "using polylog\n",
    "\n",
    "polylog2(1.5 + 2.5im)\n",
    "-0.14660383628064544 + 2.5784831446827763im\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9154c876-bf45-43f1-94cc-63d9686e3449",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "using polylog"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89ffbe99-1a75-464f-bbed-3609f0b66aba",
   "metadata": {},
   "source": [
    "To run the accuracy tests in `polylog_test.jl`, manually include this file and run each of the five tests. Each test uses a dilogarithm function identity to compare number of bits of agreement between the two values. The test report gives the number of tests, the average number of bits in agreement, and the worst agreement between values. Finally, the test shows a histogram of the number of tests with each bits of agreement.\n",
    "\n",
    "Some of the identitites that are used for testing are also used as a transformation for numerical evalution. Thus, some of these tests are not particually telling about numerical accuracy.\n",
    "\n",
    "With `Float64` numbers, the test `polylog2_test1` shows some tests with 40 or fewer bits of agreement. This might seem terrible, but the test looks for \n",
    "equality in `polylog2(x) + polylog2(x/(x-1)) = -log(1-x)^2 / 2`. The relatively small number of bits of agreement is due to the fact that the sum \n",
    "`polylog2(x) + polylog2(x/(x-1))` is ill conditioned when `x` is near zero, so the lack of bits of agreement is not as terrible as it may seem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "284fc23e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "include(joinpath(dirname(pathof(polylog)), \"polylog_test.jl\"));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "61e02283",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of tests = 10200\n",
      "average correct bits = 48.69892156862745\n",
      "worst correct bits = 35\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "18-element Vector{Pair{Any, Any}}:\n",
       " 53 => 219\n",
       " 52 => 559\n",
       " 51 => 1113\n",
       " 50 => 1979\n",
       " 49 => 2188\n",
       " 48 => 1618\n",
       " 47 => 1065\n",
       " 46 => 642\n",
       " 45 => 362\n",
       " 44 => 228\n",
       " 43 => 117\n",
       " 42 => 57\n",
       " 41 => 32\n",
       " 40 => 11\n",
       " 39 => 5\n",
       " 38 => 1\n",
       " 37 => 3\n",
       " 35 => 1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "polylog2_test1(Complex{Float64},100,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0e6b0de7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of tests = 999999\n",
      "average correct bits = 49.90979290979291\n",
      "worst correct bits = 29\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "24-element Vector{Pair{Any, Any}}:\n",
       " 53 => 31266\n",
       " 52 => 121174\n",
       " 51 => 213354\n",
       " 50 => 295547\n",
       " 49 => 187039\n",
       " 48 => 77192\n",
       " 47 => 37222\n",
       " 46 => 18399\n",
       " 45 => 9272\n",
       " 44 => 4817\n",
       " 43 => 2318\n",
       " 42 => 1220\n",
       " 41 => 582\n",
       " 40 => 304\n",
       " 39 => 153\n",
       " 38 => 73\n",
       " 37 => 36\n",
       " 36 => 16\n",
       " 35 => 7\n",
       " 34 => 4\n",
       " 33 => 1\n",
       " 32 => 1\n",
       " 30 => 1\n",
       " 29 => 1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "polylog2_test2(Complex{Float64},10^6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a1496a1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of tests = 999999\n",
      "average correct bits = 43.43304143304143\n",
      "worst correct bits = 0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "51-element Vector{Pair{Any, Any}}:\n",
       " 53 => 231\n",
       " 52 => 1472\n",
       " 51 => 4548\n",
       " 50 => 16247\n",
       " 49 => 50869\n",
       " 48 => 103532\n",
       " 47 => 127933\n",
       " 46 => 124730\n",
       " 45 => 109960\n",
       " 44 => 89975\n",
       " 43 => 74245\n",
       " 42 => 59636\n",
       " 41 => 46500\n",
       "    ⋮\n",
       " 14 => 19\n",
       " 13 => 7\n",
       " 10 => 1\n",
       "  8 => 3\n",
       "  7 => 2\n",
       "  6 => 8\n",
       "  5 => 16\n",
       "  4 => 18\n",
       "  3 => 45\n",
       "  2 => 78\n",
       "  1 => 132\n",
       "  0 => 8372"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "polylog2_test3(Complex{Float64},10^3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e014b974",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of tests = 1000000\n",
      "average correct bits = 50.501347\n",
      "worst correct bits = 30\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "23-element Vector{Pair{Any, Any}}:\n",
       " 53 => 112052\n",
       " 52 => 200057\n",
       " 51 => 226606\n",
       " 50 => 221450\n",
       " 49 => 128424\n",
       " 48 => 56054\n",
       " 47 => 27843\n",
       " 46 => 13723\n",
       " 45 => 6982\n",
       " 44 => 3398\n",
       " 43 => 1720\n",
       " 42 => 833\n",
       " 41 => 419\n",
       " 40 => 233\n",
       " 39 => 106\n",
       " 38 => 49\n",
       " 37 => 26\n",
       " 36 => 10\n",
       " 35 => 7\n",
       " 34 => 4\n",
       " 33 => 2\n",
       " 32 => 1\n",
       " 30 => 1"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "polylog2_test4(Float64,10^6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1f0e035f",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of tests = 1000000\n",
      "average correct bits = 49.296464\n",
      "worst correct bits = 0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "38-element Vector{Pair{Any, Any}}:\n",
       " 53 => 30271\n",
       " 52 => 94873\n",
       " 51 => 181015\n",
       " 50 => 235191\n",
       " 49 => 187892\n",
       " 48 => 114461\n",
       " 47 => 67616\n",
       " 46 => 39271\n",
       " 45 => 22142\n",
       " 44 => 12167\n",
       " 43 => 6433\n",
       " 42 => 3419\n",
       " 41 => 1612\n",
       "    ⋮\n",
       " 26 => 4\n",
       " 23 => 4\n",
       " 10 => 1\n",
       "  9 => 1\n",
       "  7 => 3\n",
       "  6 => 6\n",
       "  5 => 11\n",
       "  4 => 18\n",
       "  3 => 40\n",
       "  2 => 60\n",
       "  1 => 77\n",
       "  0 => 1783"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "polylog2_test5(Float64,10^3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07099b1a",
   "metadata": {},
   "source": [
    "Here we run the unit tests--for the details of what each test does, you'll need to read the source code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e1458102",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\u001b[31m\u001b[1mSpecial Values Test\u001b[22m\u001b[39m\n",
      "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal  \u001b[22m\u001b[39m\u001b[0m\u001b[1mTime\u001b[22m\n",
      "test set      | \u001b[32m   3  \u001b[39m\u001b[36m    3  \u001b[39m\u001b[0m0.6s\n",
      "\n",
      "\u001b[31m\u001b[1mBinary 16 Tests\u001b[22m\u001b[39m\n",
      "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal  \u001b[22m\u001b[39m\u001b[0m\u001b[1mTime\u001b[22m\n",
      "test set      | \u001b[32m  17  \u001b[39m\u001b[36m   17  \u001b[39m\u001b[0m1.0s\n",
      "\n",
      "\u001b[31m\u001b[1mBinary32 Tests\u001b[22m\u001b[39m\n",
      "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal  \u001b[22m\u001b[39m\u001b[0m\u001b[1mTime\u001b[22m\n",
      "test set      | \u001b[32m  17  \u001b[39m\u001b[36m   17  \u001b[39m\u001b[0m0.7s\n",
      "\n",
      "\u001b[31m\u001b[1mBinary64 Tests\u001b[22m\u001b[39m\n",
      "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal  \u001b[22m\u001b[39m\u001b[0m\u001b[1mTime\u001b[22m\n",
      "test set      | \u001b[32m  17  \u001b[39m\u001b[36m   17  \u001b[39m\u001b[0m0.1s\n",
      "\n",
      "\u001b[31m\u001b[1mBigFloat Tests\u001b[22m\u001b[39m\n",
      "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal  \u001b[22m\u001b[39m\u001b[0m\u001b[1mTime\u001b[22m\n",
      "test set      | \u001b[32m  17  \u001b[39m\u001b[36m   17  \u001b[39m\u001b[0m1.0s\n",
      "\n",
      "\u001b[31m\u001b[1mTable 27.7 Abramowitz & Stegun\u001b[22m\u001b[39m\n",
      "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal  \u001b[22m\u001b[39m\u001b[0m\u001b[1mTime\u001b[22m\n",
      "test set      | \u001b[32m  51  \u001b[39m\u001b[36m   51  \u001b[39m\u001b[0m0.1s\n",
      "\n",
      "\u001b[31m\u001b[1mTest DLMF identity 25.12.3E3\u001b[22m\u001b[39m\n",
      "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal  \u001b[22m\u001b[39m\u001b[0m\u001b[1m Time\u001b[22m\n",
      "test set      | \u001b[32m   4  \u001b[39m\u001b[36m    4  \u001b[39m\u001b[0m52.1s\n",
      "\n",
      "\u001b[31m\u001b[1mTest DLMF identity 25.12.E5\u001b[22m\u001b[39m\n",
      "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal  \u001b[22m\u001b[39m\u001b[0m\u001b[1m Time\u001b[22m\n",
      "test set      | \u001b[32m   4  \u001b[39m\u001b[36m    4  \u001b[39m\u001b[0m49.1s\n",
      "\n",
      "\u001b[31m\u001b[1mTest DLMF identity 25.12.E7\u001b[22m\u001b[39m\n",
      "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal  \u001b[22m\u001b[39m\u001b[0m\u001b[1m Time\u001b[22m\n",
      "test set      | \u001b[32m   4  \u001b[39m\u001b[36m    4  \u001b[39m\u001b[0m37.9s\n",
      "\n",
      "\u001b[31m\u001b[1mTest Dilogarithm reflection identity\u001b[22m\u001b[39m\n",
      "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal  \u001b[22m\u001b[39m\u001b[0m\u001b[1m   Time\u001b[22m\n",
      "test set      | \u001b[32m   4  \u001b[39m\u001b[36m    4  \u001b[39m\u001b[0m1m28.9s\n",
      "\n",
      "\u001b[31m\u001b[1mCompare to PolyLog\u001b[22m\u001b[39m\n",
      "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal  \u001b[22m\u001b[39m\u001b[0m\u001b[1m Time\u001b[22m\n",
      "test set      | \u001b[32m   4  \u001b[39m\u001b[36m    4  \u001b[39m\u001b[0m49.0s\n",
      "\n",
      "\u001b[31m\u001b[1mMultiple precision Tests\u001b[22m\u001b[39m\n",
      "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal  \u001b[22m\u001b[39m\u001b[0m\u001b[1mTime\u001b[22m\n",
      "test set      | \u001b[32m   5  \u001b[39m\u001b[36m    5  \u001b[39m\u001b[0m0.2s\n",
      "\n",
      "\u001b[31m\u001b[1mTest Int64 inputs\u001b[22m\u001b[39m\n",
      "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal  \u001b[22m\u001b[39m\u001b[0m\u001b[1mTime\u001b[22m\n",
      "test set      | \u001b[32m   2  \u001b[39m\u001b[36m    2  \u001b[39m\u001b[0m0.0s\n",
      "\n",
      "\u001b[31m\u001b[1mRegression Tests\u001b[22m\u001b[39m\n",
      "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal  \u001b[22m\u001b[39m\u001b[0m\u001b[1mTime\u001b[22m\n",
      "test set      | \u001b[32m   8  \u001b[39m\u001b[36m    8  \u001b[39m\u001b[0m0.0s\n"
     ]
    }
   ],
   "source": [
    "include(joinpath(dirname(pathof(polylog)), \"tests.jl\"));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd31dc0f-148d-4acd-8b4d-5e2b5ff46426",
   "metadata": {},
   "source": [
    "This function probes points inside the unit circle and returns the complex number `z` that minimizes the bits of agreement between\n",
    "evaluation with type `T` and with BigFloat evaluation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2494e344",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "compare_polylog2 (generic function with 2 methods)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function compare_polylog2(T::Type, n::Int64)\n",
    "    mm = Inf\n",
    "    xxx = 0\n",
    "    pie = convert(BigFloat,pi)\n",
    "    for i = 1 : n\n",
    "        for j = 0 : n-1\n",
    "            x = (i/n) * cis(2*pie* j/n)\n",
    "            m = boa(polylog2(x), polylog2(convert(Complex{T},x)))\n",
    "            if m < mm\n",
    "                xxx = x\n",
    "                mm = m\n",
    "            end\n",
    "        end\n",
    "    end\n",
    "  convert(Float64,mm), convert(Complex{Float64}, xxx)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "68c9848c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(43.0, 0.06391994911779517 + 0.5059784976703837im)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compare_polylog2(Float64, 100)"
   ]
  },
  {
   "cell_type": "raw",
   "id": "d9f23e84-1661-49c0-89f9-d494dbc0029c",
   "metadata": {},
   "source": [
    "This function computes the dilogarithm of the input using all floating point types and compares the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9cf1efdd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "multiple_prec (generic function with 1 method)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function multiple_prec(x)\n",
    "    y16 = polylog2(convert(Complex{Float16},x))\n",
    "    y32 = polylog2(convert(Complex{Float32},x))\n",
    "    y64 = polylog2(convert(Complex{Float64},x))\n",
    "    ybf = polylog2(convert(Complex{BigFloat},x))\n",
    "    isapprox(y16, convert(Complex{Float16},y32), atol=8*eps(Float16)) &&\n",
    "    isapprox(y32, convert(Complex{Float32},y32), atol=4*eps(Float32)) &&\n",
    "    isapprox(y64, convert(Complex{Float64},ybf), atol=4*eps(Float64))\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1807a80-6f70-4fd4-9c2c-49733d2f0293",
   "metadata": {},
   "source": [
    "This test passes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "239b5f0c-3027-454a-95d4-f6799cf4b060",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiple_prec(1.3*cis(2*pi/3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3300d508-efe2-47d8-821f-f1df48d5211a",
   "metadata": {},
   "source": [
    "I asked chatGPT 3.5 \"Write accurate Julia code that evaluates the dilogarithm function.\"  This is what I got"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a60eab2c-fa2c-43e0-ab80-8f79082e51dc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "using QuadGK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "f02c3733-8b6b-4364-b278-53b5b252bc47",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "using BenchmarkTools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "33541c52",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dilogarithm_chatGPT (generic function with 1 method)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function dilogarithm_chatGPT(z::Number)\n",
    "    if z == 1.0\n",
    "        return π^2 / 6\n",
    "    elseif abs(z) > 1\n",
    "        return real(dilogarithm_chatGPT(complex(z)))\n",
    "    end\n",
    "\n",
    "    f(t) = log(1 - t) / t\n",
    "    result, err = quadgk(f, 0, z)\n",
    "    return -result\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7cefdbf-da57-411e-bdcd-529968e4454f",
   "metadata": {},
   "source": [
    "For inputs outside the unit circle, the function `dilogarithm_chatGPT` is broken. Likely, just removing the `elseif abs(z) > 1` will fix this error.\n",
    "Let's eliminate this clause and modify the code a bit more, but keep the numerical quadrature approach."
   ]
  },
  {
   "cell_type": "raw",
   "id": "5167744a-3535-4fab-b4ae-9aec838bd414",
   "metadata": {},
   "source": [
    "One more more adjustment--we'll use a `z -> 1/z` functional idenitity for evaluation outside the unit circle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "81a12069-37ec-4aac-aa8a-6bc82cdd8613",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dilogarithm_chatGPT (generic function with 1 method)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function dilogarithm_chatGPT(z::Number)\n",
    "    if abs2(z) < 1\n",
    "        first(quadgk(x -> -log1p(-x)/x, 0, z))\n",
    "    else\n",
    "      -dilogarithm_chatGPT(1/z) - polylog.zeta2(typeof(z)) - log(-z)^2/2 # http://dlmf.nist.gov/25.12.E4\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "raw",
   "id": "69859ac2-3c7b-4526-8a70-3bbc852be994",
   "metadata": {
    "tags": []
   },
   "source": [
    "Let's do some timings to compare speeds. With one test, the quadrature based test is about twice as fast and uses less memory. The two values argree to about 53 bits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9fba5568-8178-4200-b6cc-77a56cf5e7d0",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-5.374999999999997 + 9.309773090682716im"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 10.75*cis(2*pi/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "454a6100-9a1c-473d-ba65-5f3ab1b14fa3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1.660 μs (5 allocations: 160 bytes)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-3.8692050672096134 + 2.5656863058242028im"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q1 = @btime dilogarithm_chatGPT(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b8c2cf52-0d45-4d9d-8714-68163e4abeec",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  3.237 μs (27 allocations: 800 bytes)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-3.869205067209614 + 2.5656863058242028im"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q2 = @btime polylog2(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "89fe6f65-8224-4cb0-8eef-6b9732ade8c5",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "boa(q1,q2)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.10.0",
   "language": "julia",
   "name": "julia-1.10"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}