From fc4342ffe55655b8c145e3cc1ce964713d7dfbb2 Mon Sep 17 00:00:00 2001 From: John Long Date: Thu, 14 Dec 2023 13:56:29 -0500 Subject: [PATCH] Converted files to package form --- .github/dependabot.yml | 7 + .github/workflows/CI.yml | 64 + .github/workflows/CompatHelper.yml | 16 + .github/workflows/TagBot.yml | 44 + .gitignore | 13 +- LICENSE | 13 + Project.toml | 9 + README.md | 25 + benchmarks/Manifest.toml | 1366 +++++++++++++++++ benchmarks/Project.toml | 3 + benchmarks/rabi-diffeq.jl | 19 + benchmarks/rabi-dormand-prince.jl | 19 + docs/Project.toml | 7 + docs/make.jl | 21 + docs/src/index.md | 14 + original-files/Project.toml | 6 - .../benchmarks/dp5_profile_calls.jl | 31 - .../ordinarydiffeq_profile_calls.jl | 26 - .../benchmarks/single_atom_bloqade.jl | 19 - original-files/benchmarks/single_atom_dp5.jl | 43 - original-files/benchmarks/struct_profiler.jl | 12 - original-files/classic_dp5/dp5.jl | 514 ------- original-files/classic_dp5/test_dp5.jl | 24 - .../classic_dp5/test_schrodinger_eq.jl | 41 - .../classic_dp5/test_stateful_dp5.jl | 38 - original-files/integrate_test.jl | 45 - original-files/phil-ode/phil-ode.jl | 15 - original-files/schrodinger_eq_reference.jl | 10 - original-files/solver_test.jl | 44 - src/DormandPrince.jl | 10 + {original-files => src}/checks.jl | 2 +- {original-files => src}/helpers.jl | 32 +- {original-files => src}/integrate.jl | 47 +- {original-files => src}/solver.jl | 14 +- {original-files => src}/types.jl | 2 +- test/Manifest.toml | 59 + test/Project.toml | 3 + test/exact_evol_helpers.jl | 16 + test/runtests.jl | 85 + 39 files changed, 1832 insertions(+), 946 deletions(-) create mode 100644 .github/dependabot.yml create mode 100644 .github/workflows/CI.yml create mode 100644 .github/workflows/CompatHelper.yml create mode 100644 .github/workflows/TagBot.yml create mode 100644 LICENSE create mode 100644 Project.toml create mode 100644 README.md create mode 100644 benchmarks/Manifest.toml create mode 100644 benchmarks/Project.toml create mode 100644 benchmarks/rabi-diffeq.jl create mode 100644 benchmarks/rabi-dormand-prince.jl create mode 100644 docs/Project.toml create mode 100644 docs/make.jl create mode 100644 docs/src/index.md delete mode 100644 original-files/Project.toml delete mode 100644 original-files/benchmarks/dp5_profile_calls.jl delete mode 100644 original-files/benchmarks/ordinarydiffeq_profile_calls.jl delete mode 100644 original-files/benchmarks/single_atom_bloqade.jl delete mode 100644 original-files/benchmarks/single_atom_dp5.jl delete mode 100644 original-files/benchmarks/struct_profiler.jl delete mode 100644 original-files/classic_dp5/dp5.jl delete mode 100644 original-files/classic_dp5/test_dp5.jl delete mode 100644 original-files/classic_dp5/test_schrodinger_eq.jl delete mode 100644 original-files/classic_dp5/test_stateful_dp5.jl delete mode 100644 original-files/integrate_test.jl delete mode 100644 original-files/phil-ode/phil-ode.jl delete mode 100644 original-files/schrodinger_eq_reference.jl delete mode 100644 original-files/solver_test.jl create mode 100644 src/DormandPrince.jl rename {original-files => src}/checks.jl (97%) rename {original-files => src}/helpers.jl (88%) rename {original-files => src}/integrate.jl (66%) rename {original-files => src}/solver.jl (95%) rename {original-files => src}/types.jl (98%) create mode 100644 test/Manifest.toml create mode 100644 test/Project.toml create mode 100644 test/exact_evol_helpers.jl create mode 100644 test/runtests.jl diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..6fddca0 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,7 @@ +version: 2 +updates: + # Maintain dependencies for GitHub Actions + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "weekly" diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml new file mode 100644 index 0000000..b49d045 --- /dev/null +++ b/.github/workflows/CI.yml @@ -0,0 +1,64 @@ +name: CI +on: + push: + branches: + - main + tags: ['*'] + pull_request: +concurrency: + # Skip intermediate builds: always. + # Cancel intermediate builds: only if it is a pull request build. + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ startsWith(github.ref, 'refs/pull/') }} +jobs: + test: + name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }} - ${{ github.event_name }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + version: + - "1" + - "1.9" + - "nightly" + os: + - ubuntu-latest + - macos-latest + - windows-latest + arch: + - x86 + - x86_64 + steps: + - uses: actions/checkout@v2 + - uses: julia-actions/setup-julia@v1 + with: + version: ${{ matrix.version }} + arch: ${{ matrix.arch }} + - uses: julia-actions/cache@v1 + - uses: julia-actions/julia-buildpkg@v1 + - uses: julia-actions/julia-runtest@v1 + - uses: julia-actions/julia-processcoverage@v1 + - uses: codecov/codecov-action@v2 + with: + files: lcov.info + docs: + name: Documentation + runs-on: ubuntu-latest + permissions: + contents: write + statuses: write + steps: + - uses: actions/checkout@v2 + - uses: julia-actions/setup-julia@v1 + with: + version: '1' + - uses: julia-actions/julia-buildpkg@v1 + - uses: julia-actions/julia-docdeploy@v1 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + - run: | + julia --project=docs -e ' + using Documenter: DocMeta, doctest + using DormandPrince + DocMeta.setdocmeta!(DormandPrince, :DocTestSetup, :(using DormandPrince); recursive=true) + doctest(DormandPrince)' diff --git a/.github/workflows/CompatHelper.yml b/.github/workflows/CompatHelper.yml new file mode 100644 index 0000000..cba9134 --- /dev/null +++ b/.github/workflows/CompatHelper.yml @@ -0,0 +1,16 @@ +name: CompatHelper +on: + schedule: + - cron: 0 0 * * * + workflow_dispatch: +jobs: + CompatHelper: + runs-on: ubuntu-latest + steps: + - name: Pkg.add("CompatHelper") + run: julia -e 'using Pkg; Pkg.add("CompatHelper")' + - name: CompatHelper.main() + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + COMPATHELPER_PRIV: ${{ secrets.DOCUMENTER_KEY }} + run: julia -e 'using CompatHelper; CompatHelper.main()' diff --git a/.github/workflows/TagBot.yml b/.github/workflows/TagBot.yml new file mode 100644 index 0000000..464b9ea --- /dev/null +++ b/.github/workflows/TagBot.yml @@ -0,0 +1,44 @@ +name: TagBot +on: + issue_comment: + types: + - created + workflow_dispatch: +jobs: + TagBot: + if: github.event_name == 'workflow_dispatch' || github.actor == '{{{TRIGGER}}}' + runs-on: ubuntu-latest + steps: + - uses: JuliaRegistries/TagBot@v1 + with: + token: {{{TOKEN}}} + {{#SSH}} + ssh: {{{SSH}}} + {{/SSH}} + {{#SSH_PASSWORD}} + ssh_password: {{{SSH_PASSWORD}}} + {{/SSH_PASSWORD}} + {{#CHANGELOG}} + changelog: {{{CHANGELOG}}} + {{/CHANGELOG}} + {{#CHANGELOG_IGNORE}} + changelog_ignore: {{{CHANGELOG_IGNORE}}} + {{/CHANGELOG_IGNORE}} + {{#GPG}} + gpg: {{{GPG}}} + {{/GPG}} + {{#GPG_PASSWORD}} + gpg_password: {{{GPG_PASSWORD}}} + {{/GPG_PASSWORD}} + {{#REGISTRY}} + registry: {{{REGISTRY}}} + {{/REGISTRY}} + {{#BRANCHES}} + branches: {{{BRANCHES}}} + {{/BRANCHES}} + {{#DISPATCH}} + dispatch: {{{DISPATCH}}} + {{/DISPATCH}} + {{#DISPATCH_DELAY}} + dispatch_delay: {{{DISPATCH_DELAY}}} + {{/DISPATCH_DELAY}} diff --git a/.gitignore b/.gitignore index 2e528c7..eff5f6d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,11 @@ -.vscode/ -.CondaPkg/ +/.vscode +**/**/**.cov + +/Manifest.toml +/docs/build/ +/docs/Manifest.toml +/docs/src/assets/main.css +/docs/src/assets/indigo.css + .DS_Store -Manifest.toml \ No newline at end of file +.CondaPkg diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..0735f0b --- /dev/null +++ b/LICENSE @@ -0,0 +1,13 @@ +Copyright 2023 John Long + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/Project.toml b/Project.toml new file mode 100644 index 0000000..c273fd0 --- /dev/null +++ b/Project.toml @@ -0,0 +1,9 @@ +name = "DormandPrince" +uuid = "5e45e72d-22b8-4dd0-9c8b-f96714864bcd" +authors = ["John Long",] +version = "0.1.0" + +[deps] + +[compat] +julia = "1.9" diff --git a/README.md b/README.md new file mode 100644 index 0000000..7a97971 --- /dev/null +++ b/README.md @@ -0,0 +1,25 @@ +# DormandPrince + +Julia-native implementation of the Dormand-Prince 5th order solver + +## Installation + +

+DormandPrince is a   + + + Julia Language + +   package. To install DormandPrince, + please open + Julia's interactive session (known as REPL) and press ] + key in the REPL to use the package mode, then type the following command +

