diff --git a/conf.py b/conf.py index b379c196..eb357f82 100644 --- a/conf.py +++ b/conf.py @@ -463,7 +463,8 @@ 'more_julia': [], 'multi_agent_models': [], 'time_series_models': [], - 'tools_and_techniques': [] + 'tools_and_techniques': [], + 'continuous_time': [] } jupyter_download_nb_execute=True diff --git a/source/_static/Manifest.toml b/source/_static/Manifest.toml new file mode 100644 index 00000000..2c298088 --- /dev/null +++ b/source/_static/Manifest.toml @@ -0,0 +1,1732 @@ +# This file is machine-generated - editing it directly is not advised + +[[AMD]] +deps = ["Libdl", "LinearAlgebra", "SparseArrays", "Test"] +git-tree-sha1 = "fc66ffc5cff568936649445f58a55b81eaf9592c" +uuid = "14f7f29c-3bd6-536c-9a0b-7339e30b5a3e" +version = "0.4.0" + +[[AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "051c95d6836228d120f5f4b984dd5aba1624f716" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "0.5.0" + +[[AbstractTrees]] +deps = ["Markdown"] +git-tree-sha1 = "33e450545eaf7699da1a6e755f9ea65f14077a45" +uuid = "1520ce14-60c1-5f80-bbc7-55ef81b5835c" +version = "0.3.3" + +[[Adapt]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "fd04049c7dd78cfef0b06cdc1f0f181467655712" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "1.1.0" + +[[AlgebraicMultigrid]] +deps = ["Compat", "IterativeSolvers", "Random"] +git-tree-sha1 = "a26560b0f8cb9104d96715c32f7c272504631ea9" +uuid = "2169fc97-5a83-5252-b627-83903c6c433c" +version = "0.2.2" + +[[ApproxFun]] +deps = ["AbstractFFTs", "ApproxFunBase", "ApproxFunFourier", "ApproxFunOrthogonalPolynomials", "ApproxFunSingularities", "Calculus", "DomainSets", "DualNumbers", "FFTW", "FastTransforms", "LinearAlgebra", "RecipesBase", "Reexport"] +git-tree-sha1 = "bec0c375dbd4a5f49e6ebc0869084a5d28b40a75" +uuid = "28f2ccd6-bb30-5033-b560-165f7b14dc2f" +version = "0.11.13" + +[[ApproxFunBase]] +deps = ["AbstractFFTs", "BandedMatrices", "BlockArrays", "BlockBandedMatrices", "Calculus", "DSP", "DomainSets", "DualNumbers", "FFTW", "FastGaussQuadrature", "FillArrays", "InfiniteArrays", "IntervalSets", "LazyArrays", "LinearAlgebra", "LowRankApprox", "SparseArrays", "SpecialFunctions", "StaticArrays", "Statistics", "Test", "ToeplitzMatrices"] +git-tree-sha1 = "9472a96577df9a1b2697c70ccf7a8d50e571868c" +uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05" +version = "0.3.5" + +[[ApproxFunFourier]] +deps = ["AbstractFFTs", "ApproxFunBase", "DomainSets", "FFTW", "FastTransforms", "InfiniteArrays", "IntervalSets", "LinearAlgebra", "Reexport"] +git-tree-sha1 = "80c6fdc09bc7c36851480f9d83a637363aed9209" +uuid = "59844689-9c9d-51bf-9583-5b794ec66d30" +version = "0.2.4" + +[[ApproxFunOrthogonalPolynomials]] +deps = ["AbstractFFTs", "ApproxFunBase", "BandedMatrices", "BlockArrays", "BlockBandedMatrices", "DomainSets", "FFTW", "FastGaussQuadrature", "FastTransforms", "FillArrays", "IntervalSets", "LinearAlgebra", "Reexport", "SpecialFunctions", "Statistics"] +git-tree-sha1 = "235ec33955eef6066e6ef4ecfae23ce2d5cc4d7b" +uuid = "b70543e2-c0d9-56b8-a290-0d4d6d4de211" +version = "0.3.4" + +[[ApproxFunSingularities]] +deps = ["ApproxFunBase", "ApproxFunOrthogonalPolynomials", "DomainSets", "IntervalSets", "LinearAlgebra", "Reexport", "Statistics"] +git-tree-sha1 = "1bf16adee3ac52531d1072074dfca712cacd29e5" +uuid = "f8fcb915-6b99-5be2-b79a-d6dbef8e6e7e" +version = "0.1.8" + +[[ArnoldiMethod]] +deps = ["DelimitedFiles", "LinearAlgebra", "Random", "SparseArrays", "StaticArrays", "Test"] +git-tree-sha1 = "2b6845cea546604fb4dca4e31414a6a59d39ddcd" +uuid = "ec485272-7323-5ecc-a04f-4719b315124d" +version = "0.0.4" + +[[Arpack]] +deps = ["Arpack_jll", "Libdl", "LinearAlgebra"] +git-tree-sha1 = "2ff92b71ba1747c5fdd541f8fc87736d82f40ec9" +uuid = "7d9fca2a-8960-54d3-9f78-7d1dccf2cb97" +version = "0.4.0" + +[[Arpack_jll]] +deps = ["Libdl", "OpenBLAS_jll", "Pkg"] +git-tree-sha1 = "e214a9b9bd1b4e1b4f15b22c0994862b66af7ff7" +uuid = "68821587-b530-5797-8361-c406ea357684" +version = "3.5.0+3" + +[[ArrayInterface]] +deps = ["LinearAlgebra", "Requires", "SparseArrays"] +git-tree-sha1 = "649c08a5a3a513f4662673d3777fe6ccb4df9f5d" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "2.8.7" + +[[ArrayLayouts]] +deps = ["FillArrays", "LinearAlgebra"] +git-tree-sha1 = "a504dca2ac7eda8761c8f7c1ed52427a1be75a3c" +uuid = "4c555306-a7a7-4459-81d9-ec55ddd5c99a" +version = "0.2.6" + +[[AxisAlgorithms]] +deps = ["LinearAlgebra", "Random", "SparseArrays", "WoodburyMatrices"] +git-tree-sha1 = "a4d07a1c313392a77042855df46c5f534076fab9" +uuid = "13072b0f-2c55-5437-9ae7-d433b7a33950" +version = "1.0.0" + +[[BandedMatrices]] +deps = ["ArrayLayouts", "FillArrays", "LinearAlgebra", "Random", "SparseArrays"] +git-tree-sha1 = "66629f153db5efd8ee0209e78e938e79463ae850" +uuid = "aae01518-5342-5314-be14-df237901396f" +version = "0.15.7" + +[[Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" + +[[BenchmarkTools]] +deps = ["JSON", "Logging", "Printf", "Statistics", "UUIDs"] +git-tree-sha1 = "9e62e66db34540a0c919d72172cc2f642ac71260" +uuid = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" +version = "0.5.0" + +[[BinaryProvider]] +deps = ["Libdl", "Logging", "SHA"] +git-tree-sha1 = "ecdec412a9abc8db54c0efc5548c64dfce072058" +uuid = "b99e7846-7c00-51b0-8f62-c81ae34c0232" +version = "0.5.10" + +[[BlackBoxOptim]] +deps = ["CPUTime", "Compat", "Distributed", "Distributions", "LinearAlgebra", "Printf", "Random", "SpatialIndexing", "StatsBase"] +git-tree-sha1 = "da5cfcc08d24a43fa4e3ad67f565f17838e26fca" +uuid = "a134a8b2-14d6-55f6-9291-3336d3ab0209" +version = "0.5.0" + +[[BlockArrays]] +deps = ["ArrayLayouts", "LinearAlgebra"] +git-tree-sha1 = "46baefe84cec9484d57abf741b854d2d5abdbc88" +uuid = "8e7c35d0-a365-5155-bbbb-fb81a777f24e" +version = "0.12.5" + +[[BlockBandedMatrices]] +deps = ["ArrayLayouts", "BandedMatrices", "BlockArrays", "Distributed", "FillArrays", "LinearAlgebra", "MatrixFactorizations", "Pkg", "Random", "SharedArrays", "SparseArrays", "Statistics", "Test"] +git-tree-sha1 = "c414c9a1f6ca84ec688a94f509ce63888e89534f" +uuid = "ffab5731-97b5-5995-9138-79e8c1846df0" +version = "0.8.4" + +[[Bzip2_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "3663bfffede2ef41358b6fc2e1d8a6d50b3c3904" +uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0" +version = "1.0.6+2" + +[[CEnum]] +git-tree-sha1 = "1b77a77c3b28e0b3f413f7567c9bb8dd9bdccd14" +uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82" +version = "0.3.0" + +[[CPUTime]] +git-tree-sha1 = "2dcc50ea6a0a1ef6440d6eecd0fe3813e5671f45" +uuid = "a9c8d775-2e2e-55fc-8582-045d282d599e" +version = "1.0.0" + +[[CSV]] +deps = ["CategoricalArrays", "DataFrames", "Dates", "FilePathsBase", "Mmap", "Parsers", "PooledArrays", "Tables", "Unicode", "WeakRefStrings"] +git-tree-sha1 = "52a8e60c7822f53d57e4403b7f2811e7e1bdd32b" +uuid = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" +version = "0.6.2" + +[[CUDAapi]] +deps = ["Libdl", "Logging"] +git-tree-sha1 = "831b825d10104bd29e28f6da93312a976830717b" +uuid = "3895d2a7-ec45-59b8-82bb-cfc6a382f9b3" +version = "4.0.0" + +[[CUDAdrv]] +deps = ["CEnum", "CUDAapi", "Printf"] +git-tree-sha1 = "f56bbf18c86bcff7a961a32a4947a5abb2963a29" +uuid = "c5f51814-7f29-56b8-a69c-e4d8f6be1fde" +version = "6.3.0" + +[[CUDAnative]] +deps = ["Adapt", "BinaryProvider", "CEnum", "CUDAapi", "CUDAdrv", "ExprTools", "GPUCompiler", "LLVM", "Libdl", "Pkg", "Printf"] +git-tree-sha1 = "ac86db2b05fdfec96b011e25a504ffe7476e8a68" +uuid = "be33ccc6-a3ff-5ff2-a52e-74243cff1e17" +version = "3.1.0" + +[[Calculus]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "f641eb0a4f00c343bbc32346e1217b86f3ce9dad" +uuid = "49dc2e85-a5d0-5ad3-a950-438e2897f1b9" +version = "0.5.1" + +[[CanonicalTraits]] +deps = ["MLStyle"] +git-tree-sha1 = "1728d2633a206e931daf818309d90eb39c1ce93b" +uuid = "a603d957-0e48-4f86-8fbd-0b7bc66df689" +version = "0.2.1" + +[[Cassette]] +git-tree-sha1 = "ff6f5109371926beb67ec3101be17d2c211e497d" +uuid = "7057c7e9-c182-5462-911a-8362d720325c" +version = "0.3.3" + +[[CategoricalArrays]] +deps = ["DataAPI", "Future", "JSON", "Missings", "Printf", "Statistics", "Unicode"] +git-tree-sha1 = "df774d7e905ca391178f0abc67f4fa5d3ff4ef12" +uuid = "324d7699-5711-5eae-9e2f-1d82baa6b597" +version = "0.8.0" + +[[ChainRulesCore]] +deps = ["MuladdMacro"] +git-tree-sha1 = "32e2c6e44d4fdd985b5688b5e85c1f6892cf3d15" +uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" +version = "0.8.0" + +[[Clustering]] +deps = ["Distances", "LinearAlgebra", "NearestNeighbors", "Printf", "SparseArrays", "Statistics", "StatsBase"] +git-tree-sha1 = "7846d785d9e4bcc904b70689bde8413f85b0ca20" +uuid = "aaaa29a8-35af-508c-8bc3-b662a17a0fe5" +version = "0.14.0" + +[[CodeTracking]] +deps = ["InteractiveUtils", "UUIDs"] +git-tree-sha1 = "cab4da992adc0a64f63fa30d2db2fd8bec40cab4" +uuid = "da1fd8a2-8d9e-5ec2-8556-3022fb5608a2" +version = "0.5.11" + +[[CodecBzip2]] +deps = ["Bzip2_jll", "Libdl", "TranscodingStreams"] +git-tree-sha1 = "2e62a725210ce3c3c2e1a3080190e7ca491f18d7" +uuid = "523fee87-0ab8-5b00-afb7-3ecf72e48cfd" +version = "0.7.2" + +[[CodecZlib]] +deps = ["TranscodingStreams", "Zlib_jll"] +git-tree-sha1 = "ded953804d019afa9a3f98981d99b33e3db7b6da" +uuid = "944b1d66-785c-5afd-91f1-9de20f533193" +version = "0.7.0" + +[[ColorSchemes]] +deps = ["ColorTypes", "Colors", "FixedPointNumbers", "Random", "StaticArrays"] +git-tree-sha1 = "7a15e3690529fd1042f0ab954dff7445b1efc8a5" +uuid = "35d6a980-a343-548e-a6ea-1d62b119f2f4" +version = "3.9.0" + +[[ColorTypes]] +deps = ["FixedPointNumbers", "Random"] +git-tree-sha1 = "c73d9cfc2a9d8433dc77f5bff4bddf46b1d78c20" +uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f" +version = "0.10.3" + +[[Colors]] +deps = ["ColorTypes", "FixedPointNumbers", "InteractiveUtils", "Reexport"] +git-tree-sha1 = "db9c215e2d92379d341e40dd1d5be893af2bfeb2" +uuid = "5ae59095-9a9b-59fe-a467-6f913c188581" +version = "0.12.1" + +[[Combinatorics]] +git-tree-sha1 = "08c8b6831dc00bfea825826be0bc8336fc369860" +uuid = "861a8166-3701-5b0c-9a16-15d98fcdc6aa" +version = "1.0.2" + +[[CommonSubexpressions]] +deps = ["Test"] +git-tree-sha1 = "efdaf19ab11c7889334ca247ff4c9f7c322817b0" +uuid = "bbf7d656-a473-5ed7-a52c-81e309532950" +version = "0.2.0" + +[[Compat]] +deps = ["Base64", "Dates", "DelimitedFiles", "Distributed", "InteractiveUtils", "LibGit2", "Libdl", "LinearAlgebra", "Markdown", "Mmap", "Pkg", "Printf", "REPL", "Random", "Serialization", "SharedArrays", "Sockets", "SparseArrays", "Statistics", "Test", "UUIDs", "Unicode"] +git-tree-sha1 = "ed2c4abadf84c53d9e58510b5fc48912c2336fbb" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "2.2.0" + +[[CompilerSupportLibraries_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "7c4f882c41faa72118841185afc58a2eb00ef612" +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "0.3.3+0" + +[[ConsoleProgressMonitor]] +deps = ["Logging", "ProgressMeter"] +git-tree-sha1 = "3ab7b2136722890b9af903859afcf457fa3059e8" +uuid = "88cd18e8-d9cc-4ea6-8889-5259c0d15c8b" +version = "0.1.2" + +[[ConstructionBase]] +git-tree-sha1 = "a2a6a5fea4d6f730ec4c18a76d27ec10e8ec1c50" +uuid = "187b0558-2788-49d3-abe0-74a17ed4e7c9" +version = "1.0.0" + +[[Contour]] +deps = ["StaticArrays"] +git-tree-sha1 = "0b17db36e7e03f8437e0d1f55aea3e4a60c74353" +uuid = "d38c429a-6771-53c6-b99e-75d170b6e991" +version = "0.5.3" + +[[CpuId]] +deps = ["Markdown", "Test"] +git-tree-sha1 = "f0464e499ab9973b43c20f8216d088b61fda80c6" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.2.2" + +[[Cthulhu]] +deps = ["CodeTracking", "InteractiveUtils", "REPL", "UUIDs", "Unicode"] +git-tree-sha1 = "f3643e78353199d3097821e806348bd83f364155" +uuid = "f68482b8-f384-11e8-15f7-abe071a5a75f" +version = "1.1.1" + +[[CuArrays]] +deps = ["AbstractFFTs", "Adapt", "CEnum", "CUDAapi", "CUDAdrv", "CUDAnative", "DataStructures", "GPUArrays", "Libdl", "LinearAlgebra", "MacroTools", "NNlib", "Pkg", "Printf", "Random", "Reexport", "Requires", "SparseArrays", "Statistics", "TimerOutputs"] +git-tree-sha1 = "870a4ac61e99c36f42d15e496fd290c841541d90" +uuid = "3a865a2d-5b23-5a0f-bc46-62713ec82fae" +version = "2.2.0" + +[[DSP]] +deps = ["FFTW", "IterTools", "LinearAlgebra", "Polynomials", "Random", "Reexport", "SpecialFunctions", "Statistics"] +git-tree-sha1 = "d52dce57c6108ef552c14799e7fcdcae6c681084" +uuid = "717857b8-e6f2-59f4-9121-6e50c889abd2" +version = "0.6.7" + +[[DataAPI]] +git-tree-sha1 = "176e23402d80e7743fc26c19c681bfb11246af32" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.3.0" + +[[DataFrames]] +deps = ["CategoricalArrays", "Compat", "DataAPI", "Future", "InvertedIndices", "IteratorInterfaceExtensions", "Missings", "PooledArrays", "Printf", "REPL", "Reexport", "SortingAlgorithms", "Statistics", "TableTraits", "Tables", "Unicode"] +git-tree-sha1 = "1b4d832288e2d919eeaccdf1d9af7a8a57d773d6" +uuid = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" +version = "0.21.0" + +[[DataFramesMeta]] +deps = ["DataFrames", "Tables"] +git-tree-sha1 = "4e2ba678c7a624c963ac09f68f9b6086607377a4" +uuid = "1313f7d8-7da2-5740-9ea0-a2ca25f37964" +version = "0.5.1" + +[[DataStructures]] +deps = ["InteractiveUtils", "OrderedCollections"] +git-tree-sha1 = "af6d9c86e191c917c2276fbede1137e8ea20157f" +uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" +version = "0.17.17" + +[[DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[DataValues]] +deps = ["DataValueInterfaces", "Dates"] +git-tree-sha1 = "d88a19299eba280a6d062e135a43f00323ae70bf" +uuid = "e7dc6d0d-1eca-5fa6-8ad6-5aecde8b7ea5" +version = "0.4.13" + +[[Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" + +[[DelimitedFiles]] +deps = ["Mmap"] +uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab" + +[[Dierckx]] +deps = ["BinaryProvider", "Libdl", "Random", "Test"] +git-tree-sha1 = "27a74763c20938a814da26f31a9e8408d16fec44" +uuid = "39dd38d3-220a-591b-8e3c-4c3a8c710a94" +version = "0.4.1" + +[[DiffEqBase]] +deps = ["ArrayInterface", "ChainRulesCore", "ConsoleProgressMonitor", "DataStructures", "Distributed", "DocStringExtensions", "FunctionWrappers", "IterativeSolvers", "IteratorInterfaceExtensions", "LabelledArrays", "LinearAlgebra", "Logging", "LoggingExtras", "MuladdMacro", "Parameters", "Printf", "ProgressLogging", "RecipesBase", "RecursiveArrayTools", "RecursiveFactorization", "Requires", "Roots", "SparseArrays", "StaticArrays", "Statistics", "SuiteSparse", "TableTraits", "TerminalLoggers", "TreeViews", "ZygoteRules"] +git-tree-sha1 = "a37901f10b63ed3e413db3320cd6c305c771430d" +uuid = "2b5f629d-d688-5b77-993f-72d75c75574e" +version = "6.36.3" + +[[DiffEqJump]] +deps = ["Compat", "DataStructures", "DiffEqBase", "FunctionWrappers", "LinearAlgebra", "Parameters", "PoissonRandom", "Random", "RandomNumbers", "RecursiveArrayTools", "StaticArrays", "Statistics", "TreeViews"] +git-tree-sha1 = "4c960b9cf209426b72de274334f5f77b4d9a4dad" +uuid = "c894b116-72e5-5b58-be3c-e6d8d4ac2b12" +version = "6.7.6" + +[[DiffEqNoiseProcess]] +deps = ["DataStructures", "DiffEqBase", "LinearAlgebra", "Random", "RandomNumbers", "RecipesBase", "RecursiveArrayTools", "Requires", "ResettableStacks", "StaticArrays", "Statistics"] +git-tree-sha1 = "f0472a979c3f85bd9a642e1107f27853b2652b15" +uuid = "77a26b50-5914-5dd7-bc55-306e6241c503" +version = "3.11.0" + +[[DiffEqOperators]] +deps = ["BandedMatrices", "BlockBandedMatrices", "DiffEqBase", "ForwardDiff", "LazyArrays", "LinearAlgebra", "ModelingToolkit", "NNlib", "SparseArrays", "StaticArrays", "SuiteSparse"] +git-tree-sha1 = "5ca3009b071a1bb6b5b874a75d54540c783ce4ec" +uuid = "9fdde737-9c7f-55bf-ade8-46b3f136cc48" +version = "4.10.0" + +[[DiffResults]] +deps = ["StaticArrays"] +git-tree-sha1 = "da24935df8e0c6cf28de340b958f6aac88eaa0cc" +uuid = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" +version = "1.0.2" + +[[DiffRules]] +deps = ["NaNMath", "Random", "SpecialFunctions"] +git-tree-sha1 = "eb0c34204c8410888844ada5359ac8b96292cfd1" +uuid = "b552c78f-8df3-52c6-915a-8e097449b14b" +version = "1.0.1" + +[[Distances]] +deps = ["LinearAlgebra", "Statistics"] +git-tree-sha1 = "23717536c81b63e250f682b0e0933769eecd1411" +uuid = "b4f34e82-e78d-54a5-968a-f98e89d6e8f7" +version = "0.8.2" + +[[Distributed]] +deps = ["Random", "Serialization", "Sockets"] +uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" + +[[Distributions]] +deps = ["FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SpecialFunctions", "Statistics", "StatsBase", "StatsFuns"] +git-tree-sha1 = "c4ed10355637fcb0725dc6a27060f74df24f13cd" +uuid = "31c24e10-a181-5473-b8eb-7969acd0382f" +version = "0.23.2" + +[[DocStringExtensions]] +deps = ["LibGit2", "Markdown", "Pkg", "Test"] +git-tree-sha1 = "88bb0edb352b16608036faadcc071adda068582a" +uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" +version = "0.8.1" + +[[DomainSets]] +deps = ["IntervalSets", "LinearAlgebra", "StaticArrays", "Statistics", "Test"] +git-tree-sha1 = "3146affa94e804fd4f42f0ac43b117c3fb1d9580" +uuid = "5b8099bc-c8ec-5219-889f-1d9e522a28bf" +version = "0.3.1" + +[[DualNumbers]] +deps = ["Calculus", "LinearAlgebra", "NaNMath", "SpecialFunctions", "Test"] +git-tree-sha1 = "e178a6768dad879ff1abfc1c612406856bb06ce0" +uuid = "fa6b7ba4-c1ee-5f82-b5fc-ecf0adba8f74" +version = "0.6.2" + +[[EllipsisNotation]] +git-tree-sha1 = "65dad386e877850e6fce4fc77f60fe75a468ce9d" +uuid = "da5c29d0-fa7d-589e-88eb-ea29b0a81949" +version = "0.4.0" + +[[Expectations]] +deps = ["Compat", "Distributions", "FastGaussQuadrature", "SpecialFunctions"] +git-tree-sha1 = "5b50b515886773484a28f19d9c103dffc7702702" +uuid = "2fe49d83-0758-5602-8f54-1f90ad0d522b" +version = "1.1.1" + +[[Expokit]] +deps = ["LinearAlgebra", "SparseArrays", "Test"] +git-tree-sha1 = "b0313f5f1825aabb1adb186c837e0d339d02f351" +uuid = "a1e7a1ef-7a5d-5822-a38c-be74e1bb89f4" +version = "0.2.0" + +[[ExponentialUtilities]] +deps = ["LinearAlgebra", "Printf", "SparseArrays"] +git-tree-sha1 = "1672dedeacaab85345fd359ad56dde8fb5d48a45" +uuid = "d4d017d3-3776-5f7e-afef-a10c40355c18" +version = "1.6.0" + +[[ExprTools]] +git-tree-sha1 = "6f0517056812fd6aa3af23d4b70d5325a2ae4e95" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.1" + +[[EzXML]] +deps = ["Printf", "XML2_jll"] +git-tree-sha1 = "0fa3b52a04a4e210aeb1626def9c90df3ae65268" +uuid = "8f5d6c58-4d21-5cfd-889c-e3ad7ee6a615" +version = "1.1.0" + +[[FFMPEG]] +deps = ["FFMPEG_jll"] +git-tree-sha1 = "c82bef6fc01e30d500f588cd01d29bdd44f1924e" +uuid = "c87230d0-a227-11e9-1b43-d7ebe4e7570a" +version = "0.3.0" + +[[FFMPEG_jll]] +deps = ["Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "LAME_jll", "LibVPX_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "Pkg", "Zlib_jll", "libass_jll", "libfdk_aac_jll", "libvorbis_jll", "x264_jll", "x265_jll"] +git-tree-sha1 = "0fa07f43e5609ea54848b82b4bb330b250e9645b" +uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5" +version = "4.1.0+3" + +[[FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "IntelOpenMP_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Reexport"] +git-tree-sha1 = "14536c95939aadcee44014728a459d2fe3ca9acf" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.2.2" + +[[FFTW_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "6c975cd606128d45d1df432fb812d6eb10fee00b" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.9+5" + +[[FastClosures]] +git-tree-sha1 = "acebe244d53ee1b461970f8910c235b259e772ef" +uuid = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a" +version = "0.3.2" + +[[FastGaussQuadrature]] +deps = ["LinearAlgebra", "SpecialFunctions"] +git-tree-sha1 = "c139e3f4c75dc489a493627c7ee44befc177420f" +uuid = "442a2c76-b920-505d-bb47-c5924d526838" +version = "0.4.2" + +[[FastTransforms]] +deps = ["AbstractFFTs", "BinaryProvider", "DSP", "FFTW", "FastGaussQuadrature", "FastTransforms_jll", "Libdl", "LinearAlgebra", "Reexport", "SpecialFunctions", "Test", "ToeplitzMatrices"] +git-tree-sha1 = "21d02133d23e6c1ff55af346502b5814fd4372ec" +uuid = "057dd010-8810-581a-b7be-e3fc3b93f78c" +version = "0.8.2" + +[[FastTransforms_jll]] +deps = ["CompilerSupportLibraries_jll", "FFTW_jll", "Libdl", "MPFR_jll", "OpenBLAS_jll", "Pkg"] +git-tree-sha1 = "b108dbc3374fc690be7cbf49813f2f6b14c4a155" +uuid = "34b6f7d7-08f9-5794-9e10-3819e4c7e49a" +version = "0.2.13+1" + +[[FileIO]] +deps = ["Pkg"] +git-tree-sha1 = "202335fd24c2776493e198d6c66a6d910400a895" +uuid = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549" +version = "1.3.0" + +[[FilePaths]] +deps = ["FilePathsBase", "MacroTools", "Reexport", "URIParser"] +git-tree-sha1 = "191796576b7f69cfe66d63b3d66a2741783204eb" +uuid = "8fc22ac5-c921-52a6-82fd-178b2807b824" +version = "0.8.0" + +[[FilePathsBase]] +deps = ["Dates", "LinearAlgebra", "Printf", "Test", "UUIDs"] +git-tree-sha1 = "2ee1d999c462425e2f848524f732ed51bc1ab63a" +uuid = "48062228-2e41-5def-b9a4-89aafe57970f" +version = "0.6.2" + +[[FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" + +[[FillArrays]] +deps = ["LinearAlgebra", "Random", "SparseArrays"] +git-tree-sha1 = "6c89d5b673e59b8173c546c84127e5f623d865f6" +uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" +version = "0.8.9" + +[[FiniteDiff]] +deps = ["ArrayInterface", "LinearAlgebra", "Requires", "SparseArrays", "StaticArrays"] +git-tree-sha1 = "fec7c2cb45c27071ef487fa7cae4fcac7509aa10" +uuid = "6a86dc24-6348-571c-b903-95158fe2bd41" +version = "2.3.2" + +[[FixedEffectModels]] +deps = ["Combinatorics", "DataFrames", "Distributions", "FillArrays", "FixedEffects", "LinearAlgebra", "Printf", "Random", "Reexport", "Statistics", "StatsBase", "StatsModels", "Tables"] +git-tree-sha1 = "a5fa42ac5c04a8df13e8818f4c731243436f8f6c" +uuid = "9d5cd8c9-2029-5cab-9928-427838db53e3" +version = "0.10.7" + +[[FixedEffects]] +deps = ["CUDAapi", "CategoricalArrays", "CuArrays", "Distributed", "FillArrays", "LinearAlgebra", "Reexport", "StatsBase"] +git-tree-sha1 = "97646511fdec1a85d8d99ab7ea01dbc3d3ae215d" +uuid = "c8885935-8500-56a7-9867-7708b20db0eb" +version = "0.7.3" + +[[FixedPointNumbers]] +git-tree-sha1 = "3ba9ea634d4c8b289d590403b4a06f8e227a6238" +uuid = "53c48c17-4a7d-5ca2-90c5-79b7896eea93" +version = "0.8.0" + +[[Flux]] +deps = ["AbstractTrees", "Adapt", "CodecZlib", "Colors", "CuArrays", "DelimitedFiles", "Juno", "MacroTools", "NNlib", "Pkg", "Printf", "Random", "Reexport", "SHA", "Statistics", "StatsBase", "Test", "ZipFile", "Zygote"] +git-tree-sha1 = "eb5801eea6294851dc2b16b20669f91776e79a3b" +uuid = "587475ba-b771-5e3f-ad9e-33799f191a9c" +version = "0.10.4" + +[[Formatting]] +deps = ["Printf"] +git-tree-sha1 = "a0c901c29c0e7c763342751c0a94211d56c0de5c" +uuid = "59287772-0a20-5a39-b81b-1366585eb4c0" +version = "0.4.1" + +[[ForwardDiff]] +deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "NaNMath", "Random", "SpecialFunctions", "StaticArrays"] +git-tree-sha1 = "869540e4367122fbffaace383a5bdc34d6e5e5ac" +uuid = "f6369f11-7733-5829-9624-2563aa707210" +version = "0.10.10" + +[[FreeType2_jll]] +deps = ["Bzip2_jll", "Libdl", "Pkg", "Zlib_jll"] +git-tree-sha1 = "7d900f32a3788d4eacac2bfa3bf5c770179c8afd" +uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7" +version = "2.10.1+2" + +[[FriBidi_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "2f56bee16bd0151de7b6a1eeea2ced190a2ad8d4" +uuid = "559328eb-81f9-559d-9380-de523a88c83c" +version = "1.0.5+3" + +[[FunctionWrappers]] +git-tree-sha1 = "e4813d187be8c7b993cb7f85cbf2b7bfbaadc694" +uuid = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e" +version = "1.1.1" + +[[Future]] +deps = ["Random"] +uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820" + +[[GLM]] +deps = ["Distributions", "LinearAlgebra", "Printf", "Random", "Reexport", "SparseArrays", "SpecialFunctions", "Statistics", "StatsBase", "StatsFuns", "StatsModels"] +git-tree-sha1 = "db0ace36f9dbe7b6a7a08434c5921377e9df2c72" +uuid = "38e38edf-8417-5370-95a0-9cbb8c7f171a" +version = "1.3.9" + +[[GMP_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "4dd9301d3a027c05ec403e756ee7a60e3c367e5d" +uuid = "781609d7-10c4-51f6-84f2-b8444358ff6d" +version = "6.1.2+5" + +[[GPUArrays]] +deps = ["AbstractFFTs", "Adapt", "LinearAlgebra", "Printf", "Random", "Serialization"] +git-tree-sha1 = "d887693eb1bd5e1fd573262a978745481895ec7d" +uuid = "0c68f7d7-f131-5f86-a1c3-88cf8149b2d7" +version = "3.4.1" + +[[GPUCompiler]] +deps = ["Cthulhu", "DataStructures", "InteractiveUtils", "LLVM", "Libdl", "TimerOutputs"] +git-tree-sha1 = "5275aa268ecd09640b32560e1eae90c78816e4d1" +uuid = "61eb1bfa-7361-4325-ad38-22787b887f55" +version = "0.2.0" + +[[GR]] +deps = ["Base64", "DelimitedFiles", "LinearAlgebra", "Printf", "Random", "Serialization", "Sockets", "Test", "UUIDs"] +git-tree-sha1 = "1185d50c5c90ec7c0784af7f8d0d1a600750dc4d" +uuid = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71" +version = "0.49.1" + +[[GeneralizedGenerated]] +deps = ["CanonicalTraits", "DataStructures", "JuliaVariables", "MLStyle"] +git-tree-sha1 = "9a917449bebc5a241d23e13d36ea62c77129ce6e" +uuid = "6b9d7cbe-bcb9-11e9-073f-15a7a543e2eb" +version = "0.2.4" + +[[GenericSVD]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "62909c3eda8a25b5673a367d1ad2392ebb265211" +uuid = "01680d73-4ee2-5a08-a1aa-533608c188bb" +version = "0.3.0" + +[[GeometryTypes]] +deps = ["ColorTypes", "FixedPointNumbers", "LinearAlgebra", "StaticArrays"] +git-tree-sha1 = "34bfa994967e893ab2f17b864eec221b3521ba4d" +uuid = "4d00f742-c7ba-57c2-abde-4428a4b178cb" +version = "0.8.3" + +[[HTTP]] +deps = ["Base64", "Dates", "IniFile", "MbedTLS", "Sockets"] +git-tree-sha1 = "ec87d5e2acbe1693789efbbe14f5ea7525758f71" +uuid = "cd3eb016-35fb-5094-929b-558a96fad6f3" +version = "0.8.15" + +[[IRTools]] +deps = ["InteractiveUtils", "MacroTools", "Test"] +git-tree-sha1 = "90ee39f9beaaa186e4968417ea2b8ed5673c91c0" +uuid = "7869d1d1-7146-5819-86e3-90919afe41df" +version = "0.3.3" + +[[IncompleteLU]] +deps = ["LinearAlgebra", "Profile", "Random", "SparseArrays", "Test"] +git-tree-sha1 = "9d269f1afce521912701bde539209b0d73bb9b94" +uuid = "40713840-3770-5561-ab4c-a76e7d0d7895" +version = "0.1.1" + +[[InfiniteArrays]] +deps = ["DSP", "FillArrays", "LazyArrays", "LinearAlgebra", "SparseArrays", "Statistics"] +git-tree-sha1 = "1133e493747c207d99d0e3fe7827ae2bf5ed19dc" +uuid = "4858937d-0d70-526a-a4dd-2d5cb5dd786c" +version = "0.7.0" + +[[Inflate]] +git-tree-sha1 = "f5fc07d4e706b84f72d54eedcc1c13d92fb0871c" +uuid = "d25df0c9-e2be-5dd7-82c8-3ad0b3e990b9" +version = "0.1.2" + +[[IniFile]] +deps = ["Test"] +git-tree-sha1 = "098e4d2c533924c921f9f9847274f2ad89e018b8" +uuid = "83e8ac13-25f8-5344-8a64-a9f2b223428f" +version = "0.5.0" + +[[InstantiateFromURL]] +deps = ["BinaryProvider", "Dates", "HTTP", "Markdown", "Pkg", "Suppressor", "Test"] +git-tree-sha1 = "fb59a1b7bca5f0a0aca3c40658779baac615287a" +uuid = "43edad99-fa64-5e4f-9937-1c09a410b73f" +version = "0.5.0" + +[[IntelOpenMP_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "fb8e1c7a5594ba56f9011310790e03b5384998d6" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2018.0.3+0" + +[[InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" + +[[Interpolations]] +deps = ["AxisAlgorithms", "LinearAlgebra", "OffsetArrays", "Random", "Ratios", "SharedArrays", "SparseArrays", "StaticArrays", "WoodburyMatrices"] +git-tree-sha1 = "3af735234d9b1ff9ff1af89875735cd9549c0c5f" +uuid = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59" +version = "0.12.9" + +[[IntervalSets]] +deps = ["Dates", "EllipsisNotation", "Statistics"] +git-tree-sha1 = "3b1cef135bc532b3c3401b309e1b8a2a2ba26af5" +uuid = "8197267c-284f-5f27-9208-e0e47529a953" +version = "0.5.1" + +[[Intervals]] +deps = ["Dates", "Printf", "RecipesBase", "TimeZones"] +git-tree-sha1 = "11555ad4a66a93e2268364f2ea11139634f9dda3" +uuid = "d8418881-c3e1-53bb-8760-2df7ec849ed5" +version = "1.2.0" + +[[InvertedIndices]] +deps = ["Test"] +git-tree-sha1 = "15732c475062348b0165684ffe28e85ea8396afc" +uuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f" +version = "1.0.0" + +[[Ipopt]] +deps = ["BinaryProvider", "Libdl", "LinearAlgebra", "MathOptInterface", "MathProgBase"] +git-tree-sha1 = "ffc29b65db22ccb31108bf09e1394868efded345" +uuid = "b6b21f68-93f8-5de0-b562-5493be1d77c9" +version = "0.6.1" + +[[IterTools]] +git-tree-sha1 = "05110a2ab1fc5f932622ffea2a003221f4782c18" +uuid = "c8e1da08-722c-5040-9ed9-7db0dc04731e" +version = "1.3.0" + +[[IterableTables]] +deps = ["DataValues", "IteratorInterfaceExtensions", "Requires", "TableTraits", "TableTraitsUtils"] +git-tree-sha1 = "70300b876b2cebde43ebc0df42bc8c94a144e1b4" +uuid = "1c8ee90f-4401-5389-894e-7a04a3dc0f4d" +version = "1.0.0" + +[[IterativeSolvers]] +deps = ["LinearAlgebra", "Printf", "Random", "RecipesBase", "SparseArrays"] +git-tree-sha1 = "3b7e2aac8c94444947facea7cc7ca91c49169be0" +uuid = "42fd0dbc-a981-5370-80f2-aaf504508153" +version = "0.8.4" + +[[IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[JSON]] +deps = ["Dates", "Mmap", "Parsers", "Unicode"] +git-tree-sha1 = "b34d7cef7b337321e97d22242c3c2b91f476748e" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "0.21.0" + +[[JSONSchema]] +deps = ["BinaryProvider", "HTTP", "JSON"] +git-tree-sha1 = "b0a7f9328967df5213691d318a03cf70ea8c76b1" +uuid = "7d188eb4-7ad8-530c-ae41-71a32a6d4692" +version = "0.2.0" + +[[JuMP]] +deps = ["Calculus", "DataStructures", "ForwardDiff", "LinearAlgebra", "MathOptInterface", "MutableArithmetics", "NaNMath", "Random", "SparseArrays", "Statistics"] +git-tree-sha1 = "84c1cf8bec4729b8b2ef4dfc4e1db1b892ad0d30" +uuid = "4076af6c-e467-56ae-b986-b466b2749572" +version = "0.21.2" + +[[JuliaInterpreter]] +deps = ["CodeTracking", "InteractiveUtils", "Random", "UUIDs"] +git-tree-sha1 = "b1a4b3782a0c2e4d3a9d97f2e0e19f69c8d1d948" +uuid = "aa1ae85d-cabe-5617-a682-6adf51b2e16a" +version = "0.7.19" + +[[JuliaVariables]] +deps = ["MLStyle", "NameResolution"] +git-tree-sha1 = "8868479ff35ab98588ed0a529a9c2a4f8bda3bd6" +uuid = "b14d175d-62b4-44ba-8fb7-3064adc8c3ec" +version = "0.2.0" + +[[Juno]] +deps = ["Base64", "Logging", "Media", "Profile"] +git-tree-sha1 = "a686b0cf235fa3e491b79b4783c2d2382292b436" +uuid = "e5e0dc1b-0480-54bc-9374-aad01c23163d" +version = "0.8.2" + +[[KernelDensity]] +deps = ["Distributions", "FFTW", "Interpolations", "Optim", "StatsBase", "Test"] +git-tree-sha1 = "c1048817fe5711f699abc8fabd47b1ac6ba4db04" +uuid = "5ab0869b-81aa-558d-bb23-cbf5423bbe9b" +version = "0.5.1" + +[[Krylov]] +deps = ["LinearAlgebra", "LinearOperators", "Printf", "SparseArrays"] +git-tree-sha1 = "cdd573617b93864b906ee7a487fd18db386dc2bd" +uuid = "ba0b0d4f-ebba-5204-a429-3ac8c609bfb7" +version = "0.5.1" + +[[KrylovKit]] +deps = ["LinearAlgebra", "Printf"] +git-tree-sha1 = "8889c47e308f49184fabb0efdfaa105067e74074" +uuid = "0b1a1467-8014-51b9-945f-bf0ae24f4b77" +version = "0.4.2" + +[[LAME_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "221cc8998b9060677448cbb6375f00032554c4fd" +uuid = "c1c5ebd0-6772-5130-a774-d5fcae4a789d" +version = "3.100.0+1" + +[[LLVM]] +deps = ["CEnum", "Libdl", "Printf", "Unicode"] +git-tree-sha1 = "dd3f584c3dbefe39b2a8fbafa1a3b77e31e21255" +uuid = "929cbde3-209d-540e-8aea-75f648917ca0" +version = "1.5.1" + +[[LaTeXStrings]] +git-tree-sha1 = "de44b395389b84fd681394d4e8d39ef14e3a2ea8" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.1.0" + +[[LabelledArrays]] +deps = ["ArrayInterface", "LinearAlgebra", "MacroTools", "StaticArrays"] +git-tree-sha1 = "674c830a4ac858e877906405410471f5af2a4756" +uuid = "2ee39098-c373-598a-b85f-a56591580800" +version = "1.2.1" + +[[Latexify]] +deps = ["Formatting", "InteractiveUtils", "LaTeXStrings", "MacroTools", "Markdown", "Printf", "Requires"] +git-tree-sha1 = "3a94cd323ba13154cf1cfc9eac2a5c4f8d844445" +uuid = "23fbe1c1-3f47-55db-b15f-69d7ec21a316" +version = "0.13.2" + +[[LazyArrays]] +deps = ["ArrayLayouts", "FillArrays", "LinearAlgebra", "MacroTools", "MatrixFactorizations", "StaticArrays"] +git-tree-sha1 = "95d9fd25f6e8a4d6b4b2c63627822eb2b73c1312" +uuid = "5078a376-72f3-5289-bfd5-ec5146d43c02" +version = "0.16.9" + +[[LeastSquaresOptim]] +deps = ["FiniteDiff", "ForwardDiff", "LinearAlgebra", "Optim", "Printf", "SparseArrays", "Statistics", "SuiteSparse"] +git-tree-sha1 = "183e655ce0cdb796cac2a2a6d442285d30e4100c" +uuid = "0fc2ff8b-aaa3-5acd-a817-1944a5e08891" +version = "0.7.5" + +[[LeftChildRightSiblingTrees]] +deps = ["AbstractTrees"] +git-tree-sha1 = "71be1eb5ad19cb4f61fa8c73395c0338fd092ae0" +uuid = "1d6d02ad-be62-4b6b-8a6d-2f90e265016e" +version = "0.1.2" + +[[LibGit2]] +deps = ["Printf"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" + +[[LibVPX_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "e3549ca9bf35feb9d9d954f4c6a9032e92f46e7c" +uuid = "dd192d2f-8180-539f-9fb4-cc70b1dcf69a" +version = "1.8.1+1" + +[[Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" + +[[Libiconv_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "e5256a3b0ebc710dbd6da0c0b212164a3681037f" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.16.0+2" + +[[LightGraphs]] +deps = ["ArnoldiMethod", "DataStructures", "Distributed", "Inflate", "LinearAlgebra", "Random", "SharedArrays", "SimpleTraits", "SparseArrays", "Statistics"] +git-tree-sha1 = "6f85a35d2377cb2db1bc448ed0d6340d2bb1ea64" +uuid = "093fc24a-ae57-5d10-9952-331d41423f4d" +version = "1.3.3" + +[[LimitedLDLFactorizations]] +deps = ["AMD", "LinearAlgebra", "SparseArrays"] +git-tree-sha1 = "09019ebe6a52d4dc3dc014e0b29f590eeb7f3cce" +uuid = "f5a24dde-3ab7-510b-b81b-6a72c6098d3b" +version = "0.3.0" + +[[LineSearches]] +deps = ["LinearAlgebra", "NLSolversBase", "NaNMath", "Parameters", "Printf", "Test"] +git-tree-sha1 = "54eb90e8dbe745d617c78dee1d6ae95c7f6f5779" +uuid = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" +version = "7.0.1" + +[[LinearAlgebra]] +deps = ["Libdl"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + +[[LinearMaps]] +deps = ["LinearAlgebra", "SparseArrays"] +git-tree-sha1 = "e204a96dbb8d49fbca24086c586734435d7bf5b5" +uuid = "7a12625a-238d-50fd-b39a-03d52299707e" +version = "2.6.1" + +[[LinearOperators]] +deps = ["FastClosures", "LinearAlgebra", "Printf", "SparseArrays", "TimerOutputs"] +git-tree-sha1 = "e622d4b9bc550042e851e83a12056dc2e28ce352" +uuid = "5c8ed15e-5a4c-59e4-a42b-c7e8811fb125" +version = "1.1.0" + +[[Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" + +[[LoggingExtras]] +git-tree-sha1 = "b60616c70eff0cc2c0831b6aace75940aeb0939d" +uuid = "e6f89c97-d47a-5376-807f-9c37f3926c36" +version = "0.4.1" + +[[LoopVectorization]] +deps = ["DocStringExtensions", "LinearAlgebra", "OffsetArrays", "SIMDPirates", "SLEEFPirates", "UnPack", "VectorizationBase"] +git-tree-sha1 = "132e6b82e3434a04992a0be60e194f817101c846" +uuid = "bdcacae8-1622-11e9-2a5c-532679323890" +version = "0.8.2" + +[[LowRankApprox]] +deps = ["FFTW", "FillArrays", "LinearAlgebra", "Nullables", "Random", "SparseArrays", "Test"] +git-tree-sha1 = "1963361c4e8a837b9ca7cca3f45372f953e6b0ed" +uuid = "898213cb-b102-5a47-900c-97e73b919f73" +version = "0.4.0" + +[[LoweredCodeUtils]] +deps = ["JuliaInterpreter"] +git-tree-sha1 = "225f0035f01c24858c0884f38bb519e22b0a5150" +uuid = "6f1432cf-f94c-5a45-995e-cdbf5db27b0b" +version = "0.4.5" + +[[MKL_jll]] +deps = ["IntelOpenMP_jll", "Libdl", "Pkg"] +git-tree-sha1 = "0ce9a7fa68c70cf83c49d05d2c04d91b47404b08" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2020.1.216+0" + +[[MLStyle]] +git-tree-sha1 = "67f9a88611bc79f992aa705d9bbc833a2547dec7" +uuid = "d8e11817-5142-5d16-987a-aa16d5891078" +version = "0.3.1" + +[[MPFR_jll]] +deps = ["GMP_jll", "Libdl", "Pkg"] +git-tree-sha1 = "584d55157951b8e029a1dafa70ee639d24e25644" +uuid = "3a97d323-0669-5f0c-9066-3539efd106a3" +version = "4.0.2+2" + +[[MacroTools]] +deps = ["Markdown", "Random"] +git-tree-sha1 = "f7d2e3f654af75f01ec49be82c231c382214223a" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.5" + +[[Markdown]] +deps = ["Base64"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" + +[[MathOptInterface]] +deps = ["BenchmarkTools", "CodecBzip2", "CodecZlib", "JSON", "JSONSchema", "LinearAlgebra", "MutableArithmetics", "OrderedCollections", "SparseArrays", "Test", "Unicode"] +git-tree-sha1 = "27f2ef85879b8f1d144266ab44f076ba0dfbd8a1" +uuid = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" +version = "0.9.13" + +[[MathProgBase]] +deps = ["LinearAlgebra", "SparseArrays"] +git-tree-sha1 = "9abbe463a1e9fc507f12a69e7f29346c2cdc472c" +uuid = "fdba3010-5040-5b88-9595-932c9decdf73" +version = "0.7.8" + +[[MatrixFactorizations]] +deps = ["ArrayLayouts", "LinearAlgebra", "Random"] +git-tree-sha1 = "b1b61c7904e8c226ec87c60d102c30f90d932f45" +uuid = "a3b82374-2e81-5b9e-98ce-41277c0e4c87" +version = "0.4.0" + +[[MbedTLS]] +deps = ["Dates", "MbedTLS_jll", "Random", "Sockets"] +git-tree-sha1 = "426a6978b03a97ceb7ead77775a1da066343ec6e" +uuid = "739be429-bea8-5141-9913-cc70e7f3736d" +version = "1.0.2" + +[[MbedTLS_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "c83f5a1d038f034ad0549f9ee4d5fac3fb429e33" +uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" +version = "2.16.0+2" + +[[Measures]] +git-tree-sha1 = "e498ddeee6f9fdb4551ce855a46f54dbd900245f" +uuid = "442fdcdd-2543-5da2-b0f3-8c86c306513e" +version = "0.3.1" + +[[Media]] +deps = ["MacroTools", "Test"] +git-tree-sha1 = "75a54abd10709c01f1b86b84ec225d26e840ed58" +uuid = "e89f7d12-3494-54d1-8411-f7d8b9ae1f27" +version = "0.5.0" + +[[Missings]] +deps = ["DataAPI"] +git-tree-sha1 = "de0a5ce9e5289f27df672ffabef4d1e5861247d5" +uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28" +version = "0.4.3" + +[[Mmap]] +uuid = "a63ad114-7e13-5084-954f-fe012c677804" + +[[Mocking]] +deps = ["ExprTools"] +git-tree-sha1 = "916b850daad0d46b8c71f65f719c49957e9513ed" +uuid = "78c3b35d-d492-501b-9361-3d52fe80e533" +version = "0.7.1" + +[[ModelingToolkit]] +deps = ["ArrayInterface", "DataStructures", "DiffEqBase", "DiffEqJump", "DiffRules", "Distributed", "DocStringExtensions", "GeneralizedGenerated", "Latexify", "LightGraphs", "LinearAlgebra", "MacroTools", "NaNMath", "RecursiveArrayTools", "SafeTestsets", "SparseArrays", "SpecialFunctions", "StaticArrays", "SymbolicUtils", "TreeViews", "UnPack", "Unitful"] +git-tree-sha1 = "6bbbe56dae5cc58d1eda0b75678f24ec692051e7" +uuid = "961ee093-0014-501f-94e3-6117800e7a78" +version = "3.6.4" + +[[MuladdMacro]] +git-tree-sha1 = "c6190f9a7fc5d9d5915ab29f2134421b12d24a68" +uuid = "46d2c3a1-f734-5fdb-9937-b9b9aeba4221" +version = "0.2.2" + +[[MultivariateStats]] +deps = ["Arpack", "LinearAlgebra", "SparseArrays", "Statistics", "StatsBase"] +git-tree-sha1 = "352fae519b447bf52e6de627b89f448bcd469e4e" +uuid = "6f286f6a-111f-5878-ab1e-185364afe411" +version = "0.7.0" + +[[Mustache]] +deps = ["Printf", "Tables"] +git-tree-sha1 = "fcfc8266461f2905534aa00c0fc59b8751b1026e" +uuid = "ffc61752-8dc7-55ee-8c37-f3e9cdd09e70" +version = "1.0.3" + +[[MutableArithmetics]] +deps = ["LinearAlgebra", "SparseArrays", "Test"] +git-tree-sha1 = "e1edd618a8f39d16f8595dd622a63b25f759cf8a" +uuid = "d8a4904e-b15c-11e9-3269-09a3773c0cb0" +version = "0.2.9" + +[[NLSolversBase]] +deps = ["DiffResults", "Distributed", "FiniteDiff", "ForwardDiff"] +git-tree-sha1 = "7c4e66c47848562003250f28b579c584e55becc0" +uuid = "d41bc354-129a-5804-8e4c-c37616107c6c" +version = "7.6.1" + +[[NLopt]] +deps = ["MathProgBase", "NLopt_jll"] +git-tree-sha1 = "48d523294d66f34d012e224ec3082d35c395ebd2" +uuid = "76087f3c-5699-56af-9a33-bf431cd00edd" +version = "0.6.0" + +[[NLopt_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "bdf1dcb42a7ef8eaf60b7d101a25136b213a28e1" +uuid = "079eb43e-fd8e-5478-9966-2cf3e3edb778" +version = "2.6.2+0" + +[[NLsolve]] +deps = ["Distances", "LineSearches", "LinearAlgebra", "NLSolversBase", "Printf", "Reexport"] +git-tree-sha1 = "cce0463af83a0f36c7bfa5820e373ac090cc46ad" +uuid = "2774e3e8-f4cf-5e23-947b-6d7e65073b56" +version = "4.3.0" + +[[NNlib]] +deps = ["BinaryProvider", "Libdl", "LinearAlgebra", "Requires", "Statistics"] +git-tree-sha1 = "d9f196d911f55aeaff11b11f681b135980783824" +uuid = "872c559c-99b0-510c-b3b7-b6c96a88d5cd" +version = "0.6.6" + +[[NaNMath]] +git-tree-sha1 = "928b8ca9b2791081dc71a51c55347c27c618760f" +uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" +version = "0.3.3" + +[[NameResolution]] +deps = ["DataStructures", "PrettyPrint"] +git-tree-sha1 = "f4119274d5a410c64a1d9f546312bb6ae54d41c0" +uuid = "71a1bf82-56d0-4bbc-8a3c-48b961074391" +version = "0.1.3" + +[[NearestNeighbors]] +deps = ["Distances", "StaticArrays"] +git-tree-sha1 = "8bc6180f328f3c0ea2663935db880d34c57d6eae" +uuid = "b8a86587-4115-5ab1-83bc-aa920d37bbce" +version = "0.4.4" + +[[NodeJS]] +deps = ["Pkg"] +git-tree-sha1 = "350ac618f41958e6e0f6b0d2005ae4547eb1b503" +uuid = "2bd173c7-0d6d-553b-b6af-13a54713934c" +version = "1.1.1" + +[[Nullables]] +git-tree-sha1 = "8f87854cc8f3685a60689d8edecaa29d2251979b" +uuid = "4d1e1d77-625e-5b40-9113-a560ec7a8ecd" +version = "1.0.0" + +[[Observables]] +git-tree-sha1 = "11832878355305984235a2e90d0e3737383c634c" +uuid = "510215fc-4207-5dde-b226-833fc4488ee2" +version = "0.3.1" + +[[OffsetArrays]] +git-tree-sha1 = "930db8ef90483570107f2396b1ffc6680f08e8b7" +uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" +version = "1.0.4" + +[[Ogg_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "59cf7a95bf5ac39feac80b796e0f39f9d69dc887" +uuid = "e7412a2a-1a6e-54c0-be00-318e2571c051" +version = "1.3.4+0" + +[[OpenBLAS_jll]] +deps = ["CompilerSupportLibraries_jll", "Libdl", "Pkg"] +git-tree-sha1 = "1887096f6897306a4662f7c5af936da7d5d1a062" +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.9+4" + +[[OpenSSL_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "d2a6f25262d568b5a7e454cf7ff5066a79d16c7d" +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "1.1.1+2" + +[[OpenSpecFun_jll]] +deps = ["CompilerSupportLibraries_jll", "Libdl", "Pkg"] +git-tree-sha1 = "d51c416559217d974a1113522d5919235ae67a87" +uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e" +version = "0.5.3+3" + +[[Optim]] +deps = ["FillArrays", "LineSearches", "LinearAlgebra", "NLSolversBase", "NaNMath", "Parameters", "PositiveFactorizations", "Printf", "SparseArrays", "StatsBase"] +git-tree-sha1 = "08f170ff0dcf07f4edb567020fcab47f415da207" +uuid = "429524aa-4258-5aef-a3af-852621145aeb" +version = "0.20.1" + +[[Opus_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "002c18f222a542907e16c83c64a1338992da7e2c" +uuid = "91d4177d-7536-5919-b921-800302f37372" +version = "1.3.1+1" + +[[OrderedCollections]] +git-tree-sha1 = "12ce190210d278e12644bcadf5b21cbdcf225cd3" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "1.2.0" + +[[OrdinaryDiffEq]] +deps = ["ArrayInterface", "DataStructures", "DiffEqBase", "ExponentialUtilities", "FiniteDiff", "ForwardDiff", "GenericSVD", "LinearAlgebra", "Logging", "MacroTools", "MuladdMacro", "NLsolve", "RecursiveArrayTools", "Reexport", "SparseArrays", "SparseDiffTools", "StaticArrays", "UnPack"] +git-tree-sha1 = "98ae9c7d2bb987a6ab0e4664ff9f6252052c18fb" +uuid = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" +version = "5.38.1" + +[[PDMats]] +deps = ["Arpack", "LinearAlgebra", "SparseArrays", "SuiteSparse", "Test"] +git-tree-sha1 = "2fc6f50ddd959e462f0a2dbc802ddf2a539c6e35" +uuid = "90014a1f-27ba-587c-ab20-58faa44d9150" +version = "0.9.12" + +[[Parameters]] +deps = ["OrderedCollections", "UnPack"] +git-tree-sha1 = "38b2e970043613c187bd56a995fe2e551821eb4a" +uuid = "d96e819e-fc66-5662-9728-84c9c7592b0a" +version = "0.12.1" + +[[Parsers]] +deps = ["Dates", "Test"] +git-tree-sha1 = "f0abb338b4d00306500056a3fd44c221b8473ef2" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "1.0.4" + +[[Pkg]] +deps = ["Dates", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "UUIDs"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" + +[[PkgTemplates]] +deps = ["Dates", "InteractiveUtils", "LibGit2", "Mustache", "Pkg", "REPL", "URIParser"] +git-tree-sha1 = "fb5de58bbf1823c4373f813a5611d37e57edb109" +uuid = "14b8a8f1-9102-5b29-a752-f990bacb7fe1" +version = "0.6.4" + +[[PlotThemes]] +deps = ["PlotUtils", "Requires", "Statistics"] +git-tree-sha1 = "c6f5ea535551b3b16835134697f0c65d06c94b91" +uuid = "ccf2f8ad-2431-5c83-bf29-c5338b663b6a" +version = "2.0.0" + +[[PlotUtils]] +deps = ["ColorSchemes", "Colors", "Dates", "Printf", "Random", "Reexport", "Statistics"] +git-tree-sha1 = "ce26340b638fdf02965a6a65aa7916d40a8c774c" +uuid = "995b91a9-d308-5afd-9ec6-746e21dbc043" +version = "1.0.4" + +[[Plots]] +deps = ["Base64", "Contour", "Dates", "FFMPEG", "FixedPointNumbers", "GR", "GeometryTypes", "JSON", "LinearAlgebra", "Measures", "NaNMath", "Pkg", "PlotThemes", "PlotUtils", "Printf", "REPL", "Random", "RecipesBase", "RecipesPipeline", "Reexport", "Requires", "Showoff", "SparseArrays", "Statistics", "StatsBase", "UUIDs"] +git-tree-sha1 = "127c38970034ae9d85a9bef6d97b3aff149927af" +uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" +version = "1.2.5" + +[[PoissonRandom]] +deps = ["Random", "Statistics", "Test"] +git-tree-sha1 = "44d018211a56626288b5d3f8c6497d28c26dc850" +uuid = "e409e4f3-bfea-5376-8464-e040bb5c01ab" +version = "0.4.0" + +[[Polynomials]] +deps = ["Intervals", "LinearAlgebra", "RecipesBase"] +git-tree-sha1 = "23b99e32043d2fa4c0d1975ca30e14e00c6ea53b" +uuid = "f27b6e38-b328-58d1-80ce-0feddd5e7a45" +version = "1.0.6" + +[[PooledArrays]] +deps = ["DataAPI"] +git-tree-sha1 = "b1333d4eced1826e15adbdf01a4ecaccca9d353c" +uuid = "2dfb63ee-cc39-5dd5-95bd-886bf059d720" +version = "0.5.3" + +[[PositiveFactorizations]] +deps = ["LinearAlgebra", "Test"] +git-tree-sha1 = "127c47b91990c101ee3752291c4f45640eeb03d1" +uuid = "85a6dd25-e78a-55b7-8502-1745935b8125" +version = "0.2.3" + +[[Preconditioners]] +deps = ["AlgebraicMultigrid", "Compat", "LimitedLDLFactorizations", "LinearAlgebra", "SparseArrays"] +git-tree-sha1 = "19b4944292f0a8352cff07c11eaa931eaef6fb4f" +uuid = "af69fa37-3177-5a40-98ee-561f696e4fcd" +version = "0.3.0" + +[[PrettyPrint]] +git-tree-sha1 = "21e1f88cb73589ec39a1181f77eb444b5276151e" +uuid = "8162dcfd-2161-5ef2-ae6c-7681170c5f98" +version = "0.1.0" + +[[Primes]] +deps = ["Test"] +git-tree-sha1 = "ff1a2323cb468ec5f201838fcbe3c232266b1f95" +uuid = "27ebfcd6-29c5-5fa9-bf4b-fb8fc14df3ae" +version = "0.4.0" + +[[Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" + +[[Profile]] +deps = ["Printf"] +uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79" + +[[ProgressLogging]] +deps = ["Logging", "SHA", "UUIDs"] +git-tree-sha1 = "e47914361d124d8760f5e356403daeb7f3b81633" +uuid = "33c8b6b6-d38a-422a-b730-caa89a2f386c" +version = "0.1.2" + +[[ProgressMeter]] +deps = ["Distributed", "Printf"] +git-tree-sha1 = "ea1f4fa0ff5e8b771bf130d87af5b7ef400760bd" +uuid = "92933f4c-e287-5a05-a399-4b506db050ca" +version = "1.2.0" + +[[QuadGK]] +deps = ["DataStructures", "LinearAlgebra"] +git-tree-sha1 = "dc84e810393cfc6294248c9032a9cdacc14a3db4" +uuid = "1fd47b50-473d-5c70-9696-f719f8f3bcdc" +version = "2.3.1" + +[[QuantEcon]] +deps = ["DSP", "DataStructures", "Distributions", "FFTW", "LightGraphs", "LinearAlgebra", "Markdown", "NLopt", "Optim", "Pkg", "Primes", "Random", "SparseArrays", "SpecialFunctions", "Statistics", "StatsBase", "Test"] +git-tree-sha1 = "4e2dc3044303aa2cbf6e321cb9af3982f6774e6a" +uuid = "fcd29c91-0bd7-5a09-975d-7ac3f643a60c" +version = "0.16.2" + +[[Query]] +deps = ["DataValues", "IterableTables", "MacroTools", "QueryOperators", "Statistics"] +git-tree-sha1 = "fd506b7101702daa4fb13cdffca771180d16c19c" +uuid = "1a8c2f83-1ff3-5112-b086-8aa67b057ba1" +version = "0.12.2" + +[[QueryOperators]] +deps = ["DataStructures", "DataValues", "IteratorInterfaceExtensions", "TableShowUtils"] +git-tree-sha1 = "7ffa41275edd6e0374a9ae8e3b048840867a06d9" +uuid = "2aef5ad7-51ca-5a8f-8e88-e75cf067b44b" +version = "0.9.1" + +[[RData]] +deps = ["CategoricalArrays", "CodecZlib", "DataFrames", "Dates", "FileIO", "Requires", "TimeZones", "Unicode"] +git-tree-sha1 = "10693c581956334a368c26b7c544e406c4c94385" +uuid = "df47a6cb-8c03-5eed-afd8-b6050d6c41da" +version = "0.7.2" + +[[RDatasets]] +deps = ["CSV", "CodecZlib", "DataFrames", "FileIO", "Printf", "RData", "Reexport"] +git-tree-sha1 = "522cd00e7354cb39208a6c8040b1ccc421862ca4" +uuid = "ce6b1742-4840-55fa-b093-852dadbb1d8b" +version = "0.6.8" + +[[REPL]] +deps = ["InteractiveUtils", "Markdown", "Sockets"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" + +[[Random]] +deps = ["Serialization"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" + +[[RandomNumbers]] +deps = ["Random", "Requires"] +git-tree-sha1 = "441e6fc35597524ada7f85e13df1f4e10137d16f" +uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" +version = "1.4.0" + +[[Ratios]] +git-tree-sha1 = "37d210f612d70f3f7d57d488cb3b6eff56ad4e41" +uuid = "c84ed2f1-dad5-54f0-aa8e-dbefe2724439" +version = "0.4.0" + +[[RecipesBase]] +git-tree-sha1 = "54f8ceb165a0f6d083f0d12cb4996f5367c6edbc" +uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" +version = "1.0.1" + +[[RecipesPipeline]] +deps = ["Dates", "PlotUtils", "RecipesBase"] +git-tree-sha1 = "9215637e28503ca85bef843a1fc02b2f76f1ba09" +uuid = "01d81517-befc-4cb6-b9ec-a95719d0359c" +version = "0.1.9" + +[[RecursiveArrayTools]] +deps = ["ArrayInterface", "LinearAlgebra", "RecipesBase", "Requires", "StaticArrays", "Statistics", "ZygoteRules"] +git-tree-sha1 = "093999ed6ae5780a4724797565adfd211e01e380" +uuid = "731186ca-8d62-57ce-b412-fbd966d074cd" +version = "2.3.5" + +[[RecursiveFactorization]] +deps = ["LinearAlgebra", "LoopVectorization"] +git-tree-sha1 = "09217cb106dd826de9960986207175b52e3035f2" +uuid = "f2c3362d-daeb-58d1-803e-2bc74f2840b4" +version = "0.1.2" + +[[Reexport]] +deps = ["Pkg"] +git-tree-sha1 = "7b1d07f411bc8ddb7977ec7f377b97b158514fe0" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "0.2.0" + +[[RegressionTables]] +deps = ["Compat", "Distributions", "FixedEffectModels", "Formatting", "GLM", "Parameters", "Statistics", "StatsBase", "StatsModels"] +git-tree-sha1 = "02ee6f9a0649bd9d36d9ee2228ee4cd3ec52e978" +uuid = "d519eb52-b820-54da-95a6-98e1306fdade" +version = "0.4.0" + +[[Requires]] +deps = ["UUIDs"] +git-tree-sha1 = "d37400976e98018ee840e0ca4f9d20baa231dc6b" +uuid = "ae029012-a4dd-5104-9daa-d747884805df" +version = "1.0.1" + +[[ResettableStacks]] +deps = ["StaticArrays"] +git-tree-sha1 = "d19e9c93de6020a96dbb2820567c78d0ab8f7248" +uuid = "ae5879a3-cd67-5da8-be7f-38c6eb64a37b" +version = "1.0.0" + +[[Revise]] +deps = ["CodeTracking", "Distributed", "FileWatching", "JuliaInterpreter", "LibGit2", "LoweredCodeUtils", "OrderedCollections", "Pkg", "REPL", "UUIDs", "Unicode"] +git-tree-sha1 = "3185d2ee31756af9e20ce045ddfaedcd0df9e4aa" +uuid = "295af30f-e4ad-537b-8983-00126c2a3abe" +version = "2.6.6" + +[[Rmath]] +deps = ["Random", "Rmath_jll"] +git-tree-sha1 = "86c5647b565873641538d8f812c04e4c9dbeb370" +uuid = "79098fc4-a85e-5d69-aa6a-4863f24498fa" +version = "0.6.1" + +[[Rmath_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "1660f8fefbf5ab9c67560513131d4e933012fc4b" +uuid = "f50d1b31-88e8-58de-be2c-1cc44531875f" +version = "0.2.2+0" + +[[Roots]] +deps = ["Printf"] +git-tree-sha1 = "955ce06c1f424ca7043c7827f5cb14d8eb397065" +uuid = "f2b01f46-fcfa-551c-844a-d8ac1e96c665" +version = "1.0.1" + +[[SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" + +[[SIMDPirates]] +deps = ["VectorizationBase"] +git-tree-sha1 = "7ac32930e05d1fcb152d792495b9cc4823ca004f" +uuid = "21efa798-c60a-11e8-04d3-e1a92915a26a" +version = "0.8.5" + +[[SLEEFPirates]] +deps = ["Libdl", "SIMDPirates", "VectorizationBase"] +git-tree-sha1 = "c5c88ccad9e4aac35e7b4737bfc08296210b2d27" +uuid = "476501e8-09a2-5ece-8869-fb82de89a1fa" +version = "0.5.0" + +[[SafeTestsets]] +deps = ["Test"] +git-tree-sha1 = "36ebc5622c82eb9324005cc75e7e2cc51181d181" +uuid = "1bc83da4-3b8d-516f-aca4-4fe02f6d838f" +version = "0.0.1" + +[[Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[Setfield]] +deps = ["ConstructionBase", "Future", "MacroTools", "Requires"] +git-tree-sha1 = "7a151f918819326a6003dba451dabe65f8c0f6fb" +uuid = "efcf1570-3423-57d1-acb7-fd33fddbac46" +version = "0.6.0" + +[[SharedArrays]] +deps = ["Distributed", "Mmap", "Random", "Serialization"] +uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383" + +[[ShiftedArrays]] +git-tree-sha1 = "22395afdcf37d6709a5a0766cc4a5ca52cb85ea0" +uuid = "1277b4bf-5013-50f5-be3d-901d8477a67a" +version = "1.0.0" + +[[Showoff]] +deps = ["Dates"] +git-tree-sha1 = "e032c9df551fb23c9f98ae1064de074111b7bc39" +uuid = "992d4aef-0814-514b-bc4d-f2e9a6c4116f" +version = "0.3.1" + +[[SimpleTraits]] +deps = ["InteractiveUtils", "MacroTools"] +git-tree-sha1 = "2ee666b24ab8be6a922f9d6c11a86e1a703a7dda" +uuid = "699a6c99-e7fa-54fc-8d76-47d257e15c1d" +version = "0.9.2" + +[[Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" + +[[SortingAlgorithms]] +deps = ["DataStructures", "Random", "Test"] +git-tree-sha1 = "03f5898c9959f8115e30bc7226ada7d0df554ddd" +uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c" +version = "0.3.1" + +[[SparseArrays]] +deps = ["LinearAlgebra", "Random"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + +[[SparseDiffTools]] +deps = ["Adapt", "ArrayInterface", "Compat", "DataStructures", "FiniteDiff", "ForwardDiff", "LightGraphs", "LinearAlgebra", "Requires", "SparseArrays", "VertexSafeGraphs"] +git-tree-sha1 = "bfe68e0d914952932594b3c838f08463b0841037" +uuid = "47a9eef4-7e08-11e9-0b38-333d64bd3804" +version = "1.8.0" + +[[SparsityDetection]] +deps = ["Cassette", "LinearAlgebra", "SparseArrays", "SpecialFunctions"] +git-tree-sha1 = "7a4709f064c721a3138b10100778777bcde26531" +uuid = "684fba80-ace3-11e9-3d08-3bc7ed6f96df" +version = "0.3.1" + +[[SpatialIndexing]] +deps = ["Printf", "Random", "Test"] +git-tree-sha1 = "7bc6fc5c363aae476ec2c8bc527aef104b90c779" +uuid = "d4ead438-fe20-5cc5-a293-4fd39a41b74c" +version = "0.1.2" + +[[SpecialFunctions]] +deps = ["OpenSpecFun_jll"] +git-tree-sha1 = "d8d8b8a9f4119829410ecd706da4cc8594a1e020" +uuid = "276daf66-3868-5448-9aa4-cd146d93841b" +version = "0.10.3" + +[[StaticArrays]] +deps = ["LinearAlgebra", "Random", "Statistics"] +git-tree-sha1 = "5c06c0aeb81bef54aed4b3f446847905eb6cbda0" +uuid = "90137ffa-7385-5640-81b9-e52037218182" +version = "0.12.3" + +[[Statistics]] +deps = ["LinearAlgebra", "SparseArrays"] +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" + +[[StatsBase]] +deps = ["DataAPI", "DataStructures", "LinearAlgebra", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics"] +git-tree-sha1 = "19bfcb46245f69ff4013b3df3b977a289852c3a1" +uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +version = "0.32.2" + +[[StatsFuns]] +deps = ["Rmath", "SpecialFunctions"] +git-tree-sha1 = "04a5a8e6ab87966b43f247920eab053fd5fdc925" +uuid = "4c63d2b9-4356-54db-8cca-17b64c39e42c" +version = "0.9.5" + +[[StatsModels]] +deps = ["DataAPI", "DataStructures", "LinearAlgebra", "ShiftedArrays", "SparseArrays", "StatsBase", "Tables"] +git-tree-sha1 = "5a140e0bf5d92b2c5c0daa0dcefdadbb57c8a7fb" +uuid = "3eaba693-59b7-5ba5-a881-562e759f1c8d" +version = "0.6.11" + +[[StatsPlots]] +deps = ["Clustering", "DataStructures", "DataValues", "Distributions", "Interpolations", "KernelDensity", "MultivariateStats", "Observables", "Plots", "RecipesBase", "RecipesPipeline", "Reexport", "StatsBase", "TableOperations", "Tables", "Widgets"] +git-tree-sha1 = "b9b7fff81f573465fcac4685df1497d968537a9e" +uuid = "f3b207a7-027a-5e70-b257-86293d7955fd" +version = "0.14.6" + +[[StochasticDiffEq]] +deps = ["ArrayInterface", "DataStructures", "DiffEqBase", "DiffEqNoiseProcess", "FillArrays", "FiniteDiff", "ForwardDiff", "LinearAlgebra", "Logging", "MuladdMacro", "NLsolve", "Random", "RandomNumbers", "RecursiveArrayTools", "Reexport", "SparseArrays", "SparseDiffTools", "StaticArrays", "UnPack"] +git-tree-sha1 = "9773696fb1791b78d095e9c0a71578fe5f159107" +uuid = "789caeaf-c7a9-5a7d-9973-96adeb23e2a0" +version = "6.20.0" + +[[SuiteSparse]] +deps = ["Libdl", "LinearAlgebra", "Serialization", "SparseArrays"] +uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9" + +[[Suppressor]] +deps = ["Compat"] +git-tree-sha1 = "a39342763981e766a72938b59032dc02a2d74da5" +uuid = "fd094767-a336-5f1f-9728-57cf17d0bbfb" +version = "0.1.1" + +[[SymbolicUtils]] +deps = ["Combinatorics", "NaNMath", "SpecialFunctions", "TimerOutputs"] +git-tree-sha1 = "7283b65889b16de32e61c81a9af9708806cb711a" +uuid = "d1185830-fcd6-423d-90d6-eec64667417b" +version = "0.3.2" + +[[TableOperations]] +deps = ["Tables", "Test"] +git-tree-sha1 = "208630a14884abd110a8f8008b0882f0d0f5632c" +uuid = "ab02a1b2-a7df-11e8-156e-fb1833f50b87" +version = "0.2.1" + +[[TableShowUtils]] +deps = ["DataValues", "Dates", "JSON", "Markdown", "Test"] +git-tree-sha1 = "14c54e1e96431fb87f0d2f5983f090f1b9d06457" +uuid = "5e66a065-1f0a-5976-b372-e0b8c017ca10" +version = "0.2.5" + +[[TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "b1ad568ba658d8cbb3b892ed5380a6f3e781a81e" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.0" + +[[TableTraitsUtils]] +deps = ["DataValues", "IteratorInterfaceExtensions", "Missings", "TableTraits"] +git-tree-sha1 = "8fc12ae66deac83e44454e61b02c37b326493233" +uuid = "382cd787-c1b6-5bf2-a167-d5b971a19bda" +version = "1.0.1" + +[[Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "LinearAlgebra", "TableTraits", "Test"] +git-tree-sha1 = "c45dcc27331febabc20d86cb3974ef095257dcf3" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.0.4" + +[[TerminalLoggers]] +deps = ["LeftChildRightSiblingTrees", "Logging", "Markdown", "Printf", "ProgressLogging", "UUIDs"] +git-tree-sha1 = "8c05be75dfe73d90e5dfb6293e0c852013f7282d" +uuid = "5d786b92-1e48-4d6f-9151-6b4477ca9bed" +version = "0.1.1" + +[[Test]] +deps = ["Distributed", "InteractiveUtils", "Logging", "Random"] +uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[TimeZones]] +deps = ["Dates", "EzXML", "Mocking", "Printf", "RecipesBase", "Serialization", "Unicode"] +git-tree-sha1 = "db7bc2051d4c2e5f336409224df81485c00de6cb" +uuid = "f269a46b-ccf7-5d73-abea-4c690281aa53" +version = "1.2.0" + +[[TimerOutputs]] +deps = ["Printf"] +git-tree-sha1 = "f7d70f9d12af171efdb9c1555db8097b5b6abeb5" +repo-rev = "master" +repo-url = "https://github.com/KristofferC/TimerOutputs.jl" +uuid = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f" +version = "0.5.5" + +[[ToeplitzMatrices]] +deps = ["AbstractFFTs", "FFTW", "LinearAlgebra", "StatsBase"] +git-tree-sha1 = "8bc327ddbce87cb5976e27ab4adb9ffce5345a05" +uuid = "c751599d-da0a-543b-9d20-d0a503d91d24" +version = "0.6.1" + +[[TranscodingStreams]] +deps = ["Random", "Test"] +git-tree-sha1 = "7c53c35547de1c5b9d46a4797cf6d8253807108c" +uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa" +version = "0.9.5" + +[[TreeViews]] +deps = ["Test"] +git-tree-sha1 = "8d0d7a3fe2f30d6a7f833a5f19f7c7a5b396eae6" +uuid = "a2a6695c-b41b-5b7d-aed9-dbfdeacea5d7" +version = "0.3.0" + +[[URIParser]] +deps = ["Unicode"] +git-tree-sha1 = "53a9f49546b8d2dd2e688d216421d050c9a31d0d" +uuid = "30578b45-9adc-5946-b283-645ec420af67" +version = "0.4.1" + +[[UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" + +[[UnPack]] +git-tree-sha1 = "d4bfa022cd30df012700cf380af2141961bb3bfb" +uuid = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" +version = "1.0.1" + +[[Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" + +[[Unitful]] +deps = ["ConstructionBase", "LinearAlgebra", "Random"] +git-tree-sha1 = "3714b55de06b11b2aa788b8643d6e91f13648be5" +uuid = "1986cc42-f94f-5a68-af5c-568840ba703d" +version = "1.2.1" + +[[VectorizationBase]] +deps = ["CpuId", "LinearAlgebra"] +git-tree-sha1 = "a7eeff8fae4f11bd1ec140169ae2b10e26adf673" +uuid = "3d5dd08c-fd9d-11e8-17fa-ed2836048c2f" +version = "0.12.6" + +[[Vega]] +deps = ["DataStructures", "DataValues", "Dates", "FileIO", "FilePaths", "IteratorInterfaceExtensions", "JSON", "JSONSchema", "MacroTools", "NodeJS", "Pkg", "REPL", "Random", "Setfield", "TableTraits", "TableTraitsUtils", "URIParser"] +git-tree-sha1 = "d0bb49ee9d77b72558b21a011922792cc9ae542a" +uuid = "239c3e63-733f-47ad-beb7-a12fde22c578" +version = "0.1.1" + +[[VegaLite]] +deps = ["DataStructures", "DataValues", "Dates", "FileIO", "FilePaths", "IteratorInterfaceExtensions", "JSON", "JSONSchema", "MacroTools", "NodeJS", "Pkg", "REPL", "Random", "Setfield", "TableTraits", "TableTraitsUtils", "URIParser", "Vega"] +git-tree-sha1 = "deb59ecf00b4afa3e1cfd106423c22b8c77c109e" +uuid = "112f6efa-9a02-5b7d-90c0-432ed331239a" +version = "2.1.3" + +[[VertexSafeGraphs]] +deps = ["LightGraphs"] +git-tree-sha1 = "b9b450c99a3ca1cc1c6836f560d8d887bcbe356e" +uuid = "19fa3120-7c27-5ec5-8db8-b0b0aa330d6f" +version = "0.1.2" + +[[WeakRefStrings]] +deps = ["DataAPI", "Random", "Test"] +git-tree-sha1 = "28807f85197eaad3cbd2330386fac1dcb9e7e11d" +uuid = "ea10d353-3f73-51f8-a26c-33c1cb351aa5" +version = "0.6.2" + +[[Widgets]] +deps = ["Colors", "Dates", "Observables", "OrderedCollections"] +git-tree-sha1 = "fc0feda91b3fef7fe6948ee09bb628f882b49ca4" +uuid = "cc8bc4a8-27d6-5769-a93b-9d913e69aa62" +version = "0.6.2" + +[[WoodburyMatrices]] +deps = ["LinearAlgebra", "SparseArrays"] +git-tree-sha1 = "28ffe06d28b1ba8fdb2f36ec7bb079fac81bac0d" +uuid = "efce3f68-66dc-5838-9240-27a6d6f5f9b6" +version = "0.5.2" + +[[XML2_jll]] +deps = ["Libdl", "Libiconv_jll", "Pkg", "Zlib_jll"] +git-tree-sha1 = "987c02a43fa10a491a5f0f7c46a6d3559ed6a8e2" +uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" +version = "2.9.9+4" + +[[ZipFile]] +deps = ["Libdl", "Printf", "Zlib_jll"] +git-tree-sha1 = "254975fef2fc526583bb9b7c9420fe66ffe09f2f" +uuid = "a5390f91-8eb1-5f08-bee0-b1d1ffed6cea" +version = "0.9.2" + +[[Zlib_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "a2e0d558f6031002e380a90613b199e37a8565bf" +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.2.11+10" + +[[Zygote]] +deps = ["AbstractFFTs", "ArrayLayouts", "DiffRules", "FillArrays", "ForwardDiff", "Future", "IRTools", "InteractiveUtils", "LinearAlgebra", "MacroTools", "NNlib", "NaNMath", "Random", "Requires", "SpecialFunctions", "Statistics", "ZygoteRules"] +git-tree-sha1 = "707ceea58e2bd0ff3077ab13a92f8355181d3ee4" +uuid = "e88e6eb3-aa80-5325-afca-941959d7151f" +version = "0.4.20" + +[[ZygoteRules]] +deps = ["MacroTools"] +git-tree-sha1 = "b3b4882cc9accf6731a08cc39543fbc6b669dca8" +uuid = "700de1a5-db45-46bc-99cf-38207098b444" +version = "0.2.0" + +[[libass_jll]] +deps = ["Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "Libdl", "Pkg", "Zlib_jll"] +git-tree-sha1 = "027a304b2a90de84f690949a21f94e5ae0f92c73" +uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0" +version = "0.14.0+2" + +[[libfdk_aac_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "480c7ed04f68ea3edd4c757f5db5b6a0a4e0bd99" +uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280" +version = "0.1.6+2" + +[[libvorbis_jll]] +deps = ["Libdl", "Ogg_jll", "Pkg"] +git-tree-sha1 = "6a66f65b5275dfa799036c8a3a26616a0a271c4a" +uuid = "f27f6e37-5d2b-51aa-960f-b287f2bc3b7a" +version = "1.3.6+4" + +[[x264_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "d89346fe63a6465a9f44e958ac0e3d366af90b74" +uuid = "1270edf5-f2f9-52d2-97e9-ab00b5d0237a" +version = "2019.5.25+2" + +[[x265_jll]] +deps = ["Libdl", "Pkg"] +git-tree-sha1 = "61324ad346b00a6e541896b94201c9426591e43a" +uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76" +version = "3.0.0+1" \ No newline at end of file diff --git a/source/_static/Project.toml b/source/_static/Project.toml new file mode 100644 index 00000000..cee678df --- /dev/null +++ b/source/_static/Project.toml @@ -0,0 +1,78 @@ +name = "quantecon-notebooks-julia" +authors = ["arnavs "] +version = "0.8.0" + +[deps] +AlgebraicMultigrid = "2169fc97-5a83-5252-b627-83903c6c433c" +ApproxFun = "28f2ccd6-bb30-5033-b560-165f7b14dc2f" +Arpack = "7d9fca2a-8960-54d3-9f78-7d1dccf2cb97" +BandedMatrices = "aae01518-5342-5314-be14-df237901396f" +BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" +BlackBoxOptim = "a134a8b2-14d6-55f6-9291-3336d3ab0209" +BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" +CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597" +Compat = "34da2185-b29b-5c13-b0c7-acf172513d20" +DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" +DataFramesMeta = "1313f7d8-7da2-5740-9ea0-a2ca25f37964" +Dierckx = "39dd38d3-220a-591b-8e3c-4c3a8c710a94" +DiffEqOperators = "9fdde737-9c7f-55bf-ade8-46b3f136cc48" +Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" +Expectations = "2fe49d83-0758-5602-8f54-1f90ad0d522b" +Expokit = "a1e7a1ef-7a5d-5822-a38c-be74e1bb89f4" +ExponentialUtilities = "d4d017d3-3776-5f7e-afef-a10c40355c18" +FastGaussQuadrature = "442a2c76-b920-505d-bb47-c5924d526838" +FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" +FixedEffectModels = "9d5cd8c9-2029-5cab-9928-427838db53e3" +FixedEffects = "c8885935-8500-56a7-9867-7708b20db0eb" +Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c" +ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" +GLM = "38e38edf-8417-5370-95a0-9cbb8c7f171a" +GR = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71" +IncompleteLU = "40713840-3770-5561-ab4c-a76e7d0d7895" +InstantiateFromURL = "43edad99-fa64-5e4f-9937-1c09a410b73f" +Interpolations = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59" +Ipopt = "b6b21f68-93f8-5de0-b562-5493be1d77c9" +IterativeSolvers = "42fd0dbc-a981-5370-80f2-aaf504508153" +JuMP = "4076af6c-e467-56ae-b986-b466b2749572" +KernelDensity = "5ab0869b-81aa-558d-bb23-cbf5423bbe9b" +Krylov = "ba0b0d4f-ebba-5204-a429-3ac8c609bfb7" +KrylovKit = "0b1a1467-8014-51b9-945f-bf0ae24f4b77" +LaTeXStrings = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02" +LeastSquaresOptim = "0fc2ff8b-aaa3-5acd-a817-1944a5e08891" +LightGraphs = "093fc24a-ae57-5d10-9952-331d41423f4d" +LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +LinearMaps = "7a12625a-238d-50fd-b39a-03d52299707e" +LinearOperators = "5c8ed15e-5a4c-59e4-a42b-c7e8811fb125" +ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78" +NLopt = "76087f3c-5699-56af-9a33-bf431cd00edd" +NLsolve = "2774e3e8-f4cf-5e23-947b-6d7e65073b56" +Optim = "429524aa-4258-5aef-a3af-852621145aeb" +OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" +Parameters = "d96e819e-fc66-5662-9728-84c9c7592b0a" +PkgTemplates = "14b8a8f1-9102-5b29-a752-f990bacb7fe1" +Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" +Polynomials = "f27b6e38-b328-58d1-80ce-0feddd5e7a45" +Preconditioners = "af69fa37-3177-5a40-98ee-561f696e4fcd" +ProgressMeter = "92933f4c-e287-5a05-a399-4b506db050ca" +QuadGK = "1fd47b50-473d-5c70-9696-f719f8f3bcdc" +QuantEcon = "fcd29c91-0bd7-5a09-975d-7ac3f643a60c" +Query = "1a8c2f83-1ff3-5112-b086-8aa67b057ba1" +RDatasets = "ce6b1742-4840-55fa-b093-852dadbb1d8b" +Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +RegressionTables = "d519eb52-b820-54da-95a6-98e1306fdade" +Revise = "295af30f-e4ad-537b-8983-00126c2a3abe" +Roots = "f2b01f46-fcfa-551c-844a-d8ac1e96c665" +SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +SparseDiffTools = "47a9eef4-7e08-11e9-0b38-333d64bd3804" +SparsityDetection = "684fba80-ace3-11e9-3d08-3bc7ed6f96df" +StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" +Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +StatsModels = "3eaba693-59b7-5ba5-a881-562e759f1c8d" +StatsPlots = "f3b207a7-027a-5e70-b257-86293d7955fd" +StochasticDiffEq = "789caeaf-c7a9-5a7d-9973-96adeb23e2a0" +Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" +TimerOutputs = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f" +VegaLite = "112f6efa-9a02-5b7d-90c0-432ed331239a" +Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" \ No newline at end of file diff --git a/source/_static/quant-econ.bib b/source/_static/quant-econ.bib index a0eda840..fac88b9b 100644 --- a/source/_static/quant-econ.bib +++ b/source/_static/quant-econ.bib @@ -21,7 +21,29 @@ @TechReport{Perla2019 Type = {Working Paper}, Institution = {University of British Columbia} } - +@article{heffernan2005perspectives, + title={Perspectives on the basic reproductive ratio}, + author={Heffernan, Jane M and Smith, Robert J and Wahl, Lindi M}, + journal={Journal of the Royal Society Interface}, + volume={2}, + number={4}, + pages={281--293}, + year={2005}, + publisher={The Royal Society London} +} +@techreport{NBERw27128, + title = "Estimating and Simulating a SIRD Model of COVID-19 for Many Countries, States, and Cities", + author = "Fernández-Villaverde, Jesús and Jones, Charles I", + institution = "National Bureau of Economic Research", + type = "Working Paper", + series = "Working Paper Series", + number = "27128", + year = "2020", + month = "May", + doi = {10.3386/w27128}, + URL = "http://www.nber.org/papers/w27128", + abstract = {We use data on deaths in New York City, Madrid, Stockholm, and other world cities as well as in various U.S. states and various countries and regions to estimate a standard epidemiological model of COVID-19. We allow for a time-varying contact rate in order to capture behavioral and policy-induced changes associated with social distancing. We simulate the model forward to consider possible futures for various countries, states, and cities, including the potential impact of herd immunity on re-opening. Our current baselinemortality rate (IFR) is assumed to be 1.0% but we recognize there is substantial uncertainty about this number. Our model fits the death data equally well with alternative mortality rates of 0.5% or 1.2%, so this parameter is unidentified in our data. However, its value matters enormously for the extent to which various places can relax social distancing without spurring a resurgence of deaths.}, +} @article{Samuelson1939, title = {Interactions Between the Multiplier Analysis and the Principle of Acceleration}, diff --git a/source/rst/Manifest.toml b/source/rst/Manifest.toml index 5c3a5994..2c298088 100644 --- a/source/rst/Manifest.toml +++ b/source/rst/Manifest.toml @@ -1729,4 +1729,4 @@ version = "2019.5.25+2" deps = ["Libdl", "Pkg"] git-tree-sha1 = "61324ad346b00a6e541896b94201c9426591e43a" uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76" -version = "3.0.0+1" +version = "3.0.0+1" \ No newline at end of file diff --git a/source/rst/Project.toml b/source/rst/Project.toml index f6f0ba35..cee678df 100644 --- a/source/rst/Project.toml +++ b/source/rst/Project.toml @@ -75,4 +75,4 @@ StochasticDiffEq = "789caeaf-c7a9-5a7d-9973-96adeb23e2a0" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" TimerOutputs = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f" VegaLite = "112f6efa-9a02-5b7d-90c0-432ed331239a" -Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" +Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" \ No newline at end of file diff --git a/source/rst/continuous_time/covid_sde.rst b/source/rst/continuous_time/covid_sde.rst new file mode 100644 index 00000000..2a765a51 --- /dev/null +++ b/source/rst/continuous_time/covid_sde.rst @@ -0,0 +1,651 @@ +.. _covid_sde: + +.. include:: /_static/includes/header.raw + +.. highlight:: julia + +**************************************************************************** +:index:`Modeling Shocks in COVID 19 with Stochastic Differential Equations` +**************************************************************************** + +.. contents:: :depth: 2 + +Overview +============= + +Coauthored with Chris Rackauckas + +This lecture continues the analyzing of the COVID-19 pandemic established in :doc:`this lecture `. + +As before, the model is inspired by +* Notes from `Andrew Atkeson `__ and `NBER Working Paper No. 26867 `__ +* `Estimating and Forecasting Disease Scenarios for COVID-19 with an SIR Model `__ by Andrew Atkeson, Karen Kopecky and Tao Zha +* `Estimating and Simulating a SIRD Model of COVID-19 for Many Countries, States, and Cities `__ by Jesús Fernández-Villaverde and Charles I. Jones +* Further variations on the classic SIR model in Julia `here `__. + +Here we extend the model to include policy-relevant aggregate shocks. + +Continuous-Time Stochastic Processes +------------------------------------ + +In continuous-time, there is an important distinction between randomness that leads to continuous paths vs. those which have (almost surely right-continuous) jumps in their paths at a finite number of points on any compact interval. The most tractable of these includes the theory of `Levy Processes `_. + +.. **TBD:** Add definition of levy processes and the intuitive connection between stationary increments and independence of increments. + +Among the appealing features of Levy Processes is that they fit well into the sorts of Markov modeling techniques that economists tend to use in discrete time, and usually fulfill the measurability required for calculating expected present discounted values. + +Unlike in discrete-time, where a modeller has license to be creative, the rules of continuous-time stochastic processes are much stricter. In practice, there are only two types of Levy Processes that can be used without careful measure theory. + +#. `Weiner Processes `__ (as known as Brownian Motion) which leads to a diffusion equations, and is the only continuous-time Levy process with continuous paths +#. `Poisson Processes `__ with an arrival rate of jumps in the variable. + +Every other Levy Process can be represented by these building blocks (e.g. a `Diffusion Process `__ such as Geometric Brownian Motion is a transformation of a Weiner process, a `jump diffusion `__ is a diffusion process with a Poisson arrival of jumps, and a continuous-time markov chain (CMTC) is a Poisson process jumping between a finite number of states). + +In this lecture, we will examine shocks driven by transformations of Brownian motion, as the prototypical Stochastic Differential Equation (SDE). + + +Setup +------------------ + +.. literalinclude:: /_static/includes/deps_generic.jl + :class: hide-output + +.. code-block:: julia + + using LinearAlgebra, Statistics, Random, SparseArrays + +.. code-block:: julia + :class: Test + + using Test # Put this before any code in the lecture. + +In addition, we will be exploring packages within the `SciML ecosystem `__ and +others covered in previous lectures + +.. code-block:: julia + + using OrdinaryDiffEq, StochasticDiffEq + using Parameters, Plots + + +The Basic SIR/SIRD Model +========================= + +To demonstrate another common `compartmentalized model `__ we will change the SEIR model to remove the exposed state, and more carefully manage the death state, D. + +The states are: susceptible (S), infected (I), resistant (R), or dead (D). + + +Comments: + +* Unlike the previous SEIR model, the R state is only for those recovered, alive, and currently resistant. + +* As before, we start by assuming those have recovered have acquired immunity. + +* Later, we could consider transitions from R to S if resistance is not permanent due to virus mutation, etc. + +Transition Rates +------------------------------- + +See the :doc:`previous lecture `, for a more detailed development of the model. + +* :math:`\beta(t)` is called the *transmission rate* or *effective contact rate* (the rate at which individuals bump into others and expose them to the virus) +* :math:`\gamma` is called the *resolution rate* (the rate at which infected people recover or die) +* :math:`\delta(t) \in [0, 1]` is the *death probability* +* As before, we re-parameterize as :math:`R_0(t) := \beta(t) / \gamma`, where :math:`R_0` has previous interpretation + +Jumping directly to the equations in :math:`s, i, r, d` already normalized by :math:`N`, + +.. math:: + \begin{aligned} + d s & = - \gamma \, R_0 \, s \, i dt + \\ + d i & = \left(\gamma \, R_0 \, s \, i - \gamma i \right) dt + \\ + d r & = (1-\delta) \gamma i \, dt + \\ + d d & = \delta \gamma i \, dt + \\ + \end{aligned} + :label: SIRD + + +Introduction to SDEs: Aggregate Shocks to Transmission Rates +============================================================== + +We start by extending our model to include randomness in :math:`R_0(t)`, which makes it a system of Stochastic Differential Equations (SDEs). + +Shocks to Transmission Rates +------------------------------ + +As before, we assume that the basic reproduction number, :math:`R_0(t)`, follows a process with a reversion to a value :math:`\bar{R}_0(t)` which could conceivably be influenced by policy. The intuition is that even if the targeted :math:`\bar{R}_0(t)` was changed through social distancing/etc., lags in behavior and implementation would smooth out the transition, where :math:`\eta` governs the speed of :math:`R_0(t)` moves towards :math:`\bar{R}_0(t)`. + + +Beyond changes in policy, randomness in :math:`R_0(t)` may come from shocks to the :math:`\beta(t)` process. For example, + +* Misinformation on Facebook spreading non-uniformly. +* Large political rallies, elections, or protests. +* Deviations in the implementation and timing of lockdown policy between demographics, locations, or businesses within the system. +* Aggregate shocks in opening/closing industries. + +To implement these sorts of randomness, we will add on a diffusion term with an instantaneous volatility of :math:`\sigma \sqrt{R_0}`. + +* This equation is used in the `Cox-Ingersoll-Ross `__ and `Heston `__ models of interest rates and stochastic volatility. +* The scaling by the :math:`\sqrt{R_0}` ensure that the process stays weakly positive. The heuristic explanation is that the variance of the shocks converges to zero as R₀ goes to zero, enabling the upwards drift to dominate. +* See `here `__ for a heuristic description of when the process is weakly and strictly positive. + +The notation for this `SDE `__ is then + +.. math:: + \begin{aligned} + d R_{0t} &= \eta (\bar{R}_{0t} - R_{0t}) dt + \sigma \sqrt{R_{0t}} dW_t\\ + \end{aligned} + :label: Rsde + +where :math:`W` is standard Brownian motion (i.e a `Weiner Process `__. + +Heuristically, if :math:`\sigma = 0`, divide this equation by :math:`dt` and it nests the original ODE used in the previous lecture. + +While we do not consider any calibration for the :math:`\sigma` parameter, empirical studies such as `Estimating and Simulating a SIRD Model of COVID-19 for Many Countries, States, and Cities `__ (Figure 6) show highly volatile :math:`R_0(t)` estimates over time. + +Even after lockdowns are first implemented, we see variation between 0.5 and 1.5. Since countries are made of interconnecting cities with such variable contact rates, a high :math:`\sigma` seems reasonable both intuitively and empirically. + +Mortality Rates +---------------- + +Unlike the previous lecture, we will build up towards mortality rates which change over time. + +Imperfect mixing of different demographic groups could lead to aggregate shocks in mortality (e.g. if a retirement home is afflicted vs. an elementary school). These sorts of relatively small changes might be best modeled as a continuous path process. + +Let :math:`\delta(t)` be the mortality rate and in addition, + +* Assume that the base mortality rate is :math:`\bar{\delta}`, which acts as the mean of the process, reverting at rate :math:`\theta`. In more elaborate models, this could be time-varying. +* The diffusion term has a volatility :math:`\xi\sqrt{\delta (1 - \delta)}`. +* As the process gets closer to either :math:`\delta = 1` or :math:`\delta = 0`, the volatility goes to 0, which acts as a force to allow the mean reversion to keep the process within the bounds +* Unlike the well-studied Cox-Ingersoll-Ross model, we make no claims on the long-run behavior of this process, but will be examining the behavior on a small timescale so this is not an issue. + +Given this, the stochastic process for the mortality rate is, + +.. math:: + \begin{aligned} + d \delta_t & = \theta (\bar{\delta} - \delta_t) dt + \xi \sqrt{(\delta_t (1-\delta_t)} d W_t\\ + \end{aligned} + :label: dmt + +Where the :math:`W_t` Brownian motion is independent from the previous process. + +System of SDEs +--------------- +The system :eq:`SIRD` can be written in vector form :math:`x := [s, i, r, d, R₀, \delta]` with parameter tuple parameter tuple :math:`p := (\gamma, \eta, \sigma, \theta, \xi, \bar{R}_0(\cdot), \bar{ \delta})` + +The general form of the SDE is. + +.. math:: + \begin{aligned} + d x_t &= F(x_t,t;p)dt + G(x_t,t;p) dW + \end{aligned} + + +With the drift, + +.. math:: + \begin{aligned} + F(x,t;p)\\ + &:= \begin{bmatrix} + - \gamma \, R_0 \, s \, i + \\ + \gamma \, R_0 \, s \, i - \gamma i + \\ + (1-\delta) \gamma i + \\ + \delta \gamma i + \\ + \eta (\bar{R}_0(t) - R_0) + \\ + \theta (\bar{\delta} - \delta) + \\ + \end{bmatrix} + \end{aligned} + :label: dfcvsde + + +Here, it is convenient but not necessary for :math:`d W` to have the same dimension as :math:`x`. If so, then we can use a square matrix :math:`G(x,t;p)` to associate the shocks with the appropriate :math:`x` (e.g. diagonal noise, or using a covariance matrix). + +As the two independent sources of Brownian motion only affect the :math:`d R_0` and :math:`d \delta` terms (i.e. the 5th and 6th equations), define the covariance matrix as + +.. math:: + \begin{aligned} + diag(G(x, t)) &:= \begin{bmatrix} 0 & 0 & 0 & 0 & \sigma \sqrt{R_0} & \xi \sqrt{\delta (1-\delta)} \end{bmatrix} + \end{aligned} + :label: dG + + +Implementation +---------------- + +First, construct our :math:`F` from :eq:`dfcvsde` and :math:`G` from :eq:`dG` + +.. code-block:: julia + + function F(x, p, t) + s, i, r, d, R₀, δ = x + @unpack γ, R̄₀, η, σ, ξ, θ, δ_bar = p + + return [-γ*R₀*s*i; # ds/dt + γ*R₀*s*i - γ*i; # di/dt + (1-δ)*γ*i; # dr/dt + δ*γ*i; # dd/dt + η*(R̄₀(t, p) - R₀);# dR₀/dt + θ*(δ_bar - δ); # dδ/dt + ] + end + + function G(x, p, t) + s, i, r, d, R₀, δ = x + @unpack γ, R̄₀, η, σ, ξ, θ, δ_bar = p + + return [0; 0; 0; 0; σ*sqrt(R₀); ξ*sqrt(δ * (1-δ))] + end + +Next create a settings generator, and then define a `SDEProblem `__ with Diagonal Noise. + +.. code-block:: julia + + p_gen = @with_kw ( T = 550.0, γ = 1.0 / 18, η = 1.0 / 20, + R₀_n = 1.6, R̄₀ = (t, p) -> p.R₀_n, δ_bar = 0.01, σ = 0.03, ξ = 0.004, θ = 0.2, N = 3.3E8) + p = p_gen() # use all defaults + i_0 = 25000 / p.N + r_0 = 0.0 + d_0 = 0.0 + s_0 = 1.0 - i_0 - r_0 - d_0 + R̄₀_0 = 0.5 # starting in lockdown + δ_0 = p.δ_bar + x_0 = [s_0, i_0, r_0, d_0, R̄₀_0, δ_0] + + prob = SDEProblem(F, G, x_0, (0, p.T), p) + +We solve the problem with the `SOSRI `__ algorithm (Adaptive strong order 1.5 methods for diagonal noise Ito and Stratonovich SDEs). + +.. code-block:: julia + + sol_1 = solve(prob, SOSRI()); + @show length(sol_1.t); + +As in the deterministic case of the previous lecture, we are using an adaptive time-stepping method. However, since this is an SDE, (1) you will tend to see more timesteps required due to the greater curvature; and (2) the number of timesteps will change with different shock realizations. + +With stochastic differential equations, a "solution" is akin to a simulation for a particular realization of the noise process. + +If we take two solutions and plot the number of infections, we will see differences over time: + +.. code-block:: julia + + sol_2 = solve(prob, SOSRI()) + plot(sol_1, vars=[2], title = "Number of Infections", label = "Trajectory 1", lm = 2, xlabel = "t", ylabel = "i(t)") + plot!(sol_2, vars=[2], label = "Trajectory 2", lm = 2, ylabel = "i(t)") + +The same holds for other variables such as the cumulative deaths, mortality, and :math:`R_0`: + +.. code-block:: julia + + plot_1 = plot(sol_1, vars=[4], title = "Cumulative Death Proportion", label = "Trajectory 1", lw = 2, xlabel = "t", ylabel = "d(t)", legend = :topleft) + plot!(plot_1, sol_2, vars=[4], label = "Trajectory 2", lw = 2) + plot_2 = plot(sol_1, vars=[3], title = "Cumulative Recovered Proportion", label = "Trajectory 1", lw = 2, xlabel = "t", ylabel = "d(t)", legend = :topleft) + plot!(plot_2, sol_2, vars=[3], label = "Trajectory 2", lw = 2) + plot_3 = plot(sol_1, vars=[5], title = "R_0 transition from lockdown", label = "Trajectory 1", lw = 2, xlabel = "t", ylabel = "R_0(t)") + plot!(plot_3, sol_2, vars=[5], label = "Trajectory 2", lw = 2) + plot_4 = plot(sol_1, vars=[6], title = "Mortality Rate", label = "Trajectory 1", lw = 2, xlabel = "t", ylabel = "delta(t)", ylim = (0.006, 0.014)) + plot!(plot_4, sol_2, vars=[6], label = "Trajectory 2", lw = 2) + plot(plot_1, plot_2, plot_3, plot_4, size = (900, 600)) + + +See `here `__ for comments on finding the appropriate SDE algorithm given the structure of :math:`F(x, t)` and :math:`G(x, t)` + +* If :math:`G` has diagonal noise (i.e. :math:`G(x, t)` is a diagonal, and possibly a function of the state), then ``SOSRI`` is the typical choice. +* If :math:`G` has additive and diagonal noise (i.e. :math:`G(t)` is a diagonal and independent from the state), then ``SOSRA`` is usually the best algorithm for even mildly stiff :math:`F`. +* If adaptivity is not required, then ``EM`` (i.e. Euler-Maruyama method typically used by economists) is flexible in its ability to handle different noise processes. + +Ensembles +----------- + +While individual simulations are useful, you often want to look at an ensemble of trajectories of the SDE in order to get an accurate picture of how the system evolves. + +To do this, use the ``EnsembleProblem`` in order to have the solution compute multiple trajectories at once. The returned ``EnsembleSolution`` acts like an array of solutions but is imbued to plot recipes to showcase aggregate quantities. For example: + +.. code-block:: julia + + ensembleprob = EnsembleProblem(prob) + sol = solve(ensembleprob, SOSRI(), EnsembleSerial(), trajectories = 10) + plot(sol, vars = [2], title = "Infection Simulations", ylabel = "i(t)", xlabel = "t", lm = 2) + + +Or, more frequently, you may want to run many trajectories and plot quantiles, which can be automatically run in `parallel `_ using multiple threads, processes, or GPUs. Here we showcase ``EnsembleSummary`` which calculates summary information from an ensemble and plots the mean of the solution along with calculated quantiles of the simulation: + +.. code-block:: julia + + trajectories = 100 # choose larger for smoother quantiles + sol = solve(ensembleprob, SOSRI(), EnsembleThreads(), trajectories = trajectories) + summ = EnsembleSummary(sol) # defaults to saving 0.05, 0.95 quantiles + plot(summ, idxs = (2,), title = "Quantiles of Infections Ensemble", ylabel = "i(t)", + xlabel = "t", labels = "Middle 95% Quantile", legend = :topright) + +In addition, you can calculate more quantiles and stack graphs + +.. code-block:: julia + + sol = solve(ensembleprob, SOSRI(), EnsembleThreads(), trajectories = trajectories) + summ = EnsembleSummary(sol) # defaults to saving 0.05, 0.95 quantiles + summ2 = EnsembleSummary(sol, quantiles = (0.25, 0.75)) + + plot(summ, idxs = (2,4,5,6), + title = ["Proportion Infected" "Proportion Dead" "R_0" "delta"], + ylabel = ["i(t)" "d(t)" "R_0(t)" "delta(t)"], xlabel = "t", + legend = [:topleft :topleft :bottomright :bottomright], + labels = "Middle 95% Quantile", layout = (2, 2), size = (900, 600)) + plot!(summ2, idxs = (2,4,5,6), + labels = "Middle 50% Quantile", legend = [:topleft :topleft :bottomright :bottomright]) + +Some additional features of the ensemble and SDE infrastructure are + +* `Plotting `__ +* `Noise Processes `__, `Non-diagonal noise `__, and `Correlated Noise `__ +* `Parallel Ensemble features `__ +* Transforming the ensemble calculations with an `output_func or reduction `__ +* Auto-GPU accelerated by using ``EnsembleGPUArray()`` from `DiffEqGPU ` + +Changing Mitigation +-------------------- + +Consider a policy maker who wants to consider the impact of relaxing lockdown at various speeds. + +We will shut down the shocks to the mortality rate (i.e. :math:`\xi = 0`) to focus on the variation caused by the volatility in :math:`R_0(t)`. + +Consider :math:`\eta = 1/50` and :math:`\eta = 1/20`, where we start at the same initial condition of :math:`R_0(0) = 0.5`. + +.. code-block:: julia + + function generate_η_experiment(η; p_gen = p_gen, trajectories = 100, saveat = 1.0, x_0 = x_0, T = 120.0) + p = p_gen(η = η, ξ = 0.0) + ensembleprob = EnsembleProblem(SDEProblem(F, G, x_0, (0, T), p)) + sol = solve(ensembleprob, SOSRI(), EnsembleThreads(), + trajectories = trajectories, saveat = saveat) + return EnsembleSummary(sol) + end + + # Evaluate two different lockdown scenarios + η_1 = 1/50 + η_2 = 1/20 + summ_1 = generate_η_experiment(η_1) + summ_2 = generate_η_experiment(η_2) + plot(summ_1, idxs = (4,5), + title = ["Proportion Dead" "R_0"], + ylabel = ["d(t)" "R_0(t)"], xlabel = "t", + legend = [:topleft :bottomright], + labels = "Middle 95% Quantile, eta = $η_1", + layout = (2, 1), size = (900, 900), fillalpha = 0.5) + plot!(summ_2, idxs = (4,5), + legend = [:topleft :bottomright], + labels = "Middle 95% Quantile, eta = $η_2", size = (900, 900), fillalpha = 0.5) + +While the the mean of the :math:`d(t)` increases, unsurprisingly, we see that the 95% quantile for later time periods is also much larger - even after the :math:`R_0` has converged. + +That is, volatile contact rates (and hence :math:`R_0`) can interact to make catastrophic worst-case scenarios due to the nonlinear dynamics of the system. + +Ending Lockdown +=============== + +As in the deterministic lecture, we can consider two mitigation scenarios + +1. choose :math:`\bar{R}_0(t)` to target :math:`R_0 = 0.5` for 30 days and then :math:`R_0 = 2` for the remaining 17 months. This corresponds to lifting lockdown in 30 days. + +2. target :math:`R_0 = 0.5` for 120 days and then :math:`R_0 = 2` for the remaining 14 months. This corresponds to lifting lockdown in 4 months. + +Since empirical estimates of :math:`R_0(t)` discussed in :cite:`NBERw27128` and other papers show it to have wide variation, we will maintain a fairly larger :math:`\sigma`. + +We start the model with 100,000 active infections. + +.. code-block:: julia + + R₀_L = 0.5 # lockdown + η_experiment = 1.0/10 + σ_experiment = 0.04 + R̄₀_lift_early(t, p) = t < 30.0 ? R₀_L : 2.0 + R̄₀_lift_late(t, p) = t < 120.0 ? R₀_L : 2.0 + + p_early = p_gen(R̄₀ = R̄₀_lift_early, η = η_experiment, σ = σ_experiment) + p_late = p_gen(R̄₀ = R̄₀_lift_late, η = η_experiment, σ = σ_experiment) + + + # initial conditions + i_0 = 100000 / p_early.N + r_0 = 0.0 + d_0 = 0.0 + s_0 = 1.0 - i_0 - r_0 - d_0 + δ_0 = p_early.δ_bar + + x_0 = [s_0, i_0, r_0, d_0, R₀_L, δ_0] # start in lockdown + prob_early = SDEProblem(F, G, x_0, (0, p_early.T), p_early) + prob_late = SDEProblem(F, G, x_0, (0, p_late.T), p_late) + + +Simulating for a single realization of the shocks, we see the results are qualitatively similar to what we had before + +.. code-block:: julia + + sol_early = solve(prob_early, SOSRI()) + sol_late = solve(prob_late, SOSRI()) + plot(sol_early, vars = [5, 1,2,4], + title = ["R_0" "Susceptible" "Infected" "Dead"], + layout = (2, 2), size = (900, 600), + ylabel = ["R_0(t)" "s(t)" "i(t)" "d(t)"], xlabel = "t", + legend = [:bottomright :topright :topright :topleft], + label = ["Early" "Early" "Early" "Early"]) + plot!(sol_late, vars = [5, 1,2,4], + legend = [:bottomright :topright :topright :topleft], + label = ["Late" "Late" "Late" "Late"]) + + +However, note that this masks highly volatile values induced by the in :math:`R_0` variation, as seen in the ensemble + +.. code-block:: julia + + trajectories = 400 + saveat = 1.0 + ensemble_sol_early = solve(EnsembleProblem(prob_early), SOSRI(), + EnsembleThreads(), trajectories = trajectories, saveat = saveat) + ensemble_sol_late = solve(EnsembleProblem(prob_late), SOSRI(), + EnsembleThreads(), trajectories = trajectories, saveat = saveat) + summ_early = EnsembleSummary(ensemble_sol_early) + summ_late = EnsembleSummary(ensemble_sol_late) + + plot(summ_early, idxs = (5, 1, 2, 4), + title = ["R_0" "Susceptible" "Infected" "Dead"], layout = (2, 2), size = (900, 600), + ylabel = ["R_0(t)" "s(t)" "i(t)" "d(t)"], xlabel = "t", + legend = [:bottomright :topright :topright :topleft], + label = ["Early" "Early" "Early" "Early"]) + plot!(summ_late, idxs = (5, 1,2,4), + legend = [:bottomright :topright :topright :topleft], + label = ["Late" "Late" "Late" "Late"]) + +Finally, rather than looking at the ensemble summary, we can extra the data directly from the ensemble to do our own analysis. + +For example, we can extract the ensemble solutions at an intermediate and final time step. + +.. code-block:: julia + + N = p_early.N + t_1 = 350 + t_2 = p_early.T # i.e. the last element + bins_1 = range(0.000, 0.009, length = 30) + + hist_1 = histogram([ensemble_sol_early.u[i](t_1)[4] for i in 1:trajectories], + fillalpha = 0.5, normalize = :probability, legend = :topleft, bins = bins_1, + label = "Early", title = "Death Proportion at t = $t_1") + histogram!(hist_1, [ensemble_sol_late.u[i](t_1)[4] for i in 1:trajectories], + label = "Late", fillalpha = 0.5, normalize = :probability, bins = bins_1) + hist_2 = histogram([ensemble_sol_early.u[i][4, end] for i in 1:trajectories], + fillalpha = 0.5, normalize = :probability, bins = 30, + label = "Early", title = "Death Proportion at t = $t_2") + histogram!(hist_2, [ensemble_sol_late.u[i][4, end] for i in 1:trajectories], + label = "Late", fillalpha = 0.5, normalize = :probability, bins = 30) + plot(hist_1, hist_2, size = (600,600), layout = (2, 1)) + + +This shows that there are significant differences after a year, but by 550 days the graphs largely coincide. + +In the above code given the return from ``solve`` on an ``EnsembleProblem`` , e.g. ``ensemble_sol = solve(...)`` + +* You can access the i'th simulation as ``ensemble_sol[i]``, which then has all of the standard `solution handling `__ features +* You can evaluate at a real time period, ``t``, with ``ensemble_sol[i](t)``. Or access the 4th element with ``ensemble_sol[i](t)[4]`` +* If the ``t`` was not exactly one of the ``saveat`` values (if specified) or the adaptive timesteps (if it was not), then it will use interpolation +* Alternatively, to access the results of the ODE as a grid exactly at the timesteps, where ``j`` is timestep index, use ``ensemble_sol[i][j]`` or the 4th element with ``ensemble_sol[i][4, j]`` +* Warning: unless you have chosen a ``saveat`` grid, the timesteps will not be aligned between simulations. That is, ``ensemble_sol[i_1].t`` wouldn't match ``ensemble_sol[i_2].t``. In that case, use interpolation with ``ensemble_sol[i_1](t)`` etc. + +Reinfection +=============== + +As a final experiment, consider a model where the immunity is only temporary, and individuals become susceptible again. + +In particular, assume that at rate :math:`\nu` immunity is lost. For illustration, we will examine the case if the average immunity lasts 12 months (i.e. :math:`1/\nu = 360`) + +The transition modifies the differential equation :eq:`SIRD` to become + +.. math:: + \begin{aligned} + d s & = \left(- \gamma \, R_0 \, s \, i + \nu \, r \right) dt + \\ + d i & = \left(\gamma \, R_0 \, s \, i - \gamma i \right) dt + \\ + d r & = \left((1-\delta) \gamma i - \nu \, r\right) dt + \\ + d d & = \delta \gamma i \, dt + \\ + \end{aligned} + :label: SIRDRE + +This change modifies the underlying ``F`` function and adds a parameter, but otherwise the model remains the same. + +We will redo the "Ending Lockdown" simulation from above, where the only difference is the new transition. + +.. code-block:: julia + + function F_reinfect(x, p, t) + s, i, r, d, R₀, δ = x + @unpack γ, R̄₀, η, σ, ξ, θ, δ_bar, ν = p + + return [-γ*R₀*s*i + ν*r; # ds/dt + γ*R₀*s*i - γ*i; # di/dt + (1-δ)*γ*i - ν*r # dr/dt + δ*γ*i; # dd/dt + η*(R̄₀(t, p) - R₀);# dR₀/dt + θ*(δ_bar - δ); # dδ/dt + ] + end + + p_re_gen = @with_kw ( T = 550.0, γ = 1.0 / 18, η = 1.0 / 20, + R₀_n = 1.6, R̄₀ = (t, p) -> p.R₀_n, + δ_bar = 0.01, σ = 0.03, ξ = 0.004, θ = 0.2, N = 3.3E8, ν = 1/120) + + p_re_early = p_re_gen(R̄₀ = R̄₀_lift_early, η = η_experiment, σ = σ_experiment) + p_re_late = p_re_gen(R̄₀ = R̄₀_lift_late, η = η_experiment, σ = σ_experiment) + + trajectories = 400 + saveat = 1.0 + prob_re_early = SDEProblem(F_reinfect, G, x_0, (0, p_re_early.T), p_re_early) + prob_re_late = SDEProblem(F_reinfect, G, x_0, (0, p_re_late.T), p_re_late) + ensemble_sol_re_early = solve(EnsembleProblem(prob_re_early), SOSRI(), EnsembleThreads(), + trajectories = trajectories, saveat = saveat) + ensemble_sol_re_late = solve(EnsembleProblem(prob_re_late), SOSRI(), EnsembleThreads(), + trajectories = trajectories, saveat = saveat) + summ_re_early = EnsembleSummary(ensemble_sol_re_early) + summ_re_late = EnsembleSummary(ensemble_sol_re_late) + +The ensemble simulations for the :math:`\nu = 0` and :math:`\nu > 0` can be compared to see the impact in the absence of medical innovations. + +.. code-block:: julia + + plot(summ_late, idxs = (1, 2, 3, 4), + title = ["Susceptible" "Infected" "Recovered" "Dead"], + layout = (2, 2), size = (900, 600), + ylabel = ["s(t)" "i(t)" "r(t)" "d(t)"], xlabel = "t", + legend = :topleft, + label = ["s(t)" "i(t)" "r(t)" "d(t)"]) + plot!(summ_re_late, idxs = (1, 2, 3, 4), + legend = :topleft, + label = ["s(t); nu > 0" "i(t); nu > 0" "r(t); nu > 0" "d(t); nu > 0"]) + +Finally, we can examine the same early vs. late lockdown histogram + +.. code-block:: julia + + bins_re_1 = range(0.003, 0.012, length = 50) + bins_re_2 = range(0.012, 0.019, length = 50) + hist_re_1 = histogram([ensemble_sol_re_early.u[i](t_1)[4] for i in 1:trajectories], + fillalpha = 0.5, normalize = :probability, legend = :topleft, bins = bins_re_1, + label = "Early", title = "Death Proportion at t = $t_1") + histogram!(hist_re_1, [ensemble_sol_re_late.u[i](t_1)[4] for i in 1:trajectories], + label = "Late", fillalpha = 0.5, normalize = :probability, bins = bins_re_1) + hist_re_2 = histogram([ensemble_sol_re_early.u[i][4, end] for i in 1:trajectories], + fillalpha = 0.5, normalize = :probability, bins = bins_re_2, + label = "Early", title = "Death Proportion at t = $t_2") + histogram!(hist_re_2, [ensemble_sol_re_late.u[i][4, end] for i in 1:trajectories], + label = "Late", fillalpha = 0.5, normalize = :probability, bins = bins = bins_re_2) + plot(hist_re_1, hist_re_2, size = (600,600), layout = (2, 1)) + +In this case, there are significant differences between the early and late deaths and high variance. + +This bleak simulation has assumed that no individuals has long-term immunity and that there will be no medical advancements on that time horizon - both of which are unlikely to be true. + +Nevertheless, it suggest that the timing of lifting lockdown has a more profound impact after 18 months if we allow stochastic shocks imperfect immunity. + + +.. NOTE: I COMMENTED THIS ALL OUT BECAUSE IT WAS SLOWER. WE CAN TUNE LATER. + +.. Static Arrays and GPUs +.. ------------------------- + + +.. Performance of these tends to be high, for example, rerunning out 1000 trajectories is measured in seconds on most computers with multi-threading enabled. + + +.. In addition, we can write versions with static arrays given the small dimension of the system. + +.. .. code-block:: julia + +.. function F_static(x, p, t) +.. s, i, r, d, R₀, δ = x +.. @unpack γ, R̄₀, η, σ, ξ, θ, δ_bar = p + +.. return SA[-γ*R₀*s*i; # ds/dt +.. γ*R₀*s*i - γ*i; # di/dt +.. (1-δ)*γ*i; # dr/dt +.. δ*γ*i; # dd/dt +.. η*(R̄₀(t, p) - R₀);# dR₀/dt +.. θ*(δ_bar - δ); # dδ/dt +.. ] +.. end + +.. function G_static(x, p, t) +.. s, i, r, d, R₀, δ = x +.. @unpack γ, R̄₀, η, σ, ξ, θ, δ_bar = p + +.. return SA[0; 0; 0; 0; σ*sqrt(R₀); ξ*sqrt(δ * (1-δ))] +.. end + +.. x_0_static = SVector{6}(x_0) +.. prob_static = SDEProblem(F_static, G_static, x_0_static, (0, p.T), p) +.. ensembleprob = EnsembleProblem(prob_static) +.. sol = solve(ensembleprob, SOSRI(), EnsembleThreads(),trajectories = 1000) +.. @time solve(ensembleprob, SOSRI(), EnsembleThreads(),trajectories = 1000) + +.. Note that these routines can also be auto-GPU accelerated by using +.. ``EnsembleGPUArray()`` from `DiffEqGPU ` + +.. +.. Daily Deaths +.. -------------- +.. +.. Outside of the system of equations, a key calculation will be the :math:`d/dt D(t)`, i.e. the daily deaths, where our timescale is already in days. +.. +.. +.. Define :math:`\Delta D \approx d/dt D(t)` where we assume that the parameters are roughly fixed over a 1-day time-horizon. In that case, we define :math:`\Delta D := N \delta \gamma i`. +.. \ No newline at end of file diff --git a/source/rst/continuous_time/index.rst b/source/rst/continuous_time/index.rst new file mode 100644 index 00000000..97fb1e9c --- /dev/null +++ b/source/rst/continuous_time/index.rst @@ -0,0 +1,22 @@ +.. _continuous_time: + +.. include:: /_static/includes/header.raw + +*************************************** +Modeling in Continuous Time +*************************************** + +This section of the course contains foundational mathematical and computational tools for working with continuous time deterministic and stochastic models. + +.. only:: html + + Lectures + ******** + + + +.. toctree:: + :maxdepth: 2 + + seir_model + covid_sde diff --git a/source/rst/continuous_time/seir_model.rst b/source/rst/continuous_time/seir_model.rst new file mode 100644 index 00000000..7887ae5f --- /dev/null +++ b/source/rst/continuous_time/seir_model.rst @@ -0,0 +1,545 @@ +.. _seir_model: + +.. include:: /_static/includes/header.raw + +.. highlight:: julia + +******************************************************************* +:index:`Modeling COVID 19 with Differential Equations` +******************************************************************* + +.. contents:: :depth: 2 + +Overview +============= + +Coauthored with Chris Rackauckas + + +This is a Julia version of code for analyzing the COVID-19 pandemic. + +The purpose of these notes is to introduce economists to quantitative modeling of infectious disease dynamics, and to modeling with ordinary differential +equations. + +In this lecture, dynamics are modeled using a standard SEIR (Susceptible-Exposed-Infected-Removed) model +of disease spread, represented as a system of ordinary differential +equations where the number of agents is large and there are no exogenous stochastic shocks. + +The first part of the model is inspired by +* Notes from `Andrew Atkeson `__ and `NBER Working Paper No. 26867 `__ +* `Estimating and Forecasting Disease Scenarios for COVID-19 with an SIR Model `__ by Andrew Atkeson, Karen Kopecky and Tao Zha +* `Estimating and Simulating a SIRD Model of COVID-19 for Many Countries, States, and Cities `__ by Jesús Fernández-Villaverde and Charles I. Jones +* Further variations on the classic SIR model in Julia `here `__. + +We then extend this deterministic model in :doc:`this lecture ` which build on this model, adding in aggregate shocks and policy tradeoffs. + +The interest is primarily in + +* studying the impact of suppression through social distancing on the spread of the infection +* the number of infections at a given time (which determines whether or not the health care system is overwhelmed); and +* how long the caseload can be deferred (hopefully until a vaccine arrives) + +Setup +------------------ + +.. literalinclude:: /_static/includes/deps_generic.jl + :class: hide-output + +.. code-block:: julia + + using LinearAlgebra, Statistics, Random, SparseArrays + +.. code-block:: julia + :class: Test + + using Test # Put this before any code in the lecture. + +In addition, we will be exploring the `Ordinary Differential Equations `__ package within the `SciML ecosystem `__. + +.. code-block:: julia + + using OrdinaryDiffEq + using Parameters, Plots + + +The SEIR Model +============== + +In the version of the SEIR model, all individuals in the population are assumed to be in a finite number of states. + +The states are: susceptible (S), exposed (E), infected (I) and removed (R). + +This type of `compartmentalized model `__ has many extensions (e.g. SEIRS relaxes lifetime immunity and allow transitions from :math:`R \to S`). + +Comments: + +* Those in state R have been infected and either recovered or died. In other versions of these models, R may refer only to recovered agents. + +* Those who have recovered, and live, are assumed to have acquired immunity. + +* Those in the exposed group are not yet infectious. + + + +Changes in the Infected State +------------------------------- + +Within the SEIR model, the flow across states follows the path :math:`S \to E \to I \to R`. + +We will ignore birth and non-covid death during our time horizon, and assume a large, constant, number of individuals of size :math:`N` throughout. + +With this, the symbols :math:`S, E, I, R` are used for the total number of individuals in each state at each point in time, and :math:`S(t) + E(t) + I(t) + R(t) = N` for all :math:`t`. + +Since we have assumed that :math:`N` is large, we can use a continuum approximation for the number of individuals in each state. + +The transitions between those states are governed by the following rates + +* :math:`\beta(t)` is called the *transmission rate* or *effective contact rate* (the rate at which individuals bump into others and expose them to the virus). +* :math:`\sigma` is called the *infection rate* (the rate at which those who are exposed become infected) +* :math:`\gamma` is called the *recovery rate* (the rate at which infected people recover or die) + +The rate :math:`\beta(t)` is influenced by both the characteristics of the disease (e.g. the type and length of prolonged contact required for a transmission) and behavior of the individuals (e.g. social distancing, hygiene). + +The SEIR model can then be written as + +.. math:: + \begin{aligned} + \frac{d S}{d t} & = - \beta \, S \, \frac{I}{N} + \\ + \frac{d E}{d t} & = \beta \, S \, \frac{I}{N} - \sigma E + \\ + \frac{d I}{d t} & = \sigma E - \gamma I + \\ + \frac{d R}{d t} & = \gamma I + \end{aligned} + :label: seir_system_big + +Here, :math:`dy/dt` represents the time derivative for the particular variable. + +The first term of :eq:`seir_system_big`, :math:`-\beta \, S \, \frac{I}{N}`, is the flow of individuals moving from :math:`S \to E`, and highlights the underlying dynamics of the epidemic + +* Individuals in the susceptible state (S) have a rate :math:`\beta(t)` of prolonged contacts with other individuals where transmission would occur if either was infected +* Of these contacts, a fraction :math:`\frac{I(t)}{N}` will be with infected agents (since we assumed that exposed individuals are not yet infectious) +* Finally, there are :math:`S(t)` susceptible individuals. +* The product of those terms is the outflow from the :math:`S` state. + + +Basic Reproduction Number +------------------------- + +If :math:`\beta` was constant, then we could define :math:`R_0 := \beta / \gamma`. This is the famous *basic reproduction number* for the SEIR model. See :cite:`heffernan2005perspectives` for more details. + +When the transmission rate is time-varying, we will follow notation in :cite:`NBERw27128` and refer to :math:`R_0(t)` as a time-varying version of the basic reproduction number. + +Analyzing the system in :eq:`seir_system_big` provides some intuition on the :math:`R_0(t) := \beta(t) / \gamma` expression: + +* Individual transitions from the infected to removed state occur at a Poisson rate :math:`\gamma`, the expected time in the infected state is :math:`1/\gamma` +* Prolonged interactions occur at rate :math:`\beta`, so a new individual entering the infected state will potentially transmit the virus to an average of :math:`R_0 = \beta \times 1 / \gamma` others +* In more complicated models, see :cite:`heffernan2005perspectives` for a formal definition for arbitrary models, and an analysis on how :math:`R_0 < 1` + +Note that the notation :math:`R_0` is standard in the epidemiology literature - though confusing, since :math:`R_0` is unrelated to :math:`R`, the symbol that represents the removed state. For the remainder of the lecture, we will avoid using :math:`R` for removed state. + +Prior to solving the model directly, we make a few changes to :eq:`seir_system_big` + +* Re-parameterize using :math:`\beta(t) = \gamma R_0(t)` +* Define the proportion of individuals in each state as :math:`s := S/N` etc. +* Divide each equation in :eq:`seir_system_big` by :math:`N`, and write the system of ODEs in terms of the proportions + +.. math:: + \begin{aligned} + \frac{d s}{d t} & = - \gamma \, R_0 \, s \, i + \\ + \frac{d e}{d t} & = \gamma \, R_0 \, s \, i - \sigma e + \\ + \frac{d i}{d t} & = \sigma e - \gamma i + \\ + \frac{d r}{d t} & = \gamma i + \end{aligned} + :label: seir_system + +Since the states form a partition, we could reconstruct the "removed" fraction of the population as :math:`r = 1 - s - e - i`. However, keeping it in the system will make plotting more convenient. + + +Implementation +-------------- + +We begin by implementing a simple version of this model with a constant :math:`R_0` and some baseline parameter values (which we discuss later). + +First, define the system of equations + +.. code-block:: julia + + function F_simple(x, p, t; γ = 1/18, R₀ = 3.0, σ = 1/5.2) + s, e, i, r = x + + return [-γ*R₀*s*i; # ds/dt = -γR₀si + γ*R₀*s*i - σ*e;# de/dt = γR₀si -σe + σ*e - γ*i; # di/dt = σe -γi + γ*i; # dr/dt = γi + ] + end + +Given this system, we choose an initial condition and a timespan, and create a ``ODEProblem`` encapsulating the system. + +.. code-block:: julia + + i_0 = 1E-7 # 33 = 1E-7 * 330 million currently infected + e_0 = 4.0 * i_0 # 132 = 1E-7 *330 million exposed + s_0 = 1.0 - i_0 - e_0 + r_0 = 0.0 + x_0 = [s_0, e_0, i_0, r_0] # initial condition + + tspan = (0.0, 350.0) # ≈ 350 days + prob = ODEProblem(F_simple, x_0, tspan) + +With this, choose an ODE algorithm and solve the initial value problem. A good default algorithm for non-stiff ODEs of this sort might be ``Tsit5()``, which is the Tsitouras 5/4 Runge-Kutta method). + +.. code-block:: julia + + sol = solve(prob, Tsit5()) + plot(sol, labels = ["s" "e" "i" "r"], title = "SEIR Dynamics", lw = 2) + + +We did not provide either a set of time steps or a ``dt`` time step size to the ``solve``. Most accurate and high-performance ODE solvers appropriate for this problem use adaptive time-stepping, changing the step size based the degree of curvature in the derivatives. + + +Or, as an alternative visualization, the proportions in each state over time + +.. code-block:: julia + + areaplot(sol.t, sol', labels = ["s" "e" "i" "r"], title = "SEIR Proportions") + + +While maintaining the core system of ODEs in :math:`(s, e, i, r)`, we will extend the basic model to enable some policy experiments and calculations of aggregate values. + +Extending the Model +----------------------- + +First, we can consider some additional calculations such as the cumulative caseload (i.e., all those who have or have had the infection) as :math:`c = i + r`. Differentiating that expression and substituting from the time-derivatives of :math:`i(t)` and :math:`r(t)` yields :math:`\frac{d c}{d t} = \sigma e` + +We will assume that the transmission rate follows a process with a reversion to a value :math:`\bar{R}_0(t)` which could conceivably be influenced by policy. The intuition is that even if the targeted :math:`\bar{R}_0(t)` was changed through social distancing/etc., lags in behavior and implementation would smooth out the transition, where :math:`\eta` governs the speed of :math:`R_0(t)` moves towards :math:`\bar{R}_0(t)`. + +.. math:: + \begin{aligned} + \frac{d R_0}{d t} &= \eta (\bar{R}_0 - R_0)\\ + \end{aligned} + :label: Rode + + +Finally, let :math:`\delta` be the mortality rate, which we will leave constant. The cumulative deaths can be integrated through the flow :math:`\gamma i` entering the "Removed" state. + +Define the cumulative number of deaths as :math:`D(t)` with the proportion :math:`d(t) := D(t)/N`. + +.. math:: + \begin{aligned}\\ + \frac{d}{d t}d(t) &= \delta \gamma i + \end{aligned} + :label: Mode + +While we could integrate the deaths given the solution to the model ex-post, it is more convenient to use the integrator built into the ODE solver. That is, we add :math:`\frac{d}{dt} d(t)` rather than calculating :math:`d(t) = \int_0^t \delta \gamma\, i(\tau) d \tau` ex-post. + +This is a common trick when solving systems of ODEs. While equivalent in principle to using the appropriate quadrature scheme, this becomes especially convenient when adaptive time-stepping algorithms are used to solve the ODEs (i.e. there is no fixed time grid). Note that when doing so, :math:`d(0) = \int_0^0 \delta \gamma i(\tau) d \tau = 0` is the initial condition. + +The system :eq:`seir_system` and the supplemental equations can be written in vector form :math:`x := [s, e, i, r, R₀, c, d]` with parameter tuple :math:`p := (\sigma, \gamma, \eta, \delta, \bar{R}_0(\cdot))` + +Note that in those parameters, the targeted reproduction number, :math:`\bar{R}_0(t)`, is an exogenous function. + + .. math:: + \begin{aligned} + \frac{d x}{d t} &= F(x,t;p)\\ + &:= \begin{bmatrix} + - \gamma \, R_0 \, s \, i + \\ + \gamma \, R_0 \, s \, i - \sigma e + \\ + \sigma \, e - \gamma i + \\ + \gamma i + \\ + \eta (\bar{R}_0(t) - R_0) + \\ + \sigma e + \\ + \delta \, \gamma \, i + \end{bmatrix} + \end{aligned} + :label: dfcv + +Note that if :math:`\bar{R}_0(t)` is time-invariant, then :math:`F(x, t)` is time-invariant as well. + +Parameters +---------- + +The parameters, :math:`\sigma, \delta,` and :math:`\gamma` should be thought of as parameters determined from biology and medical technology, and independent of social interactions. + +As in Atkeson's note, we set + +* :math:`\sigma = 1/5.2` to reflect an average incubation period of 5.2 days. +* :math:`\gamma = 1/18` to match an average illness duration of 18 days. +* :math:`\bar{R}_0(t) = R_0(0) = 1.6` to match a **basic reproduction number** of 1.6, and initially time-invariant +* :math:`\delta = 0.01` for a one-percent mortality rate + + +As we will initially consider the case where :math:`R_0(0) = \bar{R}_0(0)`, the parameter :math:`\eta` will not influence the first experiment. + +Implementation +============== + + +First, construct our :math:`F` from :eq:`dfcv` + +.. code-block:: julia + + function F(x, p, t) + s, e, i, r, R₀, c, d = x + @unpack σ, γ, R̄₀, η, δ = p + + return [-γ*R₀*s*i; # ds/dt + γ*R₀*s*i - σ*e; # de/dt + σ*e - γ*i; # di/dt + γ*i; # dr/dt + η*(R̄₀(t, p) - R₀);# dR₀/dt + σ*e; # dc/dt + δ*γ*i; # dd/dt + ] + end; + + +This function takes the vector ``x`` of states in the system and extracts the fixed parameters passed into the ``p`` object. + +The only confusing part of the notation is the ``R̄₀(t, p)`` which evaluates the ``p.R̄₀`` at this time (and also allows it to depend on the ``p`` parameter). + + +Parameters +------------- + +The baseline parameters are put into a named tuple generator (see previous lectures using `Parameters.jl `__) with default values discussed above. + +.. code-block:: julia + + p_gen = @with_kw ( T = 550.0, γ = 1.0 / 18, σ = 1 / 5.2, η = 1.0 / 20, + R₀_n = 1.6, δ = 0.01, N = 3.3E8, + R̄₀ = (t, p) -> p.R₀_n) + +Note that the default :math:`\bar{R}_0(t)` function always equals :math:`R_{0n}` -- a parameterizable natural level of :math:`R_0` used only by the ``R̄₀`` function + + +Setting initial conditions, we will assume a fixed :math:`i, e`, :math:`r=0`, :math:`R_0(0) = R_{0n}`, and :math:`m(0) = 0.01` + +.. code-block:: julia + + p = p_gen() # use all default parameters + + i_0 = 1E-7 + e_0 = 4.0 * i_0 + s_0 = 1.0 - i_0 - e_0 + + x_0 = [s_0, e_0, i_0, 0.0, p.R₀_n, 0.0, 0.0] + tspan = (0.0, p.T) + prob = ODEProblem(F, x_0, tspan, p) + + +The ``tspan`` of ``(0.0, p.T)`` determines the :math:`t` used by the solver. The time scale needs to be consistent with the arrival +rate of the transition probabilities (i.e. the :math:`\gamma, \sigma` were chosen based on daily data, so the unit of :math:`t` is a day). + +The time period we investigate will be 550 days, or around 18 months: + +Experiments +=========== + +Let's run some experiments using this code. + +.. code-block:: julia + + sol = solve(prob, Tsit5()) + @show length(sol.t); + +We see that the adaptive time-stepping used approximately 45 time-steps to solve this problem to the desired accuracy. Evaluating the solver at points outside of those time-steps uses an interpolator consistent with the solution to the ODE. + +While it may seem that 45 time intervals is extremely small for that range, for much of the :math:`t`, the functions are very flat - and hence adaptive time-stepping algorithms can move quickly and interpolate accurately. + + +The solution object has `built in `__ plotting support. + +.. code-block:: julia + + plot(sol, vars = [6, 7], label = ["c(t)" "d(t)"], lw = 2, + title = ["Cumulative Infected" "Death Proportion"], + layout = (1,2), size = (900, 300)) + + +A few more comments: + +* If you want to ensure that there are specific points that the adaptive-time stepping must include (e.g. at known discontinuities) use `tstops `__. +* The built-in plots for the solutions provide all of the `attributes `__ in `Plots.jl `__. +* See `here `__ for details on analyzing the solution and extracting the output. + +Experiment 1: Constant Reproduction Case +---------------------------------------- + +Let's start with the case where :math:`\bar{R}_0(t) = R_{0n}` is constant. + +We calculate the time path of infected people under different assumptions of :math:`R_{0n}`: + +.. code-block:: julia + + R₀_n_vals = range(1.6, 3.0, length = 6) + sols = [solve(ODEProblem(F, x_0, tspan, p_gen(R₀_n = R₀_n)), Tsit5(), saveat=0.5) for R₀_n in R₀_n_vals]; + +Here we chose ``saveat=0.5`` to get solutions that were evenly spaced every ``0.5``. + +Changing the saved points is just a question of storage/interpolation, and does not change the adaptive time-stepping of the solvers. + +Let's plot current cases as a fraction of the population. + +.. code-block:: julia + + labels = permutedims(["R_0 = $r" for r in R₀_n_vals]) + infecteds = [sol[3,:] for sol in sols] + plot(infecteds, label=labels, legend=:topleft, lw = 2, xlabel = "t", ylabel = "i(t)", title = "Current Cases") + + +As expected, lower effective transmission rates defer the peak of infections. + +They also lead to a lower peak in current cases. + +Here is cumulative cases, as a fraction of population: + +.. code-block:: julia + + cumulative_infected = [sol[6,:] for sol in sols] + plot(cumulative_infected, label=labels ,legend=:topleft, lw = 2, xlabel = "t", + ylabel = "c(t)", title = "Cumulative Cases") + + +Experiment 2: Changing Mitigation +--------------------------------- + +Let's look at a scenario where mitigation (e.g., social distancing) is +successively imposed, but the target (:math:`R_{0n}`) is fixed. + +To do this, we start with :math:`R_0(0) \neq R_{0n}` and examine the dynamics using the :math:`\frac{d R_0}{d t} = \eta (R_{0n} - R_0)` ODE. + +.. Mathematica Verification +.. (\[Beta][t] /. +.. First@DSolve[{\[Beta]'[t] == \[Eta] (b - \[Beta][t]), \[Beta][ +.. 0] == \[Beta]0}, \[Beta][t], +.. t] ) == \[Beta]0 E^(-t \[Eta]) + (1 - +.. E^(-t \[Eta])) b // FullSimplify + + +In the simple case, where :math:`\bar{R}_0(t) = R_{0n}` is independent of the state, the solution to the ODE given an initial condition is :math:`R_0(t) = R_0(0) e^{-\eta t} + R_{0n}(1 - e^{-\eta t})` + +We will examine the case where :math:`R_0(0) = 3` and then it falls to :math:`R_{0n} = 1.6` due to the progressive adoption of stricter mitigation measures. + +The parameter ``η`` controls the rate, or the speed at which restrictions are +imposed. + +We consider several different rates: + +.. code-block:: julia + + η_vals = [1/5, 1/10, 1/20, 1/50, 1/100] + labels = permutedims(["eta = $η" for η in η_vals]) + +Let's calculate the time path of infected people, current cases, and mortality + +.. code-block:: julia + + x_0 = [s_0, e_0, i_0, 0.0, 3.0, 0.0, 0.0] + sols = [solve(ODEProblem(F, x_0, tspan, p_gen(η=η)), Tsit5(), saveat=0.5) for η in η_vals]; + +Next, plot the :math:`R_0` over time: + +.. code-block:: julia + + Rs = [sol[5,:] for sol in sols] + plot(Rs, label=labels, legend=:topright, lw = 2, xlabel = "t", + ylabel = "R_0(t)", title = "Basic Reproduction Number") + +Now let's plot the number of infected persons and the cumulative number +of infected persons: + +.. code-block:: julia + + infecteds = [sol[3,:] for sol in sols] + plot(infecteds, label=labels, legend=:topleft, lw = 2, xlabel = "t", + ylabel = "i(t)", title = "Current Infected") + + +.. code-block:: julia + + cumulative_infected = [sol[6,:] for sol in sols] + plot(cumulative_infected, label=labels ,legend=:topleft, lw = 2, xlabel = "t", + ylabel = "c(t)", title = "Cumulative Infected") + + +Ending Lockdown +=============== + + +The following is inspired by `additional results `__ by Andrew Atkeson on the timing of lifting lockdown. + +Consider these two mitigation scenarios: + +1. choose :math:`\bar{R}_0(t)` to target :math:`R_0(t) = 0.5` for 30 days and then :math:`R_0(t) = 2` for the remaining 17 months. This corresponds to lifting lockdown in 30 days. + +2. :math:`R_0(t) = 0.5` for 120 days and then :math:`R_0(t) = 2` for the remaining 14 months. This corresponds to lifting lockdown in 4 months. + +For both of these, we will choose a large :math:`\eta` to focus on the case where rapid changes in the lockdown policy remain feasible. + +The parameters considered here start the model with 25,000 active infections +and 75,000 agents already exposed to the virus and thus soon to be contagious. + +.. code-block:: julia + + R₀_L = 0.5 # lockdown + R̄₀_lift_early(t, p) = t < 30.0 ? R₀_L : 2.0 + R̄₀_lift_late(t, p) = t < 120.0 ? R₀_L : 2.0 + p_early = p_gen(R̄₀= R̄₀_lift_early, η = 10.0) + p_late = p_gen(R̄₀= R̄₀_lift_late, η = 10.0) + + + # initial conditions + i_0 = 25000 / p_early.N + e_0 = 75000 / p_early.N + s_0 = 1.0 - i_0 - e_0 + + x_0 = [s_0, e_0, i_0, 0.0, R₀_L, 0.0, 0.0] # start in lockdown + + # create two problems, with rapid movement of R₀(t) towards R̄₀(t) + prob_early = ODEProblem(F, x_0, tspan, p_early) + prob_late = ODEProblem(F, x_0, tspan, p_late) + + +Unlike the previous examples, the :math:`\bar{R}_0(t)` functions have discontinuities which might occur. We can improve the efficiency of the adaptive time-stepping methods by telling them to step exactly at that point by using ``tstops`` + +Let's calculate the paths: + +.. code-block:: julia + + sol_early = solve(prob_early, Tsit5(), tstops = [30.0, 120.0]) + sol_late = solve(prob_late, Tsit5(), tstops = [30.0, 120.0]) + plot(sol_early, vars = [7], title = "Total Mortality", label = "Lift Early", legend = :topleft) + plot!(sol_late, vars = [7], label = "Lift Late") + +Next we examine the daily deaths, :math:`\frac{d D(t)}{dt} = N \delta \gamma i(t)`. + +.. code-block:: julia + + flow_deaths(sol, p) = p.N * p.δ * p.γ * sol[3,:] + + plot(sol_early.t, flow_deaths(sol_early, p_early), title = "Flow Deaths", label = "Lift Early") + plot!(sol_late.t, flow_deaths(sol_late, p_late), label = "Lift Late") + +Pushing the peak of curve further into the future may reduce cumulative deaths +if a vaccine is found, or allow health authorities to better smooth the caseload. + +Randomness +------------ + +Despite its richness, the model above is fully deterministic. The policy :math:`\bar{R}_0(t)` could change over time, but only in predictable ways. + +One way that randomness can lead to aggregate fluctuations is the granularity that comes through the discreteness of individuals. This topic, the connection between SDEs and the Langevin equations typically used in the approximation of chemical reactions in well-mixed media is explored in further lectures on continuous time Markov chains. + +Instead, in the :doc:`next lecture `, we will concentrate on randomness that comes from aggregate changes in behavior or policy. \ No newline at end of file diff --git a/source/rst/index_postgrad.rst b/source/rst/index_postgrad.rst index 487e5007..ec8ade6b 100644 --- a/source/rst/index_postgrad.rst +++ b/source/rst/index_postgrad.rst @@ -26,6 +26,7 @@ more_julia/index tools_and_techniques/index_grad dynamic_programming/index_grad + continuous_time/index multi_agent_models/index_grad time_series_models/index_grad zreferences diff --git a/source/rst/index_toc.rst b/source/rst/index_toc.rst index 09e33d17..96b42393 100644 --- a/source/rst/index_toc.rst +++ b/source/rst/index_toc.rst @@ -27,6 +27,7 @@ more_julia/index tools_and_techniques/index dynamic_programming/index + continuous_time/index multi_agent_models/index time_series_models/index dynamic_programming_squared/index