diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..f08278d --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +*.pdf \ No newline at end of file diff --git a/labo7_env/Manifest.toml b/labo7_env/Manifest.toml new file mode 100644 index 0000000..5ccd64d --- /dev/null +++ b/labo7_env/Manifest.toml @@ -0,0 +1,462 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.11.5" +manifest_format = "2.0" +project_hash = "bfb3d68fcba99f61211a810fab7bc65664d459d1" + +[[deps.ADNLPModels]] +deps = ["ADTypes", "ForwardDiff", "LinearAlgebra", "NLPModels", "Requires", "ReverseDiff", "SparseArrays", "SparseConnectivityTracer", "SparseMatrixColorings"] +git-tree-sha1 = "397c37668a74a47a16e0cdd47d1204e564549ace" +uuid = "54578032-b7ea-4c30-94aa-7cbd1cce6c9a" +version = "0.8.12" + +[[deps.ADTypes]] +git-tree-sha1 = "be7ae030256b8ef14a441726c4c37766b90b93a3" +uuid = "47edcb42-4c32-4615-8424-f2b9edc5f35b" +version = "1.15.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.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.ChainRulesCore]] +deps = ["Compat", "LinearAlgebra"] +git-tree-sha1 = "06ee8d1aa558d2833aa799f6f0b31b30cada405f" +uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" +version = "1.25.2" +weakdeps = ["SparseArrays"] + + [deps.ChainRulesCore.extensions] + ChainRulesCoreSparseArraysExt = "SparseArrays" + +[[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 = "3a3dfb30697e96a440e4149c8c51bf32f818c0f3" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.17.0" +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.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.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.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.DocStringExtensions]] +git-tree-sha1 = "7442a5dfe1ebb773c29cc2962a8980f47221d76c" +uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" +version = "0.9.5" + +[[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.FillArrays]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "6a70198746448456524cb442b8af316927ff3e1a" +uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" +version = "1.13.0" + + [deps.FillArrays.extensions] + FillArraysPDMatsExt = "PDMats" + FillArraysSparseArraysExt = "SparseArrays" + FillArraysStatisticsExt = "Statistics" + + [deps.FillArrays.weakdeps] + PDMats = "90014a1f-27ba-587c-ab20-58faa44d9150" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" + +[[deps.ForwardDiff]] +deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"] +git-tree-sha1 = "910febccb28d493032495b7009dce7d7f7aee554" +uuid = "f6369f11-7733-5829-9624-2563aa707210" +version = "1.0.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.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.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "a007feb38b422fbdab534406aeca1b86823cb4d6" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.7.0" + +[[deps.LaTeXStrings]] +git-tree-sha1 = "dda21b8cbd6a6c40d9d02a73230f9d70fed6918c" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.4.0" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.11.0" + +[[deps.LinearOperators]] +deps = ["FastClosures", "LinearAlgebra", "Printf", "Requires", "SparseArrays", "TimerOutputs"] +git-tree-sha1 = "1894a798ed8887895c5ae70f1fe8331c0c1d8480" +uuid = "5c8ed15e-5a4c-59e4-a42b-c7e8811fb125" +version = "2.10.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.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.Markdown]] +deps = ["Base64"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.NLPModels]] +deps = ["FastClosures", "LinearAlgebra", "LinearOperators", "Printf", "SparseArrays"] +git-tree-sha1 = "ac58082a07f0bd559292e869770d462d7ad0a7e2" +uuid = "a4795742-8479-5a88-8948-cc11e1c8c1a6" +version = "0.21.5" + +[[deps.NaNMath]] +deps = ["OpenLibm_jll"] +git-tree-sha1 = "9b8215b1ee9e78a293f99797cd31375471b2bcae" +uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" +version = "1.1.3" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.27+1" + +[[deps.OpenLibm_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "05823500-19ac-5b8b-9628-191a04bc5112" +version = "0.8.5+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 = "05868e21324cede2207c6f0f466b4bfef6d5e7ee" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "1.8.1" + +[[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 = "9306f6085165d270f7e3db02af26a400d580f5c6" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.4.3" + +[[deps.PrettyTables]] +deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "Reexport", "StringManipulation", "Tables"] +git-tree-sha1 = "1101cd475833706e4d0e7b122218257178f48f34" +uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +version = "2.4.0" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[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.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.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "0.7.0" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" +version = "1.11.0" + +[[deps.SolverCore]] +deps = ["LinearAlgebra", "NLPModels", "Printf"] +git-tree-sha1 = "03a1e0d2d39b9ebc9510f2452c0adfbe887b9cb2" +uuid = "ff4d7338-4cf1-434d-91df-b86cb86fb843" +version = "0.3.8" + +[[deps.SolverTools]] +deps = ["LinearAlgebra", "LinearOperators", "NLPModels", "Printf"] +git-tree-sha1 = "09b6c2ac30623d8205b3d56b7518ca08ef5f5870" +uuid = "b5612192-2639-5dc1-abfe-fbedd65fab29" +version = "0.9.0" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +version = "1.11.0" + +[[deps.SparseConnectivityTracer]] +deps = ["ADTypes", "DocStringExtensions", "FillArrays", "LinearAlgebra", "Random", "SparseArrays"] +git-tree-sha1 = "182990067a09adf950274f97f38f68c76f81d2d0" +uuid = "9f842d2f-2579-4b1d-911e-f412cf18a3f5" +version = "0.6.21" + + [deps.SparseConnectivityTracer.extensions] + SparseConnectivityTracerDataInterpolationsExt = "DataInterpolations" + SparseConnectivityTracerLogExpFunctionsExt = "LogExpFunctions" + SparseConnectivityTracerNNlibExt = "NNlib" + SparseConnectivityTracerNaNMathExt = "NaNMath" + SparseConnectivityTracerSpecialFunctionsExt = "SpecialFunctions" + + [deps.SparseConnectivityTracer.weakdeps] + DataInterpolations = "82cc6244-b520-54b8-b5a6-8a565e85f1d0" + 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.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 = "41852b8679f78c8d8961eeadc8f62cef861a52e3" +uuid = "276daf66-3868-5448-9aa4-cd146d93841b" +version = "2.5.1" +weakdeps = ["ChainRulesCore"] + + [deps.SpecialFunctions.extensions] + SpecialFunctionsChainRulesCoreExt = "ChainRulesCore" + +[[deps.StaticArrays]] +deps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"] +git-tree-sha1 = "0feb6b9031bd5c51f9072393eb5ab3efd31bf9e4" +uuid = "90137ffa-7385-5640-81b9-e52037218182" +version = "1.9.13" +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"] +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 = "725421ae8e530ec29bcbdddbe91ff8053421d023" +uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" +version = "0.4.1" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "Libdl", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "7.7.0+0" + +[[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 = "f2c1efbc8f3a609aadf318094f8fc5204bdaf344" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.12.1" + +[[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.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.11.0+0" diff --git a/labo7_env/Project.toml b/labo7_env/Project.toml new file mode 100644 index 0000000..3fda006 --- /dev/null +++ b/labo7_env/Project.toml @@ -0,0 +1,9 @@ +[deps] +ADNLPModels = "54578032-b7ea-4c30-94aa-7cbd1cce6c9a" +IterativeSolvers = "42fd0dbc-a981-5370-80f2-aaf504508153" +NLPModels = "a4795742-8479-5a88-8948-cc11e1c8c1a6" +PrettyTables = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7" +SolverCore = "ff4d7338-4cf1-434d-91df-b86cb86fb843" +SolverTools = "b5612192-2639-5dc1-abfe-fbedd65fab29" +SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" diff --git a/rapport.qmd b/rapport.qmd index 0653ef9..6055dbd 100644 --- a/rapport.qmd +++ b/rapport.qmd @@ -2,8 +2,8 @@ title: "Rapport de laboratoire 4" subtitle: "MTH8408" author: - - name: Votre nom - email: votre.adresse@polymtl.ca + - name: Chris David Fogué + email: Ouépiya-chris-david.fogue@polymtl.ca affiliation: - name: Polytechnique Montréal format: @@ -27,7 +27,14 @@ engine: julia #| output: false using Pkg Pkg.activate("labo7_env") -using LinearAlgebra +Pkg.add("NLPModels") +Pkg.add("ADNLPModels") +Pkg.add("SolverTools") +Pkg.add("SolverCore") +Pkg.add("Printf") +Pkg.add("IterativeSolvers") +Pkg.add("SparseArrays") +using LinearAlgebra, ADNLPModels, NLPModels, Printf, Logging, SolverTools, Test, SparseArrays, IterativeSolvers, SolverCore ``` # Contexte @@ -58,8 +65,300 @@ Votre implémentation doit avoir les caractéristiques suivantes : ```{julia} -function quad_penalty(model, eps_a=1.0e-5, eps_r=1.0e-5) - # modifier la fonction fournie en laboratoire + +function linesearch(model, x, d, grad_f) + t = 1.0 + alpha=0.5 + beta=1e-4 + max_ls=20 + f0 = obj(model, x) + g0 = dot(grad_f, d) + ls_iter = 0 + + while true + ft = obj(model, x + t*d) + if ft ≤ f0 + beta*t*g0 || ls_iter ≥ max_ls + break + end + t *= alpha + ls_iter += 1 + end + return t +end + +############################################################################### +function newton_inexacte(model; eps_a=1.0e-5, eps_r=1.0e-5) + n = model.meta.nvar + x = copy(model.meta.x0) + grad_f = grad(model, x) + gnorm0 = norm(grad_f) + max_iter=100 + eta_max=0.1 + hist = [] + # Préallocation pour CG + d = similar(x) + r = similar(x) + p = similar(x) + Ap = similar(x) + z = similar(x) + + @printf("\n%5s %15s %15s %15s\n", "Iter", "||grad_f||", "eta_k", "f(x)") + @printf("%s\n", repeat("=", 58)) + + + for k = 1:min(max_iter, 100 + 10*n) + hess_f = hess(model, x) + f_current = obj(model, x) + eta_k = min(eta_max, norm(grad_f)^0.5) # Critère d'inexactitude + + + # Initialisation du gradient conjugué + d .= 0.0 + r .= -grad_f + p .= r + rs_old = dot(r, r) + + for cg_iter = 1:min(100, 2*n) + mul!(Ap, hess_f, p) + alpha = rs_old / dot(p, Ap) + d .+= alpha * p + r .-= alpha * Ap + rs_new = dot(r, r) + + if sqrt(rs_new) < eta_k * norm(grad_f) + break + end + + p .= r .+ (rs_new / rs_old) .* p + rs_old = rs_new + end + + # Recherche linéaire + t = linesearch(model, x, d, grad_f) + + # Mise à jour + x .+= t .* d + grad_f = grad(model, x) + gnorm = norm(grad_f) + push!(hist, (k=k, x=copy(x), grad_norm=gnorm, eta_k=eta_k, f=obj(model,x))) + + @printf("%5d %15.6e %15.6e %15.6e\n", k, gnorm, eta_k, obj(model,x)) + + if gnorm ≤ eps_a + eps_r * gnorm0 + break + end + end + + println(repeat("=", 58)) + return x, hist +end + +############################################################################### +function newton_inexacte_status(model::AbstractNLPModel; eps_a=1e-5, eps_r=1e-5) + xk, hist = newton_inexacte(model; eps_a=eps_a, eps_r=eps_r) + fk = obj(model, xk) + gnorm = norm(grad(model, xk)) + return GenericExecutionStats( + model; + status = gnorm <= eps_a + eps_r * norm(grad(model, model.meta.x0)) ? :first_order : :max_iter, + solution = xk, + objective = fk, + iter = length(hist) + ) +end + +######################################################################################################################################################################### + +function quad_penalty_adnlp(nlp::ADNLPModel, ρ::Float64) + +""" + quad_penalty_adnlp(model::ADNLPModel, ρ::Float64) -> ADNLPModel + +Construit un nouveau modèle d'optimisation avec pénalité quadratique à partir d'un modèle `model` de type `ADNLPModel`. + +# Arguments +- `model::ADNLPModel`: Le modèle d'optimisation différentiable original, incluant la fonction objectif `f` et les contraintes `c!`. +- `ρ::Float64`: Le coefficient de pénalité quadratique, un scalaire positif qui pondère l'importance des contraintes dans la fonction pénalisée. + +# Retourne +- Un nouvel objet `ADNLPModel` contenant une fonction objectif modifiée de la forme : + f_p(x) = f(x) + (ρ/2) * ||c(x)||² + +""" + + x0 = copy(nlp.meta.x0) + X = eltype(x0) + C = nlp.meta.ncon + + f_penal(x) = begin + cst = similar(x, C) + nlp.c!(cst, x) + nlp.f(x) + 0.5 * ρ * dot(cst, cst) + end + return ADNLPModel(f_penal, x0) +end + +############################################################################### + +function KKT_eq_constraint(model :: AbstractNLPModel, x, y) + +""" + KKT_eq_constraint(model::AbstractNLPModel, x, y) -> (stationarity, feasibility) + +Calcule les résidus des conditions d'optimalité de Karush-Kuhn-Tucker (KKT) pour un problème +d'optimisation non-linéaire avec contraintes d'égalité uniquement. + +# Arguments +- `model::AbstractNLPModel` : Le modèle d’optimisation contenant l’objectif et les contraintes. +- `x` : Le vecteur des variables de décision, évalué à une solution candidate. +- `y` : Le vecteur des multiplicateurs de Lagrange associés aux contraintes d'égalité. + +# Retourne +Un tuple contenant : +- `stationarity` : Le vecteur de stationnarité, correspondant au gradient de la Lagrangienne : + ∇f(x) + J(x)' * y + où ∇f(x) est le gradient de la fonction objectif, J(x) est la jacobienne des contraintes, + et y est le vecteur des multiplicateurs de Lagrange. + +- `feasibility` : La violation de faisabilité des contraintes d’égalité, mesurée par la norme infinie. +""" + + grad_f = grad(model, x) + c = cons(model, x) + J = jac(model, x) + + stationarity = grad_f + J' * y + feasibility = norm(c, Inf) + + return (stationarity, feasibility) +end + +################################################################################ + +function quad_penalty(model; eps_a=1.0e-5, eps_r=1.0e-5) + +""" + quad_penalty(model; eps_a=1.0e-5, eps_r=1.0e-5) -> GenericExecutionStats + +Résout un problème de programmation non linéaire sous contraintes d’égalité à l’aide de la méthode de pénalisation quadratique. + +# Arguments +- `model::ADNLPModel`: Le modèle non linéaire à résoudre (avec contraintes d’égalité). +- `eps_a::Float64=1e-5`: Tolérance absolue pour les conditions KKT (critère d’arrêt). +- `eps_r::Float64=1e-5`: Tolérance relative pour les conditions KKT. + +La fonction construit une suite de problèmes pénalisés de la forme : +φ(x) = f(x) + 0.5ρ‖c(x)‖² +""" + + # Paramètres par défaut comme dans le document original + x = copy(model.meta.x0) + ϵ = eps_a # Tolérance pour les conditions KKT + η = 1e6 # Valeur maximale pour ρ + σ = 2.0 # Facteur d'augmentation de ρ + max_eval = 1_000 + max_time = 60.0 + max_iter = 100 + + # Initialisation + cx = cons(model, x) + normcx = normcx_old = norm(cx) + ρ = 1.0 + iter = 0 + el_time = 0.0 + tired = neval_cons(model) > max_eval || el_time > max_time + status = :unknown + start_time = time() + too_small = false + y = zeros(eltype(x), model.meta.ncon) + + # Évaluation initiale des conditions KKT + (stationarity, feasibility) = KKT_eq_constraint(model, x, y) + optimal = norm(stationarity, Inf) ≤ ϵ && feasibility ≤ ϵ + + @printf("\n%5s %6s %12s %12s %12s %8s\n", "Iter", "#F", "‖c(x)‖", "‖grad_L‖", "Status", "ρ") + @printf("%s\n", repeat("-", 64)) + + while !(optimal || tired || too_small) + # Création du problème pénalisé + model_quad = quad_penalty_adnlp(model, ρ) + + # Résolution du sous-problème avec Newton inexacte + stats = newton_inexacte_status(model_quad; eps_a=ϵ, eps_r=eps_r) + + # Mise à jour des variables + if stats.status == :first_order + x = stats.solution + cx = cons(model, x) + normcx_old = normcx + normcx = norm(cx) + end + + # Estimation des multiplicateurs de Lagrange + y .= -ρ .* cx + + # Vérification des conditions d'arrêt + (stationarity, feasibility) = KKT_eq_constraint(model, x, y) + optimal = norm(stationarity, Inf) ≤ ϵ && feasibility ≤ ϵ + + # Augmentation du paramètre de pénalité + if normcx > 0.1 * normcx_old + ρ *= σ + if ρ > η + too_small = true + end + end + + @printf("%5d %6d %12.2e %12.2e %12s %8.1e\n", + iter, neval_cons(model), normcx, norm(stationarity, Inf), + string(stats.status), ρ) + + el_time = time() - start_time + iter += 1 + many_evals = neval_cons(model) > max_eval + iter_limit = iter > max_iter + tired = many_evals || el_time > max_time || iter_limit || ρ ≥ η + end + + # Compte des évaluations + n_eval_f = neval_obj(model) + n_eval_c = neval_cons(model) + + # Détermination du statut final + status = if optimal + :first_order + elseif tired + if neval_cons(model) > max_eval + :max_eval + elseif el_time > max_time + :max_time + elseif iter > max_iter + :max_iter + else + :unknown + end + elseif too_small + :stalled + else + :unknown + end + + return GenericExecutionStats( + model, + status = optimal ? :first_order : :max_iter, + solution = x, + objective = obj(model, x), + primal_feas = normcx, + dual_feas = norm(stationarity, Inf), + iter = iter, + elapsed_time = el_time, + solver_specific = Dict( + :penalty => ρ, + :multipliers => y, + :n_eval_f => n_eval_f, + :n_eval_c => n_eval_c + ) + ) end ``` @@ -72,6 +371,13 @@ Ceci vous donne deux variantes de la méthode de pénalité quadratique. ```{julia} # votre code ici + +include("test_set.jl") + +results = [ + (nlp.meta.name, nlp.meta.nvar, nlp.meta.ncon, quad_penalty(nlp)) + for nlp in test_set +] ``` ## Résumé des résultats @@ -93,8 +399,78 @@ Le module `PrettyTables.jl` pourrait être utile. ```{julia} # votre code ici +using PrettyTables + +function analyze_problem(nlp) + try + # Exécuter la méthode de pénalité quadratique + stats = quad_penalty(nlp) + + # Calculer les résidus KKT initiaux + y0 = zeros(nlp.meta.ncon) + (stat0, feas0) = KKT_eq_constraint(nlp, nlp.meta.x0, y0) + initial_kkt = max(norm(stat0, Inf), feas0) + + # Extraire les résultats finaux + return ( + name = nlp.meta.name, + nvar = nlp.meta.nvar, + ncon = nlp.meta.ncon, + initial_kkt = initial_kkt, + final_kkt = max(stats.dual_feas, stats.primal_feas), + y_norm = norm(stats.solver_specific[:multipliers]), + final_rho = stats.solver_specific[:penalty], + iterations = stats.iter, + evaluations = stats.solver_specific[:n_eval_f] + stats.solver_specific[:n_eval_c], + status = stats.status + ) + catch e + @warn "Échec sur $(nlp.meta.name): $e" + return ( + name = nlp.meta.name, + nvar = nlp.meta.nvar, + ncon = nlp.meta.ncon, + initial_kkt = NaN, + final_kkt = NaN, + y_norm = NaN, + final_rho = NaN, + iterations = 0, + evaluations = 0, + status = :error + ) + end +end + +function load_test_set() + include("test_set.jl") + try + return test_set() + catch + return test_set + end +end + +# Analyser les problèmes +problems = load_test_set() +results = analyze_problem.(problems) + +# Afficher le tableau +pretty_table(results, + header = ["Problème", "n", "m", "KKT init", "KKT final", "‖y‖", "ρ", "Iters", "Évals", "Statut"], + alignment = [:l, :c, :c, :r, :r, :r, :r, :c, :c, :c], + formatters = (ft_printf("%.1e", 4:7), ft_printf("%d", [2,3,8,9])), + tf = tf_markdown # Meilleur rendu pour les rapports +) ``` ## Commentaires sur les résultats - +La méthode montre une décroissance des résidus KKT (‖grad_L‖ et ‖c(x)‖), avec plusieurs problèmes atteignant le statut `first_order` (tolérances 1e-5 remplies). Certains cas restent en `stalled` ou `unknown`, probablement dus à : +- La progression prudente du paramètre ρ (condition : `normcx > 0.1*normcx_old`). Remarque: Cela varie en changeant le facteur multiplicateur `0.1` par une valeur plus basse ( par exemple `1e-3`) +- Des plateaux de convergence ou l'atteinte de `max_iter`. + +La norme des multiplicateurs de Lagrange `y` augmente avec ρ, suivant la relation théorique `y ≈ -ρc(x)`. La gestion de la valeur de ρ évite des valeurs extrêmes, favorisant la stabilité numérique. + +La résolution semble efficace dans l'ensemble, pour les problèmes bien conditionnés. + +L'implémentation semble respecter les attentes théoriques. Les rares échecs de convergence reflètent les limites naturelles de la méthode de pénalité quadratique, qui pourraient être atténuées par des ajustements de la stratégie de pénalisation. diff --git a/test_set.jl b/test_set.jl new file mode 100644 index 0000000..6cc4ab1 --- /dev/null +++ b/test_set.jl @@ -0,0 +1,123 @@ +test_set = [ + ADNLPModel(x -> 2x[1]^2 + x[1] * x[2] + x[2]^2 - 9x[1] - 9x[2] + 14, + [1.0; 2.0], + x -> [4x[1] + 6x[2] - 10], + zeros(1), zeros(1), + name="Simple linear-quadratique problem"), + ADNLPModel(x -> (x[1] - 1)^2, + [-1.2; 1.0], + x -> [10 * (x[2] - x[1]^2)], + zeros(1), zeros(1), + name="HS6"), + ADNLPModel(x -> (x[1] - 1)^2 + 100 * (x[2] - x[1]^2)^2, + [-1.2; 1.0], + x -> [(x[1] - 2)^2 + (x[2] - 2)^2 - 2], + zeros(1), zeros(1), + name="Rosenbrock with (x₁-2)²+(x₂-2)²=2"), + ADNLPModel(x -> -x[1] + 1, + [0.5; 1 / 3], + x -> [(4x[1])^2 + (3x[2])^2 - 25; + 4x[1] * 3x[2] - 12], + zeros(2), zeros(2), + name="scaled HS8"), + ADNLPModel(x -> dot(x, x) - 30, + zeros(30), + x -> [sum(x) - 30], + zeros(1), zeros(1), + name="||x||² s.t. ∑x = n"), + ADNLPModel(x -> (x[1] - 1.0)^2 + 100 * (x[2] - x[1]^2)^2, + [-1.2; 1.0], + x -> [sum(x) - 2], [0.0], [0.0], + name="Rosenbrock with ∑x = 2"), + ADNLPModel(x -> (x[1] - x[2])^2 + (x[2] - x[3])^4, + [-2.6, 2.0, 2.0], + x -> [(1 + x[2]^2) * x[1] + x[3]^4 - 3], [0.0], [0.0], + name="HS26"), + ADNLPModel(x -> 0.01 * (x[1] - 1)^2 + (x[2] - x[1]^2)^2, + 2ones(3), + x -> [x[1] + x[3]^2 + 1], [0.0], [0.0], + name="HS27"), + ADNLPModel(x -> (x[1] + x[2])^2 + (x[2] + x[3])^2, + [-4., 1, 1], + x -> [x[1] + 2 * x[2] + 3 * x[3] - 1], [0.0], [0.0], + name="HS28"), + ADNLPModel(x -> -x[1], + 2ones(4), + x -> [x[2] - x[1]^3 - x[3]^2; x[1]^2 - x[2] - x[4]^2], zeros(2), zeros(2), + name="HS39"), + ADNLPModel(x -> -x[1] * x[2] * x[3] * x[4], + 0.8ones(4), + x -> [x[1]^3 + x[2]^2 - 1; x[4] * x[1]^2 - x[3]; x[4]^2 - x[2]], zeros(3), zeros(3), + name="HS40"), + ADNLPModel(x -> (x[1] - 1)^2 + (x[2] - 2)^2 + (x[3] - 3)^2 + (x[4] - 4)^2, + ones(4), + x -> [x[3]^2 + x[4]^2 - 2; x[1] - 2], zeros(2), zeros(2), + name="HS42"), + ADNLPModel(x -> (x[1] - x[2])^2 + (x[3] - 1)^2 + (x[4] - 1)^4 + (x[5] - 1)^6, + [sqrt(2) / 2, 1.75, 0.5, 2, 2], + x -> [(x[1]^2) * x[4] + sin(x[4] - x[5]) - 1; x[2] + (x[3]^4) * (x[4]^2) - 2], zeros(2), zeros(2), + name="HS46"), + ADNLPModel(x -> (x[1] - x[2])^2 + (x[2] - x[3])^3 + (x[3] - x[4])^4 + (x[4] - x[5])^4, + [35., -31, 11, 5, -5], + x -> [x[1] + x[2]^2 + x[3]^3 - 3; x[2] - x[3]^2 + x[4] - 1; x[1] * x[5] - 1], zeros(3), zeros(3), + name="HS47"), + ADNLPModel(x -> (x[1] - 1)^2 + (x[2] - x[3])^2 + (x[4] - x[5])^2, + [3., 5, -3, 2, -2], + x -> [x[1] + x[2] + x[3] + x[4] + x[5] - 5; x[3] - 2 * (x[4] + x[5]) + 3], zeros(2), zeros(2), + name="HS48"), + ADNLPModel(x -> (x[1] - x[2])^2 + (x[3] - 1)^2 + (x[4] - 1)^4 + (x[5] - 1)^6, + [10, 7, 2, -3, 0.8], + x -> [x[1] + x[2] + x[3] + 4 * x[4] - 7; x[3] + 5 * x[5] - 6], zeros(2), zeros(2), + name="HS49"), + ADNLPModel(x -> (x[1] - x[2])^2 + (x[2] - x[3])^2 + (x[3] - x[4])^4 + (x[4] - x[5])^2, + [35., -31, 11, 5, -5], + x -> [x[1] + 2 * x[2] + 3 * x[3] - 6; x[2] + 2 * x[3] + 3 * x[4] - 6; x[3] + 2 * x[4] + 3 * x[5] - 6], zeros(3), zeros(3), + name="HS50"), + ADNLPModel(x -> (x[1] - x[2])^2 + (x[2] + x[3] - 2)^2 + (x[4] - 1)^2 + (x[5] - 1)^2, + [2.5, 0.5, 2, -1, 0.5], + x -> [x[1] + 3 * x[2] - 4; x[3] + x[4] - 2 * x[5]; x[2] - x[5]], zeros(3), zeros(3), + name="HS51"), + ADNLPModel(x -> (4 * x[1] - x[2])^2 + (x[2] + x[3] - 2)^2 + (x[4] - 1)^2 + (x[5] - 1)^2, + 2ones(5), + x -> [x[1] + 3 * x[2]; x[3] + x[4] - 2 * x[5]; x[2] - x[5]], zeros(3), zeros(3), + name="HS52"), + ADNLPModel(x -> -x[1] * x[2] * x[3], + [1, 1, 1, asin(sqrt(1 / 4.2)), asin(sqrt(1 / 4.2)), asin(sqrt(1 / 4.2)), asin(sqrt(5 / 7.2))], + x -> [x[1] - 4.2 * sin(x[4])^2; x[2] - 4.2 * sin(x[5])^2; x[3] - 4.2 * sin(x[6])^2; x[1] + 2 * x[2] + 2 * x[3] - 7.2 * sin(x[7])^2], zeros(4), zeros(4), + name="HS56"), + ADNLPModel(x -> (1 - x[1])^2, + [-1.2; 1.0], + x -> [10 * (x[2] - x[1]^2)], [0.0], [0.0], + name="HS6"), + ADNLPModel(x -> 1000 - x[1]^2 - 2 * x[2]^2 - x[3]^2 - x[1] * x[2] - x[1] * x[3], + 2ones(3), + x -> [8 * x[1] + 14 * x[2] + 7 * x[3] - 56; x[1]^2 + x[2]^2 + x[3]^2 - 25], zeros(2), zeros(2), + name="HS63"), + ADNLPModel(x -> log(1 + x[1]^2) - x[2], + [2.0; 2.0], + x -> [(1 + x[1]^2)^2 + x[2]^2 - 4], [0.0], [0.0], name="HS7"), + ADNLPModel(x -> (x[1] - 1)^2 + (x[1] - x[2])^2 + (x[3] - 1)^2 + (x[4] - 1)^4 + (x[5] - 1)^6, + 2ones(5), + x -> [x[1] + x[2]^2 + x[3]^3 - 2 - 3 * sqrt(2); x[2] - x[3]^2 + x[4] + 2 - 2 * sqrt(2); x[1] * x[5] - 2], + zeros(3), zeros(3), name="HS77"), + ADNLPModel(x -> (x[1] - 1)^2 + (x[1] - x[2])^2 + (x[2] - x[3])^2 + (x[3] - x[4])^4 + (x[4] - x[5])^4, + 2ones(5), + x -> [x[1] + x[2]^2 + x[3]^3 - 2 - 3 * sqrt(2); x[2] - x[3]^2 + x[4] + 2 - 2 * sqrt(2); x[1] * x[5] - 2], + zeros(3), zeros(3), name="HS79"), + ADNLPModel(x -> -1.0, [2.0; 1.0], + x -> [x[1]^2 + x[2]^2 - 25; x[1] * x[2] - 9], + zeros(2), zeros(2), name="HS8"), + ADNLPModel(x -> sin(π * x[1] / 12) * cos(π * x[2] / 16), + zeros(2), + x -> [4 * x[1] - 3 * x[2]], [0.0], [0.0], name="HS9"), + ADNLPModel(x -> (x[1] - x[2])^2 + (x[2] - x[3])^4, + [-2.6; 2.0; 2.0], + x -> [(1 + x[2]^2) * x[1] + x[3]^4 - 3], [0.0], [0.0], name="HS26"), + ADNLPModel(x -> 0.01 * (x[1] - 1)^2 + (x[2] - x[1]^2)^2, + [2.0; 2.0; 2.0], + x -> [x[1] + x[3]^2 + 1.0], [0.0], [0.0], name="HS27"), + ADNLPModel(x -> 100 * x[1]^2 + 100 * x[2]^2 - x[1] - 100, [0.08, 0.06], + x -> [x[1]^2 + x[2]^2 - 1.0], [0.0], [0.0], name="BT1"), + ADNLPModel(x -> 0., [100.0, -1.0, 2.5], + x -> [x[1] - x[2] + x[3]; -x[1] + x[2] + x[3]; x[1] + x[2] - x[3]], zeros(3), zeros(3)) +] \ No newline at end of file