+ +```julia +pkg> add DormandPrince +``` + +## License + +Apache License 2.0 diff --git a/benchmarks/Manifest.toml b/benchmarks/Manifest.toml new file mode 100644 index 0000000..43d85da --- /dev/null +++ b/benchmarks/Manifest.toml @@ -0,0 +1,1366 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.9.3" +manifest_format = "2.0" +project_hash = "5bae4969e4896d866c6d46e19a8cf08fc4be0896" + +[[deps.ADTypes]] +git-tree-sha1 = "332e5d7baeff8497b923b730b994fa480601efc7" +uuid = "47edcb42-4c32-4615-8424-f2b9edc5f35b" +version = "0.2.5" + +[[deps.Accessors]] +deps = ["CompositionsBase", "ConstructionBase", "Dates", "InverseFunctions", "LinearAlgebra", "MacroTools", "Test"] +git-tree-sha1 = "a7055b939deae2455aa8a67491e034f735dd08d3" +uuid = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697" +version = "0.1.33" + + [deps.Accessors.extensions] + AccessorsAxisKeysExt = "AxisKeys" + AccessorsIntervalSetsExt = "IntervalSets" + AccessorsStaticArraysExt = "StaticArrays" + AccessorsStructArraysExt = "StructArrays" + + [deps.Accessors.weakdeps] + AxisKeys = "94b1ba4f-4ee9-5380-92f1-94cde586c3c5" + IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" + Requires = "ae029012-a4dd-5104-9daa-d747884805df" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + +[[deps.Adapt]] +deps = ["LinearAlgebra", "Requires"] +git-tree-sha1 = "cde29ddf7e5726c9fb511f340244ea3481267608" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "3.7.2" +weakdeps = ["StaticArrays"] + + [deps.Adapt.extensions] + AdaptStaticArraysExt = "StaticArrays" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.1" + +[[deps.ArnoldiMethod]] +deps = ["LinearAlgebra", "Random", "StaticArrays"] +git-tree-sha1 = "62e51b39331de8911e4a7ff6f5aaf38a5f4cc0ae" +uuid = "ec485272-7323-5ecc-a04f-4719b315124d" +version = "0.2.0" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra", "Requires", "SparseArrays", "SuiteSparse"] +git-tree-sha1 = "247efbccf92448be332d154d6ca56b9fcdd93c31" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.6.1" + + [deps.ArrayInterface.extensions] + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.ArrayLayouts]] +deps = ["FillArrays", "LinearAlgebra"] +git-tree-sha1 = "e2a63c49d6ed91065ae3e892b0382495a5ad45e3" +uuid = "4c555306-a7a7-4459-81d9-ec55ddd5c99a" +version = "1.4.4" +weakdeps = ["SparseArrays"] + + [deps.ArrayLayouts.extensions] + ArrayLayoutsSparseArraysExt = "SparseArrays" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" + +[[deps.BandedMatrices]] +deps = ["ArrayLayouts", "FillArrays", "LinearAlgebra", "PrecompileTools"] +git-tree-sha1 = "b7d2ca2461eeee5828ee9dcf6186e41fe6b6f78b" +uuid = "aae01518-5342-5314-be14-df237901396f" +version = "1.3.1" +weakdeps = ["SparseArrays"] + + [deps.BandedMatrices.extensions] + BandedMatricesSparseArraysExt = "SparseArrays" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" + +[[deps.BenchmarkTools]] +deps = ["JSON", "Logging", "Printf", "Profile", "Statistics", "UUIDs"] +git-tree-sha1 = "f1f03a9fa24271160ed7e73051fba3c1a759b53f" +uuid = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" +version = "1.4.0" + +[[deps.BitTwiddlingConvenienceFunctions]] +deps = ["Static"] +git-tree-sha1 = "0c5f81f47bbbcf4aea7b2959135713459170798b" +uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" +version = "0.1.5" + +[[deps.BoundaryValueDiffEq]] +deps = ["ADTypes", "Adapt", "ArrayInterface", "BandedMatrices", "ConcreteStructs", "DiffEqBase", "FastAlmostBandedMatrices", "ForwardDiff", "LinearAlgebra", "LinearSolve", "NonlinearSolve", "PreallocationTools", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "Setfield", "SparseArrays", "SparseDiffTools", "Tricks", "TruncatedStacktraces", "UnPack"] +git-tree-sha1 = "959bf1e2ada0bcc21f92fe2593a32ab5e7a78993" +uuid = "764a87c0-6b3e-53db-9096-fe964310641d" +version = "5.5.0" + + [deps.BoundaryValueDiffEq.extensions] + BoundaryValueDiffEqODEInterfaceExt = "ODEInterface" + BoundaryValueDiffEqOrdinaryDiffEqExt = "OrdinaryDiffEq" + + [deps.BoundaryValueDiffEq.weakdeps] + ODEInterface = "54ca160b-1b9f-5127-a996-1867f4bc2a2c" + OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" + +[[deps.CEnum]] +git-tree-sha1 = "389ad5c84de1ae7cf0e28e381131c98ea87d54fc" +uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82" +version = "0.5.0" + +[[deps.CPUSummary]] +deps = ["CpuId", "IfElse", "PrecompileTools", "Static"] +git-tree-sha1 = "601f7e7b3d36f18790e2caf83a882d88e9b71ff1" +uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" +version = "0.2.4" + +[[deps.Calculus]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "f641eb0a4f00c343bbc32346e1217b86f3ce9dad" +uuid = "49dc2e85-a5d0-5ad3-a950-438e2897f1b9" +version = "0.5.1" + +[[deps.CloseOpenIntervals]] +deps = ["Static", "StaticArrayInterface"] +git-tree-sha1 = "70232f82ffaab9dc52585e0dd043b5e0c6b714f1" +uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" +version = "0.1.12" + +[[deps.CommonSolve]] +git-tree-sha1 = "0eee5eb66b1cf62cd6ad1b460238e60e4b09400c" +uuid = "38540f10-b2f7-11e9-35d8-d573e4eb0ff2" +version = "0.2.4" + +[[deps.CommonSubexpressions]] +deps = ["MacroTools", "Test"] +git-tree-sha1 = "7b8a93dba8af7e3b42fecabf646260105ac373f7" +uuid = "bbf7d656-a473-5ed7-a52c-81e309532950" +version = "0.3.0" + +[[deps.Compat]] +deps = ["UUIDs"] +git-tree-sha1 = "886826d76ea9e72b35fcd000e535588f7b60f21d" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.10.1" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.0.5+0" + +[[deps.CompositionsBase]] +git-tree-sha1 = "802bb88cd69dfd1509f6670416bd4434015693ad" +uuid = "a33af91c-f02d-484b-be07-31d278c5ca2b" +version = "0.1.2" +weakdeps = ["InverseFunctions"] + + [deps.CompositionsBase.extensions] + CompositionsBaseInverseFunctionsExt = "InverseFunctions" + +[[deps.ConcreteStructs]] +git-tree-sha1 = "f749037478283d372048690eb3b5f92a79432b34" +uuid = "2569d6c7-a4a2-43d3-a901-331e8e4be471" +version = "0.2.3" + +[[deps.ConstructionBase]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "c53fc348ca4d40d7b371e71fd52251839080cbc9" +uuid = "187b0558-2788-49d3-abe0-74a17ed4e7c9" +version = "1.5.4" + + [deps.ConstructionBase.extensions] + ConstructionBaseIntervalSetsExt = "IntervalSets" + ConstructionBaseStaticArraysExt = "StaticArrays" + + [deps.ConstructionBase.weakdeps] + IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.CpuId]] +deps = ["Markdown"] +git-tree-sha1 = "fcbb72b032692610bfbdb15018ac16a36cf2e406" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.3.1" + +[[deps.DataAPI]] +git-tree-sha1 = "8da84edb865b0b5b0100c0666a9bc9a0b71c553c" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.15.0" + +[[deps.DataStructures]] +deps = ["Compat", "InteractiveUtils", "OrderedCollections"] +git-tree-sha1 = "3dbd312d370723b6bb43ba9d02fc36abade4518d" +uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" +version = "0.18.15" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" + +[[deps.DelayDiffEq]] +deps = ["ArrayInterface", "DataStructures", "DiffEqBase", "LinearAlgebra", "Logging", "OrdinaryDiffEq", "Printf", "RecursiveArrayTools", "Reexport", "SciMLBase", "SimpleNonlinearSolve", "SimpleUnPack"] +git-tree-sha1 = "e40378efd2af7658d0a0579aa9e15b17137368f4" +uuid = "bcd4f6db-9728-5f36-b5f7-82caef46ccdb" +version = "5.44.0" + +[[deps.DelimitedFiles]] +deps = ["Mmap"] +git-tree-sha1 = "9e2f36d3c96a820c678f2f1f1782582fcf685bae" +uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab" +version = "1.9.1" + +[[deps.DiffEqBase]] +deps = ["ArrayInterface", "DataStructures", "DocStringExtensions", "EnumX", "EnzymeCore", "FastBroadcast", "ForwardDiff", "FunctionWrappers", "FunctionWrappersWrappers", "LinearAlgebra", "Logging", "Markdown", "MuladdMacro", "Parameters", "PreallocationTools", "PrecompileTools", "Printf", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLOperators", "Setfield", "SparseArrays", "Static", "StaticArraysCore", "Statistics", "Tricks", "TruncatedStacktraces"] +git-tree-sha1 = "09ce9525b590bcdd9a807142dc493692aee85ef9" +uuid = "2b5f629d-d688-5b77-993f-72d75c75574e" +version = "6.143.0" + + [deps.DiffEqBase.extensions] + DiffEqBaseChainRulesCoreExt = "ChainRulesCore" + DiffEqBaseDistributionsExt = "Distributions" + DiffEqBaseEnzymeExt = ["ChainRulesCore", "Enzyme"] + DiffEqBaseGeneralizedGeneratedExt = "GeneralizedGenerated" + DiffEqBaseMPIExt = "MPI" + DiffEqBaseMeasurementsExt = "Measurements" + DiffEqBaseMonteCarloMeasurementsExt = "MonteCarloMeasurements" + DiffEqBaseReverseDiffExt = "ReverseDiff" + DiffEqBaseTrackerExt = "Tracker" + DiffEqBaseUnitfulExt = "Unitful" + + [deps.DiffEqBase.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + GeneralizedGenerated = "6b9d7cbe-bcb9-11e9-073f-15a7a543e2eb" + MPI = "da04e1cc-30fd-572f-bb4f-1f8673147195" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.DiffEqCallbacks]] +deps = ["DataStructures", "DiffEqBase", "ForwardDiff", "Functors", "LinearAlgebra", "Markdown", "NLsolve", "Parameters", "RecipesBase", "RecursiveArrayTools", "SciMLBase", "StaticArraysCore"] +git-tree-sha1 = "d0b94b3694d55e7eedeee918e7daee9e3b873399" +uuid = "459566f4-90b8-5000-8ac3-15dfb0a30def" +version = "2.35.0" +weakdeps = ["OrdinaryDiffEq", "Sundials"] + +[[deps.DiffEqNoiseProcess]] +deps = ["DiffEqBase", "Distributions", "GPUArraysCore", "LinearAlgebra", "Markdown", "Optim", "PoissonRandom", "QuadGK", "Random", "Random123", "RandomNumbers", "RecipesBase", "RecursiveArrayTools", "Requires", "ResettableStacks", "SciMLBase", "StaticArraysCore", "Statistics"] +git-tree-sha1 = "319377c927a4aa1f491228b2ac23f3554a3497c6" +uuid = "77a26b50-5914-5dd7-bc55-306e6241c503" +version = "5.20.0" + + [deps.DiffEqNoiseProcess.extensions] + DiffEqNoiseProcessReverseDiffExt = "ReverseDiff" + + [deps.DiffEqNoiseProcess.weakdeps] + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + +[[deps.DiffResults]] +deps = ["StaticArraysCore"] +git-tree-sha1 = "782dd5f4561f5d267313f23853baaaa4c52ea621" +uuid = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" +version = "1.1.0" + +[[deps.DiffRules]] +deps = ["IrrationalConstants", "LogExpFunctions", "NaNMath", "Random", "SpecialFunctions"] +git-tree-sha1 = "23163d55f885173722d1e4cf0f6110cdbaf7e272" +uuid = "b552c78f-8df3-52c6-915a-8e097449b14b" +version = "1.15.1" + +[[deps.DifferentialEquations]] +deps = ["BoundaryValueDiffEq", "DelayDiffEq", "DiffEqBase", "DiffEqCallbacks", "DiffEqNoiseProcess", "JumpProcesses", "LinearAlgebra", "LinearSolve", "NonlinearSolve", "OrdinaryDiffEq", "Random", "RecursiveArrayTools", "Reexport", "SciMLBase", "SteadyStateDiffEq", "StochasticDiffEq", "Sundials"] +git-tree-sha1 = "19a5b6314715139ddefea4108a105bb9b90dc4fb" +uuid = "0c46a032-eb83-5123-abaf-570d42b7fbaa" +version = "7.11.0" + +[[deps.Distances]] +deps = ["LinearAlgebra", "Statistics", "StatsAPI"] +git-tree-sha1 = "66c4c81f259586e8f002eacebc177e1fb06363b0" +uuid = "b4f34e82-e78d-54a5-968a-f98e89d6e8f7" +version = "0.10.11" + + [deps.Distances.extensions] + DistancesChainRulesCoreExt = "ChainRulesCore" + DistancesSparseArraysExt = "SparseArrays" + + [deps.Distances.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + +[[deps.Distributed]] +deps = ["Random", "Serialization", "Sockets"] +uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" + +[[deps.Distributions]] +deps = ["FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"] +git-tree-sha1 = "9242eec9b7e2e14f9952e8ea1c7e31a50501d587" +uuid = "31c24e10-a181-5473-b8eb-7969acd0382f" +version = "0.25.104" + + [deps.Distributions.extensions] + DistributionsChainRulesCoreExt = "ChainRulesCore" + DistributionsDensityInterfaceExt = "DensityInterface" + DistributionsTestExt = "Test" + + [deps.Distributions.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DensityInterface = "b429d917-457f-4dbc-8f4c-0cc954292b1d" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.DocStringExtensions]] +deps = ["LibGit2"] +git-tree-sha1 = "2fb1e02f2b635d0845df5d7c167fec4dd739b00d" +uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" +version = "0.9.3" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.6.0" + +[[deps.DualNumbers]] +deps = ["Calculus", "NaNMath", "SpecialFunctions"] +git-tree-sha1 = "5837a837389fccf076445fce071c8ddaea35a566" +uuid = "fa6b7ba4-c1ee-5f82-b5fc-ecf0adba8f74" +version = "0.6.8" + +[[deps.EnumX]] +git-tree-sha1 = "bdb1942cd4c45e3c678fd11569d5cccd80976237" +uuid = "4e289a0a-7415-4d19-859d-a7e5c4648b56" +version = "1.0.4" + +[[deps.EnzymeCore]] +deps = ["Adapt"] +git-tree-sha1 = "2efe862de93cd87f620ad6ac9c9e3f83f1b2841b" +uuid = "f151be2c-9106-41f4-ab19-57ee4f262869" +version = "0.6.4" + +[[deps.ExponentialUtilities]] +deps = ["Adapt", "ArrayInterface", "GPUArraysCore", "GenericSchur", "LinearAlgebra", "PrecompileTools", "Printf", "SparseArrays", "libblastrampoline_jll"] +git-tree-sha1 = "602e4585bcbd5a25bc06f514724593d13ff9e862" +uuid = "d4d017d3-3776-5f7e-afef-a10c40355c18" +version = "1.25.0" + +[[deps.ExprTools]] +git-tree-sha1 = "27415f162e6028e81c72b82ef756bf321213b6ec" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.10" + +[[deps.FastAlmostBandedMatrices]] +deps = ["ArrayInterface", "ArrayLayouts", "BandedMatrices", "ConcreteStructs", "LazyArrays", "LinearAlgebra", "MatrixFactorizations", "PrecompileTools", "Reexport"] +git-tree-sha1 = "178316d87f883f0702e79d9c83a8049484c9f619" +uuid = "9d29842c-ecb8-4973-b1e9-a27b1157504e" +version = "0.1.0" + +[[deps.FastBroadcast]] +deps = ["ArrayInterface", "LinearAlgebra", "Polyester", "Static", "StaticArrayInterface", "StrideArraysCore"] +git-tree-sha1 = "a6e756a880fc419c8b41592010aebe6a5ce09136" +uuid = "7034ab61-46d4-4ed7-9d0f-46aef9175898" +version = "0.2.8" + +[[deps.FastClosures]] +git-tree-sha1 = "acebe244d53ee1b461970f8910c235b259e772ef" +uuid = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a" +version = "0.3.2" + +[[deps.FastLapackInterface]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "b12f05108e405dadcc2aff0008db7f831374e051" +uuid = "29a986be-02c6-4525-aec4-84b980013641" +version = "2.0.0" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" + +[[deps.FillArrays]] +deps = ["LinearAlgebra", "Random"] +git-tree-sha1 = "5b93957f6dcd33fc343044af3d48c215be2562f1" +uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" +version = "1.9.3" +weakdeps = ["PDMats", "SparseArrays", "Statistics"] + + [deps.FillArrays.extensions] + FillArraysPDMatsExt = "PDMats" + FillArraysSparseArraysExt = "SparseArrays" + FillArraysStatisticsExt = "Statistics" + +[[deps.FiniteDiff]] +deps = ["ArrayInterface", "LinearAlgebra", "Requires", "Setfield", "SparseArrays"] +git-tree-sha1 = "c6e4a1fbe73b31a3dea94b1da449503b8830c306" +uuid = "6a86dc24-6348-571c-b903-95158fe2bd41" +version = "2.21.1" + + [deps.FiniteDiff.extensions] + FiniteDiffBandedMatricesExt = "BandedMatrices" + FiniteDiffBlockBandedMatricesExt = "BlockBandedMatrices" + FiniteDiffStaticArraysExt = "StaticArrays" + + [deps.FiniteDiff.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.ForwardDiff]] +deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"] +git-tree-sha1 = "cf0fe81336da9fb90944683b8c41984b08793dad" +uuid = "f6369f11-7733-5829-9624-2563aa707210" +version = "0.10.36" +weakdeps = ["StaticArrays"] + + [deps.ForwardDiff.extensions] + ForwardDiffStaticArraysExt = "StaticArrays" + +[[deps.FunctionWrappers]] +git-tree-sha1 = "d62485945ce5ae9c0c48f124a84998d755bae00e" +uuid = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e" +version = "1.1.3" + +[[deps.FunctionWrappersWrappers]] +deps = ["FunctionWrappers"] +git-tree-sha1 = "b104d487b34566608f8b4e1c39fb0b10aa279ff8" +uuid = "77dc65aa-8811-40c2-897b-53d922fa7daf" +version = "0.1.3" + +[[deps.Functors]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "9a68d75d466ccc1218d0552a8e1631151c569545" +uuid = "d9f16b24-f501-4c13-a1f2-28368ffc5196" +version = "0.4.5" + +[[deps.Future]] +deps = ["Random"] +uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "2d6ca471a6c7b536127afccfa7564b5b39227fe0" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.1.5" + +[[deps.GenericSchur]] +deps = ["LinearAlgebra", "Printf"] +git-tree-sha1 = "fb69b2a645fa69ba5f474af09221b9308b160ce6" +uuid = "c145ed77-6b09-5dd9-b285-bf645a82121e" +version = "0.5.3" + +[[deps.Graphs]] +deps = ["ArnoldiMethod", "Compat", "DataStructures", "Distributed", "Inflate", "LinearAlgebra", "Random", "SharedArrays", "SimpleTraits", "SparseArrays", "Statistics"] +git-tree-sha1 = "899050ace26649433ef1af25bc17a815b3db52b7" +uuid = "86223c79-3864-5bf0-83f7-82e725a168b6" +version = "1.9.0" + +[[deps.HostCPUFeatures]] +deps = ["BitTwiddlingConvenienceFunctions", "IfElse", "Libdl", "Static"] +git-tree-sha1 = "eb8fed28f4994600e29beef49744639d985a04b2" +uuid = "3e5b6fbb-0976-4d2c-9146-d79de83f2fb0" +version = "0.1.16" + +[[deps.HypergeometricFunctions]] +deps = ["DualNumbers", "LinearAlgebra", "OpenLibm_jll", "SpecialFunctions"] +git-tree-sha1 = "f218fe3736ddf977e0e772bc9a586b2383da2685" +uuid = "34004b35-14d8-5ef3-9330-4cdb6864b03a" +version = "0.3.23" + +[[deps.IfElse]] +git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" +uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" +version = "0.1.1" + +[[deps.Inflate]] +git-tree-sha1 = "ea8031dea4aff6bd41f1df8f2fdfb25b33626381" +uuid = "d25df0c9-e2be-5dd7-82c8-3ad0b3e990b9" +version = "0.1.4" + +[[deps.IntegerMathUtils]] +git-tree-sha1 = "b8ffb903da9f7b8cf695a8bead8e01814aa24b30" +uuid = "18e54dd8-cb9d-406c-a71d-865a43cbb235" +version = "0.1.2" + +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "31d6adb719886d4e32e38197aae466e98881320b" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2024.0.0+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" + +[[deps.InverseFunctions]] +deps = ["Test"] +git-tree-sha1 = "68772f49f54b479fa88ace904f6127f0a3bb2e46" +uuid = "3587e190-3f89-42d0-90ee-14403ec27112" +version = "0.1.12" + +[[deps.IrrationalConstants]] +git-tree-sha1 = "630b497eafcc20001bba38a4651b327dcfc491d2" +uuid = "92d709cd-6900-40b7-9082-c6be49f344b6" +version = "0.2.2" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "7e5d6779a1e09a36db2a7b6cff50942a0a7d0fca" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.5.0" + +[[deps.JSON]] +deps = ["Dates", "Mmap", "Parsers", "Unicode"] +git-tree-sha1 = "31e996f0a15c7b280ba9f76636b3ff9e2ae58c9a" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "0.21.4" + +[[deps.JumpProcesses]] +deps = ["ArrayInterface", "DataStructures", "DiffEqBase", "DocStringExtensions", "FunctionWrappers", "Graphs", "LinearAlgebra", "Markdown", "PoissonRandom", "Random", "RandomNumbers", "RecursiveArrayTools", "Reexport", "SciMLBase", "StaticArrays", "UnPack"] +git-tree-sha1 = "c451feb97251965a9fe40bacd62551a72cc5902c" +uuid = "ccbc3e58-028d-4f4c-8cd5-9ae44345cda5" +version = "9.10.1" +weakdeps = ["FastBroadcast"] + + [deps.JumpProcesses.extensions] + JumpProcessFastBroadcastExt = "FastBroadcast" + +[[deps.KLU]] +deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse_jll"] +git-tree-sha1 = "884c2968c2e8e7e6bf5956af88cb46aa745c854b" +uuid = "ef3ab10e-7fda-4108-b977-705223b18434" +version = "0.4.1" + +[[deps.Krylov]] +deps = ["LinearAlgebra", "Printf", "SparseArrays"] +git-tree-sha1 = "8a6837ec02fe5fb3def1abc907bb802ef11a0729" +uuid = "ba0b0d4f-ebba-5204-a429-3ac8c609bfb7" +version = "0.9.5" + +[[deps.LatticeRules]] +deps = ["Random"] +git-tree-sha1 = "7f5b02258a3ca0221a6a9710b0a0a2e8fb4957fe" +uuid = "73f95e8e-ec14-4e6a-8b18-0d2e271c4e55" +version = "0.0.1" + +[[deps.LayoutPointers]] +deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "62edfee3211981241b57ff1cedf4d74d79519277" +uuid = "10f19ff3-798f-405d-979b-55457f8fc047" +version = "0.1.15" + +[[deps.Lazy]] +deps = ["MacroTools"] +git-tree-sha1 = "1370f8202dac30758f3c345f9909b97f53d87d3f" +uuid = "50d2b5c4-7a5e-59d5-8109-a42b560f39c0" +version = "0.15.1" + +[[deps.LazyArrays]] +deps = ["ArrayLayouts", "FillArrays", "LinearAlgebra", "MacroTools", "MatrixFactorizations", "SparseArrays"] +git-tree-sha1 = "9cfca23ab83b0dfac93cb1a1ef3331ab9fe596a5" +uuid = "5078a376-72f3-5289-bfd5-ec5146d43c02" +version = "1.8.3" +weakdeps = ["StaticArrays"] + + [deps.LazyArrays.extensions] + LazyArraysStaticArraysExt = "StaticArrays" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" + +[[deps.LevyArea]] +deps = ["LinearAlgebra", "Random", "SpecialFunctions"] +git-tree-sha1 = "56513a09b8e0ae6485f34401ea9e2f31357958ec" +uuid = "2d8b4e74-eb68-11e8-0fb9-d5eb67b50637" +version = "1.0.0" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "0.6.3" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "7.84.0+0" + +[[deps.LibGit2]] +deps = ["Base64", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "Libdl", "MbedTLS_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.10.2+0" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" + +[[deps.LineSearches]] +deps = ["LinearAlgebra", "NLSolversBase", "NaNMath", "Parameters", "Printf"] +git-tree-sha1 = "7bbea35cec17305fc70a0e5b4641477dc0789d9d" +uuid = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" +version = "7.2.0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + +[[deps.LinearSolve]] +deps = ["ArrayInterface", "ConcreteStructs", "DocStringExtensions", "EnumX", "FastLapackInterface", "GPUArraysCore", "InteractiveUtils", "KLU", "Krylov", "Libdl", "LinearAlgebra", "MKL_jll", "PrecompileTools", "Preferences", "RecursiveFactorization", "Reexport", "Requires", "SciMLBase", "SciMLOperators", "Setfield", "SparseArrays", "Sparspak", "StaticArraysCore", "UnPack"] +git-tree-sha1 = "03cd36673f050ec49f9bdfce31e0e7e22d877e64" +uuid = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae" +version = "2.21.0" + + [deps.LinearSolve.extensions] + LinearSolveBandedMatricesExt = "BandedMatrices" + LinearSolveBlockDiagonalsExt = "BlockDiagonals" + LinearSolveCUDAExt = "CUDA" + LinearSolveEnzymeExt = ["Enzyme", "EnzymeCore"] + LinearSolveFastAlmostBandedMatricesExt = ["FastAlmostBandedMatrices"] + LinearSolveHYPREExt = "HYPRE" + LinearSolveIterativeSolversExt = "IterativeSolvers" + LinearSolveKernelAbstractionsExt = "KernelAbstractions" + LinearSolveKrylovKitExt = "KrylovKit" + LinearSolveMetalExt = "Metal" + LinearSolvePardisoExt = "Pardiso" + LinearSolveRecursiveArrayToolsExt = "RecursiveArrayTools" + + [deps.LinearSolve.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockDiagonals = "0a1fb500-61f7-11e9-3c65-f5ef3456f9f0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + FastAlmostBandedMatrices = "9d29842c-ecb8-4973-b1e9-a27b1157504e" + HYPRE = "b5ffcf37-a2bd-41ab-a3da-4bd9bc8ad771" + IterativeSolvers = "42fd0dbc-a981-5370-80f2-aaf504508153" + KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" + KrylovKit = "0b1a1467-8014-51b9-945f-bf0ae24f4b77" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + Pardiso = "46dd5b70-b6fb-5a00-ae2d-e8fea33afaf2" + RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd" + +[[deps.LogExpFunctions]] +deps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"] +git-tree-sha1 = "7d6dd4e9212aebaeed356de34ccf262a3cd415aa" +uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" +version = "0.3.26" + + [deps.LogExpFunctions.extensions] + LogExpFunctionsChainRulesCoreExt = "ChainRulesCore" + LogExpFunctionsChangesOfVariablesExt = "ChangesOfVariables" + LogExpFunctionsInverseFunctionsExt = "InverseFunctions" + + [deps.LogExpFunctions.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ChangesOfVariables = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0" + InverseFunctions = "3587e190-3f89-42d0-90ee-14403ec27112" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" + +[[deps.LoopVectorization]] +deps = ["ArrayInterface", "CPUSummary", "CloseOpenIntervals", "DocStringExtensions", "HostCPUFeatures", "IfElse", "LayoutPointers", "LinearAlgebra", "OffsetArrays", "PolyesterWeave", "PrecompileTools", "SIMDTypes", "SLEEFPirates", "Static", "StaticArrayInterface", "ThreadingUtilities", "UnPack", "VectorizationBase"] +git-tree-sha1 = "0f5648fbae0d015e3abe5867bca2b362f67a5894" +uuid = "bdcacae8-1622-11e9-2a5c-532679323890" +version = "0.12.166" + + [deps.LoopVectorization.extensions] + ForwardDiffExt = ["ChainRulesCore", "ForwardDiff"] + SpecialFunctionsExt = "SpecialFunctions" + + [deps.LoopVectorization.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "72dc3cf284559eb8f53aa593fe62cb33f83ed0c0" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2024.0.0+0" + +[[deps.MacroTools]] +deps = ["Markdown", "Random"] +git-tree-sha1 = "9ee1618cbf5240e6d4e0371d6f24065083f60c48" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.11" + +[[deps.ManualMemory]] +git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" +uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" +version = "0.1.8" + +[[deps.Markdown]] +deps = ["Base64"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" + +[[deps.MatrixFactorizations]] +deps = ["ArrayLayouts", "LinearAlgebra", "Printf", "Random"] +git-tree-sha1 = "78f6e33434939b0ac9ba1df81e6d005ee85a7396" +uuid = "a3b82374-2e81-5b9e-98ce-41277c0e4c87" +version = "2.1.0" + +[[deps.MbedTLS_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" +version = "2.28.2+0" + +[[deps.Missings]] +deps = ["DataAPI"] +git-tree-sha1 = "f66bdc5de519e8f8ae43bdc598782d35a25b1272" +uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28" +version = "1.1.0" + +[[deps.Mmap]] +uuid = "a63ad114-7e13-5084-954f-fe012c677804" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2022.10.11" + +[[deps.MuladdMacro]] +git-tree-sha1 = "cac9cc5499c25554cba55cd3c30543cff5ca4fab" +uuid = "46d2c3a1-f734-5fdb-9937-b9b9aeba4221" +version = "0.2.4" + +[[deps.NLSolversBase]] +deps = ["DiffResults", "Distributed", "FiniteDiff", "ForwardDiff"] +git-tree-sha1 = "a0b464d183da839699f4c79e7606d9d186ec172c" +uuid = "d41bc354-129a-5804-8e4c-c37616107c6c" +version = "7.8.3" + +[[deps.NLsolve]] +deps = ["Distances", "LineSearches", "LinearAlgebra", "NLSolversBase", "Printf", "Reexport"] +git-tree-sha1 = "019f12e9a1a7880459d0173c182e6a99365d7ac1" +uuid = "2774e3e8-f4cf-5e23-947b-6d7e65073b56" +version = "4.5.1" + +[[deps.NaNMath]] +deps = ["OpenLibm_jll"] +git-tree-sha1 = "0877504529a3e5c3343c6f8b4c0381e57e4387e4" +uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" +version = "1.0.2" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.2.0" + +[[deps.NonlinearSolve]] +deps = ["ADTypes", "ArrayInterface", "ConcreteStructs", "DiffEqBase", "EnumX", "FastBroadcast", "FiniteDiff", "ForwardDiff", "LineSearches", "LinearAlgebra", "LinearSolve", "PrecompileTools", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLOperators", "SimpleNonlinearSolve", "SparseArrays", "SparseDiffTools", "StaticArraysCore", "UnPack"] +git-tree-sha1 = "6166ccd8f79c93c636ca61ab4cd18f555932563d" +uuid = "8913a72c-1f9b-4ce2-8d82-65094dcecaec" +version = "2.8.2" + + [deps.NonlinearSolve.extensions] + NonlinearSolveBandedMatricesExt = "BandedMatrices" + NonlinearSolveFastLevenbergMarquardtExt = "FastLevenbergMarquardt" + NonlinearSolveLeastSquaresOptimExt = "LeastSquaresOptim" + + [deps.NonlinearSolve.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + FastLevenbergMarquardt = "7a0df574-e128-4d35-8cbd-3d84502bf7ce" + LeastSquaresOptim = "0fc2ff8b-aaa3-5acd-a817-1944a5e08891" + +[[deps.OffsetArrays]] +deps = ["Adapt"] +git-tree-sha1 = "2ac17d29c523ce1cd38e27785a7d23024853a4bb" +uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" +version = "1.12.10" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.21+4" + +[[deps.OpenLibm_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "05823500-19ac-5b8b-9628-191a04bc5112" +version = "0.8.1+0" + +[[deps.OpenSpecFun_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "13652491f6856acfd2db29360e1bbcd4565d04f1" +uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e" +version = "0.5.5+0" + +[[deps.Optim]] +deps = ["Compat", "FillArrays", "ForwardDiff", "LineSearches", "LinearAlgebra", "NLSolversBase", "NaNMath", "Parameters", "PositiveFactorizations", "Printf", "SparseArrays", "StatsBase"] +git-tree-sha1 = "01f85d9269b13fedc61e63cc72ee2213565f7a72" +uuid = "429524aa-4258-5aef-a3af-852621145aeb" +version = "1.7.8" + +[[deps.OrderedCollections]] +git-tree-sha1 = "dfdf5519f235516220579f949664f1bf44e741c5" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "1.6.3" + +[[deps.OrdinaryDiffEq]] +deps = ["ADTypes", "Adapt", "ArrayInterface", "DataStructures", "DiffEqBase", "DocStringExtensions", "ExponentialUtilities", "FastBroadcast", "FastClosures", "FiniteDiff", "ForwardDiff", "FunctionWrappersWrappers", "IfElse", "InteractiveUtils", "LineSearches", "LinearAlgebra", "LinearSolve", "Logging", "LoopVectorization", "MacroTools", "MuladdMacro", "NLsolve", "NonlinearSolve", "Polyester", "PreallocationTools", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLNLSolve", "SciMLOperators", "SimpleNonlinearSolve", "SimpleUnPack", "SparseArrays", "SparseDiffTools", "StaticArrayInterface", "StaticArrays", "TruncatedStacktraces"] +git-tree-sha1 = "5f9e7ce227d0e447c3803cc05ef5d8f75f84b9ea" +uuid = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" +version = "6.59.3" + +[[deps.PDMats]] +deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"] +git-tree-sha1 = "949347156c25054de2db3b166c52ac4728cbad65" +uuid = "90014a1f-27ba-587c-ab20-58faa44d9150" +version = "0.11.31" + +[[deps.PackageExtensionCompat]] +git-tree-sha1 = "fb28e33b8a95c4cee25ce296c817d89cc2e53518" +uuid = "65ce6f38-6b18-4e1d-a461-8949797d7930" +version = "1.0.2" +weakdeps = ["Requires", "TOML"] + +[[deps.Parameters]] +deps = ["OrderedCollections", "UnPack"] +git-tree-sha1 = "34c0e9ad262e5f7fc75b10a9952ca7692cfc5fbe" +uuid = "d96e819e-fc66-5662-9728-84c9c7592b0a" +version = "0.12.3" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools", "UUIDs"] +git-tree-sha1 = "a935806434c9d4c506ba941871b327b96d41f2bf" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "2.8.0" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.9.2" + +[[deps.PoissonRandom]] +deps = ["Random"] +git-tree-sha1 = "a0f1159c33f846aa77c3f30ebbc69795e5327152" +uuid = "e409e4f3-bfea-5376-8464-e040bb5c01ab" +version = "0.4.4" + +[[deps.Polyester]] +deps = ["ArrayInterface", "BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "ManualMemory", "PolyesterWeave", "Requires", "Static", "StaticArrayInterface", "StrideArraysCore", "ThreadingUtilities"] +git-tree-sha1 = "fca25670784a1ae44546bcb17288218310af2778" +uuid = "f517fe37-dbe3-4b94-8317-1923a5111588" +version = "0.7.9" + +[[deps.PolyesterWeave]] +deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] +git-tree-sha1 = "240d7170f5ffdb285f9427b92333c3463bf65bf6" +uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" +version = "0.2.1" + +[[deps.PositiveFactorizations]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "17275485f373e6673f7e7f97051f703ed5b15b20" +uuid = "85a6dd25-e78a-55b7-8502-1745935b8125" +version = "0.2.4" + +[[deps.PreallocationTools]] +deps = ["Adapt", "ArrayInterface", "ForwardDiff", "Requires"] +git-tree-sha1 = "01ac95fca7daabe77a9cb705862bd87016af9ddb" +uuid = "d236fae5-4411-538c-8e31-a6e3d9e00b46" +version = "0.4.13" + + [deps.PreallocationTools.extensions] + PreallocationToolsReverseDiffExt = "ReverseDiff" + + [deps.PreallocationTools.weakdeps] + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "03b4c25b43cb84cee5c90aa9b5ea0a78fd848d2f" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.2.0" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "00805cd429dcb4870060ff49ef443486c262e38e" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.4.1" + +[[deps.Primes]] +deps = ["IntegerMathUtils"] +git-tree-sha1 = "1d05623b5952aed1307bf8b43bec8b8d1ef94b6e" +uuid = "27ebfcd6-29c5-5fa9-bf4b-fb8fc14df3ae" +version = "0.5.5" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" + +[[deps.Profile]] +deps = ["Printf"] +uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79" + +[[deps.QuadGK]] +deps = ["DataStructures", "LinearAlgebra"] +git-tree-sha1 = "9ebcd48c498668c7fa0e97a9cae873fbee7bfee1" +uuid = "1fd47b50-473d-5c70-9696-f719f8f3bcdc" +version = "2.9.1" + +[[deps.QuasiMonteCarlo]] +deps = ["Accessors", "ConcreteStructs", "LatticeRules", "LinearAlgebra", "Primes", "Random", "Requires", "Sobol", "StatsBase"] +git-tree-sha1 = "cc086f8485bce77b6187141e1413c3b55f9a4341" +uuid = "8a4e6c94-4038-4cdc-81c3-7e6ffdb2a71b" +version = "0.3.3" +weakdeps = ["Distributions"] + + [deps.QuasiMonteCarlo.extensions] + QuasiMonteCarloDistributionsExt = "Distributions" + +[[deps.REPL]] +deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" + +[[deps.Random]] +deps = ["SHA", "Serialization"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" + +[[deps.Random123]] +deps = ["Random", "RandomNumbers"] +git-tree-sha1 = "552f30e847641591ba3f39fd1bed559b9deb0ef3" +uuid = "74087812-796a-5b5d-8853-05524746bad3" +version = "1.6.1" + +[[deps.RandomNumbers]] +deps = ["Random", "Requires"] +git-tree-sha1 = "043da614cc7e95c703498a491e2c21f58a2b8111" +uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" +version = "1.5.3" + +[[deps.RecipesBase]] +deps = ["PrecompileTools"] +git-tree-sha1 = "5c3d09cc4f31f5fc6af001c250bf1278733100ff" +uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" +version = "1.3.4" + +[[deps.RecursiveArrayTools]] +deps = ["Adapt", "ArrayInterface", "DocStringExtensions", "GPUArraysCore", "IteratorInterfaceExtensions", "LinearAlgebra", "RecipesBase", "Requires", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface", "Tables"] +git-tree-sha1 = "d7087c013e8a496ff396bae843b1e16d9a30ede8" +uuid = "731186ca-8d62-57ce-b412-fbd966d074cd" +version = "2.38.10" + + [deps.RecursiveArrayTools.extensions] + RecursiveArrayToolsMeasurementsExt = "Measurements" + RecursiveArrayToolsMonteCarloMeasurementsExt = "MonteCarloMeasurements" + RecursiveArrayToolsTrackerExt = "Tracker" + RecursiveArrayToolsZygoteExt = "Zygote" + + [deps.RecursiveArrayTools.weakdeps] + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.RecursiveFactorization]] +deps = ["LinearAlgebra", "LoopVectorization", "Polyester", "PrecompileTools", "StrideArraysCore", "TriangularSolve"] +git-tree-sha1 = "8bc86c78c7d8e2a5fe559e3721c0f9c9e303b2ed" +uuid = "f2c3362d-daeb-58d1-803e-2bc74f2840b4" +version = "0.2.21" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.Requires]] +deps = ["UUIDs"] +git-tree-sha1 = "838a3a4188e2ded87a4f9f184b4b0d78a1e91cb7" +uuid = "ae029012-a4dd-5104-9daa-d747884805df" +version = "1.3.0" + +[[deps.ResettableStacks]] +deps = ["StaticArrays"] +git-tree-sha1 = "256eeeec186fa7f26f2801732774ccf277f05db9" +uuid = "ae5879a3-cd67-5da8-be7f-38c6eb64a37b" +version = "1.1.1" + +[[deps.Rmath]] +deps = ["Random", "Rmath_jll"] +git-tree-sha1 = "f65dcb5fa46aee0cf9ed6274ccbd597adc49aa7b" +uuid = "79098fc4-a85e-5d69-aa6a-4863f24498fa" +version = "0.7.1" + +[[deps.Rmath_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "6ed52fdd3382cf21947b15e8870ac0ddbff736da" +uuid = "f50d1b31-88e8-58de-be2c-1cc44531875f" +version = "0.4.0+0" + +[[deps.RuntimeGeneratedFunctions]] +deps = ["ExprTools", "SHA", "Serialization"] +git-tree-sha1 = "6aacc5eefe8415f47b3e34214c1d79d2674a0ba2" +uuid = "7e49a35a-f44a-4d26-94aa-eba1b4ca6b47" +version = "0.5.12" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "0.7.0" + +[[deps.SIMDTypes]] +git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" +uuid = "94e857df-77ce-4151-89e5-788b33177be4" +version = "0.1.0" + +[[deps.SLEEFPirates]] +deps = ["IfElse", "Static", "VectorizationBase"] +git-tree-sha1 = "3aac6d68c5e57449f5b9b865c9ba50ac2970c4cf" +uuid = "476501e8-09a2-5ece-8869-fb82de89a1fa" +version = "0.6.42" + +[[deps.SciMLBase]] +deps = ["ADTypes", "ArrayInterface", "CommonSolve", "ConstructionBase", "Distributed", "DocStringExtensions", "EnumX", "FillArrays", "FunctionWrappersWrappers", "IteratorInterfaceExtensions", "LinearAlgebra", "Logging", "Markdown", "PrecompileTools", "Preferences", "Printf", "QuasiMonteCarlo", "RecipesBase", "RecursiveArrayTools", "Reexport", "RuntimeGeneratedFunctions", "SciMLOperators", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface", "Tables", "TruncatedStacktraces"] +git-tree-sha1 = "32ea825941f7b58a6f48268f4b76971ae8eb9eec" +uuid = "0bca4576-84f4-4d90-8ffe-ffa030f20462" +version = "2.10.0" + + [deps.SciMLBase.extensions] + SciMLBaseChainRulesCoreExt = "ChainRulesCore" + SciMLBasePartialFunctionsExt = "PartialFunctions" + SciMLBasePyCallExt = "PyCall" + SciMLBasePythonCallExt = "PythonCall" + SciMLBaseRCallExt = "RCall" + SciMLBaseZygoteExt = "Zygote" + + [deps.SciMLBase.weakdeps] + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + PartialFunctions = "570af359-4316-4cb7-8c74-252c00c2016b" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" + RCall = "6f49c342-dc21-5d91-9882-a32aef131414" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.SciMLNLSolve]] +deps = ["DiffEqBase", "LineSearches", "NLsolve", "Reexport", "SciMLBase"] +git-tree-sha1 = "765b788339abd7d983618c09cfc0192e2b6b15fd" +uuid = "e9a6253c-8580-4d32-9898-8661bb511710" +version = "0.1.9" + +[[deps.SciMLOperators]] +deps = ["ArrayInterface", "DocStringExtensions", "Lazy", "LinearAlgebra", "Setfield", "SparseArrays", "StaticArraysCore", "Tricks"] +git-tree-sha1 = "51ae235ff058a64815e0a2c34b1db7578a06813d" +uuid = "c0aeaf25-5076-4817-a8d5-81caf7dfa961" +version = "0.3.7" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.Setfield]] +deps = ["ConstructionBase", "Future", "MacroTools", "StaticArraysCore"] +git-tree-sha1 = "e2cc6d8c88613c05e1defb55170bf5ff211fbeac" +uuid = "efcf1570-3423-57d1-acb7-fd33fddbac46" +version = "1.1.1" + +[[deps.SharedArrays]] +deps = ["Distributed", "Mmap", "Random", "Serialization"] +uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383" + +[[deps.SimpleNonlinearSolve]] +deps = ["ArrayInterface", "DiffEqBase", "FiniteDiff", "ForwardDiff", "LinearAlgebra", "PrecompileTools", "Reexport", "SciMLBase", "StaticArraysCore"] +git-tree-sha1 = "69b1a53374dd14d7c165d98cb646aeb5f36f8d07" +uuid = "727e6d20-b764-4bd8-a329-72de5adea6c7" +version = "0.1.25" + + [deps.SimpleNonlinearSolve.extensions] + SimpleNonlinearSolveNNlibExt = "NNlib" + + [deps.SimpleNonlinearSolve.weakdeps] + NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd" + +[[deps.SimpleTraits]] +deps = ["InteractiveUtils", "MacroTools"] +git-tree-sha1 = "5d7e3f4e11935503d3ecaf7186eac40602e7d231" +uuid = "699a6c99-e7fa-54fc-8d76-47d257e15c1d" +version = "0.9.4" + +[[deps.SimpleUnPack]] +git-tree-sha1 = "58e6353e72cde29b90a69527e56df1b5c3d8c437" +uuid = "ce78b400-467f-4804-87d8-8f486da07d0a" +version = "1.1.0" + +[[deps.Sobol]] +deps = ["DelimitedFiles", "Random"] +git-tree-sha1 = "5a74ac22a9daef23705f010f72c81d6925b19df8" +uuid = "ed01d8cd-4d21-5b2a-85b4-cc3bdc58bad4" +version = "1.5.0" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" + +[[deps.SortingAlgorithms]] +deps = ["DataStructures"] +git-tree-sha1 = "5165dfb9fd131cf0c6957a3a7605dede376e7b63" +uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c" +version = "1.2.0" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + +[[deps.SparseDiffTools]] +deps = ["ADTypes", "Adapt", "ArrayInterface", "Compat", "DataStructures", "FiniteDiff", "ForwardDiff", "Graphs", "LinearAlgebra", "PackageExtensionCompat", "Random", "Reexport", "SciMLOperators", "Setfield", "SparseArrays", "StaticArrayInterface", "StaticArrays", "Tricks", "UnPack", "VertexSafeGraphs"] +git-tree-sha1 = "ddea63e5de5405878d990a2cea4fc1daf2d52d41" +uuid = "47a9eef4-7e08-11e9-0b38-333d64bd3804" +version = "2.14.0" + + [deps.SparseDiffTools.extensions] + SparseDiffToolsEnzymeExt = "Enzyme" + SparseDiffToolsSymbolicsExt = "Symbolics" + SparseDiffToolsZygoteExt = "Zygote" + + [deps.SparseDiffTools.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.Sparspak]] +deps = ["Libdl", "LinearAlgebra", "Logging", "OffsetArrays", "Printf", "SparseArrays", "Test"] +git-tree-sha1 = "342cf4b449c299d8d1ceaf00b7a49f4fbc7940e7" +uuid = "e56a9233-b9d6-4f03-8d0f-1825330902ac" +version = "0.3.9" + +[[deps.SpecialFunctions]] +deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] +git-tree-sha1 = "e2cfc4012a19088254b3950b85c3c1d8882d864d" +uuid = "276daf66-3868-5448-9aa4-cd146d93841b" +version = "2.3.1" + + [deps.SpecialFunctions.extensions] + SpecialFunctionsChainRulesCoreExt = "ChainRulesCore" + + [deps.SpecialFunctions.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + +[[deps.Static]] +deps = ["IfElse"] +git-tree-sha1 = "f295e0a1da4ca425659c57441bcb59abb035a4bc" +uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +version = "0.8.8" + +[[deps.StaticArrayInterface]] +deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "Requires", "SparseArrays", "Static", "SuiteSparse"] +git-tree-sha1 = "5d66818a39bb04bf328e92bc933ec5b4ee88e436" +uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" +version = "1.5.0" +weakdeps = ["OffsetArrays", "StaticArrays"] + + [deps.StaticArrayInterface.extensions] + StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" + StaticArrayInterfaceStaticArraysExt = "StaticArrays" + +[[deps.StaticArrays]] +deps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"] +git-tree-sha1 = "5ef59aea6f18c25168842bded46b16662141ab87" +uuid = "90137ffa-7385-5640-81b9-e52037218182" +version = "1.7.0" +weakdeps = ["Statistics"] + + [deps.StaticArrays.extensions] + StaticArraysStatisticsExt = "Statistics" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "36b3d696ce6366023a0ea192b4cd442268995a0d" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.2" + +[[deps.Statistics]] +deps = ["LinearAlgebra", "SparseArrays"] +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.9.0" + +[[deps.StatsAPI]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "1ff449ad350c9c4cbc756624d6f8a8c3ef56d3ed" +uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0" +version = "1.7.0" + +[[deps.StatsBase]] +deps = ["DataAPI", "DataStructures", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"] +git-tree-sha1 = "1d77abd07f617c4868c33d4f5b9e1dbb2643c9cf" +uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +version = "0.34.2" + +[[deps.StatsFuns]] +deps = ["HypergeometricFunctions", "IrrationalConstants", "LogExpFunctions", "Reexport", "Rmath", "SpecialFunctions"] +git-tree-sha1 = "f625d686d5a88bcd2b15cd81f18f98186fdc0c9a" +uuid = "4c63d2b9-4356-54db-8cca-17b64c39e42c" +version = "1.3.0" + + [deps.StatsFuns.extensions] + StatsFunsChainRulesCoreExt = "ChainRulesCore" + StatsFunsInverseFunctionsExt = "InverseFunctions" + + [deps.StatsFuns.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + InverseFunctions = "3587e190-3f89-42d0-90ee-14403ec27112" + +[[deps.SteadyStateDiffEq]] +deps = ["DiffEqBase", "DiffEqCallbacks", "LinearAlgebra", "NLsolve", "Reexport", "SciMLBase"] +git-tree-sha1 = "2ca69f4be3294e4cd987d83d6019037d420d9fc1" +uuid = "9672c7b4-1e72-59bd-8a11-6ac3964bc41f" +version = "1.16.1" + +[[deps.StochasticDiffEq]] +deps = ["Adapt", "ArrayInterface", "DataStructures", "DiffEqBase", "DiffEqNoiseProcess", "DocStringExtensions", "FiniteDiff", "ForwardDiff", "JumpProcesses", "LevyArea", "LinearAlgebra", "Logging", "MuladdMacro", "NLsolve", "OrdinaryDiffEq", "Random", "RandomNumbers", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLOperators", "SparseArrays", "SparseDiffTools", "StaticArrays", "UnPack"] +git-tree-sha1 = "753219de57ac7aab0feb88871d3c51e0eb5e3b03" +uuid = "789caeaf-c7a9-5a7d-9973-96adeb23e2a0" +version = "6.64.0" + +[[deps.StrideArraysCore]] +deps = ["ArrayInterface", "CloseOpenIntervals", "IfElse", "LayoutPointers", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface", "ThreadingUtilities"] +git-tree-sha1 = "d6415f66f3d89c615929af907fdc6a3e17af0d8c" +uuid = "7792a7ef-975c-4747-a70f-980b88e8d1da" +version = "0.5.2" + +[[deps.SuiteSparse]] +deps = ["Libdl", "LinearAlgebra", "Serialization", "SparseArrays"] +uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "Libdl", "Pkg", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "5.10.1+6" + +[[deps.Sundials]] +deps = ["CEnum", "DataStructures", "DiffEqBase", "Libdl", "LinearAlgebra", "Logging", "PrecompileTools", "Reexport", "SciMLBase", "SparseArrays", "Sundials_jll"] +git-tree-sha1 = "f8992f3fe2388e0de5f67376ce6aaf4c90b4ee4c" +uuid = "c3572dad-4567-51f8-b174-8c6c989267f4" +version = "4.22.1" + +[[deps.Sundials_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "OpenBLAS_jll", "Pkg", "SuiteSparse_jll"] +git-tree-sha1 = "04777432d74ec5bc91ca047c9e0e0fd7f81acdb6" +uuid = "fb77eaff-e24c-56d4-86b1-d163f2edb164" +version = "5.2.1+0" + +[[deps.SymbolicIndexingInterface]] +deps = ["DocStringExtensions"] +git-tree-sha1 = "f8ab052bfcbdb9b48fad2c80c873aa0d0344dfe5" +uuid = "2efcf032-c050-4f8e-a9bb-153293bab1f5" +version = "0.2.2" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.1" + +[[deps.Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "LinearAlgebra", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "cb76cf677714c095e535e3501ac7954732aeea2d" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.11.1" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.Test]] +deps = ["InteractiveUtils", "Logging", "Random", "Serialization"] +uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.ThreadingUtilities]] +deps = ["ManualMemory"] +git-tree-sha1 = "eda08f7e9818eb53661b3deb74e3159460dfbc27" +uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" +version = "0.5.2" + +[[deps.TriangularSolve]] +deps = ["CloseOpenIntervals", "IfElse", "LayoutPointers", "LinearAlgebra", "LoopVectorization", "Polyester", "Static", "VectorizationBase"] +git-tree-sha1 = "fadebab77bf3ae041f77346dd1c290173da5a443" +uuid = "d5829a12-d9aa-46ab-831f-fb7c9ab06edf" +version = "0.1.20" + +[[deps.Tricks]] +git-tree-sha1 = "eae1bb484cd63b36999ee58be2de6c178105112f" +uuid = "410a4b4d-49e4-4fbc-ab6d-cb71b17b3775" +version = "0.1.8" + +[[deps.TruncatedStacktraces]] +deps = ["InteractiveUtils", "MacroTools", "Preferences"] +git-tree-sha1 = "ea3e54c2bdde39062abf5a9758a23735558705e1" +uuid = "781d530d-4396-4725-bb49-402e4bee1e77" +version = "1.4.0" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" + +[[deps.UnPack]] +git-tree-sha1 = "387c1f73762231e86e0c9c5443ce3b4a0a9a0c2b" +uuid = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" +version = "1.0.2" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" + +[[deps.VectorizationBase]] +deps = ["ArrayInterface", "CPUSummary", "HostCPUFeatures", "IfElse", "LayoutPointers", "Libdl", "LinearAlgebra", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "7209df901e6ed7489fe9b7aa3e46fb788e15db85" +uuid = "3d5dd08c-fd9d-11e8-17fa-ed2836048c2f" +version = "0.21.65" + +[[deps.VertexSafeGraphs]] +deps = ["Graphs"] +git-tree-sha1 = "8351f8d73d7e880bfc042a8b6922684ebeafb35c" +uuid = "19fa3120-7c27-5ec5-8db8-b0b0aa330d6f" +version = "0.2.0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.2.13+0" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.8.0+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.48.0+0" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.4.0+0" diff --git a/benchmarks/Project.toml b/benchmarks/Project.toml new file mode 100644 index 0000000..541dee7 --- /dev/null +++ b/benchmarks/Project.toml @@ -0,0 +1,3 @@ +[deps] +BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" +DifferentialEquations = "0c46a032-eb83-5123-abaf-570d42b7fbaa" diff --git a/benchmarks/rabi-diffeq.jl b/benchmarks/rabi-diffeq.jl new file mode 100644 index 0000000..1c2de1a --- /dev/null +++ b/benchmarks/rabi-diffeq.jl @@ -0,0 +1,19 @@ +using DifferentialEquations +using BenchmarkTools + + +function f(du, u, p, t) + g(t) = 2.2*2π*sin(2π*t) + + du[1] = -1im * g(t)/2 * u[2] + du[2] = -1im * g(t)/2 * u[1] +end + +u0 = ComplexF64[1.0, 0.0] +tspan = (0.0, 2π) +prob = ODEProblem(f, u0, tspan) +# get precompilation out of the way +sol = solve(prob, DP5(), reltol=1e-10, abstol=1e-10) + +# terminate benchmark after maximum of 5 minutes +@benchmark solve(prob, DP5(), reltol=1e-10, abstol=1e-10) samples=10000 evals=5 seconds=300 \ No newline at end of file diff --git a/benchmarks/rabi-dormand-prince.jl b/benchmarks/rabi-dormand-prince.jl new file mode 100644 index 0000000..097d72c --- /dev/null +++ b/benchmarks/rabi-dormand-prince.jl @@ -0,0 +1,19 @@ +using BenchmarkTools +using DormandPrince:DP5Solver, dopri5 + +function fcn(x, y, f) + g(x) = 2.2*2π*sin(2π*x) + + f[1] = -1im * g(x)/2 * y[2] + f[2] = -1im * g(x)/2 * y[1] +end + +solver = DP5Solver( + fcn, + 0.0, + ComplexF64[1.0, 0.0] +) + +dopri5(solver, 2π) + +@benchmark dopri5(clean_solver, 2π) setup=(clean_solver = DP5Solver(fcn, 0.0, ComplexF64[1.0, 0.0])) samples=10000 evals=5 seconds=500 \ No newline at end of file diff --git a/docs/Project.toml b/docs/Project.toml new file mode 100644 index 0000000..9245e0d --- /dev/null +++ b/docs/Project.toml @@ -0,0 +1,7 @@ +[deps] +DocThemeIndigo = "8bac0ac5-51bf-41f9-885e-2bf1ac2bec5f" +Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4" +DormandPrince = "5e45e72d-22b8-4dd0-9c8b-f96714864bcd" + +[compat] +DocThemeIndigo = "0.1.1" diff --git a/docs/make.jl b/docs/make.jl new file mode 100644 index 0000000..023ce5f --- /dev/null +++ b/docs/make.jl @@ -0,0 +1,21 @@ +using Documenter +using DormandPrince +using DocThemeIndigo + +indigo = DocThemeIndigo.install(Configurations) + +makedocs(; + modules = [DormandPrince], + format = Documenter.HTML( + prettyurls = !("local" in ARGS), + canonical="https://John Long.github.io/DormandPrince.jl", + assets=String[indigo], + ), + pages = [ + "Home" => "index.md", + ], + repo = "https://github.com/John Long/DormandPrince.jl", + sitename = "DormandPrince.jl", +) + +deploydocs(; repo = "https://github.com/John Long/DormandPrince.jl") diff --git a/docs/src/index.md b/docs/src/index.md new file mode 100644 index 0000000..eaac378 --- /dev/null +++ b/docs/src/index.md @@ -0,0 +1,14 @@ +```@meta +CurrentModule = DormandPrince +``` + +# DormandPrince + +Documentation for [DormandPrince](https://github.com/John Long/DormandPrince.jl). + +```@index +``` + +```@autodocs +Modules = [DormandPrince] +``` diff --git a/original-files/Project.toml b/original-files/Project.toml deleted file mode 100644 index 2b33c23..0000000 --- a/original-files/Project.toml +++ /dev/null @@ -1,6 +0,0 @@ -[deps] -BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" -Bloqade = "bd27d05e-4ce1-5e79-84dd-c5d7d508bbe1" -DifferentialEquations = "0c46a032-eb83-5123-abaf-570d42b7fbaa" -JET = "c3a54625-cd67-489e-a8e7-0a5a0ff4e31b" -OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" diff --git a/original-files/benchmarks/dp5_profile_calls.jl b/original-files/benchmarks/dp5_profile_calls.jl deleted file mode 100644 index 7a10aee..0000000 --- a/original-files/benchmarks/dp5_profile_calls.jl +++ /dev/null @@ -1,31 +0,0 @@ -include("../solver.jl") -include("../types.jl") - -# fcn(x,y,f) -## f is the end result of the derivative itself -## x is the dependent variable -## y is y(x) -function fcn(x,y,f) - f[1] = -15.0*y[1] -end - -@kwdef mutable struct CounterFunc{F} - fun::F - counter::Int64 = 0 -end - -function (f::CounterFunc)(x...) - f.counter += 1 - return f.fun(x...) -end - -f = CounterFunc(fun = fcn) - -solver = DP5Solver( - f, - 0.0, # initial x - [1.0] # initial y at x -) - -dopri5(solver, 0.5) - diff --git a/original-files/benchmarks/ordinarydiffeq_profile_calls.jl b/original-files/benchmarks/ordinarydiffeq_profile_calls.jl deleted file mode 100644 index c06ccde..0000000 --- a/original-files/benchmarks/ordinarydiffeq_profile_calls.jl +++ /dev/null @@ -1,26 +0,0 @@ -using DifferentialEquations -call_count = 0 - -function f(u, p, t) - global call_count += 1 - return -15.0 * u -end - -#=- -@kwdef mutable struct CounterFunc{F} - fun::F - counter::Int64 = 0 -end - -function (f::CounterFunc)(x...) - f.counter += 1 - return f.fun(x...) -end - -counted_f = CounterFunc(fun = f) -=# - -u0 = 1 -tspan = (0.0, 0.5) -prob = ODEProblem(f, u0, tspan) -sol = solve(prob, DP5(), reltol = 1e-10, abstol = 1e-10) \ No newline at end of file diff --git a/original-files/benchmarks/single_atom_bloqade.jl b/original-files/benchmarks/single_atom_bloqade.jl deleted file mode 100644 index 078ce85..0000000 --- a/original-files/benchmarks/single_atom_bloqade.jl +++ /dev/null @@ -1,19 +0,0 @@ -using Bloqade -using BenchmarkTools - -function generate_clean_problem() - atoms = generate_sites(ChainLattice(), 1, scale = 5.74) - h = rydberg_h(atoms; Ω = 20 * 2π, Δ = 0) - reg = zero_state(1) - - prob = SchrodingerProblem(reg, 1.6, h; algo=DP8()) - - return prob -end - -emulate!(generate_clean_problem()) - -# b = @benchmark emulate!(clean_problem) samples=100 evals=1 seconds=172800 setup=(clean_problem=SchrodingerProblem(deepcopy(reg), 1.6, h)) -b = @benchmark emulate!(clean_problem) samples=10000 evals=5 seconds=172800 setup=(clean_problem=generate_clean_problem()) - -# statevec(prob.reg) \ No newline at end of file diff --git a/original-files/benchmarks/single_atom_dp5.jl b/original-files/benchmarks/single_atom_dp5.jl deleted file mode 100644 index 36c1641..0000000 --- a/original-files/benchmarks/single_atom_dp5.jl +++ /dev/null @@ -1,43 +0,0 @@ -include("../solver.jl") -include("../types.jl") -using Bloqade -using BloqadeExpr: Hamiltonian -using BenchmarkTools - -function generate_clean_solver() - nsites = 1; - atoms = generate_sites(ChainLattice(), nsites, scale = 5.74) - h = rydberg_h(atoms; Ω = 20 * 2π, Δ = 0) - reg = zero_state(1) - # stop short of creating the SchrodingerProblem, we want the SchrodignerEquation - # which we can than trivially wrap with the fcn(n,x,y,f) that DP5 accepts - - # Generate SchrodingerEquation - state = statevec(reg) - space = YaoSubspaceArrayReg.space(reg) - T = real(eltype(state)) - T = isreal(h) ? T : Complex{T} - eq = SchrodingerEquation(h, Hamiltonian(T, h, space)) - - function fcn(x, y, f) - eq(f, y, nothing, x) - end - - y = statevec(reg) - - solver = DP5Solver( - fcn, - 0.0, - y - ) - - return solver -end - -# invoke eq via eq(dstate, state, p, t::Number) - -# trigger precompilation -dopri5(generate_clean_solver(), 1.6) - -# b = @benchmark dopri5(clean_solver, 1.6) samples=100 evals=1 seconds=172800 setup=(clean_solver = DP5Solver(fcn, 0.0, deepcopy(y))) -@benchmark dopri5(clean_solver, 1.6) samples=10000 evals=5 seconds=172800 setup=(clean_solver = generate_clean_solver()) \ No newline at end of file diff --git a/original-files/benchmarks/struct_profiler.jl b/original-files/benchmarks/struct_profiler.jl deleted file mode 100644 index 8c46cc9..0000000 --- a/original-files/benchmarks/struct_profiler.jl +++ /dev/null @@ -1,12 +0,0 @@ -# recommended by Phillip Weinberg -# for profiling the number of calls to the ODE function - -@kwdef mutable struct CounterFunc{F} - fun::F - counter::Int64 = 0 -end - -function (f::CounterFunc)(x...) - f.counter += 1 - return f.fun(x...) -end \ No newline at end of file diff --git a/original-files/classic_dp5/dp5.jl b/original-files/classic_dp5/dp5.jl deleted file mode 100644 index dd50eb8..0000000 --- a/original-files/classic_dp5/dp5.jl +++ /dev/null @@ -1,514 +0,0 @@ -# include("dp5_types.jl") -using Base.Iterators:repeated - -function dopri5( - n, - fcn, - x, # mutate - y, # mutate - xend, - rtol, - atol, - options, - work, -) - - arret = false - - ###### nmax - maximal number of steps - if options.maximum_allowed_steps < 0 - if options.print_error_messages - println("Maximum Allowed steps cannot be negative") - end - arret = true - end - - nmax = options.maximum_allowed_steps - - ###### nstiff - parameters for stiffness detection - nstiff = options.stiffness_test_activation_step - - if nstiff < 0 - nstiff = nmax + 10 - end - - ###### uround - smallest number satisfying 1.0 + uround > 1.0 - - uround = options.uround - if (uround <= 1e-35) || (uround >= 1.0) - if options.print_error_messages - println("WHICH MACHINE DO YOU HAVE? YOUR UROUND WAS:", work[1]) - end - arret = true - end - - ####### safety factor - safe = options.safety_factor - - if (safe >= 1.0) || (safe <= 1e-4) - if options.print_error_messages - println("CURIOUS INPUT FOR SAFETY FACTOR WORK[2]=", work[2]) - end - arret = true - end - - ###### fac1, fac2 - parameters for step size selection - fac1 = options.step_size_selection_one - fac2 = options.step_size_selection_two - - ###### beta - for step control stabilization - - beta = options.beta - if beta > 0.2 - if options.print_error_messages - println("CURIOUS INPUT FOR BETA: ", beta) - end - arret = true - end - - ####### maximal step size - - if work[6] == 0.0 - hmax = xend-x - else - hmax = options.maximal_step_size - end - - ####### initial step size - h = options.initial_step_size - - ####### prepare entry-points for arrays in work - iey1 = 1 - iek1 = iey1 + n - iek2 = iek1 + n - iek3 = iek2 + n - iek4 = iek3 + n - iek5 = iek4 + n - iek6 = iek5 + n - ieys = iek6 + n - - ####### total storage requirement - istore = ieys - if istore > length(work) - if options.print_error_messages - println("INSUFFICIENT STORAGE FOR WORK, MIN. LWORK=", istore) - end - arret = true - end - - ###### When a fail has occurred, return with idid = -1 - if arret - return DP5Report(x, -1, 0, 0, 0, 0) - end - - # indices to work start at the starting locations but for a view we need - dp5_report = dopcor( - n, fcn, x, y, xend, hmax, h, rtol, atol, nmax, uround, nstiff, - safe, beta, fac1, fac2, - #view(work, iey1:iey1+n-1), - view(work, iek1:iek1+n-1), - view(work, iek2:iek2+n-1), - view(work, iek3:iek3+n-1), - view(work, iek4:iek4+n-1), - view(work, iek5:iek5+n-1), - view(work, iek6:iek6+n-1), - #view(work, ieys:ieys+n-1) - ) - - return dp5_report - -end - -# return idid, x, StepsEvalReport -function dopcor( - n, - fcn, - x, - y, - xend, - hmax, - h, - rtol, - atol, - nmax, - uround, - nstiff, - safe, - beta, - fac1, - fac2, - #y1, - k1, - k2, - k3, - k4, - k5, - k6, - #ysti -) - ##### Initializations - - coeffs = cdopri() - c2 = coeffs[1] - c3 = coeffs[2] - c4 = coeffs[3] - c5 = coeffs[4] - a21 = coeffs[5] - a31 = coeffs[6] - a32 = coeffs[7] - a41 = coeffs[8] - a42 = coeffs[9] - a43 = coeffs[10] - a51 = coeffs[11] - a52 = coeffs[12] - a53 = coeffs[13] - a54 = coeffs[14] - a61 = coeffs[15] - a62 = coeffs[16] - a63 = coeffs[17] - a64 = coeffs[18] - a65 = coeffs[19] - a71 = coeffs[20] - a73 = coeffs[21] - a74 = coeffs[22] - a75 = coeffs[23] - a76 = coeffs[24] - e1 = coeffs[25] - e3 = coeffs[26] - e4 = coeffs[27] - e5 = coeffs[28] - e6 = coeffs[29] - e7 = coeffs[30] - - facold = 1e-4 - expo1 = 0.20-beta*0.75 - facc1 = 1.0/fac1 - facc2 = 1.0/fac2 - posneg = sign(1.0, xend-x) - - ###### Initial Preparations - nfcn = 0 - nstep = 0 - naccpt = 0 - nrejct = 0 - - #atoli = atol[1] # works with integers or arrays - #rtoli = rtol[1] # works with integers or arrays - atol_iter = atol isa Number ? repeated(atol) : atol - rtol_iter = rtol isa Number ? repeated(rtol) : rtol - - last = false - hlamb = 0.0 - iasti = 0 - nonsti = 0 - fcn(n, x, y, k1) - hmax = abs(hmax) - iord = 5 - - if h == 0.0 - h = hinit(n, fcn, x, y, xend, posneg, k1, k2, k3, iord, hmax, atol, rtol) - end - - nfcn += 2 - reject = false - - - ###### Basic Integration Step - xph = 0.0 # need to put this here because FORTRAN seems to be looser with scoping - while true - if nstep > nmax - # GOTO 78 - println(" MORE THAN NMAX = ", nmax, " STEPS ARE NEEDED") - return DP5Report(x, -2, 0, 0, 0, 0) - end - - if (0.10 * abs(h)) <= abs(x)*uround - # GOTO 77 - println("STEP SIZE TOO SMALL, H = ", h) - return DP5Report(x, -3, 0, 0, 0, 0) - end - - if ((x+1.01*h-xend)*posneg) > 0.0 - h = xend-x - last = true - end - - nstep += 1 - - ####### First 6 stages, just set to equality and should work bc everything is vector (no need for loops) - # 22 - y1 = y + h * a21 * k1 - fcn(n, x + c2 * h, y1, k2) - # 23 - y1 = y + h * ( a31 * k1 + a32 * k2) - fcn(n, x + c3 * h, y1, k3) - # 24 - y1 = y + h * (a41 * k1 + a42 * k2 + a43 * k3) - fcn(n, x + c4 * h, y1, k4) - # 25 - y1 = y + h * (a51 * k1 + a52 * k2 + a53 * k3 + a54 * k4) - fcn(n, x+c5*h, y1, k5) - # 26 - ysti = y + h * (a61 * k1 + a62 * k2 + a63 * k3 + a64 * k4 + a65 * k5) - xph = x + h - fcn(n, xph, ysti, k6) - # 27 - y1 = y + h * (a71 * k1 + a73 * k3 + a74 * k4 + a75 * k5 + a76 * k6) - fcn(n, xph, y1, k2) - # 28 - k4 = h * (e1 * k1 + e3 * k3 + e4 * k4 + e5 * k5 + e6 * k6 + e7 * k2) - - nfcn += 6 - - ###### Error Estimation - err = 0.0 - - #= - if itol == 0 # do some kind of reduction here - for i in range(1, n) - sk = atoli + rtoli*max(abs(y[i]), abs(y1[i])) - err += abs(k4[i]/sk)^2 - end - else - for i in range(1, n) - sk = atoli[i] + rtoli[i]*max(abs(y[i]), abs(y1[i])) - err += abs(k4[i]/sk)^2 - end - end - =# - - err = mapreduce(+, atol_iter, rtol_iter, k4, y, ysti) do atoli, rtoli, k4i, yi, ystii - sk = atoli + rtoli*max(abs(yi), abs(ystii)) - abs(k4i/sk)^2 - end - - err = sqrt(err/n) - - ###### Computation of hnew - fac11 = err^expo1 - ###### Lund-Stabilization - fac = fac11/(facold^beta) - ###### we require fac1 <= hnew/h <= fac2 - fac = max(facc2, min(facc1, fac/safe)) # facc1, facc2, fac must be Float64 - hnew = h/fac - if err <= 1.0 - ###### Step is accepted - facold = max(err, 1e-4) - naccpt += 1 - ###### Stiffness Detection - if (mod(naccpt, nstiff) == 0) || (iasti > 0) - stnum = 0.0 - stden = 0.0 - - #= - for i in range(1, n) - stnum += abs(k2[i]-k6[i])^2 # added "abs" per Phillip's advice - stden += abs(y1[i]-ysti[i])^2 - end - =# - - stnum, stden = mapreduce(.+, k2, k6, y1, ysti) do k2i, k6i, y1i, ystii - stnum = abs(k2i-k6i)^2 - stden = abs(y1i-ystii)^2 - stnum, stden - end - - if stden > 0.0 - hlamb = h*sqrt(stnum/stden) - end - - - if hlamb > 3.25 - iasti += 1 - if iasti == 15 - println("THE PROBLEM SEEMS TO BECOME STIFF AT X = ", x) - end - else - nonsti += 1 - if nonsti == 6 - iasti = 0 - end - end - end - - # 44 - #= - for i in range(1, n) - k1[i] = k2[i] - y[i] = y1[i] - end - =# - copyto!(k1, k2) - copyto!(y, y1) - - x = xph - - ###### Normal Exit - if last - h = hnew - return DP5Report( - x, - 1, - nfcn, - nstep, - naccpt, - nrejct - ) - end - - if(abs(hnew) > hmax) - hnew = posneg*hmax - end - - if reject - hnew = posneg*min(abs(hnew), abs(h)) - end - reject = false - else - ###### Step is rejected - hnew = h/min(facc1, fac11/safe) - reject = true - if naccpt > 1 - nrejct += 1 - end - last = false - - end - h = hnew - end - -end - -function hinit( - n, - fcn, - x, - y, - xend, - posneg, - f0, - f1, - y1, - iord, - hmax, - atol, - rtol, -) - #= - Compute a first guess for explicit euler as - h = 0.01 * norm (y0) / norm (f0) - the increment for explicit euler is small - compared to the solution - =# - dnf = 0.0 - dny = 0.0 - #atoli = atol[1] - #rtoli = rtol[1] - - # [dnf, dny] = mapreduce(+, atol, rtol, f0, y; init=[0.0, 0.0]) do (atoli, rtoli, f0i, yi) - # sk = atoli + rtoli*abs(yi) - # dnf = abs(f0i/sk)^2 - # dny = abs(yi/sk)^2 - # [dnf, dny] - # end - - - atol_iter = atol isa Number ? repeated(atol) : atol - rtol_iter = rtol isa Number ? repeated(rtol) : rtol - - dnf, dny = mapreduce(.+, atol_iter, rtol_iter, f0, y) do atoli, rtoli, f0i, yi - sk = atoli + rtoli*abs(yi) - dnf = abs(f0i/sk)^2 - dny = abs(yi/sk)^2 - dnf, dny - end - - - - # problem with comparing ComplexF64 with Float64 - # take abs of dnf - if (dnf <= 1.0e-10) || (dny <= 1.0e-10) - h = 1.0e-6 - else - h = 0.01*sqrt(dny/dnf) - end - h = min(h, hmax) - h = sign(h, posneg) - - ###### Perform an explicit step - #= - for i in range(1, n) - y1[i] = y[i] + h*f0[i] - end - =# - y1 = y + h*f0 - fcn(n, x+h, y1, f1) - ###### Estimate the second derivative of the solution - der2 = 0.0 - - der2 = mapreduce(+, atol_iter, rtol_iter, f1, f0, y) do atoli, rtoli, f1i, f0i, yi - sk = atoli + rtoli*abs(yi) - ((f1i-f0i)/sk)^2 - end - - der2 = sqrt(der2)/h - - ##### Step size is computed such that - ##### H**IORD * MAX ( NORM(F0), NORM(F1), DER2 ) = 0.01 - der12 = max(abs(der2), sqrt(dnf)) - if der12 <= 1e-15 - h1 = max(1.0e-6, abs(h)*1.0e-3) - else - h1 = (0.01/der12)^(1.0/iord) - end - h = min(100*abs(h), h1, hmax) - return sign(h, posneg) - -end - -function cdopri() - - return [ - 0.2, #C2 - 0.3, #C3 - 0.8, #C4 - 8.0/9.0, #C5 - 0.2, #A21 - 3.0/40.0, #A31 - 9.0/40.0, #A32 - 44.0/45.0, #A4 - -56.0/15.0, #A42 - 32.0/9.0, #A43 - 19372.0/6561.0, #A52 - -25360.0/2187.0, # - 64448.0/6561.0, - -212.0/729.0, - 9017.0/3168.0, - -355.0/33.0, - 46732.0/5247.0, - 49.0/176.0, - -5103.0/18656.0, - 35.0/384.0, - 500.0/1113.0, - 125.0/192.0, - -2187.0/6784.0, - 11.0/84.0, - 71.0/57600.0, - -71.0/16695.0, - 71.0/1920.0, - -17253.0/339200.0, - 22.0/525.0, - -1.0/40.0 - ] -end - -# FORTRAN sign - returns the value of A with the sign of B -function sign(a,b) - if b >= 0 - sign = 1.0 - else - sign = -1.0 - end - - return a*sign -end \ No newline at end of file diff --git a/original-files/classic_dp5/test_dp5.jl b/original-files/classic_dp5/test_dp5.jl deleted file mode 100644 index 657fedd..0000000 --- a/original-files/classic_dp5/test_dp5.jl +++ /dev/null @@ -1,24 +0,0 @@ -include("dp5.jl") -include("dp5_types.jl") - -# FCN must follow format FCN(N, X, Y, F, RPAR, IPAR) - -function fcn(n, x, y, f) - f[1] = ℯ^x - f[2] = ℯ^x -end - -y = [1.0, 1.0] -work = zeros(16) - -dopri5( - 2, - fcn, - 0.0, - y, - 1.0, - 1e-10, - 1e-10, - DP5Options(), - work,# work, should be 8*N -) \ No newline at end of file diff --git a/original-files/classic_dp5/test_schrodinger_eq.jl b/original-files/classic_dp5/test_schrodinger_eq.jl deleted file mode 100644 index 8781438..0000000 --- a/original-files/classic_dp5/test_schrodinger_eq.jl +++ /dev/null @@ -1,41 +0,0 @@ -using Bloqade -using BloqadeExpr: Hamiltonian -include("dp5.jl") -include("dp5_types.jl") - -nsites = 1; -atoms = generate_sites(ChainLattice(), nsites, scale = 5.74) -h = rydberg_h(atoms; Ω = 11 * 2π, Δ = 0) -reg = zero_state(1) -# stop short of creating the SchrodingerProblem, we want the SchrodignerEquation -# which we can than trivially wrap with the fcn(n,x,y,f) that DP5 accepts - -# Generate SchrodingerEquation -state = statevec(reg) -space = YaoSubspaceArrayReg.space(reg) -T = real(eltype(state)) -T = isreal(h) ? T : Complex{T} -eq = SchrodingerEquation(h, Hamiltonian(T, h, space)) -# invoke eq via eq(dstate, state, p, t::Number) - -function fcn(n, x, y, f) - eq(f, y, nothing, x) -end - -# y = [zeros(ComplexF64, 2)] # initial y_0 at x = 0`` -y = statevec(reg) -# work = [zeros(ComplexF64, 2) for i in range(1,8)] -work = zeros(ComplexF64, 16) - -dopri5( - 2, - fcn, - 0.0, - y, - 1.6, - 1e-10, - 1e-10, - DP5Options(), - work,# work, should be 8*N -) - diff --git a/original-files/classic_dp5/test_stateful_dp5.jl b/original-files/classic_dp5/test_stateful_dp5.jl deleted file mode 100644 index 821bc91..0000000 --- a/original-files/classic_dp5/test_stateful_dp5.jl +++ /dev/null @@ -1,38 +0,0 @@ -include("dp5.jl") - - -# differential equation to solve for -function fcn(n, x, y, f) - f[1] = y[1] - x^2 + 1 -end - -# initial y -y = [0.5] - -# intermediate times to save -times = [1.0, 2.0, 3.0, 4.0] -# place to save values -values = [] -# initial x -x = 0.0 - -for t in times - xend = t - - dopri5( - 1, - fcn, - x, - y, - xend, - 1e-10, - 1e-10, - 0, - DP5Options(), - zeros(8),# work, should be 8*N + 5*NRDENS+21 = 8*2 + 5*0 + 21 - ) - - push!(values, y[1]) - global x = xend # set next initial x to last x - -end \ No newline at end of file diff --git a/original-files/integrate_test.jl b/original-files/integrate_test.jl deleted file mode 100644 index a82e7c6..0000000 --- a/original-files/integrate_test.jl +++ /dev/null @@ -1,45 +0,0 @@ -include("integrate.jl") - -using Bloqade -using BloqadeExpr: Hamiltonian - -nsites = 1; -atoms = generate_sites(ChainLattice(), nsites, scale = 5.74) -h = rydberg_h(atoms; Ω = 11 * 2π, Δ = 0) -reg = zero_state(1) - -state = statevec(reg) -space = YaoSubspaceArrayReg.space(reg) -T = real(eltype(state)) -T = isreal(h) ? T : Complex{T} -eq = SchrodingerEquation(h, Hamiltonian(T, h, space)) - -function fcn(x, y, f) - eq(f, y, nothing, x) -end - -y = statevec(reg) - -solver = DP5Solver( - fcn, - 0.0, - y -) - -iterator = integrate(solver, [1.8, 1.9, 2.0]) - - -for (t, y) in iterator - println(t) - println(y) -end - - -#= -function simple_callback(time, state) - println("State ", state, " at time ", time) - return copy(state) -end - -integrate(simple_callback, solver, [1.8, 1.9, 2.0]) -=# \ No newline at end of file diff --git a/original-files/phil-ode/phil-ode.jl b/original-files/phil-ode/phil-ode.jl deleted file mode 100644 index 486d910..0000000 --- a/original-files/phil-ode/phil-ode.jl +++ /dev/null @@ -1,15 +0,0 @@ -include("../types.jl") -include("../solver.jl") - -function fcn(x, y, f) - f[1] = -1im * y[2] - f[2] = -1im * y[1] -end - -solver = DP5Solver( - fcn, - 0.0, - ComplexF64[1.0, 0.0] -) - -dopri5(solver, 2π) \ No newline at end of file diff --git a/original-files/schrodinger_eq_reference.jl b/original-files/schrodinger_eq_reference.jl deleted file mode 100644 index e7de9d2..0000000 --- a/original-files/schrodinger_eq_reference.jl +++ /dev/null @@ -1,10 +0,0 @@ -using Bloqade - -atoms = generate_sites(ChainLattice(), 1, scale = 5.74) -h = rydberg_h(atoms; Ω = 20 * 2π, Δ = 0) -reg = zero_state(1) - -prob = SchrodingerProblem(reg, 1.6, h; algo=DP5()) -emulate!(prob) - -statevec(prob.reg) \ No newline at end of file diff --git a/original-files/solver_test.jl b/original-files/solver_test.jl deleted file mode 100644 index d18562c..0000000 --- a/original-files/solver_test.jl +++ /dev/null @@ -1,44 +0,0 @@ -include("solver.jl") -include("types.jl") -using Bloqade -using BloqadeExpr: Hamiltonian -using JET - -nsites = 1; -atoms = generate_sites(ChainLattice(), nsites, scale = 5.74) -h = rydberg_h(atoms; Ω = 20 * 2π, Δ = 0) -reg = zero_state(1) -# stop short of creating the SchrodingerProblem, we want the SchrodignerEquation -# which we can than trivially wrap with the fcn(n,x,y,f) that DP5 accepts - -# Generate SchrodingerEquation -state = statevec(reg) -space = YaoSubspaceArrayReg.space(reg) -T = real(eltype(state)) -T = isreal(h) ? T : Complex{T} -eq = SchrodingerEquation(h, Hamiltonian(T, h, space)) -# invoke eq via eq(dstate, state, p, t::Number) - -function fcn(x, y, f) - #println(y) - #println(x) - #println(f) - eq(f, y, nothing, x) -end - -y = statevec(reg) - -solver = DP5Solver( - fcn, - 0.0, - y -) - -#@report_opt dopri5(solver, 1.6) -# @code_warntype dopri5(solver, 1.6) -dopri5(solver, 1.6) - -# narrow down to Dopcor -## dopcor(solver, xend, hmax, h) -## @report_opt dopcor(solver, 1.6, 1.6, 0.0) - diff --git a/src/DormandPrince.jl b/src/DormandPrince.jl new file mode 100644 index 0000000..832347f --- /dev/null +++ b/src/DormandPrince.jl @@ -0,0 +1,10 @@ +module DormandPrince +using Base.Iterators:repeated, Repeated + +include("types.jl") +include("solver.jl") +include("integrate.jl") +include("checks.jl") +include("helpers.jl") + +end # DormandPrince diff --git a/original-files/checks.jl b/src/checks.jl similarity index 97% rename from original-files/checks.jl rename to src/checks.jl index ef87401..95465de 100644 --- a/original-files/checks.jl +++ b/src/checks.jl @@ -1,4 +1,4 @@ -include("types.jl") +# include("types.jl") # make enums for every error type and return that instead of printing errors function check_max_allowed_steps(options::DP5Options{T}) where T diff --git a/original-files/helpers.jl b/src/helpers.jl similarity index 88% rename from original-files/helpers.jl rename to src/helpers.jl index 47937cf..73a76cd 100644 --- a/original-files/helpers.jl +++ b/src/helpers.jl @@ -1,14 +1,3 @@ -# FORTRAN sign - returns the value of A with the sign of B -function sign(a,b) - if b >= 0 - sign = 1.0 - else - sign = -1.0 - end - - return a*sign -end - function do_step!(solver, h) # define constants @@ -43,27 +32,27 @@ function do_step!(solver, h) e6=22.0/525.0 e7=-1.0/40.0 - ####### First 6 stages, just set to equality and should work bc everything is vector (no need for loops) - # 22 + ####### First 6 stages + solver.y1 .= solver.y .+ h .* a21 .* solver.k1 solver.f(solver.vars.x + c2 * h, solver.y1, solver.k2) - # 23 + solver.y1 .= solver.y .+ h .* (a31 .* solver.k1 .+ a32 .* solver.k2) solver.f(solver.vars.x + c3 * h, solver.y1, solver.k3) - # 24 + solver.y1 .= solver.y .+ h .* (a41 .* solver.k1 .+ a42 .* solver.k2 .+ a43 .* solver.k3) solver.f(solver.vars.x + c4 * h, solver.y1, solver.k4) - # 25 + solver.y1 .= solver.y .+ h .* (a51 .* solver.k1 .+ a52 .* solver.k2 .+ a53 .* solver.k3 .+ a54 .* solver.k4) solver.f(solver.vars.x + c5*h, solver.y1, solver.k5) - # 26 + solver.ysti .= solver.y .+ h .* (a61 .* solver.k1 .+ a62 .* solver.k2 .+ a63 .* solver.k3 .+ a64 .* solver.k4 .+ a65 .* solver.k5) xph = solver.vars.x + h solver.f(xph, solver.ysti, solver.k6) - # 27 + solver.y1 .= solver.y .+ h .* (a71 .* solver.k1 .+ a73 .* solver.k3 .+ a74 .* solver.k4 .+ a75 .* solver.k5 .+ a76 .* solver.k6) solver.f(xph, solver.y1, solver.k2) - # 28 + solver.k4 .= h .* (e1 .* solver.k1 .+ e3 .* solver.k3 .+ e4 .* solver.k4 .+ e5 .* solver.k5 .+ e6 .* solver.k6 .+ e7 .* solver.k2) end @@ -115,7 +104,6 @@ function stiffness_detection!(solver, naccpt, h) if solver.vars.hlamb > 3.25 solver.vars.iasti += 1 if solver.vars.iasti == 15 - # turn this into a debug statement @debug "The problem seems to become stiff at $x" end else @@ -134,9 +122,7 @@ function euler_first_guess(solver, hmax, posneg) abs(f0i/sk)^2, abs(yi/sk)^2 # dnf, dny end - - # problem with comparing ComplexF64 with Float64 - # take abs of dnf + if (dnf <= 1.0e-10) || (dny <= 1.0e-10) h = 1.0e-6 else diff --git a/original-files/integrate.jl b/src/integrate.jl similarity index 66% rename from original-files/integrate.jl rename to src/integrate.jl index dd6e468..3066b8c 100644 --- a/original-files/integrate.jl +++ b/src/integrate.jl @@ -1,47 +1,3 @@ -#= -# low level interface: - -solver = DP5Solver(fcn,0,y0) -# low level interface -integrate(solver, 0.1) -# do stuff here -integrate(solver, 0.2) -# do stuff here -integrate(solver, 0.3) - -# iterator interface -# TODO: Check how to dispatch to Iterator of a specific type objects -iterator = integrate(solver, times) - -for t,y in iterator: - #do stuff -end - -# callback for each time in times -integrate(callback, solver, times) -> Vector - -results = integrate(solver, times) do t, state - # do stuff with t and state -end - - - -# 99% of use cases: -function integrate(callback, solver::DP5Solver{StateVec, T}, times::AbstractVector{T}; sort_times::Bool = true) where {StateVec, T} - times = sort_times ? sorted(collect(times)) : times - - result = [] - for time in times - integrate(solver, time) - push!(result, callback(time, solver.y)) - end -end -=# - -# integrate(solver, times) should return an iterator - -include("solver.jl") - mutable struct DP5Iterator{T <: Real} solver::DP5Solver times::AbstractVector{T} @@ -81,9 +37,10 @@ function Base.iterate(dp5_iterator::DP5Iterator, state) end # 3 modes of operation for integrate -# 1. integrate(solver, time) -> state +# 1. integrate(solver, time) -> state (modify solver object in place) # 2. integrate(solver, times) -> iterator # 3. integrate(callback, solver, times) -> vector of states with callback applied + integrate(solver::DP5Solver, time::Real) = dopri5(solver, time) integrate(solver::DP5Solver, times::AbstractVector{T}) where {T <: Real} = DP5Iterator(solver, times) diff --git a/original-files/solver.jl b/src/solver.jl similarity index 95% rename from original-files/solver.jl rename to src/solver.jl index a3b8bd0..5540843 100644 --- a/original-files/solver.jl +++ b/src/solver.jl @@ -1,7 +1,7 @@ -using Base.Iterators:repeated -include("types.jl") -include("checks.jl") -include("helpers.jl") +# using Base.Iterators:repeated +#include("types.jl") +#include("checks.jl") +#include("helpers.jl") function dopri5( solver, @@ -57,6 +57,9 @@ function dopri5( # update with final h solver.vars.h = h + # reset the necessary vars + solver.vars.last = false + return dp5_report end @@ -195,7 +198,8 @@ function hinit( ###### Perform an explicit step #y1 = y + h*f0 #fcn(n, x+h, y1, f1) - copyto!(solver.y1, solver.y + h*solver.k1) + # copyto!(solver.y1, solver.y + h*solver.k1) + solver.y1 .= solver.y .+ h .*solver.k1 solver.f(solver.vars.x + h, solver.k3, solver.k2) ###### Estimate the second derivative of the solution diff --git a/original-files/types.jl b/src/types.jl similarity index 98% rename from original-files/types.jl rename to src/types.jl index 7222b6c..fd34444 100644 --- a/original-files/types.jl +++ b/src/types.jl @@ -1,4 +1,4 @@ -using Base.Iterators:repeated, Repeated +# using Base.Iterators:repeated, Repeated @enum Idid begin COMPUTATION_SUCCESSFUL = 1 diff --git a/test/Manifest.toml b/test/Manifest.toml new file mode 100644 index 0000000..99e7320 --- /dev/null +++ b/test/Manifest.toml @@ -0,0 +1,59 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.9.3" +manifest_format = "2.0" +project_hash = "70c6548fc0267b7c924ca6e56c4af9fd2abca604" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.0.5+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" + +[[deps.Markdown]] +deps = ["Base64"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.21+4" + +[[deps.Random]] +deps = ["SHA", "Serialization"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "0.7.0" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.Test]] +deps = ["InteractiveUtils", "Logging", "Random", "Serialization"] +uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.8.0+0" diff --git a/test/Project.toml b/test/Project.toml new file mode 100644 index 0000000..a2cd2f8 --- /dev/null +++ b/test/Project.toml @@ -0,0 +1,3 @@ +[deps] +LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" diff --git a/test/exact_evol_helpers.jl b/test/exact_evol_helpers.jl new file mode 100644 index 0000000..c92f5a5 --- /dev/null +++ b/test/exact_evol_helpers.jl @@ -0,0 +1,16 @@ +function evolution_operator(t::Float64) + ϕ = 2.2 * sin(π * t)^2 + U = zeros(ComplexF64, 2,2) + U[1,1] = 1 / sqrt(2) + U[2,1] = 1 / sqrt(2) + U[2,2] = 1 / sqrt(2) + U[1,2] = -1 / sqrt(2) + + U * diagm(exp.([-im*ϕ, im*ϕ])) * U' +end + +function solution(t) + U = evolution_operator(t) + return U * [1.0, 0.0] + +end \ No newline at end of file diff --git a/test/runtests.jl b/test/runtests.jl new file mode 100644 index 0000000..0c6dda0 --- /dev/null +++ b/test/runtests.jl @@ -0,0 +1,85 @@ +using Test +using LinearAlgebra +using DormandPrince: DP5Solver, dopri5, integrate + +include("exact_evol_helpers.jl") + + +function fcn(x, y, f) + g(x) = 2.2*2π*sin(2π*x) + + f[1] = -1im * g(x)/2 * y[2] + f[2] = -1im * g(x)/2 * y[1] +end + +# standalone solver test +@testset "Integration Test" begin + solver = DP5Solver( + fcn, + 0.0, + ComplexF64[1.0, 0.0] + ) + + dopri5(solver, 2π) + + @test solver.y ≈ solution(2π) +end + +# Test integrate() +@testset "Integration Interface Test" begin + + # test iterator generation + @testset "Iterator Interface" begin + times = [0.1, 0.5, 1.1] + exact_values = [] + dp5_values = [] + + # get exact values + for t in times + push!(exact_values, solution(t)) + end + + # use iterator to get exact values + solver = DP5Solver( + fcn, + 0.0, + ComplexF64[1.0, 0.0] + ) + + iter = integrate(solver, times) + + for (t,y) in iter + push!(dp5_values, copy(y)) + end + + @test dp5_values ≈ exact_values + end + + @testset "Callback Interface" begin + times = [0.1, 0.5, 1.1] + callback_times = [] + exact_values = [] + dp5_values = [] + + # get exact values + for t in times + push!(exact_values, solution(t)) + end + + # use iterator to get exact values + solver = DP5Solver( + fcn, + 0.0, + ComplexF64[1.0, 0.0] + ) + + integrate(solver, times) do t, y + push!(callback_times, t) + push!(dp5_values, copy(y)) + end + + @test dp5_values ≈ exact_values + end +end + +