diff --git a/Manifest.toml b/Manifest.toml new file mode 100644 index 00000000..192322be --- /dev/null +++ b/Manifest.toml @@ -0,0 +1,1125 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.10.9" +manifest_format = "2.0" +project_hash = "a942ad98baff80b0127b6e1956867427a4381f8f" + +[[deps.ADNLPModels]] +deps = ["ADTypes", "ForwardDiff", "LinearAlgebra", "NLPModels", "Requires", "ReverseDiff", "SparseArrays", "SparseConnectivityTracer", "SparseMatrixColorings"] +git-tree-sha1 = "c51dc1d4eeb37a40f6aecdd08e5cdcddd8332726" +uuid = "54578032-b7ea-4c30-94aa-7cbd1cce6c9a" +version = "0.8.13" + +[[deps.ADTypes]] +git-tree-sha1 = "27cecae79e5cc9935255f90c53bb831cc3c870d7" +uuid = "47edcb42-4c32-4615-8424-f2b9edc5f35b" +version = "1.18.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.AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.5.0" +weakdeps = ["ChainRulesCore", "Test"] + + [deps.AbstractFFTs.extensions] + AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + +[[deps.Adapt]] +deps = ["LinearAlgebra", "Requires"] +git-tree-sha1 = "7e35fca2bdfba44d797c53dfe63a51fabf39bfc0" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.4.0" +weakdeps = ["SparseArrays", "StaticArrays"] + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + +[[deps.AliasTables]] +deps = ["PtrArrays", "Random"] +git-tree-sha1 = "9876e1e164b144ca45e9e3198d0b689cadfed9ff" +uuid = "66dad0bd-aa9a-41b7-9441-69ab47430ed8" +version = "1.1.3" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.1" + +[[deps.Arpack]] +deps = ["Arpack_jll", "Libdl", "LinearAlgebra", "Logging"] +git-tree-sha1 = "9b9b347613394885fd1c8c7729bfc60528faa436" +uuid = "7d9fca2a-8960-54d3-9f78-7d1dccf2cb97" +version = "0.5.4" + +[[deps.Arpack_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "OpenBLAS_jll", "Pkg"] +git-tree-sha1 = "5ba6c757e8feccf03a1554dfaf3e26b3cfc7fd5e" +uuid = "68821587-b530-5797-8361-c406ea357684" +version = "3.5.1+1" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" + +[[deps.BenchmarkTools]] +deps = ["Compat", "JSON", "Logging", "Printf", "Profile", "Statistics", "UUIDs"] +git-tree-sha1 = "e38fbc49a620f5d0b660d7f543db1009fe0f8336" +uuid = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" +version = "1.6.0" + +[[deps.Bzip2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1b96ea4a01afe0ea4090c5c8039690672dd13f2e" +uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0" +version = "1.0.9+0" + +[[deps.ChainRulesCore]] +deps = ["Compat", "LinearAlgebra"] +git-tree-sha1 = "e4c6a16e77171a5f5e25e9646617ab1c276c5607" +uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" +version = "1.26.0" +weakdeps = ["SparseArrays"] + + [deps.ChainRulesCore.extensions] + ChainRulesCoreSparseArraysExt = "SparseArrays" + +[[deps.ChunkCodecCore]] +git-tree-sha1 = "51f4c10ee01bda57371e977931de39ee0f0cdb3e" +uuid = "0b6fb165-00bc-4d37-ab8b-79f91016dbe1" +version = "1.0.0" + +[[deps.ChunkCodecLibZlib]] +deps = ["ChunkCodecCore", "Zlib_jll"] +git-tree-sha1 = "cee8104904c53d39eb94fd06cbe60cb5acde7177" +uuid = "4c0bbee4-addc-4d73-81a0-b6caacae83c8" +version = "1.0.0" + +[[deps.ChunkCodecLibZstd]] +deps = ["ChunkCodecCore", "Zstd_jll"] +git-tree-sha1 = "34d9873079e4cb3d0c62926a225136824677073f" +uuid = "55437552-ac27-4d47-9aa3-63184e8fd398" +version = "1.0.0" + +[[deps.CodecBzip2]] +deps = ["Bzip2_jll", "TranscodingStreams"] +git-tree-sha1 = "84990fa864b7f2b4901901ca12736e45ee79068c" +uuid = "523fee87-0ab8-5b00-afb7-3ecf72e48cfd" +version = "0.8.5" + +[[deps.CodecZlib]] +deps = ["TranscodingStreams", "Zlib_jll"] +git-tree-sha1 = "962834c22b66e32aa10f7611c08c8ca4e20749a9" +uuid = "944b1d66-785c-5afd-91f1-9de20f533193" +version = "0.7.8" + +[[deps.ColorTypes]] +deps = ["FixedPointNumbers", "Random"] +git-tree-sha1 = "b10d0b65641d57b8b4d5e234446582de5047050d" +uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f" +version = "0.11.5" + +[[deps.Colors]] +deps = ["ColorTypes", "FixedPointNumbers", "Reexport"] +git-tree-sha1 = "362a287c3aa50601b0bc359053d5c2468f0e7ce0" +uuid = "5ae59095-9a9b-59fe-a467-6f913c188581" +version = "0.12.11" + +[[deps.CommonSolve]] +git-tree-sha1 = "0eee5eb66b1cf62cd6ad1b460238e60e4b09400c" +uuid = "38540f10-b2f7-11e9-35d8-d573e4eb0ff2" +version = "0.2.4" + +[[deps.CommonSubexpressions]] +deps = ["MacroTools"] +git-tree-sha1 = "cda2cfaebb4be89c9084adaca7dd7333369715c5" +uuid = "bbf7d656-a473-5ed7-a52c-81e309532950" +version = "0.3.1" + +[[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.1.1+0" + +[[deps.ConstructionBase]] +git-tree-sha1 = "b4b092499347b18a015186eae3042f72267106cb" +uuid = "187b0558-2788-49d3-abe0-74a17ed4e7c9" +version = "1.6.0" + + [deps.ConstructionBase.extensions] + ConstructionBaseIntervalSetsExt = "IntervalSets" + ConstructionBaseLinearAlgebraExt = "LinearAlgebra" + ConstructionBaseStaticArraysExt = "StaticArrays" + + [deps.ConstructionBase.weakdeps] + IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.Crayons]] +git-tree-sha1 = "249fe38abf76d48563e2f4556bebd215aa317e15" +uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f" +version = "4.1.1" + +[[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 = "c967271c27a95160e30432e011b58f42cd7501b5" +uuid = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" +version = "1.8.0" + +[[deps.DataStructures]] +deps = ["OrderedCollections"] +git-tree-sha1 = "6c72198e6a101cccdd4c9731d3985e904ba26037" +uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" +version = "0.19.1" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" + +[[deps.DiffResults]] +deps = ["StaticArraysCore"] +git-tree-sha1 = "782dd5f4561f5d267313f23853baaaa4c52ea621" +uuid = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" +version = "1.1.0" + +[[deps.DiffRules]] +deps = ["IrrationalConstants", "LogExpFunctions", "NaNMath", "Random", "SpecialFunctions"] +git-tree-sha1 = "23163d55f885173722d1e4cf0f6110cdbaf7e272" +uuid = "b552c78f-8df3-52c6-915a-8e097449b14b" +version = "1.15.1" + +[[deps.Distributions]] +deps = ["AliasTables", "FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"] +git-tree-sha1 = "3bc002af51045ca3b47d2e1787d6ce02e68b943a" +uuid = "31c24e10-a181-5473-b8eb-7969acd0382f" +version = "0.25.122" + + [deps.Distributions.extensions] + DistributionsChainRulesCoreExt = "ChainRulesCore" + DistributionsDensityInterfaceExt = "DensityInterface" + DistributionsTestExt = "Test" + + [deps.Distributions.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DensityInterface = "b429d917-457f-4dbc-8f4c-0cc954292b1d" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.DocStringExtensions]] +git-tree-sha1 = "7442a5dfe1ebb773c29cc2962a8980f47221d76c" +uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" +version = "0.9.5" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.6.0" + +[[deps.ExprTools]] +git-tree-sha1 = "27415f162e6028e81c72b82ef756bf321213b6ec" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.10" + +[[deps.FastClosures]] +git-tree-sha1 = "acebe244d53ee1b461970f8910c235b259e772ef" +uuid = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a" +version = "0.3.2" + +[[deps.FileIO]] +deps = ["Pkg", "Requires", "UUIDs"] +git-tree-sha1 = "d60eb76f37d7e5a40cc2e7c36974d864b82dc802" +uuid = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549" +version = "1.17.1" + + [deps.FileIO.extensions] + HTTPExt = "HTTP" + + [deps.FileIO.weakdeps] + HTTP = "cd3eb016-35fb-5094-929b-558a96fad6f3" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" + +[[deps.FillArrays]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "173e4d8f14230a7523ae11b9a3fa9edb3e0efd78" +uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" +version = "1.14.0" +weakdeps = ["PDMats", "SparseArrays", "Statistics"] + + [deps.FillArrays.extensions] + FillArraysPDMatsExt = "PDMats" + FillArraysSparseArraysExt = "SparseArrays" + FillArraysStatisticsExt = "Statistics" + +[[deps.FixedPointNumbers]] +deps = ["Statistics"] +git-tree-sha1 = "05882d6995ae5c12bb5f36dd2ed3f61c98cbb172" +uuid = "53c48c17-4a7d-5ca2-90c5-79b7896eea93" +version = "0.8.5" + +[[deps.ForwardDiff]] +deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"] +git-tree-sha1 = "dc41303865a16274ecb8450c220021ce1e0cf05f" +uuid = "f6369f11-7733-5829-9624-2563aa707210" +version = "1.2.1" +weakdeps = ["StaticArrays"] + + [deps.ForwardDiff.extensions] + ForwardDiffStaticArraysExt = "StaticArrays" + +[[deps.FunctionWrappers]] +git-tree-sha1 = "d62485945ce5ae9c0c48f124a84998d755bae00e" +uuid = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e" +version = "1.1.3" + +[[deps.Future]] +deps = ["Random"] +uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820" + +[[deps.Graphics]] +deps = ["Colors", "LinearAlgebra", "NaNMath"] +git-tree-sha1 = "a641238db938fff9b2f60d08ed9030387daf428c" +uuid = "a2bd30eb-e257-5431-a919-1863eab51364" +version = "1.1.3" + +[[deps.HashArrayMappedTries]] +git-tree-sha1 = "2eaa69a7cab70a52b9687c8bf950a5a93ec895ae" +uuid = "076d061b-32b6-4027-95e0-9a2c6f6d7e74" +version = "0.2.0" + +[[deps.HypergeometricFunctions]] +deps = ["LinearAlgebra", "OpenLibm_jll", "SpecialFunctions"] +git-tree-sha1 = "68c173f4f449de5b438ee67ed0c9c748dc31a2ec" +uuid = "34004b35-14d8-5ef3-9330-4cdb6864b03a" +version = "0.3.28" + +[[deps.ImageCore]] +deps = ["AbstractFFTs", "Colors", "FixedPointNumbers", "Graphics", "MappedArrays", "MosaicViews", "OffsetArrays", "PaddedViews", "Reexport"] +git-tree-sha1 = "db645f20b59f060d8cfae696bc9538d13fd86416" +uuid = "a09fc81d-aa75-5fe9-8630-4744c3626534" +version = "0.8.22" + +[[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.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" + +[[deps.InvertedIndices]] +git-tree-sha1 = "6da3c4316095de0f5ee2ebd875df8721e7e0bdbe" +uuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f" +version = "1.3.1" + +[[deps.IrrationalConstants]] +git-tree-sha1 = "e2222959fbc6c19554dc15174c81bf7bf3aa691c" +uuid = "92d709cd-6900-40b7-9082-c6be49f344b6" +version = "0.2.4" + +[[deps.IterativeSolvers]] +deps = ["LinearAlgebra", "Printf", "Random", "RecipesBase", "SparseArrays"] +git-tree-sha1 = "59545b0a2b27208b0650df0a46b8e3019f85055b" +uuid = "42fd0dbc-a981-5370-80f2-aaf504508153" +version = "0.9.4" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLD2]] +deps = ["ChunkCodecLibZlib", "ChunkCodecLibZstd", "FileIO", "MacroTools", "Mmap", "OrderedCollections", "PrecompileTools", "ScopedValues"] +git-tree-sha1 = "da2e9b4d1abbebdcca0aa68afa0aa272102baad7" +uuid = "033835bb-8acc-5ee8-8aae-3f567f8a3819" +version = "0.6.2" + + [deps.JLD2.extensions] + UnPackExt = "UnPack" + + [deps.JLD2.weakdeps] + UnPack = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "0533e564aae234aff59ab625543145446d8b6ec2" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.7.1" + +[[deps.JSON]] +deps = ["Dates", "Mmap", "Parsers", "Unicode"] +git-tree-sha1 = "31e996f0a15c7b280ba9f76636b3ff9e2ae58c9a" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "0.21.4" + +[[deps.JSON3]] +deps = ["Dates", "Mmap", "Parsers", "PrecompileTools", "StructTypes", "UUIDs"] +git-tree-sha1 = "411eccfe8aba0814ffa0fdf4860913ed09c34975" +uuid = "0f8b85d8-7281-11e9-16c2-39a750bddbf1" +version = "1.14.3" + + [deps.JSON3.extensions] + JSON3ArrowExt = ["ArrowTypes"] + + [deps.JSON3.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + +[[deps.JSOSolvers]] +deps = ["Krylov", "LinearAlgebra", "LinearOperators", "Logging", "NLPModels", "NLPModelsModifiers", "Printf", "SolverCore", "SolverParameters", "SolverTools"] +git-tree-sha1 = "5f324cd0e49e9877fa8c1c2e75cc7a26d3b11f40" +uuid = "10dff2fc-5484-5881-a0e0-c90441020f8a" +version = "0.14.3" + +[[deps.JuMP]] +deps = ["LinearAlgebra", "MacroTools", "MathOptInterface", "MutableArithmetics", "OrderedCollections", "PrecompileTools", "Printf", "SparseArrays"] +git-tree-sha1 = "b201ac010ecdcc3617649175fa59c3dbd9bf96a0" +uuid = "4076af6c-e467-56ae-b986-b466b2749572" +version = "1.29.1" + + [deps.JuMP.extensions] + JuMPDimensionalDataExt = "DimensionalData" + + [deps.JuMP.weakdeps] + DimensionalData = "0703355e-b756-11e9-17c0-8b28908087d0" + +[[deps.Krylov]] +deps = ["LinearAlgebra", "Printf", "SparseArrays"] +git-tree-sha1 = "d1fc961038207e43982851e57ee257adc37be5e8" +uuid = "ba0b0d4f-ebba-5204-a429-3ac8c609bfb7" +version = "0.10.2" + +[[deps.LLSModels]] +deps = ["LinearAlgebra", "LinearOperators", "NLPModels", "NLPModelsModifiers", "SparseArrays", "SparseMatricesCOO"] +git-tree-sha1 = "433bbcf5c50b2f22d513710f6190424c3e5891c7" +uuid = "39f5bc3e-5160-4bf8-ac48-504fd2534d24" +version = "0.5.0" +weakdeps = ["Krylov"] + + [deps.LLSModels.extensions] + LLSModelsKrylovExt = ["Krylov", "NLPModels"] + +[[deps.LaTeXStrings]] +git-tree-sha1 = "dda21b8cbd6a6c40d9d02a73230f9d70fed6918c" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.4.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", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.4.0+0" + +[[deps.LibGit2]] +deps = ["Base64", "LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.6.4+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "Libdl", "MbedTLS_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.0+1" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + +[[deps.LinearOperators]] +deps = ["FastClosures", "LinearAlgebra", "Printf", "Requires", "SparseArrays", "TimerOutputs"] +git-tree-sha1 = "db137007d2c4ed948aa5f2518a2b451851ea8bda" +uuid = "5c8ed15e-5a4c-59e4-a42b-c7e8811fb125" +version = "2.11.0" + + [deps.LinearOperators.extensions] + LinearOperatorsAMDGPUExt = "AMDGPU" + LinearOperatorsCUDAExt = "CUDA" + LinearOperatorsChainRulesCoreExt = "ChainRulesCore" + LinearOperatorsJLArraysExt = "JLArrays" + LinearOperatorsLDLFactorizationsExt = "LDLFactorizations" + LinearOperatorsMetalExt = "Metal" + + [deps.LinearOperators.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + JLArrays = "27aeb0d3-9eb9-45fb-866b-73c2ecf80fcb" + LDLFactorizations = "40e66cde-538c-5869-a4ad-c39174c6795b" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + +[[deps.LogExpFunctions]] +deps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"] +git-tree-sha1 = "13ca9e2586b89836fd20cccf56e57e2b9ae7f38f" +uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" +version = "0.3.29" + + [deps.LogExpFunctions.extensions] + LogExpFunctionsChainRulesCoreExt = "ChainRulesCore" + LogExpFunctionsChangesOfVariablesExt = "ChangesOfVariables" + LogExpFunctionsInverseFunctionsExt = "InverseFunctions" + + [deps.LogExpFunctions.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ChangesOfVariables = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0" + InverseFunctions = "3587e190-3f89-42d0-90ee-14403ec27112" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" + +[[deps.METIS_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "2eefa8baa858871ae7770c98c3c2a7e46daba5b4" +uuid = "d00139f3-1899-568f-a2f0-47f597d42d70" +version = "5.1.3+0" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.ManualNLPModels]] +deps = ["NLPModels"] +git-tree-sha1 = "fe7def19fbd81b5ce8e386ebc5eadda4cb3899a0" +uuid = "30dfa513-9b2f-4fb3-9796-781eabac1617" +version = "0.2.0" + +[[deps.MappedArrays]] +git-tree-sha1 = "2dab0221fe2b0f2cb6754eaa743cc266339f527e" +uuid = "dbb5928d-eab1-5f90-85c2-b9b0edb7c900" +version = "0.4.2" + +[[deps.Markdown]] +deps = ["Base64"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" + +[[deps.MathOptInterface]] +deps = ["BenchmarkTools", "CodecBzip2", "CodecZlib", "DataStructures", "ForwardDiff", "JSON3", "LinearAlgebra", "MutableArithmetics", "NaNMath", "OrderedCollections", "PrecompileTools", "Printf", "SparseArrays", "SpecialFunctions", "Test"] +git-tree-sha1 = "700acfa97a2b23569c0a6dcfcd85f183d7258e31" +uuid = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" +version = "1.45.0" + +[[deps.MbedTLS_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" +version = "2.28.2+1" + +[[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" + +[[deps.MosaicViews]] +deps = ["MappedArrays", "OffsetArrays", "PaddedViews", "StackViews"] +git-tree-sha1 = "7b86a5d4d70a9f5cdf2dacb3cbe6d251d1a61dbe" +uuid = "e94cdb99-869f-56ef-bcf0-1ae2bcbe0389" +version = "0.3.4" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2023.1.10" + +[[deps.MutableArithmetics]] +deps = ["LinearAlgebra", "SparseArrays", "Test"] +git-tree-sha1 = "5801388fbfb801822721b5dee720a55a6d03d41d" +uuid = "d8a4904e-b15c-11e9-3269-09a3773c0cb0" +version = "1.6.6" + +[[deps.NLPModels]] +deps = ["FastClosures", "LinearAlgebra", "LinearOperators", "Printf", "SparseArrays"] +git-tree-sha1 = "ac58082a07f0bd559292e869770d462d7ad0a7e2" +uuid = "a4795742-8479-5a88-8948-cc11e1c8c1a6" +version = "0.21.5" + +[[deps.NLPModelsModifiers]] +deps = ["FastClosures", "LinearAlgebra", "LinearOperators", "NLPModels", "Printf", "SparseArrays"] +git-tree-sha1 = "a80505adbe42104cbbe9674591a5ccd9e9c2dfda" +uuid = "e01155f1-5c6f-4375-a9d8-616dd036575f" +version = "0.7.2" + +[[deps.NaNMath]] +deps = ["OpenLibm_jll"] +git-tree-sha1 = "9b8215b1ee9e78a293f99797cd31375471b2bcae" +uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" +version = "1.1.3" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.2.0" + +[[deps.Noise]] +deps = ["ImageCore", "PoissonRandom", "Random"] +git-tree-sha1 = "42224fd87de5c50a593bbf1bce16c67b1d65da88" +uuid = "81d43f40-5267-43b7-ae1c-8b967f377efa" +version = "0.2.2" + +[[deps.OSQP]] +deps = ["Libdl", "LinearAlgebra", "MathOptInterface", "OSQP_jll", "SparseArrays"] +git-tree-sha1 = "50faf456a64ac1ca097b78bcdf288d94708adcdd" +uuid = "ab2f91bb-94b4-55e3-9ba0-7f65df51de79" +version = "0.8.1" + +[[deps.OSQP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "d0f73698c33e04e557980a06d75c2d82e3f0eb49" +uuid = "9c4f68bf-6205-5545-a508-2878b064d984" +version = "0.600.200+0" + +[[deps.OffsetArrays]] +git-tree-sha1 = "117432e406b5c023f665fa73dc26e79ec3630151" +uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" +version = "1.17.0" +weakdeps = ["Adapt"] + + [deps.OffsetArrays.extensions] + OffsetArraysAdaptExt = "Adapt" + +[[deps.OpenBLAS32_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6065c4cff8fee6c6770b277af45d5082baacdba1" +uuid = "656ef2d0-ae68-5445-9ca0-591084a874a2" +version = "0.3.24+0" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.23+4" + +[[deps.OpenLibm_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "05823500-19ac-5b8b-9628-191a04bc5112" +version = "0.8.1+4" + +[[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.OptimizationProblems]] +deps = ["DataFrames", "JLD2", "JuMP", "LinearAlgebra", "Requires", "SparseArrays", "SpecialFunctions"] +git-tree-sha1 = "886a6193c7eadb8da5f06b520f026cd1a443c657" +uuid = "5049e819-d29b-5fba-b941-0eee7e64c1c6" +version = "0.9.2" + +[[deps.OrderedCollections]] +git-tree-sha1 = "05868e21324cede2207c6f0f466b4bfef6d5e7ee" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "1.8.1" + +[[deps.PDMats]] +deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"] +git-tree-sha1 = "f07c06228a1c670ae4c87d1276b92c7c597fdda0" +uuid = "90014a1f-27ba-587c-ab20-58faa44d9150" +version = "0.11.35" + +[[deps.PaddedViews]] +deps = ["OffsetArrays"] +git-tree-sha1 = "0fac6313486baae819364c52b4f483450a9d793f" +uuid = "5432bcbf-9aad-5242-b902-cca2824c8663" +version = "0.5.12" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools", "UUIDs"] +git-tree-sha1 = "7d2f8f21da5db6a806faf7b9b292296da42b2810" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "2.8.3" + +[[deps.Percival]] +deps = ["JSOSolvers", "Krylov", "LinearAlgebra", "LinearOperators", "Logging", "NLPModels", "NLPModelsModifiers", "SolverCore", "SolverTools"] +git-tree-sha1 = "fed70ca706d28c20ae7a7da086e1fd1a1c0ede46" +uuid = "01435c0c-c90d-11e9-3788-63660f8fbccc" +version = "0.7.5" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.10.0" + +[[deps.PoissonRandom]] +deps = ["LogExpFunctions", "Random"] +git-tree-sha1 = "67afbcbe9e184d6729a92a022147ed4cf972ca7b" +uuid = "e409e4f3-bfea-5376-8464-e040bb5c01ab" +version = "0.4.7" + +[[deps.PooledArrays]] +deps = ["DataAPI", "Future"] +git-tree-sha1 = "36d8b4b899628fb92c2749eb488d884a926614d3" +uuid = "2dfb63ee-cc39-5dd5-95bd-886bf059d720" +version = "1.4.3" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "5aa36f7049a63a1528fe8f7c3f2113413ffd4e1f" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.2.1" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "0f27480397253da18fe2c12a4ba4eb9eb208bf3d" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.5.0" + +[[deps.PrettyTables]] +deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "REPL", "Reexport", "StringManipulation", "Tables"] +git-tree-sha1 = "6b8e2f0bae3f678811678065c09571c1619da219" +uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +version = "3.1.0" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" + +[[deps.Profile]] +deps = ["Printf"] +uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79" + +[[deps.ProximalCore]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "1f9f650b4b7a60533098dc5e864458f0e4a5b926" +uuid = "dc4f5ac2-75d1-4f31-931e-60435d74994b" +version = "0.1.2" + +[[deps.ProximalOperators]] +deps = ["IterativeSolvers", "LinearAlgebra", "OSQP", "ProximalCore", "SparseArrays", "SuiteSparse", "TSVD"] +git-tree-sha1 = "13a384f52be09c6795ab1c3ad71c8a207decb0ba" +uuid = "a725b495-10eb-56fe-b38b-717eba820537" +version = "0.15.3" + +[[deps.PtrArrays]] +git-tree-sha1 = "1d36ef11a9aaf1e8b74dacc6a731dd1de8fd493d" +uuid = "43287f4e-b6f4-7ad1-bb20-aadabca52c3d" +version = "1.3.0" + +[[deps.QRMumps]] +deps = ["Libdl", "LinearAlgebra", "OpenBLAS32_jll", "Printf", "SparseArrays", "qr_mumps_jll"] +git-tree-sha1 = "e2433092c9374f82934cab7b07044a52d081e2fb" +uuid = "422b30a1-cc69-4d85-abe7-cc07b540c444" +version = "0.3.1" +weakdeps = ["SparseMatricesCOO"] + + [deps.QRMumps.extensions] + QRMumpsSparseMatricesCOOExt = "SparseMatricesCOO" + +[[deps.QuadGK]] +deps = ["DataStructures", "LinearAlgebra"] +git-tree-sha1 = "9da16da70037ba9d701192e27befedefb91ec284" +uuid = "1fd47b50-473d-5c70-9696-f719f8f3bcdc" +version = "2.11.2" + + [deps.QuadGK.extensions] + QuadGKEnzymeExt = "Enzyme" + + [deps.QuadGK.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + +[[deps.QuadraticModels]] +deps = ["LinearAlgebra", "LinearOperators", "NLPModels", "NLPModelsModifiers", "SolverCore", "SparseArrays", "SparseMatricesCOO"] +git-tree-sha1 = "44b45644e1cb2391c62377625ee12b970483a996" +uuid = "f468eda6-eac5-11e8-05a5-ff9e497bcd19" +version = "0.9.14" + + [deps.QuadraticModels.extensions] + QuadraticModelsQPSReaderExt = "QPSReader" + + [deps.QuadraticModels.weakdeps] + QPSReader = "10f199a5-22af-520b-b891-7ce84a7b1bd0" + +[[deps.REPL]] +deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" + +[[deps.RecipesBase]] +deps = ["PrecompileTools"] +git-tree-sha1 = "5c3d09cc4f31f5fc6af001c250bf1278733100ff" +uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" +version = "1.3.4" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.RegularizedProblems]] +deps = ["Distributions", "LinearAlgebra", "ManualNLPModels", "NLPModels", "Noise", "Random", "Requires", "SparseArrays"] +git-tree-sha1 = "6acf4aff146ccf50298020f46986faa016be6021" +uuid = "ea076b23-609f-44d2-bb12-a4ae45328278" +version = "0.1.2" + +[[deps.Requires]] +deps = ["UUIDs"] +git-tree-sha1 = "62389eeff14780bfe55195b7204c0d8738436d64" +uuid = "ae029012-a4dd-5104-9daa-d747884805df" +version = "1.3.1" + +[[deps.ReverseDiff]] +deps = ["ChainRulesCore", "DiffResults", "DiffRules", "ForwardDiff", "FunctionWrappers", "LinearAlgebra", "LogExpFunctions", "MacroTools", "NaNMath", "Random", "SpecialFunctions", "StaticArrays", "Statistics"] +git-tree-sha1 = "3ab8eee3620451b09f0272c271875b4bc02146d9" +uuid = "37e2e3b7-166d-5795-8a7a-e32c996b4267" +version = "1.16.1" + +[[deps.Rmath]] +deps = ["Random", "Rmath_jll"] +git-tree-sha1 = "852bd0f55565a9e973fcfee83a84413270224dc4" +uuid = "79098fc4-a85e-5d69-aa6a-4863f24498fa" +version = "0.8.0" + +[[deps.Rmath_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "58cdd8fb2201a6267e1db87ff148dd6c1dbd8ad8" +uuid = "f50d1b31-88e8-58de-be2c-1cc44531875f" +version = "0.5.1+0" + +[[deps.Roots]] +deps = ["CommonSolve", "Printf", "Setfield"] +git-tree-sha1 = "838b60ee62bebc794864c880a47e331e00c47505" +uuid = "f2b01f46-fcfa-551c-844a-d8ac1e96c665" +version = "1.4.1" + +[[deps.SCOTCH_jll]] +deps = ["Artifacts", "Bzip2_jll", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "XZ_jll", "Zlib_jll"] +git-tree-sha1 = "a4faa27c7959fb6aed0fede85c7afa0c0a194a03" +uuid = "a8d0f55d-b80e-548d-aff6-1a04c175f0f9" +version = "7.0.7+0" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "0.7.0" + +[[deps.ScopedValues]] +deps = ["HashArrayMappedTries", "Logging"] +git-tree-sha1 = "c3b2323466378a2ba15bea4b2f73b081e022f473" +uuid = "7e506255-f358-4e82-b7e4-beb19740aa63" +version = "1.5.0" + +[[deps.SentinelArrays]] +deps = ["Dates", "Random"] +git-tree-sha1 = "712fb0231ee6f9120e005ccd56297abbc053e7e0" +uuid = "91c51154-3ec4-41a3-a24f-3f23e20d615c" +version = "1.4.8" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.Setfield]] +deps = ["ConstructionBase", "Future", "MacroTools", "Requires"] +git-tree-sha1 = "d0f4c9f8630b695001003d793d1349729e2af26e" +uuid = "efcf1570-3423-57d1-acb7-fd33fddbac46" +version = "0.8.3" + +[[deps.ShiftedProximalOperators]] +deps = ["LinearAlgebra", "ProximalOperators", "QRMumps", "Roots", "SparseMatricesCOO", "libblastrampoline_jll"] +git-tree-sha1 = "464e82faae4cee7a045e45a4344fd98216138924" +uuid = "d4fd37fa-580c-4e43-9b30-361c21aae263" +version = "0.2.2" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" + +[[deps.SolverCore]] +deps = ["LinearAlgebra", "NLPModels", "Printf"] +git-tree-sha1 = "03a1e0d2d39b9ebc9510f2452c0adfbe887b9cb2" +uuid = "ff4d7338-4cf1-434d-91df-b86cb86fb843" +version = "0.3.8" + +[[deps.SolverParameters]] +deps = ["Random"] +git-tree-sha1 = "f081293b4fde7e07b94a00fa95a8e3b4c943c7af" +uuid = "d076d87d-d1f9-4ea3-a44b-64b4cdd1e470" +version = "0.1.2" + +[[deps.SolverTools]] +deps = ["LinearAlgebra", "LinearOperators", "NLPModels", "Printf"] +git-tree-sha1 = "d0d5007429786fb74e6ab00e81c8091380cb51a0" +uuid = "b5612192-2639-5dc1-abfe-fbedd65fab29" +version = "0.10.0" + +[[deps.SortingAlgorithms]] +deps = ["DataStructures"] +git-tree-sha1 = "64d974c2e6fdf07f8155b5b2ca2ffa9069b608d9" +uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c" +version = "1.2.2" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +version = "1.10.0" + +[[deps.SparseConnectivityTracer]] +deps = ["ADTypes", "DocStringExtensions", "FillArrays", "LinearAlgebra", "Random", "SparseArrays"] +git-tree-sha1 = "62f3dbfa8e0bb01ce41076ee31686f0514a9e339" +uuid = "9f842d2f-2579-4b1d-911e-f412cf18a3f5" +version = "1.1.1" + + [deps.SparseConnectivityTracer.extensions] + SparseConnectivityTracerChainRulesCoreExt = "ChainRulesCore" + SparseConnectivityTracerLogExpFunctionsExt = "LogExpFunctions" + SparseConnectivityTracerNNlibExt = "NNlib" + SparseConnectivityTracerNaNMathExt = "NaNMath" + SparseConnectivityTracerSpecialFunctionsExt = "SpecialFunctions" + + [deps.SparseConnectivityTracer.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + LogExpFunctions = "2ab3a3ac-af41-5b50-aa03-7779005ae688" + NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd" + NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.SparseMatricesCOO]] +deps = ["LinearAlgebra", "SparseArrays"] +git-tree-sha1 = "87f0b186943b0630e454e33699278e34748dd0fa" +uuid = "fa32481b-f100-4b48-8dc8-c62f61b13870" +version = "0.2.6" + +[[deps.SparseMatrixColorings]] +deps = ["ADTypes", "DocStringExtensions", "LinearAlgebra", "PrecompileTools", "Random", "SparseArrays"] +git-tree-sha1 = "9de43e0b9b976f1019bf7a879a686c4514520078" +uuid = "0a514795-09f3-496d-8182-132a7b665d35" +version = "0.4.21" + + [deps.SparseMatrixColorings.extensions] + SparseMatrixColoringsCUDAExt = "CUDA" + SparseMatrixColoringsCliqueTreesExt = "CliqueTrees" + SparseMatrixColoringsColorsExt = "Colors" + + [deps.SparseMatrixColorings.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CliqueTrees = "60701a23-6482-424a-84db-faee86b9b1f8" + Colors = "5ae59095-9a9b-59fe-a467-6f913c188581" + +[[deps.SpecialFunctions]] +deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] +git-tree-sha1 = "f2685b435df2613e25fc10ad8c26dddb8640f547" +uuid = "276daf66-3868-5448-9aa4-cd146d93841b" +version = "2.6.1" +weakdeps = ["ChainRulesCore"] + + [deps.SpecialFunctions.extensions] + SpecialFunctionsChainRulesCoreExt = "ChainRulesCore" + +[[deps.StackViews]] +deps = ["OffsetArrays"] +git-tree-sha1 = "be1cf4eb0ac528d96f5115b4ed80c26a8d8ae621" +uuid = "cae243ae-269e-4f55-b966-ac2d0dc13c15" +version = "0.1.2" + +[[deps.StaticArrays]] +deps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"] +git-tree-sha1 = "b8693004b385c842357406e3af647701fe783f98" +uuid = "90137ffa-7385-5640-81b9-e52037218182" +version = "1.9.15" +weakdeps = ["ChainRulesCore", "Statistics"] + + [deps.StaticArrays.extensions] + StaticArraysChainRulesCoreExt = "ChainRulesCore" + StaticArraysStatisticsExt = "Statistics" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "192954ef1208c7019899fbf8049e717f92959682" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.3" + +[[deps.Statistics]] +deps = ["LinearAlgebra", "SparseArrays"] +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.10.0" + +[[deps.StatsAPI]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "9d72a13a3f4dd3795a195ac5a44d7d6ff5f552ff" +uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0" +version = "1.7.1" + +[[deps.StatsBase]] +deps = ["AliasTables", "DataAPI", "DataStructures", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"] +git-tree-sha1 = "2c962245732371acd51700dbb268af311bddd719" +uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +version = "0.34.6" + +[[deps.StatsFuns]] +deps = ["HypergeometricFunctions", "IrrationalConstants", "LogExpFunctions", "Reexport", "Rmath", "SpecialFunctions"] +git-tree-sha1 = "8e45cecc66f3b42633b8ce14d431e8e57a3e242e" +uuid = "4c63d2b9-4356-54db-8cca-17b64c39e42c" +version = "1.5.0" + + [deps.StatsFuns.extensions] + StatsFunsChainRulesCoreExt = "ChainRulesCore" + StatsFunsInverseFunctionsExt = "InverseFunctions" + + [deps.StatsFuns.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + InverseFunctions = "3587e190-3f89-42d0-90ee-14403ec27112" + +[[deps.StringManipulation]] +deps = ["PrecompileTools"] +git-tree-sha1 = "725421ae8e530ec29bcbdddbe91ff8053421d023" +uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" +version = "0.4.1" + +[[deps.StructTypes]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "159331b30e94d7b11379037feeb9b690950cace8" +uuid = "856f2bd8-1eba-4b0a-8007-ebc267875bd4" +version = "1.11.0" + +[[deps.SuiteSparse]] +deps = ["Libdl", "LinearAlgebra", "Serialization", "SparseArrays"] +uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "Libdl", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "7.2.1+1" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TSVD]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "c39caef6bae501e5607a6caf68dd9ac6e8addbcb" +uuid = "9449cd9e-2762-5aa3-a617-5413e99d722e" +version = "0.4.4" + +[[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 = "f2c1efbc8f3a609aadf318094f8fc5204bdaf344" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.12.1" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.Test]] +deps = ["InteractiveUtils", "Logging", "Random", "Serialization"] +uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.TimerOutputs]] +deps = ["ExprTools", "Printf"] +git-tree-sha1 = "3748bd928e68c7c346b52125cf41fff0de6937d0" +uuid = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f" +version = "0.5.29" + + [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.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" + +[[deps.XZ_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "fee71455b0aaa3440dfdd54a9a36ccef829be7d4" +uuid = "ffd25f8a-64ca-5728-b0f7-c24cf3aae800" +version = "5.8.1+0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.2.13+1" + +[[deps.Zstd_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "446b23e73536f84e8037f5dce465e92275f6a308" +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.5.7+1" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.11.0+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.52.0+1" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.4.0+2" + +[[deps.qr_mumps_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "METIS_jll", "SCOTCH_jll", "SuiteSparse_jll", "libblastrampoline_jll"] +git-tree-sha1 = "875f1858b94ba19ae0b3b571525a3114ecbb3413" +uuid = "e37b5aa0-c611-5f0f-83fb-aee446c0b77e" +version = "3.1.1+0" diff --git a/Project.toml b/Project.toml index e6e5aff0..a02b0aee 100644 --- a/Project.toml +++ b/Project.toml @@ -4,16 +4,20 @@ author = ["Robert Baraldi and Dominique Orban 0` is a regularization parameter and `v` is a vector of the same size as `F(xk)` used for intermediary computations. -""" -mutable struct LMModel{ - T <: Real, - V <: AbstractVector{T}, - Jac <: Union{AbstractMatrix, AbstractLinearOperator}, -} <: AbstractNLPModel{T, V} - J::Jac - F::V - v::V - xk::V - σ::T - meta::NLPModelMeta{T, V} - counters::Counters -end - -function LMModel(J::Jac, F::V, σ::T, xk::V) where {T, V, Jac} - meta = NLPModelMeta( - length(xk), - x0 = xk, # Perhaps we should add lvar and uvar as well here. - ) - v = similar(F) - return LMModel(J, F, v, xk, σ, meta, Counters()) -end - -function NLPModels.obj(nlp::LMModel, x::AbstractVector{T}; skip_sigma = false) where {T} - @lencheck nlp.meta.nvar x - increment!(nlp, :neval_obj) - mul!(nlp.v, nlp.J, x) - nlp.v .+= nlp.F - skip_sigma && return dot(nlp.v, nlp.v)/2 - return (dot(nlp.v, nlp.v) + nlp.σ * dot(x, x)) / 2 -end - -function NLPModels.grad!(nlp::LMModel, x::AbstractVector{T}, g::AbstractVector{T}) where {T} - @lencheck nlp.meta.nvar x - @lencheck nlp.meta.nvar g - increment!(nlp, :neval_grad) - mul!(nlp.v, nlp.J, x) - nlp.v .+= nlp.F - mul!(g, nlp.J', nlp.v) - @. g += nlp.σ .* x - return g -end diff --git a/src/LMTR_alg.jl b/src/LMTR_alg.jl index d6116533..e71bb90f 100644 --- a/src/LMTR_alg.jl +++ b/src/LMTR_alg.jl @@ -41,8 +41,9 @@ function LMTRSolver( xk = similar(x0) ∇fk = similar(x0) mν∇fk = similar(x0) - Fk = similar(x0, reg_nls.model.nls_meta.nequ) - Fkn = similar(Fk) + # residuals will be allocated after creating Jacobian operator + Fk = similar(x0, 0) + Fkn = similar(x0, 0) xkn = similar(x0) s = similar(x0) has_bnds = any(l_bound .!= T(-Inf)) || any(u_bound .!= T(Inf)) || subsolver == TRDHSolver @@ -67,7 +68,24 @@ function LMTRSolver( ) : shifted(reg_nls.h, xk, one(T), χ) Jk = jac_op_residual(reg_nls.model, xk) - sub_nlp = LMModel(Jk, Fk, T(0), xk) + m = size(Jk, 1) + Fk = zeros(T, m) + Fkn = similar(Fk) + residual!(reg_nls.model, xk, Fk) + + # Matrix-free Gram operator for J'J + gram_op = JacobianGram{T}(Jk, zeros(T, m)) + # Or, if JacobianGram is not available, use LinearOperator: + # gram_op = LinearOperator{T}(size(Jk,2), size(Jk,2), false, false, + # (y, x) -> mul!(y, Jk', Jk * x), + # (y, x) -> mul!(y, Jk, Jk' * x), + # (y, x) -> mul!(y, Jk, Jk' * x), + # ) + + JtF = similar(xk) + mul!(JtF, Jk', Fk) + # Don't include the constant term to avoid numerical overflow in obj evaluation + sub_nlp = QuadraticModel(JtF, gram_op, c0 = zero(T), x0 = zeros(T, length(xk)), name = "LMTR-subproblem") subpb = RegularizedNLPModel(sub_nlp, ψ) substats = RegularizedExecutionStats(subpb) subsolver = subsolver(subpb) @@ -273,8 +291,20 @@ function SolverCore.solve!( jtprod_residual!(nls, xk, Fk, ∇fk) fk = dot(Fk, Fk) / 2 - σmax, found_σ = opnorm(solver.subpb.model.J) + # Get Jacobian operator from original NLS model since QuadraticModel doesn't store it + Jk = jac_op_residual(nls, xk) + σmax, found_σ = opnorm(Jk) found_σ || error("operator norm computation failed") + + # Update the QuadraticModel with current Jacobian and gradient + JtF = Jk' * Fk + JtJ = Jk' * Jk + # In-place update of QuadraticModel fields to avoid allocation + solver.subpb.model.data.c = JtF + solver.subpb.model.data.H = JtJ + solver.subpb.model.data.c0 = zero(T) + solver.subpb.model.x0 .= 0 + solver.subpb.model.name = "LMTR-subproblem" ν = α * Δk / (1 + σmax^2 * (α * Δk + 1)) @. mν∇fk = -∇fk * ν sqrt_ξ1_νInv = one(T) @@ -416,8 +446,15 @@ function SolverCore.solve!( shift!(ψ, xk) jtprod_residual!(nls, xk, Fk, ∇fk) - σmax, found_σ = opnorm(solver.subpb.model.J) + # Get Jacobian operator from original NLS model + Jk_update = jac_op_residual(nls, xk) + σmax, found_σ = opnorm(Jk_update) found_σ || error("operator norm computation failed") + + # Update the QuadraticModel with new Jacobian and gradient + JtF = Jk_update' * Fk + JtJ = Jk_update' * Jk_update + update_quadratic_model!(solver.subpb.model, JtF, JtJ) end if η2 ≤ ρk < Inf diff --git a/src/LM_alg.jl b/src/LM_alg.jl index 1f4658f6..58e220bf 100644 --- a/src/LM_alg.jl +++ b/src/LM_alg.jl @@ -16,6 +16,7 @@ mutable struct LMSolver{ Fkn::V Jv::V Jtv::V + JtF::V # Add JtF to store the gradient J'F ψ::G xkn::V s::V @@ -28,6 +29,12 @@ mutable struct LMSolver{ subsolver::ST subpb::PB substats::GenericExecutionStats{T, V, V, T} + # Preallocated QuadraticModel components to avoid reallocations + x0_quad::V + reg_hess_wrapper::ShiftedHessian{T} + reg_hess_op::LinearOperator + v0::V # workspace for power method + tmp_res::V # temporary residual storage for power method end function LMSolver( @@ -42,9 +49,10 @@ function LMSolver( xk = similar(x0) ∇fk = similar(x0) mν∇fk = similar(x0) - Fk = similar(x0, reg_nls.model.nls_meta.nequ) - Fkn = similar(Fk) - Jv = similar(Fk) + # residuals will be allocated after creating Jacobian operator (size may vary) + Fk = similar(x0, 0) + Fkn = similar(x0, 0) + Jv = similar(x0, 0) Jtv = similar(x0) xkn = similar(x0) s = similar(x0) @@ -65,11 +73,40 @@ function LMSolver( has_bnds ? shifted(reg_nls.h, xk, l_bound_m_x, u_bound_m_x, reg_nls.selected) : shifted(reg_nls.h, xk) - Jk = jac_op_residual(reg_nls.model, xk) - sub_nlp = LMModel(Jk, Fk, T(1), xk) + # Defer Jacobian/residual construction to solve!; preallocate JtF (length n) + JtF = similar(xk) + # residuals will be allocated in solve! when the Jacobian operator is available + Fk = similar(x0, 0) + Fkn = similar(x0, 0) + Jv = similar(x0, 0) + n = length(xk) + c0_val = dot(Fk, Fk) / 2 # Initial constant term = 1/2||F||² + x0_quad = zeros(T, n) # Pre-allocated x0 for QuadraticModel + # Create mutable wrapper around Hessian; use JacobianGram to avoid forming J'J + gram = JacobianGram{T}(nothing, zeros(T, 0)) + # Try to initialize JacobianGram.tmp with the row size of the Jacobian at x0 + try + J_init = jac_op_residual(reg_nls.model, x0) + gram.J = J_init + gram.tmp = zeros(T, size(J_init, 1)) + catch + # If jac_op_residual is not available for this model type, leave tmp empty + gram.J = nothing + gram.tmp = zeros(T, 0) + end + reg_hess_wrapper = ShiftedHessian{T}(gram, T(1)) + reg_hess_op = LinearOperator{T}(n, n, false, false, + (y, x) -> mul!(y, reg_hess_wrapper, x), + (y, x) -> mul!(y, adjoint(reg_hess_wrapper), x), + (y, x) -> mul!(y, adjoint(reg_hess_wrapper), x), + ) + sub_nlp = QuadraticModel(JtF, reg_hess_op, c0 = c0_val, x0 = x0_quad, name = "LM-subproblem") subpb = RegularizedNLPModel(sub_nlp, ψ) substats = RegularizedExecutionStats(subpb) subsolver = subsolver(subpb) + v0 = [(-1.0)^i for i = 0:(n - 1)] + v0 ./= sqrt(n) + tmp_res = copy(gram.tmp) return LMSolver{T, typeof(ψ), V, typeof(subsolver), typeof(subpb)}( xk, @@ -79,6 +116,7 @@ function LMSolver( Fkn, Jv, Jtv, + JtF, # Add JtF to constructor ψ, xkn, s, @@ -91,6 +129,11 @@ function LMSolver( subsolver, subpb, substats, + x0_quad, + reg_hess_wrapper, + reg_hess_op, + v0, + tmp_res, ) end @@ -106,7 +149,7 @@ lower semi-continuous, proper and prox-bounded. At each iteration, a step s is computed as an approximate solution of - min ½ ‖J(x) s + F(x)‖² + ½ σ ‖s‖² + ψ(s; x) + min ½ ‖J(x) s + F(x)‖² + ½ σ ‖s‖² + ψ(s; xₖ) where F(x) and J(x) are the residual and its Jacobian at x, respectively, ψ(s; xₖ) is either h(xₖ + s) or an approximation of h(xₖ + s), ‖⋅‖ is the ℓ₂ norm and σₖ > 0 is the regularization parameter. @@ -154,6 +197,8 @@ function LM(nls::AbstractNLSModel, h::H, options::ROSolverOptions; kwargs...) wh kwargs_dict = Dict(kwargs...) selected = pop!(kwargs_dict, :selected, 1:(nls.meta.nvar)) x0 = pop!(kwargs_dict, :x0, nls.meta.x0) + # allow callers to request skipping σ in the quadratic regularizer + skip_sigma = pop!(kwargs_dict, :skip_sigma, false) reg_nls = RegularizedNLPModel(nls, h, selected) return LM( reg_nls; @@ -169,6 +214,7 @@ function LM(nls::AbstractNLSModel, h::H, options::ROSolverOptions; kwargs...) wh η1 = options.η1, η2 = options.η2, γ = options.γ, + skip_sigma = skip_sigma, kwargs_dict..., ) end @@ -177,9 +223,11 @@ function LM(reg_nls::AbstractRegularizedNLPModel; kwargs...) kwargs_dict = Dict(kwargs...) subsolver = pop!(kwargs_dict, :subsolver, R2Solver) m_monotone = pop!(kwargs_dict, :m_monotone, 1) + # propagate skip_sigma to the solver + skip_sigma = pop!(kwargs_dict, :skip_sigma, false) solver = LMSolver(reg_nls, subsolver = subsolver, m_monotone = m_monotone) stats = RegularizedExecutionStats(reg_nls) - solve!(solver, reg_nls, stats; kwargs_dict...) + solve!(solver, reg_nls, stats; kwargs_dict..., skip_sigma = skip_sigma) return stats end @@ -203,7 +251,7 @@ function SolverCore.solve!( η2::T = T(0.9), γ::T = T(3), θ::T = 1/(1 + eps(T)^(1 / 5)), - sub_kwargs::NamedTuple = NamedTuple(), + skip_sigma::Bool = false, # <-- new kwarg (default: false) ) where {T, V, G} reset!(stats) @@ -272,14 +320,40 @@ function SolverCore.solve!( local ξ1::T local ρk::T = zero(T) local prox_evals::Int = 0 - + local inner_stall_count::Int = 0 + INNER_STALL_THRESHOLD = 500 + # Track subsolver stalls and keep a backup step + stall_counter = 0 + s_backup = similar(s) + + # Ensure residual vectors are sized to match the Jacobian rows + Jk = jac_op_residual(nls, xk) + m = size(Jk, 1) + if length(Fk) != m + solver.Fk = zeros(T, m) + solver.Fkn = similar(solver.Fk) + solver.Jv = similar(solver.Fk) + Fk = solver.Fk + Fkn = solver.Fkn + Jv = solver.Jv + end residual!(nls, xk, Fk) jtprod_residual!(nls, xk, Fk, ∇fk) fk = dot(Fk, Fk) / 2 - σmax, found_σ = opnorm(solver.subpb.model.J) - found_σ || error("operator norm computation failed") - ν = θ / (σmax^2 + σk) # ‖J'J + σₖ I‖ = ‖J‖² + σₖ + # Compute Jacobian norm for normalization + Jk = jac_op_residual(nls, xk) + # Estimate Jacobian operator norm (largest singular value) via power method to avoid heavy allocations + if length(solver.tmp_res) != size(Jk, 1) + solver.tmp_res = zeros(T, size(Jk, 1)) + end + σmax = power_method_singular!(Jk, solver.v0, solver.subpb.model.data.v, solver.tmp_res, 5) + # if the caller requested skipping σ, compute ν without adding σk into the denominator + if skip_sigma + ν = θ / (σmax^2) + else + ν = θ / (σmax^2 + σk) # ‖J'J + σₖ I‖ = ‖J‖² + σₖ + end sqrt_ξ1_νInv = one(T) @. mν∇fk = -ν * ∇fk @@ -302,7 +376,7 @@ function SolverCore.solve!( end mk = let ψ = ψ, solver = solver - d -> obj(solver.subpb.model, d, skip_sigma = true) + ψ(d) + d -> obj(solver.subpb.model, d) + ψ(d) end prox!(s, ψ, mν∇fk, ν) @@ -333,32 +407,108 @@ function SolverCore.solve!( while !done sub_atol = stats.iter == 0 ? 1.0e-3 : min(sqrt_ξ1_νInv ^ (1.5), sqrt_ξ1_νInv * 1e-3) - solver.subpb.model.σ = σk - isa(solver.subsolver, R2DHSolver) && (solver.subsolver.D.d[1] = 1/ν) - if isa(solver.subsolver, R2Solver) #FIXME - solve!( - solver.subsolver, - solver.subpb, - solver.substats; - x = s, - atol = sub_atol, - ν = ν, - sub_kwargs..., - ) - else - solve!( - solver.subsolver, - solver.subpb, - solver.substats; - x = s, - atol = sub_atol, - σk = σk, #FIXME - sub_kwargs..., - ) - end + + # Update the QuadraticModel in-place: update J'F and mutate the Hessian wrapper + Jk = jac_op_residual(nls, xk) + mul!(solver.JtF, Jk', Fk) # Update gradient J'F in-place + # Update underlying JacobianGram wrapper to reference the new J and resize tmp + solver.reg_hess_wrapper.B.J = Jk + if length(solver.tmp_res) != size(Jk, 1) + solver.reg_hess_wrapper.B.tmp = zeros(T, size(Jk, 1)) + else + solver.reg_hess_wrapper.B.tmp .= 0 + end + # respect skip_sigma: when true the shifted Hessian should not include the outer σk + solver.reg_hess_wrapper.sigma = skip_sigma ? zero(T) : σk + # Update QuadraticModel's gradient/counters in-place + c0_val = dot(Fk, Fk) / 2 # Constant term = 1/2||F||² + solver.subpb.model.data.c0 = c0_val # Ensure the constant term is stored + update_quadratic_model!(solver.subpb.model, solver.JtF) + # If the subsolver requires any special scaling (e.g. R2DHSolver), set it + isa(solver.subsolver, R2DHSolver) && (solver.subsolver.D.d[1] = 1/ν) + # Backup current candidate step before calling subsolver + copyto!(s_backup, s) + if isa(solver.subsolver, R2Solver) #FIXME + solve!(solver.subsolver, solver.subpb, solver.substats, x = s, atol = sub_atol, ν = ν, max_iter = 1000) + else + solve!( + solver.subsolver, + solver.subpb, + solver.substats, + x = s, + atol = sub_atol, + σk = σk, #FIXME + max_iter = 1000, + ) + end - prox_evals += solver.substats.iter + prox_evals += solver.substats.iter + + # If the subsolver spent too many iterations (stalled), restore previous step + # and use a cheap proximal-gradient fallback to make progress instead of + # spinning on the inner solver. Also adjust σk to try a different + # regularization direction and cap its growth. + if solver.substats.iter > INNER_STALL_THRESHOLD + stall_counter += 1 + @warn "LM: subsolver iter count high - restoring previous step" iter=solver.substats.iter stall=stall_counter + # restore previous candidate step + copyto!(s, s_backup) + # Fallback: take a single prox-gradient step (cheap) to make outer loop progress + try + prox!(s, ψ, mν∇fk, ν) + catch e + @warn "LM: prox fallback failed" err=string(e) + end + # reset substats.solution to the fallback for downstream logic + solver.substats.solution .= s + # Adjust σk to try a different regularization direction and cap its growth + σk = max(σk / γ, σmin) + σ_cap = 1e40 + if σk > σ_cap + σk = σ_cap + end + else + # Accept subsolver solution s .= solver.substats.solution + stall_counter = 0 + end + + # If we've observed repeated stalls, accept the (prox) fallback step and + # advance the outer iteration to avoid spinning on the inner solver. + if stall_counter >= 3 + @warn "LM: repeated inner stalls — accepting prox fallback and continuing" stall=stall_counter + # apply step + xk .= xk .+ s + # update residuals and gradient for the new xk + residual!(nls, xk, Fk) + fk = dot(Fk, Fk) / 2 + hk = @views h(xk[selected]) + shift!(ψ, xk) + jtprod_residual!(nls, xk, Fk, ∇fk) + # reset counters so we don't immediately re-enter this branch + stall_counter = 0 + prox_evals += 1 + # proceed to next outer iteration + set_iter!(stats, stats.iter + 1) + set_time!(stats, time() - start_time) + continue + end + + # Diagnostic: if the subsolver used a very large number of iterations, log state + if solver.substats.iter > 1000 + @warn "LM: subsolver iter count high" iter=solver.substats.iter fk=fk hk=hk σk=σk ν=ν + @warn "QuadraticModel gradient (first 10)" grad=solver.subpb.model.data.c[1:min(10,end)] + @warn "QuadraticModel H type" H_type=typeof(solver.subpb.model.data.H) + try + @warn "H* s (first 10)" Hs=begin + tmp = similar(s) + mul!(tmp, solver.subpb.model.data.H, s) + tmp[1:min(10,end)] + end + catch e + @warn "Failed to mul! H* s" err=string(e) + end + end xkn .= xk .+ s residual!(nls, xkn, Fkn) @@ -367,6 +517,28 @@ function SolverCore.solve!( mks = mk(s) ξ = fk + hk - mks + max(1, abs(hk)) * 10 * eps() + # Diagnostic: if ξ is not finite, emit helpful warnings with nearby state + if !isfinite(ξ) + @warn "LM diagnostic: ξ not finite" ξ=ξ fk=fk hk=hk mks=mks + try + @warn "QuadraticModel data.c (first 8)" c_first = solver.subpb.model.data.c[1:min(end,8)] + catch + end + try + @warn "QuadraticModel c0" c0 = getfield(solver.subpb.model.data, :c0) + catch + end + try + @warn "JtF contains NaN?" any_nan = any(isnan, solver.JtF) + catch + end + try + Jk_dbg = jac_op_residual(nls, xk) + @warn "Jacobian operator size" m=size(Jk_dbg,1) n=size(Jk_dbg,2) + catch + end + end + if (ξ ≤ 0 || isnan(ξ)) error("LM: failed to compute a step: ξ = $ξ") end @@ -413,7 +585,8 @@ function SolverCore.solve!( # update opnorm if not linear least squares if nonlinear == true - σmax, found_σ = opnorm(solver.subpb.model.J) + Jk = jac_op_residual(nls, xk) + σmax, found_σ = opnorm(Jk) found_σ || error("operator norm computation failed") end end @@ -441,13 +614,28 @@ function SolverCore.solve!( prox!(s, ψ, mν∇fk, ν) mks = mk1(s) - ξ1 = fk + hk - mks + max(1, abs(hk)) * 10 * eps() - sqrt_ξ1_νInv = ξ1 ≥ 0 ? sqrt(ξ1 / ν) : sqrt(-ξ1 / ν) - solved = (ξ1 < 0 && sqrt_ξ1_νInv ≤ neg_tol) || (ξ1 ≥ 0 && sqrt_ξ1_νInv ≤ atol) + ξ = fk + hk - mks + max(1, abs(hk)) * 10 * eps() + + if isnan(ξ) + @info "QuadraticModel gradient" solver.subpb.model.data.c + @info "QuadraticModel Hessian operator" solver.subpb.model.data.H + @info "QuadraticModel full" solver.subpb.model + @info "JacobianGram J" solver.reg_hess_wrapper.B.J + @info "JacobianGram tmp" solver.reg_hess_wrapper.B.tmp + @info "Residual Fk" Fk + @info "Residual Fkn" Fkn + @info "JtF" solver.JtF + error("LM: failed to compute a step: ξ = NaN") + elseif ξ ≤ 0 + error("LM: failed to compute a step: ξ = $ξ") + end + (ξ < 0 && sqrt_ξ1_νInv > neg_tol) && + error("LM: prox-gradient step should produce a decrease but ξ = $(ξ)") - (ξ1 < 0 && sqrt_ξ1_νInv > neg_tol) && - error("LM: prox-gradient step should produce a decrease but ξ1 = $(ξ1)") + # Recompute stationarity measure and solved flag using current ξ and ν + sqrt_ξ1_νInv = ξ ≥ 0 ? sqrt(ξ / ν) : sqrt(-ξ / ν) + solved = (ξ < 0 && sqrt_ξ1_νInv ≤ neg_tol) || (ξ ≥ 0 && sqrt_ξ1_νInv ≤ atol) set_status!( stats, diff --git a/src/R2N.jl b/src/R2N.jl index 14d47075..0f8c8344 100644 --- a/src/R2N.jl +++ b/src/R2N.jl @@ -1,6 +1,11 @@ export R2N, R2NSolver, solve! import SolverCore.solve! +using LinearAlgebra +using LinearOperators + + # ShiftedHessian moved to utils.jl + mutable struct R2NSolver{ T <: Real, @@ -28,6 +33,10 @@ mutable struct R2NSolver{ subsolver::ST subpb::PB substats::GenericExecutionStats{T, V, V, T} + # Pre-allocated components for QuadraticModel recreation + x0_quad::V + reg_hess_wrapper::ShiftedHessian{T} + reg_hess_op::LinearOperator end function R2NSolver( @@ -68,7 +77,19 @@ function R2NSolver( shifted(reg_nlp.h, xk) Bk = hess_op(reg_nlp.model, x0) - sub_nlp = R2NModel(Bk, ∇fk, T(1), x0) + # Create quadratic model: min ∇f^T s + 1/2 s^T B s + σ/2 ||s||^2 + # QuadraticModel represents: min c^T x + 1/2 x^T H x + c0 + # So we need c = ∇fk, H = Bk + σI, c0 = 0 + σ = T(1) + n = length(∇fk) + x0_quad = zeros(T, n) + reg_hess_wrapper = ShiftedHessian{T}(Bk, T(1)) + reg_hess_op = LinearOperator{T}(n, n, false, false, + (y, x) -> mul!(y, reg_hess_wrapper, x), + (y, x) -> mul!(y, adjoint(reg_hess_wrapper), x), + (y, x) -> mul!(y, adjoint(reg_hess_wrapper), x), + ) + sub_nlp = QuadraticModel(∇fk, reg_hess_op, c0 = zero(T), x0 = x0_quad, name = "R2N-subproblem") subpb = RegularizedNLPModel(sub_nlp, ψ) substats = RegularizedExecutionStats(subpb) subsolver = subsolver(subpb) @@ -93,6 +114,9 @@ function R2NSolver( subsolver, subpb, substats, + x0_quad, + reg_hess_wrapper, + reg_hess_op, ) end @@ -195,6 +219,41 @@ function R2N(reg_nlp::AbstractRegularizedNLPModel; kwargs...) return stats end +# Helper function to update QuadraticModel in-place to avoid allocations +function update_quadratic_model!(qm::QuadraticModel, c::AbstractVector, H=nothing) + copyto!(qm.data.c, c) + if H !== nothing + qm.data.H = H + end + # Attempt to reset evaluation counters if the QuadraticModel exposes them. + # Different versions / wrappers might store counters as a field, a Dict, or + # expose reset_counters! — handle the common cases gracefully without + # depending on an external function. + try + if hasproperty(qm, :counters) + # common pattern: qm.counters.neval_hess + try + qm.counters.neval_hess = 0 + catch + try + qm.counters[:neval_hess] = 0 + catch + # ignore if assignment isn't supported + end + end + elseif hasproperty(qm, :neval_hess) + qm.neval_hess = 0 + elseif hasproperty(qm, :reset_counters!) + qm.reset_counters!() + end + catch + # Be conservative: if anything fails, don't error out — the counters are + # only diagnostic and not required for correctness. + end + + return qm +end + function SolverCore.solve!( solver::R2NSolver{T, G, V}, reg_nlp::AbstractRegularizedNLPModel{T, V}, @@ -292,12 +351,18 @@ function SolverCore.solve!( quasiNewtTest = isa(nlp, QuasiNewtonModel) λmax::T = T(1) found_λ = true - solver.subpb.model.B = hess_op(nlp, xk) + # Update the Hessian and update the QuadraticModel + Bk_new = hess_op(nlp, xk) + σ = T(1) + # Update the existing ShiftedHessian wrapper in-place to avoid allocations + solver.reg_hess_wrapper.B = Bk_new + solver.reg_hess_wrapper.sigma = σ + update_quadratic_model!(solver.subpb.model, solver.∇fk) if opnorm_maxiter ≤ 0 - λmax, found_λ = opnorm(solver.subpb.model.B) + λmax, found_λ = opnorm(Bk_new) else - λmax = power_method!(solver.subpb.model.B, solver.v0, solver.subpb.model.v, opnorm_maxiter) + λmax = power_method!(Bk_new, solver.v0, solver.subpb.model.data.v, opnorm_maxiter) end found_λ || error("operator norm computation failed") @@ -327,7 +392,14 @@ function SolverCore.solve!( end mk = let ψ = ψ, solver = solver - d -> obj(solver.subpb.model, d, skip_sigma = true) + ψ(d)::T + d -> begin + # Avoid allocating a temporary from `B * d` — use the preallocated + # scratch vector stored in the QuadraticModel and perform `mul!` on + # the underlying Hessian operator `data.H`. + tmp = solver.subpb.model.data.v + mul!(tmp, solver.subpb.model.data.H, d) + (0.5 * dot(d, tmp) + dot(solver.subpb.model.data.c, d)) + ψ(d)::T + end end prox!(s1, ψ, mν∇fk, ν₁) @@ -361,9 +433,14 @@ function SolverCore.solve!( while !done sub_atol = stats.iter == 0 ? 1.0e-3 : min(sqrt_ξ1_νInv ^ (1.5), sqrt_ξ1_νInv * 1e-3) - solver.subpb.model.σ = σk - isa(solver.subsolver, R2DHSolver) && (solver.subsolver.D.d[1] = 1/ν₁) - if isa(solver.subsolver, R2Solver) #FIXME + # Update QuadraticModel with updated regularization parameter + Bk_current = hess_op(nlp, xk) + # mutate wrapper in-place + solver.reg_hess_wrapper.B = Bk_current + solver.reg_hess_wrapper.sigma = σk + update_quadratic_model!(solver.subpb.model, solver.∇fk) + isa(solver.subsolver, R2DHSolver) && (solver.subsolver.D.d[1] = 1/ν₁) + if isa(solver.subsolver, R2Solver) #FIXME solve!( solver.subsolver, solver.subpb, @@ -445,12 +522,17 @@ function SolverCore.solve!( push!(nlp, s, solver.y) qn_copy!(nlp, solver, stats) end - solver.subpb.model.B = hess_op(nlp, xk) + # Update the Hessian and update the QuadraticModel + Bk_new = hess_op(nlp, xk) + σ = T(1) + solver.reg_hess_wrapper.B = Bk_new + solver.reg_hess_wrapper.sigma = σ + update_quadratic_model!(solver.subpb.model, solver.∇fk) if opnorm_maxiter ≤ 0 - λmax, found_λ = opnorm(solver.subpb.model.B) + λmax, found_λ = opnorm(Bk_new) else - λmax = power_method!(solver.subpb.model.B, solver.v0, solver.subpb.model.v, opnorm_maxiter) + λmax = power_method!(Bk_new, solver.v0, solver.subpb.model.data.v, opnorm_maxiter) end found_λ || error("operator norm computation failed") end diff --git a/src/R2NModel.jl b/src/R2NModel.jl deleted file mode 100644 index 3ce4d779..00000000 --- a/src/R2NModel.jl +++ /dev/null @@ -1,53 +0,0 @@ -export R2NModel - -@doc raw""" - R2NModel(B, ∇f, v, σ, x0) - -Given the unconstrained optimization problem: -```math -\min f(x), -``` -this model represents the smooth R2N subproblem: -```math -\min_s \ ∇f^T s + \tfrac{1}{2} s^T B s + \tfrac{1}{2} σ \|s\|^2 -``` -where `B` is either an approximation of the Hessian of `f` or the Hessian itself and `∇f` represents the gradient of `f` at `x0`. -`σ > 0` is a regularization parameter and `v` is a vector of the same size as `x0` used for intermediary computations. -""" -mutable struct R2NModel{T <: Real, V <: AbstractVector{T}, G <: AbstractLinearOperator{T}} <: - AbstractNLPModel{T, V} - B::G - ∇f::V - v::V - σ::T - meta::NLPModelMeta{T, V} - counters::Counters -end - -function R2NModel(B::G, ∇f::V, σ::T, x0::V) where {T, V, G} - @assert length(x0) == length(∇f) - meta = NLPModelMeta( - length(∇f), - x0 = x0, # Perhaps we should add lvar and uvar as well here. - ) - v = similar(x0) - return R2NModel(B::G, ∇f::V, v::V, σ::T, meta, Counters()) -end - -function NLPModels.obj(nlp::R2NModel, x::AbstractVector; skip_sigma = false) - @lencheck nlp.meta.nvar x - increment!(nlp, :neval_obj) - mul!(nlp.v, nlp.B, x) - skip_sigma && return dot(nlp.v, x)/2 + dot(nlp.∇f, x) - return dot(nlp.v, x)/2 + dot(nlp.∇f, x) + nlp.σ * dot(x, x) / 2 -end - -function NLPModels.grad!(nlp::R2NModel, x::AbstractVector, g::AbstractVector) - @lencheck nlp.meta.nvar x - @lencheck nlp.meta.nvar g - increment!(nlp, :neval_grad) - mul!(g, nlp.B, x) - g .+= nlp.∇f - g .+= nlp.σ .* x - return g -end diff --git a/src/RegularizedOptimization.jl b/src/RegularizedOptimization.jl index acc9406d..00609459 100644 --- a/src/RegularizedOptimization.jl +++ b/src/RegularizedOptimization.jl @@ -7,13 +7,13 @@ using LinearAlgebra, Logging, Printf using Arpack, ProximalOperators # dependencies from us -using LinearOperators, - ManualNLPModels, - NLPModels, - NLPModelsModifiers, - RegularizedProblems, - ShiftedProximalOperators, - SolverCore +using LinearOperators +try + using LLSModels +catch e + @warn "LLSModels not available; some features may be disabled" exception=(e, catch_backtrace()) +end +using ManualNLPModels, NLPModels, NLPModelsModifiers, QuadraticModels, RegularizedProblems, ShiftedProximalOperators, SolverCore using Percival: AugLagModel, update_y!, update_μ! const callback_docstring = " @@ -22,9 +22,6 @@ The expected signature of the callback is `callback(nlp, solver, stats)`, and it Changing any of the input arguments will affect the subsequent iterations. In particular, setting `stats.status = :user` will stop the algorithm. All relevant information should be available in `nlp` and `solver`. -Notably, you can access, and modify, the following: -- `solver.xk`: current iterate; -- `solver.∇fk`: current gradient; - `stats`: structure holding the output of the algorithm (`GenericExecutionStats`), which contains, among other things: - `stats.iter`: current iteration counter; - `stats.objective`: current objective function value; @@ -39,11 +36,9 @@ include("input_struct.jl") include("TR_alg.jl") include("TRDH_alg.jl") include("R2_alg.jl") -include("LMModel.jl") include("LM_alg.jl") include("LMTR_alg.jl") include("R2DH.jl") -include("R2NModel.jl") include("R2N.jl") include("AL_alg.jl") diff --git a/src/TR_alg.jl b/src/TR_alg.jl index 0b75df70..b6ee012e 100644 --- a/src/TR_alg.jl +++ b/src/TR_alg.jl @@ -70,7 +70,10 @@ function TRSolver( Bk = isa(reg_nlp.model, QuasiNewtonModel) ? hess_op(reg_nlp.model, xk) : hess_op!(reg_nlp.model, xk, similar(xk)) - sub_nlp = R2NModel(Bk, ∇fk, zero(T), x0) #FIXME + # Create quadratic model: min ∇f^T s + 1/2 s^T B s + # QuadraticModel represents: min c^T x + 1/2 x^T H x + c0 + # So we need c = ∇fk, H = Bk, c0 = 0 (no regularization σ = 0) + sub_nlp = QuadraticModel(∇fk, Bk, c0 = zero(T), x0 = zeros(T, length(∇fk)), name = "TR-subproblem") subpb = RegularizedNLPModel(sub_nlp, ψ) substats = RegularizedExecutionStats(subpb) subsolver = subsolver(subpb) @@ -297,9 +300,9 @@ function SolverCore.solve!( found_λ = true if opnorm_maxiter ≤ 0 - λmax, found_λ = opnorm(solver.subpb.model.B) + λmax, found_λ = opnorm(solver.subpb.model.data.H) else - λmax = power_method!(solver.subpb.model.B, solver.v0, solver.subpb.model.v, opnorm_maxiter) + λmax = power_method!(solver.subpb.model.data.H, solver.v0, solver.subpb.model.data.v, opnorm_maxiter) end found_λ || error("operator norm computation failed") @@ -458,9 +461,9 @@ function SolverCore.solve!( end if opnorm_maxiter ≤ 0 - λmax, found_λ = opnorm(solver.subpb.model.B) + λmax, found_λ = opnorm(solver.subpb.model.data.H) else - λmax = power_method!(solver.subpb.model.B, solver.v0, solver.subpb.model.v, opnorm_maxiter) + λmax = power_method!(solver.subpb.model.data.H, solver.v0, solver.subpb.model.data.v, opnorm_maxiter) end found_λ || error("operator norm computation failed") diff --git a/src/utils.jl b/src/utils.jl index ee257198..cb0b073c 100644 --- a/src/utils.jl +++ b/src/utils.jl @@ -15,6 +15,62 @@ function power_method!(B::M, v₀::S, v₁::S, max_iter::Int = 1) where {M, S} return abs(dot(v₀, v₁)) end +# Power method to estimate largest singular value of J (operator) without forming J'J. +# J: operator supporting mul!(y, J, x) as Jacobian (m×n) +function power_method_singular!(J, v₀::AbstractVector, v₁::AbstractVector, tmp::AbstractVector, max_iter::Int = 5) + # v0 and v1 are length n, tmp is length m + @assert length(tmp) == size(J, 1) + @assert length(v₀) == size(J, 2) + @assert length(v₁) == size(J, 2) + # initialize + mul!(tmp, J, v₀) # tmp = J * v0 + mul!(v₁, adjoint(J), tmp) # v1 = J' * tmp + normalize!(v₁) + for i in 2:max_iter + v₀ .= v₁ + mul!(tmp, J, v₀) + mul!(v₁, adjoint(J), tmp) + normalize!(v₁) + end + mul!(tmp, J, v₀) + mul!(v₁, adjoint(J), tmp) + λ = abs(dot(v₀, v₁)) + return sqrt(λ) +end + +# A small mutable wrapper that represents B + sigma*I without allocating a new +# LinearOperator every time sigma or B changes. It provides mul! methods so it +# can be used where a LinearOperator is expected. +mutable struct ShiftedHessian{T} + B::Any + sigma::T +end + +Base.size(op::ShiftedHessian) = size(op.B) +Base.eltype(op::ShiftedHessian) = eltype(op.B) + +import LinearAlgebra: adjoint +function adjoint(op::ShiftedHessian{T}) where T + return LinearAlgebra.Adjoint(op) +end + +function LinearAlgebra.mul!(y::AbstractVector{T}, op::ShiftedHessian{T}, x::AbstractVector{T}) where T + mul!(y, op.B, x) + @inbounds for i in eachindex(y) + y[i] += op.sigma * x[i] + end + return y +end + +function LinearAlgebra.mul!(y::AbstractVector{T}, opAd::Adjoint{<:Any,ShiftedHessian{T}}, x::AbstractVector{T}) where T + # Use the adjoint of the underlying operator and add sigma*x + mul!(y, adjoint(opAd.parent.B), x) + @inbounds for i in eachindex(y) + y[i] += opAd.parent.sigma * x[i] + end + return y +end + # use Arpack to obtain largest eigenvalue in magnitude with a minimum of robustness function LinearAlgebra.opnorm(B; kwargs...) m, n = size(B) @@ -112,6 +168,35 @@ ShiftedProximalOperators.iprox!( LinearAlgebra.diag(op::AbstractDiagonalQuasiNewtonOperator) = copy(op.d) LinearAlgebra.diag(op::SpectralGradient{T}) where {T} = zeros(T, op.nrow) .* op.d[1] +# A wrapper that represents the Gram operator J'J without forming it explicitly. +# It stores a Jacobian operator `J` and a preallocated temporary `tmp` for J*x. + +mutable struct JacobianGram{T} + J::Any + tmp::Vector{T} +end + +Base.size(g::JacobianGram) = g.J === nothing ? (0, 0) : (size(g.J, 2), size(g.J, 2)) + +function LinearAlgebra.mul!(y::AbstractVector{T}, g::JacobianGram{T}, x::AbstractVector{T}) where T + @assert g.J !== nothing "JacobianGram: J not set" + # tmp = J * x + mul!(g.tmp, g.J, x) + # y = J' * tmp + mul!(y, adjoint(g.J), g.tmp) + return y +end + +function LinearAlgebra.mul!(y::AbstractVector{T}, opAd::Adjoint{<:Any,JacobianGram{T}}, x::AbstractVector{T}) where T + # For adjoint(J'J) = J'J since symmetric; delegate to forward + mul!(y, opAd.parent, x) + return y +end + +function adjoint(g::JacobianGram{T}) where T + return LinearAlgebra.Adjoint(g) +end + """ GenericExecutionStats(reg_nlp :: AbstractRegularizedNLPModel{T, V})