diff --git a/Manifest.toml b/Manifest.toml new file mode 100644 index 0000000..cfe6b1f --- /dev/null +++ b/Manifest.toml @@ -0,0 +1,2111 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.12.6" +manifest_format = "2.0" +project_hash = "539808533115e5c712b22dd31b3db229bc67f3a2" + +[[deps.ADTypes]] +git-tree-sha1 = "5970c86505ae9c07bf5bc521ef2bbbb3849e8b7b" +uuid = "47edcb42-4c32-4615-8424-f2b9edc5f35b" +version = "1.23.0" + + [deps.ADTypes.extensions] + ADTypesChainRulesCoreExt = "ChainRulesCore" + ADTypesConstructionBaseExt = "ConstructionBase" + ADTypesEnzymeCoreExt = "EnzymeCore" + + [deps.ADTypes.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + +[[deps.AMD]] +deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse_jll"] +git-tree-sha1 = "45a1272e3f809d36431e57ab22703c6896b8908f" +uuid = "14f7f29c-3bd6-536c-9a0b-7339e30b5a3e" +version = "0.5.3" + +[[deps.AbstractPlutoDingetjes]] +git-tree-sha1 = "6c3913f4e9bdf6ba3c08041a446fb1332716cbc2" +uuid = "6e696c72-6542-2067-7265-42206c756150" +version = "1.4.0" + +[[deps.AbstractTrees]] +git-tree-sha1 = "2d9c9a55f9c93e8887ad391fbae72f8ef55e1177" +uuid = "1520ce14-60c1-5f80-bbc7-55ef81b5835c" +version = "0.4.5" + +[[deps.Accessors]] +deps = ["CompositionsBase", "ConstructionBase", "Dates", "InverseFunctions", "MacroTools"] +git-tree-sha1 = "7063ad1083578215c7c4bf410368150abe8d5524" +uuid = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697" +version = "0.1.45" + + [deps.Accessors.extensions] + AxisKeysExt = "AxisKeys" + IntervalSetsExt = "IntervalSets" + LinearAlgebraExt = "LinearAlgebra" + StaticArraysExt = "StaticArrays" + StructArraysExt = "StructArrays" + TestExt = "Test" + UnitfulExt = "Unitful" + + [deps.Accessors.weakdeps] + AxisKeys = "94b1ba4f-4ee9-5380-92f1-94cde586c3c5" + IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.Adapt]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "daa72978cd7a624246e894a4f4f067706d4e17e2" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.7.0" +weakdeps = ["SparseArrays", "StaticArrays"] + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.2" + +[[deps.ArnoldiMethod]] +deps = ["LinearAlgebra", "Random", "StaticArrays"] +git-tree-sha1 = "d57bd3762d308bded22c3b82d033bff85f6195c6" +uuid = "ec485272-7323-5ecc-a04f-4719b315124d" +version = "0.4.0" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "60f11b38ebeabd984f5535838d91e197d97202f0" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.28.1" + + [deps.ArrayInterface.extensions] + ArrayInterfaceAMDGPUExt = "AMDGPU" + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = ["CUDSS", "CUDA"] + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" + ArrayInterfaceFillArraysExt = "FillArrays" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceMetalExt = "Metal" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.ArrayLayouts]] +deps = ["FillArrays", "LinearAlgebra", "StaticArrays"] +git-tree-sha1 = "e0b47732a192dd59b9d079a06d04235e2f833963" +uuid = "4c555306-a7a7-4459-81d9-ec55ddd5c99a" +version = "1.12.2" +weakdeps = ["SparseArrays"] + + [deps.ArrayLayouts.extensions] + ArrayLayoutsSparseArraysExt = "SparseArrays" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" + +[[deps.Atomix]] +deps = ["UnsafeAtomics"] +git-tree-sha1 = "b8651b2eb5796a386b0398a20b519a6a6150f75c" +uuid = "a9b6321e-bd34-4604-b9c9-b65b8de01458" +version = "1.1.3" + + [deps.Atomix.extensions] + AtomixCUDAExt = "CUDA" + AtomixMetalExt = "Metal" + AtomixOpenCLExt = "OpenCL" + AtomixoneAPIExt = "oneAPI" + + [deps.Atomix.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + OpenCL = "08131aa3-fb12-5dee-8b74-c09406e224a2" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.BandedMatrices]] +deps = ["ArrayLayouts", "FillArrays", "LinearAlgebra", "PrecompileTools"] +git-tree-sha1 = "02fa77c70ba84361b9bc9ff28523bd9d78519265" +uuid = "aae01518-5342-5314-be14-df237901396f" +version = "1.11.0" + + [deps.BandedMatrices.extensions] + BandedMatricesSparseArraysExt = "SparseArrays" + CliqueTreesExt = "CliqueTrees" + + [deps.BandedMatrices.weakdeps] + CliqueTrees = "60701a23-6482-424a-84db-faee86b9b1f8" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.Bijections]] +git-tree-sha1 = "a2d308fcd4c2fb90e943cf9cd2fbfa9c32b69733" +uuid = "e2ed5e7c-b2de-5872-ae92-c73ca462fb04" +version = "0.2.2" + +[[deps.BinaryHeaps]] +git-tree-sha1 = "25718f410ed710fda29a8122eb8f9dcdb640c5fc" +uuid = "b2a6c25c-c996-4615-94ab-6e519ffb8690" +version = "1.0.4" + +[[deps.BipartiteGraphs]] +deps = ["DataStructures", "DocStringExtensions", "Graphs", "PrecompileTools"] +git-tree-sha1 = "36379a1fde8938f379d5df2b12f3db887701f0bc" +uuid = "caf10ac8-0290-4205-88aa-f15908547e8d" +version = "0.1.11" +weakdeps = ["SparseArrays"] + + [deps.BipartiteGraphs.extensions] + BipartiteGraphsSparseArraysExt = "SparseArrays" + +[[deps.BlockArrays]] +deps = ["ArrayLayouts", "FillArrays", "LinearAlgebra"] +git-tree-sha1 = "75c9c4d41f387b58ac7ecac17a02062f4cf8e92a" +uuid = "8e7c35d0-a365-5155-bbbb-fb81a777f24e" +version = "1.10.0" +weakdeps = ["Adapt", "BandedMatrices"] + + [deps.BlockArrays.extensions] + BlockArraysAdaptExt = "Adapt" + BlockArraysBandedMatricesExt = "BandedMatrices" + +[[deps.BlockComponents]] +deps = ["DataInterpolations", "DataInterpolationsND", "DyadData", "DyadInterface", "Markdown", "ModelingToolkit", "Moshi", "OrdinaryDiffEqDefault", "PreallocationTools", "PrecompileTools", "RuntimeGeneratedFunctions", "Symbolics"] +git-tree-sha1 = "d08557864eb68bdf19573bb0b95e8f540ec06aed" +uuid = "1ef5d832-be8e-447f-9f2c-8b5d17d15fd3" +version = "4.5.2" + +[[deps.BracketingNonlinearSolve]] +deps = ["CommonSolve", "ConcreteStructs", "NonlinearSolveBase", "PrecompileTools", "Reexport", "SciMLBase", "SciMLLogging"] +git-tree-sha1 = "ed4222fe2ee1a4ac58a156ec3f33f94d4713718c" +uuid = "70df07ce-3d50-431d-a3e7-ca6ddb60ac1e" +version = "1.12.4" + + [deps.BracketingNonlinearSolve.extensions] + BracketingNonlinearSolveChainRulesCoreExt = ["ChainRulesCore", "ForwardDiff"] + BracketingNonlinearSolveForwardDiffExt = "ForwardDiff" + + [deps.BracketingNonlinearSolve.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + +[[deps.CSV]] +deps = ["CodecZlib", "Dates", "FilePathsBase", "InlineStrings", "Mmap", "Parsers", "PooledArrays", "PrecompileTools", "SentinelArrays", "Tables", "Unicode", "WeakRefStrings", "WorkerUtilities"] +git-tree-sha1 = "8d8e0b0f350b8e1c91420b5e64e5de774c2f0f4d" +uuid = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" +version = "0.10.16" + +[[deps.CodecZlib]] +deps = ["TranscodingStreams", "Zlib_jll"] +git-tree-sha1 = "962834c22b66e32aa10f7611c08c8ca4e20749a9" +uuid = "944b1d66-785c-5afd-91f1-9de20f533193" +version = "0.7.8" + +[[deps.Combinatorics]] +git-tree-sha1 = "08c8b6831dc00bfea825826be0bc8336fc369860" +uuid = "861a8166-3701-5b0c-9a16-15d98fcdc6aa" +version = "1.0.2" + +[[deps.CommonSolve]] +git-tree-sha1 = "cf963add2340ad9960e5eb22844e61ad8f931fe1" +uuid = "38540f10-b2f7-11e9-35d8-d573e4eb0ff2" +version = "0.2.13" + +[[deps.CommonSubexpressions]] +deps = ["MacroTools"] +git-tree-sha1 = "cda2cfaebb4be89c9084adaca7dd7333369715c5" +uuid = "bbf7d656-a473-5ed7-a52c-81e309532950" +version = "0.3.1" + +[[deps.CommonWorldInvalidations]] +git-tree-sha1 = "ef2022bff55342a8c9846cdf218f62e475f0444d" +uuid = "f70d9fcc-98c5-4d4a-abd7-e4cdeebd8ca8" +version = "1.1.2" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.18.1" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.3.0+1" + +[[deps.CompositeTypes]] +git-tree-sha1 = "bce26c3dab336582805503bed209faab1c279768" +uuid = "b152e2b5-7a66-4b01-a709-34e65c35f657" +version = "0.1.4" + +[[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 = "804fc3ca1cbfdd5aa52ae3149c0cb0555f875eec" +uuid = "2569d6c7-a4a2-43d3-a901-331e8e4be471" +version = "0.2.7" + +[[deps.ConstructionBase]] +git-tree-sha1 = "b4b092499347b18a015186eae3042f72267106cb" +uuid = "187b0558-2788-49d3-abe0-74a17ed4e7c9" +version = "1.6.0" +weakdeps = ["IntervalSets", "LinearAlgebra", "StaticArrays"] + + [deps.ConstructionBase.extensions] + ConstructionBaseIntervalSetsExt = "IntervalSets" + ConstructionBaseLinearAlgebraExt = "LinearAlgebra" + ConstructionBaseStaticArraysExt = "StaticArrays" + +[[deps.Crayons]] +git-tree-sha1 = "54b76cbb40d9a0f5368c880725b2f141da77c94f" +uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f" +version = "4.2.0" + +[[deps.DataAPI]] +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.16.0" + +[[deps.DataFrames]] +deps = ["Compat", "DataAPI", "DataStructures", "Future", "InlineStrings", "InvertedIndices", "IteratorInterfaceExtensions", "LinearAlgebra", "Markdown", "Missings", "PooledArrays", "PrecompileTools", "PrettyTables", "Printf", "Random", "Reexport", "SentinelArrays", "SortingAlgorithms", "Statistics", "TableTraits", "Tables", "Unicode"] +git-tree-sha1 = "5fab31e2e01e70ad66e3e24c968c264d1cf166d6" +uuid = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" +version = "1.8.2" + +[[deps.DataInterpolations]] +deps = ["EnumX", "FindFirstFunctions", "ForwardDiff", "LinearAlgebra", "PrettyTables", "RecipesBase", "Reexport", "StaticArrays"] +git-tree-sha1 = "bc12b37c54a66b688264f39e947d449e0f180fbb" +uuid = "82cc6244-b520-54b8-b5a6-8a565e85f1d0" +version = "9.2.0" + + [deps.DataInterpolations.extensions] + DataInterpolationsChainRulesCoreExt = "ChainRulesCore" + DataInterpolationsCurveFitExt = "CurveFit" + DataInterpolationsMakieExt = "Makie" + DataInterpolationsMooncakeExt = ["Mooncake", "ChainRulesCore"] + DataInterpolationsSparseConnectivityTracerExt = "SparseConnectivityTracer" + DataInterpolationsSymbolicsExt = "Symbolics" + + [deps.DataInterpolations.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + CurveFit = "5a033b19-8c74-5913-a970-47c3779ef25c" + Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + SparseConnectivityTracer = "9f842d2f-2579-4b1d-911e-f412cf18a3f5" + Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.DataInterpolationsND]] +deps = ["Adapt", "EllipsisNotation", "KernelAbstractions", "PrecompileTools", "RecipesBase"] +git-tree-sha1 = "623dc38f3d9b25a88fede53b99bc770cced77f18" +uuid = "4f1ef021-621a-47a5-ac8a-95402a2d1ea8" +version = "0.1.7" +weakdeps = ["SymbolicUtils", "Symbolics"] + + [deps.DataInterpolationsND.extensions] + DataInterpolationsNDSymbolicsExt = ["SymbolicUtils", "Symbolics"] + +[[deps.DataStructures]] +deps = ["OrderedCollections"] +git-tree-sha1 = "b0bc6d2cad1fed8b7fd59a1551a991cb3d2809e6" +uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" +version = "0.19.6" + +[[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" +version = "1.11.0" + +[[deps.Dictionaries]] +deps = ["Indexing", "Random", "Serialization"] +git-tree-sha1 = "a55766a9c8f66cf19ffcdbdb1444e249bb4ace33" +uuid = "85a47980-9c8c-11e8-2b9f-f7ca1fa99fb4" +version = "0.4.6" + +[[deps.DiffEqBase]] +deps = ["ArrayInterface", "BracketingNonlinearSolve", "ConcreteStructs", "DocStringExtensions", "FastBroadcast", "FastClosures", "FastPower", "FunctionWrappers", "FunctionWrappersWrappers", "LinearAlgebra", "Logging", "Markdown", "MuladdMacro", "PrecompileTools", "Printf", "RecursiveArrayTools", "Reexport", "RespecializeParams", "SciMLBase", "SciMLLogging", "SciMLOperators", "SciMLStructures", "Setfield", "StaticArraysCore", "SymbolicIndexingInterface", "TruncatedStacktraces"] +git-tree-sha1 = "9f21a7ba7fc48e10afe0437bebb9a7fe199914fe" +uuid = "2b5f629d-d688-5b77-993f-72d75c75574e" +version = "7.13.0" + + [deps.DiffEqBase.extensions] + DiffEqBaseCUDAExt = "CUDA" + DiffEqBaseChainRulesCoreExt = "ChainRulesCore" + DiffEqBaseDynamicQuantitiesExt = "DynamicQuantities" + DiffEqBaseEnzymeExt = ["ChainRulesCore", "Enzyme"] + DiffEqBaseFlexUnitsExt = "FlexUnits" + DiffEqBaseForwardDiffExt = ["ForwardDiff"] + DiffEqBaseGTPSAExt = "GTPSA" + DiffEqBaseGeneralizedGeneratedExt = "GeneralizedGenerated" + DiffEqBaseMPIExt = "MPI" + DiffEqBaseMeasurementsExt = "Measurements" + DiffEqBaseMonteCarloMeasurementsExt = "MonteCarloMeasurements" + DiffEqBaseMooncakeExt = "Mooncake" + DiffEqBaseReverseDiffExt = "ReverseDiff" + DiffEqBaseSparseArraysExt = "SparseArrays" + DiffEqBaseTrackerExt = "Tracker" + DiffEqBaseUnitfulExt = "Unitful" + + [deps.DiffEqBase.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" + DynamicQuantities = "06fc5a27-2a28-4c7c-a15d-362465fb6821" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + FlexUnits = "76e01b6b-c995-4ce6-8559-91e72a3d4e95" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + GTPSA = "b27dd330-f138-47c5-815b-40db9dd9b6e8" + GeneralizedGenerated = "6b9d7cbe-bcb9-11e9-073f-15a7a543e2eb" + MPI = "da04e1cc-30fd-572f-bb4f-1f8673147195" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.DiffEqCallbacks]] +deps = ["ConcreteStructs", "DataStructures", "DiffEqBase", "DifferentiationInterface", "LinearAlgebra", "Markdown", "PrecompileTools", "RecipesBase", "RecursiveArrayTools", "SciMLBase", "StaticArraysCore"] +git-tree-sha1 = "50212426ed10a2da3494a56b35874c2148606d78" +uuid = "459566f4-90b8-5000-8ac3-15dfb0a30def" +version = "4.19.1" + + [deps.DiffEqCallbacks.extensions] + DiffEqCallbacksFunctorsExt = "Functors" + + [deps.DiffEqCallbacks.weakdeps] + Functors = "d9f16b24-f501-4c13-a1f2-28368ffc5196" + +[[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 = "79a2aca180a85c690c58a020d47b426954b590f8" +uuid = "b552c78f-8df3-52c6-915a-8e097449b14b" +version = "1.16.0" + +[[deps.DifferentiationInterface]] +deps = ["ADTypes", "LinearAlgebra"] +git-tree-sha1 = "dbd46a5cd0e79a97438b0ebbec42e744e8f436fe" +uuid = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" +version = "0.7.20" + + [deps.DifferentiationInterface.extensions] + DifferentiationInterfaceChainRulesCoreExt = "ChainRulesCore" + DifferentiationInterfaceDiffractorExt = "Diffractor" + DifferentiationInterfaceEnzymeExt = ["EnzymeCore", "Enzyme"] + DifferentiationInterfaceFastDifferentiationExt = "FastDifferentiation" + DifferentiationInterfaceFiniteDiffExt = "FiniteDiff" + DifferentiationInterfaceFiniteDifferencesExt = "FiniteDifferences" + DifferentiationInterfaceForwardDiffExt = ["ForwardDiff", "DiffResults"] + DifferentiationInterfaceGPUArraysCoreExt = ["GPUArraysCore", "Adapt"] + DifferentiationInterfaceGTPSAExt = "GTPSA" + DifferentiationInterfaceHyperHessiansExt = "HyperHessians" + DifferentiationInterfaceMooncakeExt = "Mooncake" + DifferentiationInterfacePolyesterForwardDiffExt = ["PolyesterForwardDiff", "ForwardDiff", "DiffResults"] + DifferentiationInterfaceReverseDiffExt = ["ReverseDiff", "DiffResults"] + DifferentiationInterfaceSparseArraysExt = "SparseArrays" + DifferentiationInterfaceSparseConnectivityTracerExt = "SparseConnectivityTracer" + DifferentiationInterfaceSparseMatrixColoringsExt = "SparseMatrixColorings" + DifferentiationInterfaceStaticArraysExt = "StaticArrays" + DifferentiationInterfaceSymbolicsExt = "Symbolics" + DifferentiationInterfaceTrackerExt = "Tracker" + DifferentiationInterfaceZygoteExt = ["Zygote", "ForwardDiff"] + + [deps.DifferentiationInterface.weakdeps] + Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DiffResults = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" + Diffractor = "9f5e2b26-1114-432f-b630-d3fe2085c51c" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + FastDifferentiation = "eb9bf01b-bf85-4b60-bf87-ee5de06c00be" + FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41" + FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + GTPSA = "b27dd330-f138-47c5-815b-40db9dd9b6e8" + HyperHessians = "06b494a0-c8e0-40cc-ad32-d99506a00a6c" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + PolyesterForwardDiff = "98d1487c-24ca-40b6-b7ab-df2af84e126b" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + SparseConnectivityTracer = "9f842d2f-2579-4b1d-911e-f412cf18a3f5" + SparseMatrixColorings = "0a514795-09f3-496d-8182-132a7b665d35" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.Distributed]] +deps = ["Random", "Serialization", "Sockets"] +uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" +version = "1.11.0" + +[[deps.DocStringExtensions]] +git-tree-sha1 = "7442a5dfe1ebb773c29cc2962a8980f47221d76c" +uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" +version = "0.9.5" + +[[deps.DomainSets]] +deps = ["CompositeTypes", "FunctionMaps", "IntervalSets", "LinearAlgebra", "StaticArrays"] +git-tree-sha1 = "c0f576ae49bd2d1bc904b9946f4783db8f0ef530" +uuid = "5b8099bc-c8ec-5219-889f-1d9e522a28bf" +version = "0.8.1" + + [deps.DomainSets.extensions] + DomainSetsMakieExt = "Makie" + DomainSetsRandomExt = "Random" + + [deps.DomainSets.weakdeps] + Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" + Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.7.0" + +[[deps.DyadCompilerPasses]] +deps = ["DataStructures", "DocStringExtensions", "Graphs", "LinearAlgebra", "ModelingToolkit", "ModelingToolkitBase", "Moshi", "PreallocationTools", "Random", "Setfield", "SparseArrays", "StaticArrays", "SymbolicUtils", "Symbolics"] +git-tree-sha1 = "8eb08161778a852ed2ea957e15fd4a834521228d" +uuid = "7ad99603-9b08-4a9b-96cd-82ecdbcce176" +version = "0.2.7" + + [deps.DyadCompilerPasses.extensions] + DyadCompilerPassesRotationsExt = ["Rotations"] + SCPLinearSolveExt = ["LinearSolve", "StaticArrays"] + + [deps.DyadCompilerPasses.weakdeps] + LinearSolve = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae" + Rotations = "6038ab10-8711-5258-84ad-4b1120ba62dc" + +[[deps.DyadData]] +deps = ["CSV", "Tables", "TypedTables"] +git-tree-sha1 = "274c3622a143f3271552767affdd8d2a5c859d51" +uuid = "cab12561-e36c-4498-ae70-c9a5e79fef2a" +version = "2.0.1" + + [deps.DyadData.extensions] + DyadDataJuliaHubExt = "JuliaHub" + + [deps.DyadData.weakdeps] + JuliaHub = "bc7fa6ce-b75e-4d60-89ad-56c957190b6e" + +[[deps.DyadInterface]] +deps = ["ADTypes", "Base64", "CommonSolve", "DataFrames", "DyadCompilerPasses", "EnumX", "Logging", "ModelingToolkit", "Moshi", "NonlinearSolve", "OrdinaryDiffEqBDF", "OrdinaryDiffEqCore", "OrdinaryDiffEqDefault", "OrdinaryDiffEqRosenbrock", "OrdinaryDiffEqTsit5", "PrecompileTools", "Preferences", "RecipesBase", "RelocatableFolders", "RuntimeGeneratedFunctions", "SciMLBase", "SciMLLogging", "SciMLStructures", "Serialization", "Setfield", "StructTypes", "SymbolicIndexingInterface", "Symbolics", "UUIDs"] +git-tree-sha1 = "33579c2d14a1af4e485248358893f5e99dc53faa" +uuid = "99806f68-afab-45ca-9d8c-ceff6bc61f54" +version = "7.2.1" + + [deps.DyadInterface.extensions] + DyadInterfaceMakieExt = "Makie" + + [deps.DyadInterface.weakdeps] + Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" + +[[deps.DynamicPolynomials]] +deps = ["LinearAlgebra", "MultivariatePolynomials", "MutableArithmetics", "Reexport", "StarAlgebras", "Test"] +git-tree-sha1 = "5bfabc3827dfdd164359bad6800c115a81280c00" +uuid = "7c1d4256-1411-5781-91ec-d7bc3513ac07" +version = "0.6.6" + +[[deps.EllipsisNotation]] +deps = ["PrecompileTools"] +git-tree-sha1 = "4337603d8124cf76db5e9a8077c2bf150040b2ed" +uuid = "da5c29d0-fa7d-589e-88eb-ea29b0a81949" +version = "1.11.0" + + [deps.EllipsisNotation.extensions] + EllipsisNotationStaticArrayInterfaceExt = ["ArrayInterface", "Static", "StaticArrayInterface"] + + [deps.EllipsisNotation.weakdeps] + ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" + Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" + StaticArrayInterface = "0d7ed370-da01-4f52-bd93-41d350b8b718" + +[[deps.EnumX]] +git-tree-sha1 = "c49898e8438c828577f04b92fc9368c388ac783c" +uuid = "4e289a0a-7415-4d19-859d-a7e5c4648b56" +version = "1.0.7" + +[[deps.EnzymeCore]] +git-tree-sha1 = "971d7831cc85f43bc9f51d615a3f7f21270c2f1d" +uuid = "f151be2c-9106-41f4-ab19-57ee4f262869" +version = "0.8.21" + + [deps.EnzymeCore.extensions] + AdaptExt = "Adapt" + EnzymeCoreChainRulesCoreExt = "ChainRulesCore" + + [deps.EnzymeCore.weakdeps] + Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + +[[deps.ExprTools]] +git-tree-sha1 = "d2e49e7efd29719d6f28b891b0e0e159daa9d2b4" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.11" + +[[deps.ExproniconLite]] +git-tree-sha1 = "c13f0b150373771b0fdc1713c97860f8df12e6c2" +uuid = "55351af7-c7e9-48d6-89ff-24e801d99491" +version = "0.10.14" + +[[deps.FastBroadcast]] +deps = ["ArrayInterface", "LinearAlgebra"] +git-tree-sha1 = "6a97f3e08655ea9df1a946e378770c4d3fb3c4e9" +uuid = "7034ab61-46d4-4ed7-9d0f-46aef9175898" +version = "1.3.6" + + [deps.FastBroadcast.extensions] + FastBroadcastPolyesterExt = "Polyester" + FastBroadcastStaticExt = "Static" + + [deps.FastBroadcast.weakdeps] + Polyester = "f517fe37-dbe3-4b94-8317-1923a5111588" + Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" + +[[deps.FastClosures]] +git-tree-sha1 = "acebe244d53ee1b461970f8910c235b259e772ef" +uuid = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a" +version = "0.3.2" + +[[deps.FastPower]] +git-tree-sha1 = "eb92a563909f2d4cb2911e0e2cb247ad17c6e9ae" +uuid = "a4df4552-cc26-4903-aec0-212e50a0e84b" +version = "1.4.1" + + [deps.FastPower.extensions] + FastPowerEnzymeExt = "Enzyme" + FastPowerForwardDiffExt = "ForwardDiff" + FastPowerMeasurementsExt = "Measurements" + FastPowerMonteCarloMeasurementsExt = "MonteCarloMeasurements" + FastPowerMooncakeExt = "Mooncake" + FastPowerReverseDiffExt = "ReverseDiff" + FastPowerTrackerExt = "Tracker" + + [deps.FastPower.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.FilePathsBase]] +deps = ["Compat", "Dates"] +git-tree-sha1 = "3bab2c5aa25e7840a4b065805c0cdfc01f3068d2" +uuid = "48062228-2e41-5def-b9a4-89aafe57970f" +version = "0.9.24" +weakdeps = ["Mmap", "Test"] + + [deps.FilePathsBase.extensions] + FilePathsBaseMmapExt = "Mmap" + FilePathsBaseTestExt = "Test" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" + +[[deps.FillArrays]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "5bad39456d9f0166184fce2248783dd9862645c1" +uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" +version = "1.17.0" + + [deps.FillArrays.extensions] + FillArraysPDMatsExt = "PDMats" + FillArraysSparseArraysExt = "SparseArrays" + FillArraysStaticArraysExt = "StaticArrays" + FillArraysStatisticsExt = "Statistics" + + [deps.FillArrays.weakdeps] + PDMats = "90014a1f-27ba-587c-ab20-58faa44d9150" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" + +[[deps.FindFirstFunctions]] +deps = ["PrecompileTools"] +git-tree-sha1 = "bba475ce782fc77777f539cf0b7c029207798db1" +uuid = "64ca27bc-2ba2-4a57-88aa-44e436879224" +version = "3.2.1" + +[[deps.FiniteDiff]] +deps = ["ArrayInterface", "LinearAlgebra", "Setfield"] +git-tree-sha1 = "5031f23e040bf17082e5b52422d77b5e844eefb1" +uuid = "6a86dc24-6348-571c-b903-95158fe2bd41" +version = "2.33.0" + + [deps.FiniteDiff.extensions] + FiniteDiffBandedMatricesExt = "BandedMatrices" + FiniteDiffBlockBandedMatricesExt = "BlockBandedMatrices" + FiniteDiffSparseArraysExt = "SparseArrays" + FiniteDiffStaticArraysExt = "StaticArrays" + + [deps.FiniteDiff.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.ForwardDiff]] +deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"] +git-tree-sha1 = "1b86cca764a61dcac4fef4c5e16e378e5ed6953c" +uuid = "f6369f11-7733-5829-9624-2563aa707210" +version = "1.4.5" +weakdeps = ["StaticArrays"] + + [deps.ForwardDiff.extensions] + ForwardDiffStaticArraysExt = "StaticArrays" + +[[deps.FunctionMaps]] +deps = ["CompositeTypes", "LinearAlgebra", "StaticArrays"] +git-tree-sha1 = "31bd99a57edf98990d1c21486032963955450e8d" +uuid = "a85aefff-f8ca-4649-a888-c8e5398bc76c" +version = "0.1.2" + +[[deps.FunctionWrappers]] +git-tree-sha1 = "d62485945ce5ae9c0c48f124a84998d755bae00e" +uuid = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e" +version = "1.1.3" + +[[deps.FunctionWrappersWrappers]] +deps = ["FunctionWrappers", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "daced009d54a7cf502a9b5ed2f615c341f78af6f" +uuid = "77dc65aa-8811-40c2-897b-53d922fa7daf" +version = "1.12.1" + + [deps.FunctionWrappersWrappers.extensions] + FunctionWrappersWrappersEnzymeExt = ["Enzyme", "EnzymeCore"] + FunctionWrappersWrappersMooncakeExt = "Mooncake" + + [deps.FunctionWrappersWrappers.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + +[[deps.Future]] +deps = ["Random"] +uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820" +version = "1.11.0" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "83cf05ab16a73219e5f6bd1bdfa9848fa24ac627" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.2.0" + +[[deps.Graphs]] +deps = ["ArnoldiMethod", "DataStructures", "Inflate", "LinearAlgebra", "Random", "SimpleTraits", "SparseArrays", "Statistics"] +git-tree-sha1 = "7eb45fe833a5b7c51cf6d89c5a841d5967e44be3" +uuid = "86223c79-3864-5bf0-83f7-82e725a168b6" +version = "1.14.0" + + [deps.Graphs.extensions] + GraphsSharedArraysExt = "SharedArrays" + + [deps.Graphs.weakdeps] + Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b" + SharedArrays = "1a1011a3-84de-559e-8e89-a11a2f7dc383" + +[[deps.ImplicitDiscreteSolve]] +deps = ["CommonSolve", "ConcreteStructs", "DiffEqBase", "NonlinearSolveBase", "NonlinearSolveFirstOrder", "OrdinaryDiffEqCore", "Reexport", "SciMLBase", "SymbolicIndexingInterface"] +git-tree-sha1 = "d218490f288ac4a44fadcda005358f4725096fbf" +uuid = "3263718b-31ed-49cf-8a0f-35a466e8af96" +version = "2.1.5" + +[[deps.Indexing]] +git-tree-sha1 = "ce1566720fd6b19ff3411404d4b977acd4814f9f" +uuid = "313cdc1a-70c2-5d6a-ae34-0150d3930a38" +version = "1.1.1" + +[[deps.Inflate]] +git-tree-sha1 = "d1b1b796e47d94588b3757fe84fbf65a5ec4a80d" +uuid = "d25df0c9-e2be-5dd7-82c8-3ad0b3e990b9" +version = "0.1.5" + +[[deps.InlineStrings]] +git-tree-sha1 = "8f3d257792a522b4601c24a577954b0a8cd7334d" +uuid = "842dd82b-1e85-43dc-bf29-5d0ee9dffc48" +version = "1.4.5" + + [deps.InlineStrings.extensions] + ArrowTypesExt = "ArrowTypes" + ParsersExt = "Parsers" + + [deps.InlineStrings.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + Parsers = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" + +[[deps.IntegerMathUtils]] +git-tree-sha1 = "c72458f1962faeb003bf23cbdb75164fe6280906" +uuid = "18e54dd8-cb9d-406c-a71d-865a43cbb235" +version = "0.1.4" + +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2025.2.0+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" + +[[deps.IntervalSets]] +git-tree-sha1 = "79d6bd28c8d9bccc2229784f1bd637689b256377" +uuid = "8197267c-284f-5f27-9208-e0e47529a953" +version = "0.7.14" +weakdeps = ["Random", "RecipesBase", "Statistics"] + + [deps.IntervalSets.extensions] + IntervalSetsRandomExt = "Random" + IntervalSetsRecipesBaseExt = "RecipesBase" + IntervalSetsStatisticsExt = "Statistics" + +[[deps.InverseFunctions]] +git-tree-sha1 = "a779299d77cd080bf77b97535acecd73e1c5e5cb" +uuid = "3587e190-3f89-42d0-90ee-14403ec27112" +version = "0.1.17" +weakdeps = ["Dates", "Test"] + + [deps.InverseFunctions.extensions] + InverseFunctionsDatesExt = "Dates" + InverseFunctionsTestExt = "Test" + +[[deps.InvertedIndices]] +git-tree-sha1 = "6da3c4316095de0f5ee2ebd875df8721e7e0bdbe" +uuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f" +version = "1.3.1" + +[[deps.IrrationalConstants]] +git-tree-sha1 = "b2d91fe939cae05960e760110b328288867b5758" +uuid = "92d709cd-6900-40b7-9082-c6be49f344b6" +version = "0.2.6" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "7204148362dafe5fe6a273f855b8ccbe4df8173e" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.8.0" + +[[deps.JSON]] +deps = ["Dates", "Logging", "Parsers", "PrecompileTools", "StructUtils", "UUIDs", "Unicode"] +git-tree-sha1 = "c7345ab1a7ca4dc8a02c9f6510da0d9857bbe513" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "1.7.1" + + [deps.JSON.extensions] + JSONArrowExt = ["ArrowTypes"] + + [deps.JSON.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + +[[deps.Jieko]] +deps = ["ExproniconLite"] +git-tree-sha1 = "2f05ed29618da60c06a87e9c033982d4f71d0b6c" +uuid = "ae98c720-c025-4a4a-838c-29b094483192" +version = "0.2.1" + +[[deps.JuliaCon2026Components]] +deps = ["BlockComponents", "DyadData", "DyadInterface", "JSON", "Markdown", "ModelingToolkit", "Moshi", "OrdinaryDiffEqDefault", "PrecompileTools", "RotationalComponents", "RuntimeGeneratedFunctions", "TOML"] +path = "." +uuid = "cb0cf210-d080-4a98-89fc-0e4ae9a4086e" +version = "0.1.0" + +[[deps.JuliaSyntaxHighlighting]] +deps = ["StyledStrings"] +uuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011" +version = "1.12.0" + +[[deps.JumpProcesses]] +deps = ["ArrayInterface", "DataStructures", "DiffEqBase", "DiffEqCallbacks", "DocStringExtensions", "FunctionWrappers", "Graphs", "LinearAlgebra", "PoissonRandom", "Random", "RecursiveArrayTools", "Reexport", "SciMLBase", "StaticArrays", "SymbolicIndexingInterface"] +git-tree-sha1 = "ca029f96ad24403a4de6b9e03835fb890155c641" +uuid = "ccbc3e58-028d-4f4c-8cd5-9ae44345cda5" +version = "9.29.2" +weakdeps = ["Adapt", "KernelAbstractions", "OrdinaryDiffEqCore"] + + [deps.JumpProcesses.extensions] + JumpProcessesKernelAbstractionsExt = ["Adapt", "KernelAbstractions"] + JumpProcessesOrdinaryDiffEqCoreExt = "OrdinaryDiffEqCore" + +[[deps.KernelAbstractions]] +deps = ["Adapt", "Atomix", "InteractiveUtils", "MacroTools", "PrecompileTools", "Requires", "StaticArrays", "UUIDs"] +git-tree-sha1 = "a5b87110fa95d711355af44832497745aa93fb52" +uuid = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +version = "0.9.42" +weakdeps = ["EnzymeCore", "LinearAlgebra", "SparseArrays"] + + [deps.KernelAbstractions.extensions] + EnzymeExt = "EnzymeCore" + LinearAlgebraExt = "LinearAlgebra" + SparseArraysExt = "SparseArrays" + +[[deps.Krylov]] +deps = ["LinearAlgebra", "Printf", "SparseArrays"] +git-tree-sha1 = "71e740d00d71cdb15145d7fe0d6000ec70534598" +uuid = "ba0b0d4f-ebba-5204-a429-3ac8c609bfb7" +version = "0.10.9" + +[[deps.LaTeXStrings]] +git-tree-sha1 = "dda21b8cbd6a6c40d9d02a73230f9d70fed6918c" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.4.0" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" +version = "1.11.0" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "0.6.4" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "Zlib_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.15.0+0" + +[[deps.LibGit2]] +deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "OpenSSL_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.9.0+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "Libdl", "OpenSSL_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.3+1" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.LineSearch]] +deps = ["ADTypes", "CommonSolve", "ConcreteStructs", "FastClosures", "LinearAlgebra", "MaybeInplace", "PrecompileTools", "SciMLBase", "SciMLJacobianOperators", "StaticArraysCore"] +git-tree-sha1 = "36d9ea45f400b185d291528dd2e7659ace2da2c7" +uuid = "87fe0de2-c867-4266-b59a-2f0a94fc965b" +version = "0.1.13" + + [deps.LineSearch.extensions] + LineSearchLineSearchesExt = "LineSearches" + + [deps.LineSearch.weakdeps] + LineSearches = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.12.0" + +[[deps.LinearSolve]] +deps = ["AMD", "ArrayInterface", "ConcreteStructs", "DocStringExtensions", "EnumX", "GPUArraysCore", "InteractiveUtils", "Krylov", "Libdl", "LinearAlgebra", "MKL_jll", "Markdown", "OpenBLAS_jll", "PrecompileTools", "Preferences", "PureKLU", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLLogging", "SciMLOperators", "Setfield", "SparseArrays", "SparseColumnPivotedQR", "StaticArraysCore"] +git-tree-sha1 = "4158b58db3d1ff154fc4e02965df24b6dec3f3e2" +uuid = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae" +version = "5.9.0" + + [deps.LinearSolve.extensions] + LinearSolveAMDGPUExt = "AMDGPU" + LinearSolveAlgebraicMultigridExt = "AlgebraicMultigrid" + LinearSolveArnoldiMethodExt = "ArnoldiMethod" + LinearSolveArpackExt = "Arpack" + LinearSolveBLISExt = ["blis_jll", "LAPACK_jll"] + LinearSolveBandedMatricesExt = "BandedMatrices" + LinearSolveBlockDiagonalsExt = "BlockDiagonals" + LinearSolveCUDAExt = ["cuSOLVER"] + LinearSolveCUDSSExt = "CUDSS" + LinearSolveCUSOLVERRFExt = "CUSOLVERRF" + LinearSolveChainRulesCoreExt = "ChainRulesCore" + LinearSolveCliqueTreesExt = "CliqueTrees" + LinearSolveElementalExt = "Elemental" + LinearSolveEnzymeExt = "EnzymeCore" + LinearSolveFastAlmostBandedMatricesExt = "FastAlmostBandedMatrices" + LinearSolveFastLapackInterfaceExt = "FastLapackInterface" + LinearSolveForwardDiffExt = "ForwardDiff" + LinearSolveGinkgoExt = "Ginkgo" + LinearSolveHSLExt = "HSL" + LinearSolveHYPREExt = "HYPRE" + LinearSolveIterativeSolversExt = "IterativeSolvers" + LinearSolveJacobiDavidsonExt = "JacobiDavidson" + LinearSolveKernelAbstractionsExt = "KernelAbstractions" + LinearSolveKrylovKitExt = "KrylovKit" + LinearSolveMUMPSExt = "MUMPS" + LinearSolveMetalExt = "Metal" + LinearSolveMooncakeExt = "Mooncake" + LinearSolvePETScExt = ["PETSc", "SparseMatricesCSR"] + LinearSolvePETScMPIExt = ["PETSc", "PartitionedArrays", "SparseMatricesCSR"] + LinearSolveParUExt = "ParU_jll" + LinearSolvePardisoExt = "Pardiso" + LinearSolvePartitionedSolversExt = ["PartitionedArrays", "PartitionedSolvers"] + LinearSolvePureUMFPACKExt = "PureUMFPACK" + LinearSolveRecursiveFactorizationExt = ["RecursiveFactorization", "TriangularSolve"] + LinearSolveSTRUMPACKExt = "STRUMPACK_jll" + LinearSolveSparspakExt = "Sparspak" + LinearSolveSpecializingFactorizationsExt = "SpecializingFactorizations" + LinearSolveSuperLUDISTExt = "SuperLUDIST" + + [deps.LinearSolve.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + AlgebraicMultigrid = "2169fc97-5a83-5252-b627-83903c6c433c" + ArnoldiMethod = "ec485272-7323-5ecc-a04f-4719b315124d" + Arpack = "7d9fca2a-8960-54d3-9f78-7d1dccf2cb97" + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockDiagonals = "0a1fb500-61f7-11e9-3c65-f5ef3456f9f0" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + CUSOLVERRF = "a8cc9031-bad2-4722-94f5-40deabb4245c" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + CliqueTrees = "60701a23-6482-424a-84db-faee86b9b1f8" + Elemental = "902c3f28-d1ec-5e7e-8399-a24c3845ee38" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + FastAlmostBandedMatrices = "9d29842c-ecb8-4973-b1e9-a27b1157504e" + FastLapackInterface = "29a986be-02c6-4525-aec4-84b980013641" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + Ginkgo = "4c8bd3c9-ead9-4b5e-a625-08f1338ba0ec" + HSL = "34c5aeac-e683-54a6-a0e9-6e0fdc586c50" + HYPRE = "b5ffcf37-a2bd-41ab-a3da-4bd9bc8ad771" + IterativeSolvers = "42fd0dbc-a981-5370-80f2-aaf504508153" + JLArrays = "27aeb0d3-9eb9-45fb-866b-73c2ecf80fcb" + JacobiDavidson = "11c68b98-9c9b-11e8-267b-bbb95576cead" + KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" + KrylovKit = "0b1a1467-8014-51b9-945f-bf0ae24f4b77" + LAPACK_jll = "51474c39-65e3-53ba-86ba-03b1b862ec14" + MUMPS = "55d2b088-9f4e-11e9-26c0-150b02ea6a46" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + PETSc = "ace2c81b-2b5f-4b1e-a30d-d662738edfe0" + ParU_jll = "9e0b026c-e8ce-559c-a2c4-6a3d5c955bc9" + Pardiso = "46dd5b70-b6fb-5a00-ae2d-e8fea33afaf2" + PartitionedArrays = "5a9dfac6-5c52-46f7-8278-5e2210713be9" + PartitionedSolvers = "11b65f7f-80ac-401b-9ef2-3db765482d62" + PureUMFPACK = "b7e1f0a2-3c4d-4e5f-9a0b-1c2d3e4f5a6b" + RecursiveFactorization = "f2c3362d-daeb-58d1-803e-2bc74f2840b4" + STRUMPACK_jll = "86fbd0b9-476f-557c-b766-62c724b42d8c" + SparseMatricesCSR = "a0a7dd2c-ebf4-11e9-1f05-cf50bc540ca1" + Sparspak = "e56a9233-b9d6-4f03-8d0f-1825330902ac" + SpecializingFactorizations = "fa08b7a1-13d3-4faf-875d-5cbc1520e3f3" + SuperLUDIST = "4cd002a6-0da4-410d-a012-232df062f478" + TriangularSolve = "d5829a12-d9aa-46ab-831f-fb7c9ab06edf" + blis_jll = "6136c539-28a5-5bf0-87cc-b183200dce32" + cuSOLVER = "887afef0-6a32-4de5-add4-7827692ba8fc" + +[[deps.LogExpFunctions]] +deps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"] +git-tree-sha1 = "bba2d9aa057d8f126415de240573e86a8f39d2a1" +uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" +version = "1.0.1" + + [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" +version = "1.11.0" + +[[deps.LoggingExtras]] +deps = ["Dates", "Logging"] +git-tree-sha1 = "f00544d95982ea270145636c181ceda21c4e2575" +uuid = "e6f89c97-d47a-5376-807f-9c37f3926c36" +version = "1.2.0" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "282cadc186e7b2ae0eeadbd7a4dffed4196ae2aa" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2025.2.0+0" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.Markdown]] +deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.MaybeInplace]] +deps = ["ArrayInterface", "LinearAlgebra", "MacroTools"] +git-tree-sha1 = "69ad9ad584510f04f0ce75841253aa4b7c83e6f2" +uuid = "bb5d69b7-63fc-4a16-80bd-7e42200c7bdb" +version = "0.1.7" +weakdeps = ["SparseArrays"] + + [deps.MaybeInplace.extensions] + MaybeInplaceSparseArraysExt = "SparseArrays" + +[[deps.Missings]] +deps = ["DataAPI"] +git-tree-sha1 = "ec4f7fbeab05d7747bdf98eb74d130a2a2ed298d" +uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28" +version = "1.2.0" + +[[deps.Mmap]] +uuid = "a63ad114-7e13-5084-954f-fe012c677804" +version = "1.11.0" + +[[deps.ModelingToolkit]] +deps = ["ADTypes", "BipartiteGraphs", "BlockArrays", "Combinatorics", "CommonSolve", "ConstructionBase", "DataStructures", "DiffEqBase", "DifferentiationInterface", "DocStringExtensions", "FillArrays", "ForwardDiff", "Graphs", "InteractiveUtils", "Libdl", "LinearAlgebra", "ModelingToolkitBase", "ModelingToolkitTearing", "Moshi", "OffsetArrays", "OrderedCollections", "PreallocationTools", "PrecompileTools", "REPL", "Reexport", "RuntimeGeneratedFunctions", "SCCNonlinearSolve", "SciMLBase", "SciMLPublic", "SciMLStructures", "Serialization", "Setfield", "SimpleNonlinearSolve", "SparseArrays", "StateSelection", "StaticArrays", "SymbolicIndexingInterface", "SymbolicUtils", "Symbolics", "TermInterface", "UnPack"] +git-tree-sha1 = "8b42e7560f568b4f01d27f8a493142c7263f84aa" +uuid = "961ee093-0014-501f-94e3-6117800e7a78" +version = "11.38.2" + + [deps.ModelingToolkit.extensions] + MTKFMIExt = "FMIImport" + MTKOrdinaryDiffEqBDFExt = "OrdinaryDiffEqBDF" + MTKOrdinaryDiffEqDefaultExt = "OrdinaryDiffEqDefault" + MTKOrdinaryDiffEqRosenbrockExt = "OrdinaryDiffEqRosenbrock" + + [deps.ModelingToolkit.weakdeps] + FMIImport = "9fcbc62e-52a0-44e9-a616-1359a0008194" + OrdinaryDiffEqBDF = "6ad6398a-0878-4a85-9266-38940aa047c8" + OrdinaryDiffEqDefault = "50262376-6c5a-4cf5-baba-aaf4f84d72d7" + OrdinaryDiffEqRosenbrock = "43230ef6-c299-4910-a778-202eb28ce4ce" + +[[deps.ModelingToolkitBase]] +deps = ["ADTypes", "AbstractTrees", "ArrayInterface", "BandedMatrices", "BipartiteGraphs", "BlockArrays", "Combinatorics", "CommonSolve", "Compat", "ConstructionBase", "DataStructures", "DiffEqBase", "DiffEqCallbacks", "DiffRules", "DifferentiationInterface", "DocStringExtensions", "DomainSets", "EnumX", "EnzymeCore", "ExprTools", "FillArrays", "ForwardDiff", "FunctionWrappers", "FunctionWrappersWrappers", "Graphs", "ImplicitDiscreteSolve", "InteractiveUtils", "JumpProcesses", "Libdl", "LinearAlgebra", "Moshi", "NaNMath", "OffsetArrays", "OrderedCollections", "PreallocationTools", "PrecompileTools", "Printf", "REPL", "Random", "ReadOnlyDicts", "RecursiveArrayTools", "Reexport", "RuntimeGeneratedFunctions", "SCCNonlinearSolve", "SciMLBase", "SciMLPublic", "SciMLStructures", "Serialization", "Setfield", "SimpleNonlinearSolve", "SparseArrays", "SpecialFunctions", "StaticArrays", "SymbolicIndexingInterface", "SymbolicUtils", "Symbolics", "TaskLocalValues", "UnPack"] +git-tree-sha1 = "8dd64e8a5c12967d12097882fceb5e59d2e2fa88" +uuid = "7771a370-6774-4173-bd38-47e70ca0b839" +version = "1.62.0" + + [deps.ModelingToolkitBase.extensions] + MTKBifurcationKitExt = "BifurcationKit" + MTKCasADiDynamicOptExt = "CasADi" + MTKChainRulesCoreExt = "ChainRulesCore" + MTKDiffEqNoiseProcessExt = "DiffEqNoiseProcess" + MTKDynamicQuantitiesExt = "DynamicQuantities" + MTKInfiniteOptExt = "InfiniteOpt" + MTKJuliaFormatterExt = "JuliaFormatter" + MTKLabelledArraysExt = "LabelledArrays" + MTKLatexifyExt = "Latexify" + MTKMooncakeExt = "Mooncake" + MTKPyomoDynamicOptExt = "Pyomo" + MTKTrackerExt = "Tracker" + + [deps.ModelingToolkitBase.weakdeps] + BifurcationKit = "0f109fa4-8a5d-4b75-95aa-f515264e7665" + CasADi = "c49709b8-5c63-11e9-2fb2-69db5844192f" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DiffEqNoiseProcess = "77a26b50-5914-5dd7-bc55-306e6241c503" + DynamicQuantities = "06fc5a27-2a28-4c7c-a15d-362465fb6821" + InfiniteOpt = "20393b10-9daf-11e9-18c9-8db751c92c57" + JuliaFormatter = "98e50ef6-434e-11e9-1051-2b60c6c9e899" + LabelledArrays = "2ee39098-c373-598a-b85f-a56591580800" + Latexify = "23fbe1c1-3f47-55db-b15f-69d7ec21a316" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + Pyomo = "0e8e1daf-01b5-4eba-a626-3897743a3816" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.ModelingToolkitTearing]] +deps = ["BipartiteGraphs", "CommonSolve", "DocStringExtensions", "Graphs", "LinearAlgebra", "ModelingToolkitBase", "Moshi", "OffsetArrays", "OrderedCollections", "SciMLBase", "Setfield", "SparseArrays", "StateSelection", "SymbolicIndexingInterface", "SymbolicUtils", "Symbolics", "UUIDs"] +git-tree-sha1 = "8887ddce86dd62e9493f13429a5871bb4b55eec7" +uuid = "6bb917b9-1269-42b9-9f7c-b0dca72083ab" +version = "1.20.5" + +[[deps.Moshi]] +deps = ["ExproniconLite", "Jieko"] +git-tree-sha1 = "60beb0717782a3bbe0f7df56decad0ef89048c23" +uuid = "2e0e35c7-a2e4-4343-998d-7ef72827ed2d" +version = "0.3.12" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2025.11.4" + +[[deps.MuladdMacro]] +deps = ["PrecompileTools"] +git-tree-sha1 = "283bf85d4a767481dd924dff0eee1735e95f449e" +uuid = "46d2c3a1-f734-5fdb-9937-b9b9aeba4221" +version = "0.2.7" + +[[deps.MultivariatePolynomials]] +deps = ["DataStructures", "LinearAlgebra", "MutableArithmetics", "StarAlgebras"] +git-tree-sha1 = "4838893d9b035c2f6967c0d533350e1755b58a70" +uuid = "102ac46a-7ee4-5c85-9060-abc95bfdeaa3" +version = "0.5.19" + + [deps.MultivariatePolynomials.extensions] + MultivariatePolynomialsChainRulesCoreExt = "ChainRulesCore" + + [deps.MultivariatePolynomials.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + +[[deps.MutableArithmetics]] +deps = ["LinearAlgebra", "SparseArrays", "Test"] +git-tree-sha1 = "dc5b2c4c111c46bc79ac4405eeb563523b39c004" +uuid = "d8a4904e-b15c-11e9-3269-09a3773c0cb0" +version = "1.8.0" + +[[deps.NaNMath]] +deps = ["OpenLibm_jll"] +git-tree-sha1 = "dbd2e8cd2c1c27f0b584f6661b4309609c5a685e" +uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" +version = "1.1.4" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.3.0" + +[[deps.NonlinearSolve]] +deps = ["ADTypes", "ArrayInterface", "BracketingNonlinearSolve", "CommonSolve", "ConcreteStructs", "DifferentiationInterface", "FastClosures", "FiniteDiff", "ForwardDiff", "LineSearch", "LinearAlgebra", "LinearSolve", "NonlinearSolveBase", "NonlinearSolveFirstOrder", "NonlinearSolveQuasiNewton", "NonlinearSolveSpectralMethods", "PrecompileTools", "Preferences", "Reexport", "SciMLBase", "Setfield", "SimpleNonlinearSolve", "StaticArraysCore", "SymbolicIndexingInterface"] +git-tree-sha1 = "65439a7cbffd3cbc1434ff81f468c1fcfcc8b813" +uuid = "8913a72c-1f9b-4ce2-8d82-65094dcecaec" +version = "4.26.0" + + [deps.NonlinearSolve.extensions] + NonlinearSolveFastLevenbergMarquardtExt = "FastLevenbergMarquardt" + NonlinearSolveFixedPointAccelerationExt = "FixedPointAcceleration" + NonlinearSolveLeastSquaresOptimExt = "LeastSquaresOptim" + NonlinearSolveMINPACKExt = "MINPACK" + NonlinearSolveNLSolversExt = "NLSolvers" + NonlinearSolveNLsolveExt = ["NLsolve", "LineSearches"] + NonlinearSolvePETScExt = ["PETSc", "MPI", "SparseArrays"] + NonlinearSolveSIAMFANLEquationsExt = "SIAMFANLEquations" + NonlinearSolveSpeedMappingExt = "SpeedMapping" + NonlinearSolveSundialsExt = "Sundials" + + [deps.NonlinearSolve.weakdeps] + FastLevenbergMarquardt = "7a0df574-e128-4d35-8cbd-3d84502bf7ce" + FixedPointAcceleration = "817d07cb-a79a-5c30-9a31-890123675176" + LeastSquaresOptim = "0fc2ff8b-aaa3-5acd-a817-1944a5e08891" + LineSearches = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" + MINPACK = "4854310b-de5a-5eb6-a2a5-c1dee2bd17f9" + MPI = "da04e1cc-30fd-572f-bb4f-1f8673147195" + NLSolvers = "337daf1e-9722-11e9-073e-8b9effe078ba" + NLsolve = "2774e3e8-f4cf-5e23-947b-6d7e65073b56" + PETSc = "ace2c81b-2b5f-4b1e-a30d-d662738edfe0" + SIAMFANLEquations = "084e46ad-d928-497d-ad5e-07fa361a48c4" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + SpeedMapping = "f1835b91-879b-4a3f-a438-e4baacf14412" + Sundials = "c3572dad-4567-51f8-b174-8c6c989267f4" + +[[deps.NonlinearSolveBase]] +deps = ["ADTypes", "Adapt", "ArrayInterface", "CommonSolve", "Compat", "ConcreteStructs", "DifferentiationInterface", "EnumX", "EnzymeCore", "FastClosures", "FunctionWrappers", "FunctionWrappersWrappers", "LinearAlgebra", "LogExpFunctions", "Markdown", "MaybeInplace", "PreallocationTools", "PrecompileTools", "Preferences", "Printf", "RecursiveArrayTools", "RespecializeParams", "SciMLBase", "SciMLJacobianOperators", "SciMLLogging", "SciMLOperators", "SciMLStructures", "Setfield", "StaticArraysCore", "SymbolicIndexingInterface", "TimerOutputs"] +git-tree-sha1 = "05b1365216bd3d12323ff827306917e76386068a" +uuid = "be0214bd-f91f-a760-ac4e-3421ce2b2da0" +version = "2.42.0" + + [deps.NonlinearSolveBase.extensions] + NonlinearSolveBaseBandedMatricesExt = "BandedMatrices" + NonlinearSolveBaseChainRulesCoreExt = "ChainRulesCore" + NonlinearSolveBaseEnzymeExt = ["ChainRulesCore", "Enzyme"] + NonlinearSolveBaseForwardDiffExt = "ForwardDiff" + NonlinearSolveBaseLineSearchExt = "LineSearch" + NonlinearSolveBaseLinearSolveExt = "LinearSolve" + NonlinearSolveBaseMooncakeExt = "Mooncake" + NonlinearSolveBaseReverseDiffExt = "ReverseDiff" + NonlinearSolveBaseSparseArraysExt = "SparseArrays" + NonlinearSolveBaseSparseMatrixColoringsExt = "SparseMatrixColorings" + NonlinearSolveBaseTrackerExt = "Tracker" + + [deps.NonlinearSolveBase.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + LineSearch = "87fe0de2-c867-4266-b59a-2f0a94fc965b" + LinearSolve = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + SparseMatrixColorings = "0a514795-09f3-496d-8182-132a7b665d35" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.NonlinearSolveFirstOrder]] +deps = ["ADTypes", "ArrayInterface", "CommonSolve", "ConcreteStructs", "FiniteDiff", "ForwardDiff", "LineSearch", "LinearAlgebra", "LinearSolve", "MaybeInplace", "NonlinearSolveBase", "PrecompileTools", "Reexport", "SciMLBase", "SciMLJacobianOperators", "SciMLLogging", "Setfield", "StaticArraysCore"] +git-tree-sha1 = "7a59c702a077d19a1d17a48def0ab74073abee24" +uuid = "5959db7a-ea39-4486-b5fe-2dd0bf03d60d" +version = "2.3.1" + +[[deps.NonlinearSolveQuasiNewton]] +deps = ["ArrayInterface", "CommonSolve", "ConcreteStructs", "LinearAlgebra", "LinearSolve", "MaybeInplace", "NonlinearSolveBase", "PrecompileTools", "Reexport", "SciMLBase", "SciMLLogging", "SciMLOperators", "StaticArraysCore"] +git-tree-sha1 = "7945b4c37ffd6f6d782a3e8a6288ad22ba39e081" +uuid = "9a2c21bd-3a47-402d-9113-8faf9a0ee114" +version = "1.15.0" +weakdeps = ["ForwardDiff"] + + [deps.NonlinearSolveQuasiNewton.extensions] + NonlinearSolveQuasiNewtonForwardDiffExt = "ForwardDiff" + +[[deps.NonlinearSolveSpectralMethods]] +deps = ["CommonSolve", "ConcreteStructs", "LineSearch", "MaybeInplace", "NonlinearSolveBase", "PrecompileTools", "Reexport", "SciMLBase", "SciMLLogging"] +git-tree-sha1 = "344e673a0364838836c8f9bc9ea8da5f99e91f2b" +uuid = "26075421-4e9a-44e1-8bd1-420ed7ad02b2" +version = "1.8.0" +weakdeps = ["ForwardDiff"] + + [deps.NonlinearSolveSpectralMethods.extensions] + NonlinearSolveSpectralMethodsForwardDiffExt = "ForwardDiff" + +[[deps.OffsetArrays]] +git-tree-sha1 = "117432e406b5c023f665fa73dc26e79ec3630151" +uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" +version = "1.17.0" +weakdeps = ["Adapt"] + + [deps.OffsetArrays.extensions] + OffsetArraysAdaptExt = "Adapt" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.29+0" + +[[deps.OpenLibm_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "05823500-19ac-5b8b-9628-191a04bc5112" +version = "0.8.7+0" + +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.5.4+0" + +[[deps.OpenSpecFun_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1346c9208249809840c91b26703912dff463d335" +uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e" +version = "0.5.6+0" + +[[deps.OrderedCollections]] +git-tree-sha1 = "94ba93778373a53bfd5a0caaf7d809c445292ff4" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "1.8.2" + +[[deps.OrdinaryDiffEqBDF]] +deps = ["ADTypes", "ArrayInterface", "DiffEqBase", "FastBroadcast", "LinearAlgebra", "MacroTools", "MuladdMacro", "OrdinaryDiffEqCore", "OrdinaryDiffEqDifferentiation", "OrdinaryDiffEqNonlinearSolve", "OrdinaryDiffEqSDIRK", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "TruncatedStacktraces"] +git-tree-sha1 = "1f09822c2fcbe683a811e0e475a23351d0e7b5a4" +uuid = "6ad6398a-0878-4a85-9266-38940aa047c8" +version = "2.4.1" + +[[deps.OrdinaryDiffEqCore]] +deps = ["ADTypes", "Accessors", "Adapt", "ArrayInterface", "BinaryHeaps", "CommonSolve", "ConstructionBase", "DiffEqBase", "DocStringExtensions", "EnumX", "EnzymeCore", "FastBroadcast", "FastClosures", "FastPower", "FindFirstFunctions", "FunctionWrappers", "FunctionWrappersWrappers", "InteractiveUtils", "LinearAlgebra", "Logging", "MacroTools", "MuladdMacro", "PrecompileTools", "Preferences", "Printf", "Random", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLLogging", "SciMLOperators", "SciMLStructures", "SymbolicIndexingInterface", "TruncatedStacktraces"] +git-tree-sha1 = "53a0a4c674bda0829db08412b31e13285ee0f76b" +uuid = "bbf590c4-e513-4bbe-9b18-05decba2e5d8" +version = "4.13.0" + + [deps.OrdinaryDiffEqCore.extensions] + OrdinaryDiffEqCoreMooncakeExt = "Mooncake" + OrdinaryDiffEqCorePolyesterExt = "Polyester" + OrdinaryDiffEqCoreSparseArraysExt = "SparseArrays" + + [deps.OrdinaryDiffEqCore.weakdeps] + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + Polyester = "f517fe37-dbe3-4b94-8317-1923a5111588" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + +[[deps.OrdinaryDiffEqDefault]] +deps = ["ADTypes", "DiffEqBase", "EnumX", "LinearAlgebra", "LinearSolve", "OrdinaryDiffEqBDF", "OrdinaryDiffEqCore", "OrdinaryDiffEqRosenbrock", "OrdinaryDiffEqTsit5", "OrdinaryDiffEqVerner", "PrecompileTools", "Preferences", "SciMLBase"] +git-tree-sha1 = "03f6679bfd35d09cc378fa3dbadbe0c018766296" +uuid = "50262376-6c5a-4cf5-baba-aaf4f84d72d7" +version = "2.4.3" + +[[deps.OrdinaryDiffEqDifferentiation]] +deps = ["ADTypes", "ArrayInterface", "ConcreteStructs", "ConstructionBase", "DiffEqBase", "DifferentiationInterface", "FastBroadcast", "FiniteDiff", "ForwardDiff", "FunctionWrappersWrappers", "LinearAlgebra", "LinearSolve", "OrdinaryDiffEqCore", "SciMLBase", "SciMLOperators", "SparseMatrixColorings", "StaticArraysCore"] +git-tree-sha1 = "d9d3cc8c585a8698548a9a7349590ac0455936ea" +uuid = "4302a76b-040a-498a-8c04-15b101fed76b" +version = "3.7.0" +weakdeps = ["SparseArrays"] + + [deps.OrdinaryDiffEqDifferentiation.extensions] + OrdinaryDiffEqDifferentiationSparseArraysExt = "SparseArrays" + +[[deps.OrdinaryDiffEqNonlinearSolve]] +deps = ["ADTypes", "ArrayInterface", "CommonSolve", "ConstructionBase", "DiffEqBase", "FastBroadcast", "FastClosures", "ForwardDiff", "LinearAlgebra", "LinearSolve", "MuladdMacro", "NonlinearSolve", "NonlinearSolveBase", "OrdinaryDiffEqCore", "OrdinaryDiffEqDifferentiation", "PreallocationTools", "RecursiveArrayTools", "SciMLBase", "SciMLOperators", "SciMLPublic", "SimpleNonlinearSolve", "SparseArrays", "StaticArraysCore"] +git-tree-sha1 = "f09d1b6375a6a8506a16aa7e8de971b4bac96322" +uuid = "127b3ac7-2247-4354-8eb6-78cf4e7c58e8" +version = "2.7.0" + +[[deps.OrdinaryDiffEqRosenbrock]] +deps = ["ADTypes", "ArrayInterface", "DiffEqBase", "DifferentiationInterface", "FastBroadcast", "FiniteDiff", "ForwardDiff", "LinearAlgebra", "LinearSolve", "MacroTools", "MuladdMacro", "OrdinaryDiffEqCore", "OrdinaryDiffEqDifferentiation", "OrdinaryDiffEqRosenbrockTableaus", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase"] +git-tree-sha1 = "e89f1526236ad9f8fb66af6140e6a163e3089788" +uuid = "43230ef6-c299-4910-a778-202eb28ce4ce" +version = "2.6.3" + +[[deps.OrdinaryDiffEqRosenbrockTableaus]] +git-tree-sha1 = "0ecd1c905c82963f8748e82b6d2bf16d2b1bdf2b" +uuid = "b4bd8bb3-f80f-41d2-9b21-73a655b304b9" +version = "2.4.1" + +[[deps.OrdinaryDiffEqSDIRK]] +deps = ["ADTypes", "CommonSolve", "ConstructionBase", "DiffEqBase", "FastBroadcast", "LinearAlgebra", "MacroTools", "MuladdMacro", "OrdinaryDiffEqCore", "OrdinaryDiffEqDifferentiation", "OrdinaryDiffEqNonlinearSolve", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "TruncatedStacktraces"] +git-tree-sha1 = "805c050714d23064eb4f8ee8793604d294938dc0" +uuid = "2d112036-d095-4a1e-ab9a-08536f3ecdbf" +version = "2.8.2" + +[[deps.OrdinaryDiffEqTsit5]] +deps = ["CommonSolve", "DiffEqBase", "FastBroadcast", "LinearAlgebra", "MuladdMacro", "OrdinaryDiffEqCore", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "TruncatedStacktraces"] +git-tree-sha1 = "a680d5d89faf72bfb4886f7d5b80292f65ff81a6" +uuid = "b1df2697-797e-41e3-8120-5422d3b24e4a" +version = "2.1.2" + +[[deps.OrdinaryDiffEqVerner]] +deps = ["DiffEqBase", "FastBroadcast", "LinearAlgebra", "MuladdMacro", "OrdinaryDiffEqCore", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "TruncatedStacktraces"] +git-tree-sha1 = "f7ffc12bf6572a1c55fc58d297d864e6d6cb99e6" +uuid = "79d7bb75-1356-48c1-b8c0-6832512096c2" +version = "2.2.2" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools", "UUIDs"] +git-tree-sha1 = "3de8f5e6e90ebfa8d6d1f86997d6cdcd6a912ff3" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "2.8.7" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.12.1" +weakdeps = ["REPL"] + + [deps.Pkg.extensions] + REPLExt = "REPL" + +[[deps.PoissonRandom]] +deps = ["LogExpFunctions", "PrecompileTools", "Random"] +git-tree-sha1 = "faa278c0dc901606775554f6171350ad962d0e18" +uuid = "e409e4f3-bfea-5376-8464-e040bb5c01ab" +version = "0.4.13" + +[[deps.PooledArrays]] +deps = ["DataAPI", "Future"] +git-tree-sha1 = "36d8b4b899628fb92c2749eb488d884a926614d3" +uuid = "2dfb63ee-cc39-5dd5-95bd-886bf059d720" +version = "1.4.3" + +[[deps.PreallocationTools]] +deps = ["Adapt", "ArrayInterface", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "315eb21a0da58dccdbd29e3c617e3a9fbdd768a8" +uuid = "d236fae5-4411-538c-8e31-a6e3d9e00b46" +version = "1.4.1" + + [deps.PreallocationTools.extensions] + PreallocationToolsEnzymeCoreExt = "EnzymeCore" + PreallocationToolsForwardDiffExt = "ForwardDiff" + PreallocationToolsReverseDiffExt = "ReverseDiff" + PreallocationToolsSparseConnectivityTracerExt = "SparseConnectivityTracer" + + [deps.PreallocationTools.weakdeps] + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseConnectivityTracer = "9f842d2f-2579-4b1d-911e-f412cf18a3f5" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "edbeefc7a4889f528644251bdb5fc9ab5348bc2c" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.3.4" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "8b770b60760d4451834fe79dd483e318eee709c4" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.5.2" + +[[deps.PrettyTables]] +deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "REPL", "Reexport", "StringManipulation", "Tables"] +git-tree-sha1 = "4ac881f5432bd93463a41767a814a45245be22b6" +uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +version = "3.4.6" + + [deps.PrettyTables.extensions] + PrettyTablesExcelExt = "XLSX" + PrettyTablesTypstryExt = "Typstry" + + [deps.PrettyTables.weakdeps] + Typstry = "f0ed7684-a786-439e-b1e3-3b82803b501e" + XLSX = "fdbf4ff8-1666-58a4-91e7-1b58723a45e0" + +[[deps.Primes]] +deps = ["IntegerMathUtils"] +git-tree-sha1 = "25cdd1d20cd005b52fc12cb6be3f75faaf59bb9b" +uuid = "27ebfcd6-29c5-5fa9-bf4b-fb8fc14df3ae" +version = "0.5.7" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.PureKLU]] +deps = ["LinearAlgebra", "PrecompileTools", "SparseArrays"] +git-tree-sha1 = "762c7006b147e31fc7dd272b5e4714aae648e05b" +uuid = "0c0d3e7f-3a8b-4f7e-b6f1-9a4d2e7c1f01" +version = "1.4.0" +weakdeps = ["ForwardDiff"] + + [deps.PureKLU.extensions] + PureKLUForwardDiffExt = "ForwardDiff" + +[[deps.REPL]] +deps = ["InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" +version = "1.11.0" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[deps.ReadOnlyArrays]] +git-tree-sha1 = "e6f7ddf48cf141cb312b078ca21cb2d29d0dc11d" +uuid = "988b38a3-91fc-5605-94a2-ee2116b3bd83" +version = "0.2.0" + +[[deps.ReadOnlyDicts]] +deps = ["DocStringExtensions"] +git-tree-sha1 = "711acef70140078d808be9cd33040f510af57f5e" +uuid = "795d4caa-f5a7-4580-b5d8-c01d53451803" +version = "1.0.1" + +[[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", "LinearAlgebra", "PrecompileTools", "RecipesBase", "SciMLPublic", "StaticArraysCore", "SymbolicIndexingInterface"] +git-tree-sha1 = "89a235781fdda53fe6c8092e4a4ed9ce9cf04ed3" +uuid = "731186ca-8d62-57ce-b412-fbd966d074cd" +version = "4.3.6" + + [deps.RecursiveArrayTools.extensions] + RecursiveArrayToolsCUDAExt = "CUDA" + RecursiveArrayToolsFastBroadcastExt = "FastBroadcast" + RecursiveArrayToolsFastBroadcastPolyesterExt = ["FastBroadcast", "Polyester"] + RecursiveArrayToolsForwardDiffExt = "ForwardDiff" + RecursiveArrayToolsKernelAbstractionsExt = "KernelAbstractions" + RecursiveArrayToolsMeasurementsExt = "Measurements" + RecursiveArrayToolsMonteCarloMeasurementsExt = "MonteCarloMeasurements" + RecursiveArrayToolsMooncakeExt = "Mooncake" + RecursiveArrayToolsReverseDiffExt = ["ReverseDiff", "Zygote"] + RecursiveArrayToolsSparseArraysExt = ["SparseArrays"] + RecursiveArrayToolsStatisticsExt = "Statistics" + RecursiveArrayToolsStructArraysExt = "StructArrays" + RecursiveArrayToolsTablesExt = ["Tables"] + RecursiveArrayToolsTrackerExt = "Tracker" + RecursiveArrayToolsZygoteExt = "Zygote" + + [deps.RecursiveArrayTools.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + FastBroadcast = "7034ab61-46d4-4ed7-9d0f-46aef9175898" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + Polyester = "f517fe37-dbe3-4b94-8317-1923a5111588" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.RelocatableFolders]] +deps = ["SHA", "Scratch"] +git-tree-sha1 = "ffdaf70d81cf6ff22c2b6e733c900c3321cab864" +uuid = "05181044-ff0b-4ac5-8273-598c1e38db00" +version = "1.0.1" + +[[deps.Requires]] +deps = ["UUIDs"] +git-tree-sha1 = "62389eeff14780bfe55195b7204c0d8738436d64" +uuid = "ae029012-a4dd-5104-9daa-d747884805df" +version = "1.3.1" + +[[deps.RespecializeParams]] +deps = ["FunctionWrappersWrappers"] +git-tree-sha1 = "a6b8358681ac20a448dc762770487e25c98a5085" +uuid = "9fe22ead-9e00-4db2-8b46-706a60d40f5e" +version = "1.2.0" + +[[deps.RotationalComponents]] +deps = ["BlockComponents", "CSV", "DyadData", "DyadInterface", "Markdown", "ModelingToolkit", "Moshi", "OrdinaryDiffEqDefault", "PrecompileTools", "RuntimeGeneratedFunctions", "Test"] +git-tree-sha1 = "aea1aeb7607738d03a021cda4b855e39243e742a" +uuid = "824fa3ed-d7dc-4365-8bdf-ac77a1ac2011" +version = "2.5.4" + +[[deps.RuntimeGeneratedFunctions]] +deps = ["ExprTools", "SHA", "Serialization"] +git-tree-sha1 = "65c9e1142f0372bfc16ba14b9edd57737fe0039f" +uuid = "7e49a35a-f44a-4d26-94aa-eba1b4ca6b47" +version = "0.5.24" + +[[deps.SCCNonlinearSolve]] +deps = ["CommonSolve", "NonlinearSolveBase", "PrecompileTools", "SciMLBase", "SymbolicIndexingInterface"] +git-tree-sha1 = "43cf50b6c9b3eba1a2789072aec2f470d3d27ffe" +uuid = "9dfe8606-65a1-4bb3-9748-cb89d1561431" +version = "1.14.1" + + [deps.SCCNonlinearSolve.extensions] + SCCNonlinearSolveChainRulesCoreExt = "ChainRulesCore" + + [deps.SCCNonlinearSolve.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "0.7.0" + +[[deps.SciMLBase]] +deps = ["ADTypes", "Accessors", "Adapt", "ArrayInterface", "CommonSolve", "ConstructionBase", "Distributed", "DocStringExtensions", "EnumX", "FindFirstFunctions", "FunctionWrappersWrappers", "IteratorInterfaceExtensions", "LinearAlgebra", "Logging", "LoggingExtras", "Markdown", "PreallocationTools", "PrecompileTools", "Preferences", "Printf", "Random", "RecipesBase", "RecursiveArrayTools", "RuntimeGeneratedFunctions", "SciMLLogging", "SciMLOperators", "SciMLPublic", "SciMLStructures", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface"] +git-tree-sha1 = "80815d7e32cd4212a592bf699524c4f8c1dcf7d7" +uuid = "0bca4576-84f4-4d90-8ffe-ffa030f20462" +version = "3.44.0" + + [deps.SciMLBase.extensions] + SciMLBaseChainRulesCoreExt = "ChainRulesCore" + SciMLBaseDifferentiationInterfaceExt = "DifferentiationInterface" + SciMLBaseDistributionsExt = "Distributions" + SciMLBaseEnzymeExt = "Enzyme" + SciMLBaseForwardDiffExt = "ForwardDiff" + SciMLBaseFunctionPropertiesExt = "FunctionProperties" + SciMLBaseMakieExt = ["Makie", "GeometryBasics"] + SciMLBaseMeasurementsExt = "Measurements" + SciMLBaseMonteCarloMeasurementsExt = "MonteCarloMeasurements" + SciMLBaseMooncakeExt = "Mooncake" + SciMLBasePartialFunctionsExt = "PartialFunctions" + SciMLBasePyCallExt = "PyCall" + SciMLBasePythonCallExt = "PythonCall" + SciMLBaseRCallExt = "RCall" + SciMLBaseReverseDiffExt = ["ReverseDiff", "ForwardDiff"] + SciMLBaseStaticArraysExt = "StaticArrays" + SciMLBaseTrackerExt = "Tracker" + SciMLBaseZygoteExt = ["Zygote", "ChainRulesCore", "ZygoteRules", "FillArrays"] + + [deps.SciMLBase.weakdeps] + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" + Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + FunctionProperties = "f62d2435-5019-4c03-9749-2d4c77af0cbc" + GeometryBasics = "5c1252a2-5f33-56bf-86c9-59e7332b4326" + Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + PartialFunctions = "570af359-4316-4cb7-8c74-252c00c2016b" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" + RCall = "6f49c342-dc21-5d91-9882-a32aef131414" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + ZygoteRules = "700de1a5-db45-46bc-99cf-38207098b444" + +[[deps.SciMLJacobianOperators]] +deps = ["ADTypes", "ArrayInterface", "ConcreteStructs", "ConstructionBase", "DifferentiationInterface", "FastClosures", "LinearAlgebra", "SciMLBase", "SciMLOperators"] +git-tree-sha1 = "ad167d716fc134c0873c76ba0469ede56a678732" +uuid = "19f34311-ddf3-4b8b-af20-060888a46c0e" +version = "0.1.17" + +[[deps.SciMLLogging]] +deps = ["Logging", "LoggingExtras", "Preferences"] +git-tree-sha1 = "36be2198d9dc476ac27efb1fe0f789d9e1dca01c" +uuid = "a6db7da4-7206-11f0-1eab-35f2a5dbe1d1" +version = "2.0.4" + + [deps.SciMLLogging.extensions] + SciMLLoggingTracyExt = "Tracy" + + [deps.SciMLLogging.weakdeps] + Tracy = "e689c965-62c8-4b79-b2c5-8359227902fd" + +[[deps.SciMLOperators]] +deps = ["Accessors", "Adapt", "ArrayInterface", "DocStringExtensions", "LinearAlgebra", "SciMLPublic"] +git-tree-sha1 = "54333a8ba01ff383643b44d5a97a4bc2c07d4d2f" +uuid = "c0aeaf25-5076-4817-a8d5-81caf7dfa961" +version = "1.26.1" + + [deps.SciMLOperators.extensions] + SciMLOperatorsLoopVectorizationExt = "LoopVectorization" + SciMLOperatorsSparseArraysExt = "SparseArrays" + + [deps.SciMLOperators.weakdeps] + LoopVectorization = "bdcacae8-1622-11e9-2a5c-532679323890" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + +[[deps.SciMLPublic]] +git-tree-sha1 = "cf9aaf8b9ed5db993259ea8b24cf2b7ba9bd3b79" +uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" +version = "1.2.4" + +[[deps.SciMLStructures]] +deps = ["ArrayInterface", "PrecompileTools"] +git-tree-sha1 = "53bf620cb2c3763d41495b2a145611c6ca400dcd" +uuid = "53ae85a6-f571-4167-b2af-e1d143709226" +version = "1.10.4" + +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "9b81b8393e50b7d4e6d0a9f14e192294d3b7c109" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.3.0" + +[[deps.SentinelArrays]] +deps = ["Dates", "Random"] +git-tree-sha1 = "084c47c7c5ce5cfecefa0a98dff69eb3646b5a80" +uuid = "91c51154-3ec4-41a3-a24f-3f23e20d615c" +version = "1.4.10" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" +version = "1.11.0" + +[[deps.Setfield]] +deps = ["ConstructionBase", "Future", "MacroTools", "StaticArraysCore"] +git-tree-sha1 = "c5391c6ace3bc430ca630251d02ea9687169ca68" +uuid = "efcf1570-3423-57d1-acb7-fd33fddbac46" +version = "1.1.2" + +[[deps.SimpleNonlinearSolve]] +deps = ["ADTypes", "ArrayInterface", "BracketingNonlinearSolve", "CommonSolve", "ConcreteStructs", "DifferentiationInterface", "FastClosures", "FiniteDiff", "ForwardDiff", "LineSearch", "LinearAlgebra", "MaybeInplace", "NonlinearSolveBase", "PrecompileTools", "Reexport", "SciMLBase", "SciMLLogging", "Setfield", "StaticArraysCore"] +git-tree-sha1 = "bb811cd81991c786a590cc9d00a7add142f5a8b7" +uuid = "727e6d20-b764-4bd8-a329-72de5adea6c7" +version = "2.14.0" + + [deps.SimpleNonlinearSolve.extensions] + SimpleNonlinearSolveChainRulesCoreExt = "ChainRulesCore" + SimpleNonlinearSolveReverseDiffExt = "ReverseDiff" + SimpleNonlinearSolveTrackerExt = "Tracker" + + [deps.SimpleNonlinearSolve.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.SimpleTraits]] +deps = ["InteractiveUtils", "MacroTools"] +git-tree-sha1 = "7ddb0b49c109481b046972c0e4ab02b2127d6a75" +uuid = "699a6c99-e7fa-54fc-8d76-47d257e15c1d" +version = "0.9.6" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" + +[[deps.SortingAlgorithms]] +deps = ["DataStructures"] +git-tree-sha1 = "13cd91cc9be159e3f4d95b857fa2aa383b53772a" +uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c" +version = "1.2.3" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +version = "1.12.0" + +[[deps.SparseColumnPivotedQR]] +deps = ["LinearAlgebra", "PrecompileTools", "SparseArrays"] +git-tree-sha1 = "ee8155fd93f0efc510e4523850bd9e0bb6e03199" +uuid = "a57abbd0-fea5-4d57-96be-5e525945e8e4" +version = "2.1.6" +weakdeps = ["AMD"] + + [deps.SparseColumnPivotedQR.extensions] + SparseColumnPivotedQRAMDExt = "AMD" + +[[deps.SparseMatrixColorings]] +deps = ["ADTypes", "DocStringExtensions", "LinearAlgebra", "PrecompileTools", "Random", "SparseArrays"] +git-tree-sha1 = "f63d76c7b7c329cf11badd564fd8ba877b09c3fe" +uuid = "0a514795-09f3-496d-8182-132a7b665d35" +version = "0.4.27" + + [deps.SparseMatrixColorings.extensions] + SparseMatrixColoringsCUDAExt = ["CUDA", "cuSPARSE"] + SparseMatrixColoringsCliqueTreesExt = "CliqueTrees" + SparseMatrixColoringsColorsExt = "Colors" + SparseMatrixColoringsGPUArraysExt = "GPUArrays" + SparseMatrixColoringsJuMPExt = ["JuMP", "MathOptInterface"] + + [deps.SparseMatrixColorings.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CliqueTrees = "60701a23-6482-424a-84db-faee86b9b1f8" + Colors = "5ae59095-9a9b-59fe-a467-6f913c188581" + GPUArrays = "0c68f7d7-f131-5f86-a1c3-88cf8149b2d7" + JuMP = "4076af6c-e467-56ae-b986-b466b2749572" + MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" + cuSPARSE = "b26da814-b3bc-49ef-b0ee-c816305aa060" + +[[deps.SpecialFunctions]] +deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] +git-tree-sha1 = "c3ac026e735264e9bdc6a9bcbd1b1e781b36e3bc" +uuid = "276daf66-3868-5448-9aa4-cd146d93841b" +version = "2.8.3" + + [deps.SpecialFunctions.extensions] + SpecialFunctionsChainRulesCoreExt = "ChainRulesCore" + + [deps.SpecialFunctions.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + +[[deps.SplitApplyCombine]] +deps = ["Dictionaries", "Indexing"] +git-tree-sha1 = "55db78e829cf726162fc4fc1b30d05f92092f3f6" +uuid = "03a91e81-4c3e-53e1-a0a4-9c0c8f19dd66" +version = "1.3.0" + +[[deps.StarAlgebras]] +deps = ["LinearAlgebra", "MutableArithmetics", "SparseArrays"] +git-tree-sha1 = "235b1f9d287bbf34083b3d0829343a7942c0ad1c" +uuid = "0c0c59c1-dc5f-42e9-9a8b-b5dc384a6cd1" +version = "0.3.0" + +[[deps.StateSelection]] +deps = ["BipartiteGraphs", "DocStringExtensions", "FindFirstFunctions", "Graphs", "LinearAlgebra", "OrderedCollections", "Setfield", "SparseArrays"] +git-tree-sha1 = "461bd8c5dd8f6b036cdc0b95726d7fcc50b634fb" +uuid = "64909d44-ed92-46a8-bbd9-f047dfbdc84b" +version = "1.11.0" + + [deps.StateSelection.extensions] + StateSelectionDeepDiffsExt = "DeepDiffs" + + [deps.StateSelection.weakdeps] + DeepDiffs = "ab62b9b5-e342-54a8-a765-a90f495de1a6" + +[[deps.StaticArrays]] +deps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"] +git-tree-sha1 = "246a8bb2e6667f832eea063c3a56aef96429a3db" +uuid = "90137ffa-7385-5640-81b9-e52037218182" +version = "1.9.18" + + [deps.StaticArrays.extensions] + StaticArraysChainRulesCoreExt = "ChainRulesCore" + StaticArraysStatisticsExt = "Statistics" + + [deps.StaticArrays.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.4" + +[[deps.Statistics]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "ae3bb1eb3bba077cd276bc5cfc337cc65c3075c0" +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.11.1" +weakdeps = ["SparseArrays"] + + [deps.Statistics.extensions] + SparseArraysExt = ["SparseArrays"] + +[[deps.StringManipulation]] +deps = ["PrecompileTools"] +git-tree-sha1 = "8a90c1d77c3277a5d43b83927b3cbe2c70a37484" +uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" +version = "0.4.7" + +[[deps.StructTypes]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "159331b30e94d7b11379037feeb9b690950cace8" +uuid = "856f2bd8-1eba-4b0a-8007-ebc267875bd4" +version = "1.11.0" + +[[deps.StructUtils]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "2d0fc55c61321ba245c47be599570d11bac50303" +uuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42" +version = "2.8.5" + + [deps.StructUtils.extensions] + StructUtilsMeasurementsExt = ["Measurements"] + StructUtilsStaticArraysCoreExt = ["StaticArraysCore"] + StructUtilsTablesExt = ["Tables"] + + [deps.StructUtils.weakdeps] + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + +[[deps.StyledStrings]] +uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" +version = "1.11.0" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "Libdl", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "7.8.3+2" + +[[deps.SymbolicIndexingInterface]] +deps = ["Accessors", "ArrayInterface", "RuntimeGeneratedFunctions", "StaticArraysCore"] +git-tree-sha1 = "ae6fd46b22508c2dfcd0fabf144ce5e9d9d2e719" +uuid = "2efcf032-c050-4f8e-a9bb-153293bab1f5" +version = "0.3.53" +weakdeps = ["PrettyTables"] + + [deps.SymbolicIndexingInterface.extensions] + SymbolicIndexingInterfacePrettyTablesExt = "PrettyTables" + +[[deps.SymbolicLimits]] +deps = ["SymbolicUtils", "TermInterface"] +git-tree-sha1 = "90c1f0a9d1c65e462bdb7180c3ea21e0139e9748" +uuid = "19f23fe9-fdab-4a78-91af-e7b7767979c3" +version = "1.1.5" + +[[deps.SymbolicUtils]] +deps = ["AbstractTrees", "ArrayInterface", "Combinatorics", "ConstructionBase", "DataStructures", "DocStringExtensions", "DynamicPolynomials", "EnumX", "ExproniconLite", "Graphs", "LinearAlgebra", "MacroTools", "Moshi", "MultivariatePolynomials", "MutableArithmetics", "NaNMath", "PrecompileTools", "ReadOnlyArrays", "SciMLPublic", "Setfield", "SparseArrays", "SpecialFunctions", "StaticArraysCore", "SymbolicIndexingInterface", "TaskLocalValues", "TermInterface", "WeakCacheSets"] +git-tree-sha1 = "3bfccb39a7de6ebb9c834cd46909f6a7a009a967" +uuid = "d1185830-fcd6-423d-90d6-eec64667417b" +version = "4.45.0" + + [deps.SymbolicUtils.extensions] + SymbolicUtilsChainRulesCoreExt = "ChainRulesCore" + SymbolicUtilsDistributionsExt = "Distributions" + SymbolicUtilsLabelledArraysExt = "LabelledArrays" + SymbolicUtilsReverseDiffExt = "ReverseDiff" + + [deps.SymbolicUtils.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" + LabelledArrays = "2ee39098-c373-598a-b85f-a56591580800" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + +[[deps.Symbolics]] +deps = ["ADTypes", "AbstractPlutoDingetjes", "ArrayInterface", "Bijections", "CommonWorldInvalidations", "ConstructionBase", "DataStructures", "DiffRules", "DocStringExtensions", "DomainSets", "DynamicPolynomials", "IntervalSets", "Libdl", "LinearAlgebra", "LogExpFunctions", "MacroTools", "Markdown", "Moshi", "MultivariatePolynomials", "MutableArithmetics", "NaNMath", "PrecompileTools", "Preferences", "Primes", "RecipesBase", "Reexport", "RuntimeGeneratedFunctions", "SciMLPublic", "Setfield", "SparseArrays", "SpecialFunctions", "StaticArraysCore", "SymbolicIndexingInterface", "SymbolicLimits", "SymbolicUtils", "TermInterface"] +git-tree-sha1 = "83ae8cd3decb77ab9bcde0ed19f211a879335a3f" +uuid = "0c5d862f-8b57-4792-8d23-62f2024744c7" +version = "7.36.0" + + [deps.Symbolics.extensions] + SymbolicsD3TreesExt = "D3Trees" + SymbolicsDistributionsExt = "Distributions" + SymbolicsForwardDiffExt = "ForwardDiff" + SymbolicsGroebnerExt = "Groebner" + SymbolicsHypergeometricFunctionsExt = "HypergeometricFunctions" + SymbolicsLatexifyExt = ["Latexify", "LaTeXStrings"] + SymbolicsNemoExt = "Nemo" + SymbolicsPreallocationToolsExt = ["PreallocationTools", "ForwardDiff"] + SymbolicsSymPyExt = "SymPy" + SymbolicsSymPyPythonCallExt = "SymPyPythonCall" + + [deps.Symbolics.weakdeps] + D3Trees = "e3df1716-f71e-5df9-9e2d-98e193103c45" + Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + Groebner = "0b43b601-686d-58a3-8a1c-6623616c7cd4" + HypergeometricFunctions = "34004b35-14d8-5ef3-9330-4cdb6864b03a" + LaTeXStrings = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" + Latexify = "23fbe1c1-3f47-55db-b15f-69d7ec21a316" + Nemo = "2edaba10-b0f1-5616-af89-8c11ac63239a" + PreallocationTools = "d236fae5-4411-538c-8e31-a6e3d9e00b46" + SymPy = "24249f21-da20-56a4-8eb1-6a02cf4ae2e6" + SymPyPythonCall = "bc8888f7-b21e-4b7c-a06a-5d9c9496438c" + +[[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", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "0f38a06c83f0007bbab3cf911262841c9a0f07e0" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.13.0" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.TaskLocalValues]] +git-tree-sha1 = "67e469338d9ce74fc578f7db1736a74d93a49eb8" +uuid = "ed4db957-447d-4319-bfb6-7fa9ae7ecf34" +version = "0.1.3" + +[[deps.TermInterface]] +git-tree-sha1 = "d673e0aca9e46a2f63720201f55cc7b3e7169b16" +uuid = "8ea1fca8-c5ef-4a55-8b96-4e9afe9c9a3c" +version = "2.0.0" + +[[deps.Test]] +deps = ["InteractiveUtils", "Logging", "Random", "Serialization"] +uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" +version = "1.11.0" + +[[deps.TimerOutputs]] +deps = ["ExprTools", "PrettyTables", "Printf", "Tables"] +git-tree-sha1 = "4495ef304cbae61e1ac43f8770262cb5d0c94a11" +uuid = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f" +version = "1.1.1" + + [deps.TimerOutputs.extensions] + FlameGraphsExt = "FlameGraphs" + + [deps.TimerOutputs.weakdeps] + FlameGraphs = "08572546-2f56-4bcf-ba4e-bab62c3a3f89" + +[[deps.TranscodingStreams]] +git-tree-sha1 = "0c45878dcfdcfa8480052b6ab162cdd138781742" +uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa" +version = "0.11.3" + +[[deps.TruncatedStacktraces]] +deps = ["InteractiveUtils", "MacroTools", "Preferences"] +git-tree-sha1 = "ea3e54c2bdde39062abf5a9758a23735558705e1" +uuid = "781d530d-4396-4725-bb49-402e4bee1e77" +version = "1.4.0" + +[[deps.TypedTables]] +deps = ["Adapt", "Dictionaries", "Indexing", "SplitApplyCombine", "Tables", "Unicode"] +git-tree-sha1 = "84fd7dadde577e01eb4323b7e7b9cb51c62c60d4" +uuid = "9d95f2ec-7b3d-5a63-8d20-e2491e220bb9" +version = "1.4.6" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.UnPack]] +git-tree-sha1 = "387c1f73762231e86e0c9c5443ce3b4a0a9a0c2b" +uuid = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" +version = "1.0.2" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.UnsafeAtomics]] +git-tree-sha1 = "0f30765c32d66d58e41f4cb5624d4fc8a82ec13b" +uuid = "013be700-e6cd-48c3-b4a1-df204f14c38f" +version = "0.3.1" + + [deps.UnsafeAtomics.extensions] + UnsafeAtomicsLLVM = ["LLVM"] + + [deps.UnsafeAtomics.weakdeps] + LLVM = "929cbde3-209d-540e-8aea-75f648917ca0" + +[[deps.WeakCacheSets]] +git-tree-sha1 = "386050ae4353310d8ff9c228f83b1affca2f7f38" +uuid = "d30d5f5c-d141-4870-aa07-aabb0f5fe7d5" +version = "0.1.0" + +[[deps.WeakRefStrings]] +deps = ["DataAPI", "InlineStrings", "Parsers"] +git-tree-sha1 = "0716e01c3b40413de5dedbc9c5c69f27cddfddfc" +uuid = "ea10d353-3f73-51f8-a26c-33c1cb351aa5" +version = "1.4.3" + +[[deps.WorkerUtilities]] +git-tree-sha1 = "cd1659ba0d57b71a464a29e64dbc67cfe83d54e7" +uuid = "76eceee3-57b5-4d4a-8e66-0e911cebbf60" +version = "1.6.1" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.3.1+2" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.15.0+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.64.0+1" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "da8c1f6eee04831f14edcfa5dae611d309807e57" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2022.3.0+0" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.7.0+0" diff --git a/Project.toml b/Project.toml index bcbd01c..615f7e2 100644 --- a/Project.toml +++ b/Project.toml @@ -1,33 +1,39 @@ name = "JuliaCon2026Components" uuid = "cb0cf210-d080-4a98-89fc-0e4ae9a4086e" -authors = [" <>"] version = "0.1.0" +authors = [" <>"] [deps] -Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a" +BlockComponents = "1ef5d832-be8e-447f-9f2c-8b5d17d15fd3" +DyadData = "cab12561-e36c-4498-ae70-c9a5e79fef2a" DyadInterface = "99806f68-afab-45ca-9d8c-ceff6bc61f54" JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a" ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78" Moshi = "2e0e35c7-a2e4-4343-998d-7ef72827ed2d" OrdinaryDiffEqDefault = "50262376-6c5a-4cf5-baba-aaf4f84d72d7" PrecompileTools = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +RotationalComponents = "824fa3ed-d7dc-4365-8bdf-ac77a1ac2011" RuntimeGeneratedFunctions = "7e49a35a-f44a-4d26-94aa-eba1b4ca6b47" TOML = "fa267f1f-6049-4f14-aa54-33bafae1ed76" [compat] -Markdown = "1" +BlockComponents = "4.5.2" +DyadData = "2.0.1" JSON = "0.21, 1" +Markdown = "1" +RotationalComponents = "2.5.4" TOML = "1" +[dyad] +kernel = "3.3.0" + [extras] -DyadEcosystemDependencies = "7bc808db-8006-421e-b546-062440d520b7" CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" +DyadEcosystemDependencies = "7bc808db-8006-421e-b546-062440d520b7" Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" [targets] -test = ["DyadEcosystemDependencies","CSV","DataFrames","Plots","Test"] - -[dyad] -kernel = "3.3.0" \ No newline at end of file +test = ["DyadEcosystemDependencies", "CSV", "DataFrames", "Plots", "Test"] diff --git a/agent_resources/docs/analyses.md b/agent_resources/docs/analyses.md new file mode 100644 index 0000000..bdfee08 --- /dev/null +++ b/agent_resources/docs/analyses.md @@ -0,0 +1,428 @@ +--- +description: All Dyad analysis types (transient, steady-state, control, calibration, discovery, FMU) and accessing their results in Julia +--- + +# Dyad Analysis Reference + +In Dyad, an analysis is a way to operate on or run a model. +A typical workflow in Dyad is to create a set of components, and then create an +analysis that runs on the entry point to that set of components. It produces a +solution object that provides information about the model, and can be used to +build various visualizations. + +The typical user flow is to extend some partial analysis or built-in analysis and provide the model and whatever parameters are necessary in Dyad. + +For example, here's how you would create a first order component and then simulate it: + +```dyad +""" +Minimal first-order lag block with transfer function k/(sT + 1). +Matches standard BlockComponents.Continuous.FirstOrder patterns. +""" +component SimpleFirstOrder + "Output signal port" + y = RealOutput() + "State variable representing filtered value" + variable x::Real + "Time constant and gain" + parameter T::Real = 1.0 + parameter k::Real = 1.0 +relations + der(x) = (k - x)/T + y = x +end + +analysis SimpleFirstOrderTransient + extends TransientAnalysis(stop = 10.0) + model = SimpleFirstOrder() +end +``` + +You can also override parameters in the model via the analysis: + +```dyad +analysis SimpleFirstOrderTransient + extends TransientAnalysis(stop = 10.0) + model = SimpleFirstOrder(T = Tconst, k = 2.0) + parameter Tconst::Real = 1.0 +end +``` + +The way to run these analyses is to invoke them in Julia. + +```julia +using MyLibrary +result = SimpleFirstOrderTransient() +``` + +You can also pass parameters as keyword arguments to the analysis: +```julia +result = SimpleFirstOrderTransient(Tconst = 2.0) +``` + +## How analyses run under the hood + +When an analysis runs, **two separate systems are compiled**, each with its own balance check: + +1. **Main system** — `simplify_model(model)` compiles the equations of motion (internally `mtkcompile` plus the Dyad compiler passes). Checks that the number of equations matches the number of unknowns. Failure here means a structural issue (missing equations, unconnected ports, etc.). + +2. **Initialization system** — A separate nonlinear system is built from your `initial` and `guess` statements, then compiled with `mtkcompile(init_system; fully_determined=true)`. Checks that initialization equations exactly match initialization unknowns. Failure here means wrong number of initial conditions (too many or too few). + +Both throw `ExtraVariablesSystemException` or `ExtraEquationsSystemException` with "The system is unbalanced." The error message does not say which system failed, but the stacktrace will show `InitializationProblem` for initialization failures vs `get_simplified_model` for structural failures. + +**Default solvers:** + +| Analysis | Default `alg` | Resolves to | +|----------|--------------|-------------| +| TransientAnalysis | `ODEAlg.Auto()` | `DefaultODEAlgorithm(autodiff = AutoForwardDiff())` | +| TransientAnalysis with `alg=AutoImplicit` | `ODEAlg.AutoImplicit()` | `DefaultImplicitODEAlgorithm()` | +| SteadyStateAnalysis | `NonlinearSolveAlg.Auto()` | `FastShortcutNonlinearPolyalg()` | + +**Note:** the defaults above are what the Dyad kernel emits for `extends TransientAnalysis(...)`. If `DyadInterface.TransientAnalysis` is invoked directly from Julia (without going through Dyad), the field defaults in DyadInterface's `TransientAnalysisSpec` differ: `alg` defaults to `ODEAlg.AutoImplicit()`, which resolves to `DefaultImplicitODEAlgorithm()`, and `optimize` defaults to `OptimizationLevel.Aggressive()` instead of `OptimizationLevel.None()`. + +**To emulate the full Dyad analysis pipeline in Julia:** + +```julia +using ProjectName +using ModelingToolkit, DyadInterface + +# @named is required for all MTK constructors +@named m = TestHarness() +sys = simplify_model(m) + +# After simplify_model, use sys. to reference variables +prob = ODEProblem(sys, [sys.x => 0.0, sys.y => 0.0], (0.0, 10.0); fully_determined=true) + +# solve() auto-selects algorithm — no solver import needed +sol = solve(prob) +``` + +If step 1 passes but step 2 fails, the issue is initialization — not structural. Adjust the number of initial conditions, not the model equations. + +## Accessing Solution Data in Julia + +Once you run an analysis, you can access the solution data using symbolic indexing. This works for any analysis result that implements `SymbolicIndexingInterface.symbolic_container`: + +```julia +using DyadInterface: symbolic_container + +result = MyAnalysis() +sol = result.sol +model = symbolic_container(result) + +# Direct component.variable access (recommended) +temperature = sol[model.heat_capacitor.T] +voltage = sol[model.resistor.v] + +# String-based variable access (convenient for plotting) +plot(sol, idxs = sol."heat_capacitor.T") +plot(sol, idxs = sol."resistor.v") # works with nested component paths + +# Using Symbol with ₊ separator +temperature = sol[Symbol("heat_capacitor₊T")] + +# Time points and interpolation +times = sol.t # All time points +state_at_50s = sol(50.0) # Interpolated state at t=50 +value_at_50s = sol(50.0)[1] # First state variable at t=50 + +# Plotting multiple variables +using Plots +plot(sol.t, sol[model.component1.x], label="Component 1") +plot!(sol.t, sol[model.component2.x], label="Component 2") +``` + +The solution preserves your model's hierarchical structure, allowing intuitive access to variables using the same component.variable syntax from your Dyad model. + +The string-based access (`sol."variable_name"`) returns the symbolic variable, which is useful for passing to `plot(sol, idxs=...)` without needing to extract the model separately via `symbolic_container`. + +The same string-dot syntax also works on the **analysis result itself**, so you can skip the `result.sol` unwrapping: + +```julia +result = MyAnalysis() + +# String-dot syntax works directly on the analysis result +sym = result."heat_capacitor.T" # symbolic variable for heat_capacitor.T +plot(result, idxs = result."heat_capacitor.T") +plot(result, idxs = result."cars.engine.flange_a.s") # nested paths +``` + +This works for any analysis whose author has implemented `SymbolicIndexingInterface.symbolic_container(::MyAnalysisSolution)` — every built-in analysis does. + +You can also retrieve the model directly from the result using `get_model`: + +```julia +using DyadInterface: get_model + +result = MyAnalysis() +model = get_model(result) # returns the compiled model from the solution +``` + +Note that `result.spec.model` is the original model *before* structural simplification. If you need the simplified system (e.g., to inspect which variables were eliminated), use the `:SimplifiedSystem` artifact or `symbolic_container(result)`. + +## Artifacts + +Every analysis result supports the `artifacts` API, which provides structured outputs like plots, DataFrames, and downloadable files. This is the primary way to extract results from any analysis. + +### Querying Available Artifacts + +```julia +result = MyAnalysis() + +# List all available artifact names +artifacts(result) +# => [:SimulationSolutionPlot, :SimulationSolutionTable, :ObservablesTable, :RawSolution, ...] + +# Generate a specific artifact +table = artifacts(result, :SimulationSolutionTable) # Returns a DataFrame +plot = artifacts(result, :SimulationSolutionPlot) # Returns a Plots.jl plot +raw = artifacts(result, :RawSolution) # Returns the underlying solver result +``` + +### Artifact Types + +Each artifact has a type that determines what it returns: + +| Type | Returns | Description | +|------|---------|-------------| +| `PlotlyPlot` | Plots.jl plot | Visualizations rendered with the Plotly backend | +| `DataFrame` | DataFrames.jl table | Tabular data for inspection or export | +| `Download` | Downloadable blob | Files like CSV exports, FMU binaries, etc. | +| `Native` | Julia object | Raw solver objects for advanced usage | + +### Solution Metadata + +Use `AnalysisSolutionMetadata` to inspect what an analysis result provides: + +```julia +metadata = AnalysisSolutionMetadata(result) + +# Available artifacts with their types and descriptions +metadata.artifacts # Vector{ArtifactMetadata} +metadata.artifacts[1].name # :SimulationSolutionPlot +metadata.artifacts[1].type # ArtifactType.PlotlyPlot +metadata.artifacts[1].title # "Solution plot" + +# Symbol groups — which variables are available +metadata.symbol_groups # Dict{Symbol, Vector{Symbol}} +metadata.symbol_groups[:unknowns] # [:x, :y, ...] +metadata.symbol_groups[:observables] # [:u, ...] +``` + +### Custom Visualization + +TransientAnalysis and CalibrationAnalysis results support custom visualizations where you select which variables to plot: + +```julia +using DyadInterface: PlotlyVisualizationSpec, customizable_visualization + +vizspec = PlotlyVisualizationSpec([:x, :y]) +custom_plot = customizable_visualization(result, vizspec) +``` + +## Related Documentation + +For advanced analysis features: + +- **[functions.md](functions.md)** - Using Julia functions to compute complex parameter values in analyses +- **[arrays.md](arrays.md)** - Working with arrays of components in analyses +- **[plotting.md](plotting.md)** - Visualizing analysis results + +## Built-in Analyses + + +### TransientAnalysis + +**Purpose:** Simulates a system over time, given a component. +Solves initial value problems for differential-algebraic equations to capture dynamic behavior. + +**Required:** +- `model` — the component to simulate +- `stop` — end time for the integration + +**Optional:** + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `start` | `0` | Start time for the integration | +| `alg` | `ODEAlg.Auto()` | ODE solver algorithm. Variants: `Auto`, `AutoImplicit`, `Tsit5`, `Rodas5P`, `FBDF`. From Julia, `ODEAlg.NativeAlgorithm(alg, mod)` wraps any SciML ODE solver beyond the built-in variants | +| `abstol` | `1e-6` | Absolute tolerance for the solver | +| `reltol` | `1e-6` | Relative tolerance for the solver | +| `saveat` | `0` | Time interval for saving solution points, or a vector of explicit save times. `0` lets the integrator choose | +| `dtmax` | `0` | Maximum allowed timestep. `0` lets the integrator choose | +| `tstops` | `[]` | Time points where the integrator must step exactly. Useful when you know where discontinuities or events occur — forces the solver to land on those times rather than stepping over them | +| `automatic_discontinuity_detection` | `false` | When `true`, applies the `ModelingToolkit.IfLifting` pass during `mtkcompile`, which automatically detects and handles `if`/`else` discontinuities in the model equations | +| `optimize` | `OptimizationLevel.None()` | Code optimization level applied by DyadCompilerPasses. Variants: `None`, `Basic`, `Aggressive` | +| `progress` | `true` | When `true`, displays solver progress during integration | +| `respecialize` | `false` | When `true`, calls `ModelingToolkit.respecialize` on the compiled system after `mtkcompile`. This specializes nonnumeric parameters (e.g. abstractly typed containers) to their concrete types based on their defaults. Required for FMU generation and can improve simulation performance for models with complex parameter types (e.g. fluid medium models) | +| `verbose` | `DEVerbosity.Standard()` | Solver logging verbosity preset. Variants: `None`, `Minimal`, `Standard`, `Detailed`, `All` | +| `log_file` | `""` | Path to a log file for solver output. Empty string disables file logging | + +**Output:** Time series solution, plots, solution tables. As a special case, any TransientAnalysis is plottable via `plot(result; attributes...)`. + +### SteadyStateAnalysis + +**Purpose:** Finds equilibrium where system derivatives equal zero. +Useful for determining operating points and static analysis of systems at rest. + +**Required:** +- `model` — the component to find the equilibrium of + +**Optional:** + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `alg` | `NonlinearSolveAlg.Auto()` | Nonlinear solver algorithm. Variants: `Auto` (polyalgorithm), `TrustRegion`, `LevenbergMarquardt`, `NewtonRaphson` | +| `abstol` | `1e-8` | Absolute tolerance for the solver | +| `reltol` | `1e-8` | Relative tolerance for the solver | +| `automatic_discontinuity_detection` | `false` | When `true`, applies the `ModelingToolkit.IfLifting` pass during `mtkcompile`, which automatically detects and handles `if`/`else` discontinuities in the model equations | +| `respecialize` | `false` | When `true`, calls `ModelingToolkit.respecialize` on the compiled system after `mtkcompile`. This specializes nonnumeric parameters (e.g. abstractly typed containers) to their concrete types based on their defaults. Required for FMU generation and can improve simulation performance for models with complex parameter types (e.g. fluid medium models) | + +**Output:** Steady state variable values, DataFrame + +## Control Analyses (DyadControlSystems.jl) + +### ClosedLoopAnalysis +**Purpose:** Analyzes feedback system frequency/time-domain properties via linearization. +Evaluates stability margins, sensitivity functions, and closed-loop performance characteristics. +- **Required:** `model`, `measurement` (vector), `control_input` (vector) +- **Optional:** `wl=-1`, `wu=-1`, `num_frequencies=300`, `pos_feedback=true`, `duration=-1.0`, `loop_openings=[]`, `t=0.0` +- **Output:** Bode plots, disk/classical margins, step responses + +### ClosedLoopSensitivityAnalysis +**Purpose:** Computes sensitivity function S=1/(1+PC) to assess robustness. +Determines how sensitive the closed-loop system is to disturbances and model uncertainties. +- **Required:** `model`, `analysis_points` (vector) +- **Optional:** `loop_openings=[]`, `wl=-1.0`, `wu=-1.0`, `t=0.0` +- **Output:** Sensitivity Bode plot, H-infinity norm, phase/gain margin bounds + +### LinearAnalysis +**Purpose:** Linearizes model for small-signal frequency/time-domain analysis. +Provides comprehensive linear system analysis including poles, zeros, and frequency response. +- **Required:** `model`, `inputs` (vector), `outputs` (vector) +- **Optional:** `wl=-1`, `wu=-1`, `num_frequencies=3000`, `duration=-1`, `loop_openings=[]`, `t=0.0` +- **Output:** Bode/margin/step/root-locus plots, damping/observability reports + +### PIDAutotuningAnalysis +**Purpose:** Automatically optimizes PID gains for frequency-domain robustness. +Uses optimization to find controller parameters that satisfy sensitivity constraints while maximizing performance. +- **Required:** `model`, `measurement`, `control_input` +- **Optional:** `step_input=control_input`, `step_output=measurement`, `loop_openings=[]`, `ref=0.0`, `Ts=-1.0` (sampling), `duration=-1.0`, `Ms=1.5`, `Mt=1.5`, `Mt_nyquist=0.1`, `Mks=1e300`, `disc="tustin"`, `filter_order=2`, `timeweight=false`, `optimize_d=false`, `wl=-1`, `wu=-1`, `num_frequencies=200`, `tol=1e-6`, `verbose=true`, `t=0.0`, `soft=false`, `soft_penalty=1e6`, `exact_hessian=false`, `scale=true` +- **Gain bounds and guesses:** `kp_lb=0.0`, `ki_lb=0.0`, `kd_lb=0.0`, `Tf_lb=1e-16`, `kp_ub=1e300`, `ki_ub=1e300`, `kd_ub=1e300`, `Tf_ub=1e300`, `kp_guess=-1`, `ki_guess=-1`, `kd_guess=-1`, `Tf_guess=-1` (a guess of `-1` lets the optimizer choose) +- **Output:** Optimized PID parameters, sensitivity plots, Nyquist plot + +### FrequencyResponseAnalysis +**Purpose:** Performs frequency response experiments on nonlinear models. +Excites the system with a chirp or other input signal and measures the frequency response at specified outputs. +- **Required:** `model`, `input` (string), `outputs` (vector), `wl`, `wu` +- **Optional:** `loop_openings=[]`, `num_frequencies=50`, `input_type="chirp"`, `amplitude=1.0`, `duration=-1.0`, `Ts=-1.0` +- **Output:** Bode plot of measured frequency response + +### LQGAnalysis +**Purpose:** Designs an optimal Linear-Quadratic-Gaussian (LQG) controller with state feedback and Kalman observer. +Computes optimal gains by solving Riccati equations for the specified cost weights and noise covariances. +- **Required:** `model`, `measurement` (vector), `controlled_output` (vector), `control_input` (vector), `q1_diag`, `q2_diag`, `r1_diag`, `r2_diag` +- **Optional:** `disturbance_inputs=[]`, `loop_openings=[]`, `t=0.0`, `qQ=0.0`, `qR=0.0`, `disc="cont"`, `Ts=-1.0`, `integrator_indices=[]`, `integrator_r1_diag=[]`, `wl=-1`, `wu=-1`, `num_frequencies=3000`, `duration=-1.0` +- **Output:** Controller and observer gains, closed-loop analysis plots + +### PolePlacementAnalysis +**Purpose:** Designs a state feedback controller and observer via pole placement. +Places closed-loop poles to achieve desired damping and bandwidth characteristics. +- **Required:** `model`, `measurement` (vector), `control_input` (vector) +- **Optional:** `loop_openings=[]`, `t=0.0`, `min_damping=0.707`, `controller_speed_factor=1.0`, `observer_speed_factor=5.0`, `min_bandwidth=-1.0`, `max_bandwidth=-1.0`, `direct_controller=false`, `disc="cont"`, `Ts=-1.0`, `integrator_indices=[]`, `integrator_poles=[]`, `wl=-1`, `wu=-1`, `num_frequencies=3000`, `duration=-1.0` +- **Output:** Controller and observer gains, closed-loop analysis plots + +### StateEstimationAnalysis +**Purpose:** Estimates hidden states from noisy measurements using Kalman filtering or smoothing. +Supports Extended Kalman Filter for nonlinear models with configurable noise covariances. +- **Required:** `model`, `outputs` (vector), `disturbance_inputs` (vector), `r1_diag`, `r2_diag` +- **Data:** Either `input_data`/`output_data` matrices or `dataset` (DyadTimeseries) with `input_cols`/`output_cols` +- **Optional:** `inputs=[]`, `estimator="ExtendedKalmanFilter"`, `filtering_mode="filtering"`, `sigma0=1e-4`, `discretization="Rk4"`, `Ts=-1.0`, `plot_confidence=true`, `confidence_level=1.96`, `n_samples=0` +- **Output:** Filtered/smoothed state trajectories, innovation analysis, performance metrics + +### SystemIdentificationAnalysis +**Purpose:** Identifies a linear state-space model from input/output data. +Supports subspace identification and prediction-error methods to build models from experimental measurements. +- **Required:** `Ts` (sampling period), `nx` (model order, integer) +- **Data:** Either `input_data`/`output_data` matrices or `dataset` (DyadTimeseries) with `input_cols`/`output_cols` +- **Optional:** `method="subspaceid"`, `simulation_focus=false`, `stable=false`, `zeroD=false`, `h=1`, `r=10`, `W="MOESP"`, `detrend=true`, `wl=-1.0`, `wu=-1.0`, `num_frequencies=3000`, `duration=-1.0` +- **Output:** Identified model, fit metrics, frequency response + +## Model Calibration (DyadModelOptimizer.jl) + +> **Migration note.** The `calibration_alg`, `optimizer`, and `loss_func` parameters on `CalibrationAnalysis` and the discovery analyses below are dyad enum types (`CalibrationAlg`, `OptimizerAlg`, `LossFunc`), not strings. Older Dyad code may still carry the obsolete string forms (`"SingleShooting"`, `"auto"`, `"l2loss"`, etc.) — translate them to the corresponding enum variant: `CalibrationAlg.SingleShooting()`, `OptimizerAlg.Auto()`, `LossFunc.L2Loss()`. Older code may also pass `N_cols`, `depvars_cols`, or `N_tunables` — these no longer exist (sizes are inferred from the `DyadTimeseries` `data`) — and may omit `calibration_alg` or `optimizer_maxiters`, which are now required. + +**Enum variants:** + +| Enum | Variants | +|------|----------| +| `CalibrationAlg` | `SingleShooting()`, `MultipleShooting()`, `StochasticMultipleShooting(; trajectories, batch_size, block_size=2, sampling="stratified_pairs", learning_rate=1e-3, epochs=5)`, `SplineCollocation()`, `KernelCollocation()` | +| `OptimizerAlg` | `Auto()` (selects MadNLP), `MadNLP()`, `BBO()`, `Adam()`, `LBFGS()`, `Ipopt()` | +| `LossFunc` | `L2Loss()`, `NormMeanSquaredL2Loss()`, `MeanSquaredL2Loss()`, `SquaredL2Loss()`, `ZScoreMeanAbsL1Loss()` | +| `DiagnosticsLevel` | `CalibrationTracking(; track_gradients=false, save_solutions=false, save_interval=1)`, `None()` | + +### CalibrationAnalysis +**Purpose:** Fits model parameters to experimental data via optimization. +Minimizes the difference between simulated and measured outputs to find optimal parameter values. +- **Required:** `model`, `stop`, `data` (DyadTimeseries), `depvars_names`, `search_space_names`, `search_space_lb`, `search_space_ub`, `calibration_alg` (a `CalibrationAlg` variant), `optimizer_maxiters` +- **Optional:** `alg=ODEAlg.Auto()`, `start=0.0`, `abstol=1e-8`, `reltol=1e-8`, `saveat=0`, `dtmax=0`, `loss_func=LossFunc.L2Loss()`, `multiple_shooting_trajectories=0`, `pem_gain=0.0` (a value greater than 0 applies the `DiscreteFixedGainPEM` prediction-error transformation), `optimizer=OptimizerAlg.Auto()`, `optimizer_abstol=1e-4`, `optimizer_maxtime=0.0`, `optimizer_verbose=false`, `diagnostics=DiagnosticsLevel.CalibrationTracking()`, `results_path=""` +- **Output:** Calibrated parameters, comparison plots, parameter tables + +## Model Discovery (DyadModelDiscovery.jl) + +### SystemLevelNNTrainingAnalysis +**Purpose:** Trains a neural network to learn missing dynamics at the ODE system level. +Augments the compiled ODE right-hand side with a NN, then optimizes NN weights to fit observed data. +- **Required:** `model`, `stop`, `data` (DyadTimeseries), `depvars_names`, `calibration_alg` (a `CalibrationAlg` variant), `optimizer_maxiters`, `nn_depth`, `nn_width`, `nn_activation` +- **Optional:** `alg=ODEAlg.Auto()`, `start=0`, `abstol=1e-8`, `reltol=1e-8`, `saveat=0`, `dtmax=0`, `N_inputs=0`, `input_vars=[]`, `N_outputs=0`, `output_vars=[]`, `optimizer=OptimizerAlg.Auto()`, `learning_rate=1e-3`, `wrapper_type="add"`, `use_bias=false`, `first_bias=use_bias`, `scale_input=false`, `scale_output=false`, `nn_rng_seed=42`, `zero_init_last=false`, `nn_model_type="chain"`, `loss_func=LossFunc.L2Loss()`, `pem_gain=0`, `optimizer_abstol=1e-4`, `optimizer_maxtime=0.0`, `optimizer_verbose=false`, `multiple_shooting_trajectories=0`, `diagnostics=DiagnosticsLevel.CalibrationTracking()` +- **Output:** Trained NN weights (`res.r.u`), convergence plot, mean input Jacobian, calibrated simulation + +### SystemLevelUDEAnalysis +**Purpose:** Runs symbolic regression on a trained system-level NN to extract interpretable equations. +Takes trained NN weights from `SystemLevelNNTrainingAnalysis` and discovers symbolic expressions. + +> **Julia-only.** There is no Dyad-level `partial analysis` definition for this analysis, so it cannot be extended from Dyad code. Invoke it from Julia via `DyadModelDiscovery.SystemLevelUDEAnalysisSpec` and `run_analysis`. + +- **Required:** `model`, `stop`, `data` (DyadTimeseries), `depvars_names`, `calibration_alg` (a `CalibrationAlg` variant), `optimizer_maxiters`, `nn_depth`, `nn_width`, `nn_activation`, `training_result_N`, `training_result` (weight vector from step 1), `N_sr_inputs`, `sr_inputs`, `N_sr_outputs`, `sr_outputs`, `maxdepth`, `maxsize` +- **Optional:** `N_inputs=0`, `input_vars=[]`, `N_outputs=0`, `output_vars=[]`, `save_to_file=true`, `results_path=""`, plus all NN and optimizer options from `SystemLevelNNTrainingAnalysis` +- **Output:** Candidate symbolic expressions (`res.candidates`), candidate models that can be simulated + +### NNTrainingAnalysis +**Purpose:** Trains a `NeuralNetworkBlock` embedded in a Dyad component to fit observed data. +References the NN by its component name and optimizes its parameters. +- **Required:** `model`, `stop`, `data` (DyadTimeseries), `depvars_names`, `calibration_alg` (a `CalibrationAlg` variant), `optimizer_maxiters`, `network_component` +- **Optional:** `alg=ODEAlg.Auto()`, `start=0`, `abstol=1e-8`, `reltol=1e-8`, `saveat=0`, `dtmax=0`, `optimizer=OptimizerAlg.Auto()`, `learning_rate=1e-3`, `loss_func=LossFunc.L2Loss()`, `pem_gain=0`, `min_weight=-Inf`, `max_weight=Inf`, `initial_values_path=""`, `results_path=""`, `optimizer_abstol=1e-4`, `optimizer_maxtime=0.0`, `optimizer_verbose=false`, `multiple_shooting_trajectories=0`, `diagnostics=DiagnosticsLevel.CalibrationTracking()` +- **Output:** Trained NN weights (saveable via `results_path`), convergence plot, mean input Jacobian, calibrated simulation + +### SymbolicRegressionUDEAnalysis +**Purpose:** Runs symbolic regression on a trained component-level NN to extract interpretable equations. +Loads trained weights from a CSV file and discovers symbolic expressions that approximate the NN. +- **Required:** `model`, `data` (DyadTimeseries), `depvars_names`, `network_component`, `training_result` (path to CSV), `maxdepth`, `maxsize` +- **Optional:** `alg=ODEAlg.Auto()`, `abstol=1e-8`, `reltol=1e-8`, `loss_func=LossFunc.L2Loss()`, `min_weight=-Inf`, `max_weight=Inf`, `save_to_file=true`, `unary_operators=[]` +- **Output:** Candidate symbolic expressions (`res.candidates`), candidate models that can be simulated + +## FMU Generation (DyadFMUGeneration.jl) + +### FMUAnalysis +**Purpose:** Builds Functional Mock-up Unit from Dyad model for co-simulation or model exchange. +Creates a binary that implements FMI standard, enabling model exchange with other simulation tools. +- **Required:** `model` +- **Optional:** `version="FMI_V2"` (or `"FMI_V3"`), `fmu_type="FMI_BOTH"` (or `"FMI_ME"`, `"FMI_CS"`), `alg=ODEAlg.Auto()` (only for cosimulation), `n_inputs`/`inputs` and `n_outputs`/`outputs` (omit entirely when the model has no input or output connectors — do not pass `n_inputs = 0` or an empty vector), `additional_deps=[]` (extra Julia packages to bundle), `use_juliac=true` (compile the FMU with the `juliac`-based pipeline for small binaries; disabling `respecialize` alongside it may produce a type-unstable model that won't compile), `verbose=false`, `logfile=""`, `respecialize=true` (re-specialize the model based on the current parameters before compilation) +- **Output:** FMU file (.fmu), compliance report + +## Common Parameter Types +- **Time:** Numeric time values +- **String vectors:** Use `["signal1", "signal2"]` format +- **Solver algorithms:** enum variants like `ODEAlg.Auto()` or `NonlinearSolveAlg.Auto()` select automatically +- **Tolerances:** Absolute (abstol) and relative (reltol) numerical tolerances + +## Usage Pattern +```dyad +analysis MyAnalysisName + extends PackageName.AnalysisType( + required_param = value, + optional_param = value + ) + model = MyModel() +end +``` diff --git a/agent_resources/docs/analysis_points.md b/agent_resources/docs/analysis_points.md new file mode 100644 index 0000000..32735bf --- /dev/null +++ b/agent_resources/docs/analysis_points.md @@ -0,0 +1,146 @@ +--- +description: Learn about analysis points in Dyad, their purpose, and how to use them for advanced system analysis. +--- + +# Analysis Points {#analysis_points} + +## What Are Analysis Points? + +Analysis points are special constructs in Dyad that allow users to define specific locations in a model where signal connections can be manipulated for analysis purposes. These points act as named connections, enabling model transformations such as adding inputs and outputs, as well as breaking connections. + +In control systems, analysis points are particularly useful for studying feedback loops, assessing robustness, and performing frequency-domain analyses. They provide a way to isolate and inspect specific parts of a system without altering its overall behavior during simulation. + + +## How to Use Analysis Points in Dyad + +### Syntax Breakdown + +In Dyad, analysis points are declared using the `analysis_point` keyword. The syntax is: + +```dyad +u: analysis_point(output_signal, input_signal) +``` + +Here: +- `u` is the name of the analysis point. +- `output_signal` is a block output, i.e., the causal result of a computation performed by a block. This signal is typically treated as the output variable if the analysis point is marked as an output. +- `input_signal` is a block input. This signal will typically be treated as an input or additively perturbed by a new external input if the analysis point is marked as an input. + +In the most common usage, the analysis-point declaration directly mirrors a `connect` statement between an output and an input, e.g., to add an analysis point to the connection +``` +connect(controller.y, plant.u) +``` +one would add the following relation to the model: +```dyad +u: analysis_point(controller.y, plant.u) +``` +Here, the name `u` is chosen to reflect the common convention of naming control inputs with `u`. The choice of the name `u` here is just an example, you can give it any name. An analysis point may be added to connections with more than one receiving input, but the declaration may only contain a single _output_ (signal source). + +The fact that the declaration of an analysis point is separated from the formation of a connection allows for addition of analysis points to any lower level in the model hierarchy, i.e., analysis points can be added inside pre-existing components from an outer component. + +### Full Example + +Below is a simple example of a feedback system with analysis points: + +```dyad +component TestDCMotorLoadControlled + motor = DCMotor() + ground = ElectricalComponents.Analog.Basic.Ground() + source = ElectricalComponents.Analog.Sources.VoltageSource() + fixed = RotationalComponents.Components.Fixed() + load = RotationalComponents.Sources.TorqueSource() + load_source = BlockComponents.Sources.Step(height=tau_load, start_time=load_step_start_time) + speed_reference = BlockComponents.Sources.Constant(k=w_motor) + controller = BlockComponents.Continuous.LimPID(k=k, Ti=Ti, Td=Td, Nd=Nd, y_max=5, y_min=-5) + signal_ff = BlockComponents.Sources.Constant(k=0) + speed_sensor = RotationalComponents.Sensors.VelocitySensor() + # Motor desired speed + parameter w_motor::AngularVelocity = 1 + # Amplitude of load torque step + parameter tau_load::Torque = -0.3 + # Load step start time + parameter load_step_start_time::Time = 3 + # Controller gain + parameter k::Real = 0.5 + # Controller time constant of the integrator block + parameter Ti::Time = 0.1 + # Controller Time constant of the derivative block + parameter Td::Time = 1e5 + parameter Nd::Real = 10 +relations + initial motor.L1.i = 0 + initial motor.inertia.w = 0 + u: analysis_point(controller.y, source.V) + y: analysis_point(speed_sensor.w, controller.u_m) + r: analysis_point(speed_reference.y, controller.u_s) + connect(load_source.y, load.tau) + connect(source.p, motor.p) + connect(motor.n, source.n, ground.g) + connect(motor.shaft, load.spline) + connect(motor.housing, load.support, fixed.spline) + connect(speed_reference.y, controller.u_s) + connect(speed_sensor.w, controller.u_m) + connect(controller.y, source.V) + connect(controller.u_ff, signal_ff.y) + connect(speed_sensor.spline, motor.shaft) +end +``` + +In this example: +- `u` names the connection from the controller output to the voltage source input. +- `y` names the connection from the speed sensor output to the controller input. +- `r` names the connection from the speed reference to the controller reference input. + +The diagram below illustrates the connections and analysis points in this example, abstracting the controller and plant components into blocks `C` and `P` respectively: + +``` +r ┌─────┐ ┌─────┐ +───►│ │ u │ │ y + │ C ├────►│ P ├─┬─► + ┌►│ │ │ │ │ + │ └─────┘ └─────┘ │ + │ │ + └─────────────────────┘ +``` + + +## Model transformations +To facilitate analysis, ModelingToolkit may, depending on the analysis requested, transform connections and / or add new input variables. This section describes some of the available transformations. + +### Linearization +When linearizing a model between two analysis points, ModelingToolkit will automatically add one perturbation input variable to each input analysis point. For example, in the diagram +``` + ▲ + │e₁ + │ ┌─────┐ +d₁────+──┴──► P ├─────┬──►e₄ + │ └─────┘ y│ + │u │ + │ ┌─────┐ -│ + e₂◄──┴─────┤ C ◄──┬──+───d₂ + └─────┘ │ + │e₃ + ▼ +``` +linearization between analysis points `u` and `y` will add the artificial input variable `d₁`, and linearize between `d₁` and `y`. Note, the result of such a linearization is _not_ the transfer function of the system `P` between `u` and `y`, instead it is the _closed-loop transfer function_ $(I + PC)^{-1}P$ that is obtained with all the connections in the diagram intact. If the transfer function of the isolated system `P` is desired, one may make use of the `loop_openings` feature to break the connections `u` and `y` during the linearization, i.e., by passing `loop_openings = ["u", "y"]` to the analysis. Loop openings are discussed in more detail below. + +### Sensitivity analysis +When computing the sensitivity function in the signal `y` + +``` + ▲ + │e₁ + │ ┌─────┐ +d₁────+──┴──► P ├─────┬──►e₄ + │ └─────┘ y│ + │u │ + │ ┌─────┐ -│ + e₂◄──┴─────┤ C ◄──┬──+───d₂ + └─────┘ │ + │e₃ + ▼ +``` +ModelingToolkit will automatically add the input variable `d₂` and the output variable `e₃`, i.e., the analysis point `y` will be perturbed by an artificial input and the output is taken to be the signal _after_ the perturbation. If, instead, the _complementary_ sensitivity function is requested, ModelingToolkit will add the same input variable `d₂`, but the output will instead be immediately _before_ the perturbation, i.e., the output variable `e₄`. + +### Loop openings +All analysis-point transformations may be combined with _loop openings_. A loop opening is requested by passing the name of one or several analysis points to the argument `loop_openings`. For example, if `loop_openings = ["u"]` while linearizing between the analysis points `u` and `y`, the connection labeled `u` in the diagram above will be broken during the analysis. This will in this case result in the transfer function `P` being computed, rather than the closed-loop transfer function $(I + CP)^{-1}P$ that would be obtained if the loop was not opened. In this case, breaking the connection through `y` is not required in order to isolate the system `P`, since the block `C` is downstream of the analysis point `y`. diff --git a/agent_resources/docs/arrays.md b/agent_resources/docs/arrays.md new file mode 100644 index 0000000..e02ee92 --- /dev/null +++ b/agent_resources/docs/arrays.md @@ -0,0 +1,208 @@ +--- +description: Guide to arrays in Dyad - declaration, initialization, and usage +--- + +# Arrays in Dyad + +Arrays allow working with collections of variables, parameters, and components. Array sizes must be defined using literal integers or structural parameters and cannot change during simulation. + +## Declaration + +```dyad +component ArrayBasics + # Size with literals or structural parameters + structural parameter N::Integer = 5 + + # Single and multi-dimensional arrays + variable x::Real[5] # 1D array + variable matrix::Real[3, 3] # 2D matrix + variable data::Real[N] # Size from structural parameter + parameter temps::Temperature[N] # Typed array +relations + # ... +end +``` +## Initialization + +### Direct Initialization +```dyad +parameter vec::Real[3] = [1.0, 2.0, 3.0] # Literal values +parameter sequence::Real[11] = 0:0.1:1 # Range syntax (0.0 to 1.0) +parameter matrix::Real[2, 2] = [[1, 2], [3, 4]] # 2D array +``` + +### Using Fill +```dyad +structural parameter N::Integer = 10 +parameter ones::Real[N] = fill(1.0, N) # All elements = 1.0 +parameter zeros::Real[N, N] = fill(0.0, N, N) # N×N matrix of zeros +``` + +### Array Comprehensions +```dyad +# Comprehensions only work for COMPONENT arrays, not parameters +resistors = [Resistor(R=i*10) for i in 1:N] # Component array + +# Parameter arrays do NOT support comprehensions +# parameter squares::Real[N] = [i^2 for i in 1:N] # DOESN'T WORK +``` + +**Important:** Array comprehensions in Dyad are limited to component arrays only. For parameter arrays, use: +- Explicit literals: `[1.0, 2.0, 3.0]` +- Fill function: `fill(1.0, N)` +- Functions that return arrays: `MyModule.generate_array(N)` + +## Working with Arrays + +### Indexing (1-based) +```dyad +relations + result = data[1] # First element + matrix[2, 3] = 5.0 # Row 2, column 3 +end +``` + +### Loops in Relations +```dyad +relations + # Initialize all elements + for i in 1:N + initial x[i] = i * 0.1 + end + + # Element-wise operations + for i in 1:N + y[i] = 2 * x[i] + 1 + end + + # Nested loops for matrices + for i in 1:3 + for j in 1:3 + C[i, j] = A[i, j] + B[i, j] + end + end +end +``` + +### Connecting Component Arrays +```dyad +component ChainedMasses + structural parameter N::Integer = 4 + + masses = [Mass(m=1.0) for i in 1:N] + springs = [Spring(c=100.0) for i in 1:(N-1)] + +relations + # Connect in chain + for i in 1:(N-1) + connect(masses[i].flange_b, springs[i].flange_a) + connect(springs[i].flange_b, masses[i+1].flange_a) + end +end +``` + +## Complete Example: Thermal Discretization + +```dyad +component ThermalLayer + structural parameter nNodes::Integer = 5 + + port_a = HeatPort() + port_b = HeatPort() + + # Material properties + "Thermal conductivity" + parameter k::ThermalConductivity = 200.0 + "Layer thickness" + parameter thickness::Length = 0.01 + "Cross-sectional area" + parameter area::Area = 0.01 + + # Arrays for discretized model + "Temperature at each node" + variable T::Temperature[nNodes] + "Heat flow rate between nodes" + variable Q_flow::HeatFlowRate[nNodes+1] + + # Derived parameters + "Thermal resistance per segment" + parameter R_segment::ThermalResistance = thickness/(nNodes * k * area) + "Heat capacity per node" + parameter C_node::HeatCapacity = 100.0 + +relations + # Boundary connections + port_a.Q_flow = Q_flow[1] + port_b.Q_flow = -Q_flow[nNodes+1] + + # Heat flow between nodes + Q_flow[1] = (port_a.T - T[1]) / R_segment + for i in 2:nNodes + Q_flow[i] = (T[i-1] - T[i]) / R_segment + end + Q_flow[nNodes+1] = (T[nNodes] - port_b.T) / R_segment + + # Energy balance at each node + for i in 1:nNodes + C_node * der(T[i]) = Q_flow[i] - Q_flow[i+1] + end + + # Initial linear temperature distribution + for i in 1:nNodes + initial T[i] = 293.15 + 10.0 * (i-1) / (nNodes-1) + end +end +``` + +## Common Pitfalls and Solutions + +### Parameter array comprehensions not supported +```dyad +# WRONG - Parser doesn't support comprehensions for parameters +parameter vals::Real[N] = [i^2 for i in 1:N] # DOESN'T WORK +parameter vals::Real[N] = [ifelse(i < 3, i*2, i*3) for i in 1:N] # DOESN'T WORK + +# CORRECT - Use alternatives: +# Option 1: Explicit literals +parameter vals::Real[5] = [1, 4, 9, 16, 25] + +# Option 2: Fill for uniform values +parameter vals::Real[N] = fill(0.0, N) + +# Option 3: Function that returns array +parameter vals::Real[N] = MyModule.generate_squares(N) + +# Option 4: Initialize in relations (for variables only) +variable vals::Real[N] +relations + for i in 1:N + initial vals[i] = i^2 + end +``` + +### Function calls in parameter arrays are supported +```dyad +# Functions CAN be used if they return arrays +parameter vals::Real[N] = MyModule.compute_values(N) + +# Still valid - fill function +parameter vals::Real[N] = fill(1.0, N) +``` + +### Function calls inside array literals not supported +```dyad +# The parser does NOT allow function calls as elements of an array literal: +parameter arr::Real[3] = [MyModule.func(1.0), + MyModule.func(2.0), + MyModule.func(3.0)] # throws parse error +``` +Use a helper Julia function that returns the whole array (see above) instead. + +## Key Points + +- Arrays use 1-based indexing +- Sizes must be literal integers or structural parameters +- Array comprehensions work only for component arrays, not parameter arrays +- Complex initialization belongs in relations, not declarations +- Structural parameter changes require recompilation +- All array elements must have the same type \ No newline at end of file diff --git a/agent_resources/docs/components.md b/agent_resources/docs/components.md new file mode 100644 index 0000000..0de5728 --- /dev/null +++ b/agent_resources/docs/components.md @@ -0,0 +1,153 @@ +--- +description: Guide to defining components in Dyad +--- + +# Components {#Components} + +Components are the main unit of Dyad. A Dyad "model" is components all the way down, which can use or extend each other. + +Components can contain other components, `variable`s, `parameter`s, and `relation`s. They can also `extend` other components or `partial component`s for code reuse. + +## Using Components from Libraries {#using-library-components} + +Components from other libraries (BlockComponents, ElectricalComponents, etc.) are referenced by their fully qualified name — omitting the namespace fails to compile with "component not found": + +```dyad +component MyCircuit + resistor = ElectricalComponents.Analog.Basic.Resistor(R=100) # fully qualified + filter = BlockComponents.Continuous.FirstOrder(T=0.1, k=2.0) # fully qualified + # capacitor = Capacitor(C=1e-6) # ERROR: Capacitor not found +relations + # component connections and equations... +end +``` + +See [library_namespacing.md](library_namespacing.md) for the full qualification rules (base connectors that need no namespace, sublibraries, common namespaces) and [syntax.md](syntax.md#syntax-importing-libraries) for the `using Lib: Symbol` import form. + +### Inheritance {#syntax-component-inheritance} + +Any component can `extend`, or inherit from, any other component. This means that the new component will have all the variables, parameters, and relations of the base component, plus any additional variables, parameters, and relations defined in itself. + +The way this is done is by using the `extends` keyword in the component definition. Let's say we have a base component `FirstOrder`, which is a simple linear system: + +```dyad +component FirstOrder + variable x::Real + variable k::Real +relations + initial x = 1 + initial k = 1 + der(x) = k +end +``` + + +Now, we can define a new component `SecondOrder` that extends `FirstOrder`, adds a new parameter `z`, and uses it to drive the `k` parameter of `FirstOrder`: + +```dyad +component SecondOrder + extends FirstOrder + parameter z::Real = 1 +relations + der(k) = z +end +``` + +#### Partial components {#syntax-partial-components} + +Partial components are components that are not complete on their own, but can be used as a base for other components. + +You can define a partial component by prefixing the component definition with `partial`. + +```dyad +partial component MyPartialComponent + variable x::Real + parameter y::Real +relations + # ... +end +``` + + +Then, regular components (or other partial components) can extend it: + +```dyad +component MyComponent + extends MyPartialComponent + parameter z::Real +relations + initial x = 0 + der(x) = y + z +end +``` + + +Here, `MyComponent` has all the variables and parameters of `MyPartialComponent`, even though we haven't explicitly written them out in the definition. + +Partial components and inheritance are useful for sharing code between components that have a common structure but differ in their specific parameters and behaviour, like electric circuit parts. + +The advantage of inheritance over simply using a sub-component is namespacing: all the variables and parameters of the base component are available directly in the new component, without having to prefix them with the base component's name. For example, if a base component `MyBaseComponent` has a variable `x` and `MyComponent` extends it, `x` is referred to as `mycomponent.x`; if `MyComponent` instead held a subcomponent `base = MyBaseComponent()`, the same variable would be `mycomponent.base.x`. + +## External Components {#external-components} + +An `external` component is a component whose implementation is written in Julia rather than in Dyad relations. The Dyad declaration specifies only the interface — parameters, connectors, and metadata — and the library author provides the behavior as a hand-written Julia function. + +**Terminology:** `external` refers to where the *implementation* lives (in Julia, outside the Dyad language, but in the same library). It does not mean a component from another library. + +Use an external component when the behavior cannot be expressed with Dyad relations but can be implemented in Julia/MTK. Dyad uses the declared interface to make the component usable in the GUI. + +For a complete worked example — declaration, Julia implementation, file placement, and use in a model — see [external_components.md](external_components.md). + +### Declaring an external component + +Prefix the definition with `external` and declare only the interface: parameters (including structural parameters) and connectors. The compiler rejects anything that implies an implementation — `variable` declarations, subcomponents, and relation equations all raise an `unexpected-implementation` error. An empty `relations` section is allowed as an anchor for metadata: + +```dyad +external component ParameterizedInterpolation + structural parameter interpolation_type::InterpolationType + parameter data::Real[:] + parameter independent_var::Real[:] + "Input value to be interpolated" + u = RealInput() + "Interpolated output value" + y = RealOutput() +relations +metadata { + "Dyad": {"icons": {"default": "dyad://BlockComponents/Interpolation.svg"}} +} +end +``` + +Avoid `extends` in an external component; declare the full interface inline. Parts of the toolchain reject it with an `extends-in-external` error ("External component X cannot extends other components"). + +### Providing the Julia implementation + +For an external component the Dyad compiler generates no behavior. It generates only a stub — a function declaration with no methods — in the `generated/` directory: + +```julia +# generated/Tables/ParameterizedInterpolation_definition.jl (auto-generated) +# The implementation of the function (function ParameterizedInterpolation(; name, params...)) +# must be manually written. +function ParameterizedInterpolation end +export ParameterizedInterpolation +``` + +You write the implementation by hand in a Julia file inside the library's `dyad/` directory and include it from `dyad/module.jl`. The generated `generated/module.jl` automatically includes `dyad/module.jl` when it exists, so the implementation lives alongside the `.dyad` sources and no generated file needs editing. The contract: + +1. **Signature:** `ComponentName(; name, params...)` — keyword arguments only. `name` is always passed by the generated code; the remaining keywords receive the parameter values given at instantiation. +2. **Return value:** a ModelingToolkit `System` constructed with that `name`. Its parameters and connectors must match the interface declared in the Dyad file; internal unknowns and equations are free to be whatever the implementation needs. + +If the external component is declared inside a sub-library, put the files under that sub-library's folder instead: `dyad//module.jl` including `dyad// +