docs: fix external references

Author: avik-pal

docs/make.jl

@@ -21,6 +21,7 @@ makedocs(; sitename = "NonlinearSolve.jl",
     modules = [NonlinearSolve, SimpleNonlinearSolve, SteadyStateDiffEq,
         Sundials, DiffEqBase, SciMLBase, SciMLJacobianOperators],
     clean = true,
+    draft=true,
     doctest = false,
     linkcheck = true,
     linkcheck_ignore = ["https://twitter.com/ChrisRackauckas/status/1544743542094020615",

docs/src/basics/autodiff.md

@@ -8,24 +8,25 @@
 
 ## Summary of Finite Differencing Backends
 
-  - [`AutoFiniteDiff`](@extref ADTypes): Finite differencing using `FiniteDiff.jl`, not
-    optimal but always applicable.
-  - [`AutoFiniteDifferences`](@extref ADTypes): Finite differencing using
-    `FiniteDifferences.jl`, not optimal but always applicable.
+  - [`AutoFiniteDiff`](@extref ADTypes.AutoFiniteDiff): Finite differencing using
+    `FiniteDiff.jl`, not optimal but always applicable.
+  - [`AutoFiniteDifferences`](@extref ADTypes.AutoFiniteDifferences): Finite differencing
+    using `FiniteDifferences.jl`, not optimal but always applicable.
 
 ## Summary of Forward Mode AD Backends
 
-  - [`AutoForwardDiff`](@extref ADTypes): The best choice for dense problems.
-  - [`AutoPolyesterForwardDiff`](@extref ADTypes): Might be faster than
-    [`AutoForwardDiff`](@extref ADTypes) for large problems. Requires
+  - [`AutoForwardDiff`](@extref ADTypes.AutoForwardDiff): The best choice for dense
+    problems.
+  - [`AutoPolyesterForwardDiff`](@extref ADTypes.AutoPolyesterForwardDiff): Might be faster
+    than [`AutoForwardDiff`](@extref ADTypes.AutoForwardDiff) for large problems. Requires
     `PolyesterForwardDiff.jl` to be installed and loaded.
 
 ## Summary of Reverse Mode AD Backends
 
-  - [`AutoZygote`](@extref ADTypes): The fastest choice for non-mutating array-based (BLAS)
-    functions.
-  - [`AutoEnzyme`](@extref ADTypes): Uses `Enzyme.jl` Reverse Mode and works for both
-    in-place and out-of-place functions.
+  - [`AutoZygote`](@extref ADTypes.AutoZygote): The fastest choice for non-mutating
+    array-based (BLAS) functions.
+  - [`AutoEnzyme`](@extref ADTypes.AutoEnzyme): Uses `Enzyme.jl` Reverse Mode and works for
+    both in-place and out-of-place functions.
 
 !!! tip
 

docs/src/tutorials/code_optimization.md

@@ -90,7 +90,7 @@ end
 
 Allocations are only expensive if they are “heap allocations”. For a more in-depth
 definition of heap allocations,
-[there are many sources online](http://net-informations.com/faq/net/stack-heap.htm).
+[there are many sources online](https://net-informations.com/faq/net/stack-heap.htm).
 But a good working definition is that heap allocations are variable-sized slabs of memory
 which have to be pointed to, and this pointer indirection costs time. Additionally, the heap
 has to be managed, and the garbage controllers has to actively keep track of what's on the

docs/src/tutorials/large_systems.md

@@ -162,10 +162,11 @@ sparse differentiation!
 
 One of the useful companion tools for NonlinearSolve.jl is
 [ADTypes.jl](https://github.com/SciML/ADTypes.jl) that specifies the interface for sparsity
-detection via [`jacobian_sparsity`](@extref ADTypes). This allows for automatic
-declaration of Jacobian sparsity types. To see this in action, we can give an example `du`
-and `u` and call `jacobian_sparsity` on our function with the example arguments, and it will
-kick out a sparse matrix with our pattern, that we can turn into our `jac_prototype`.
+detection via [`jacobian_sparsity`](@extref ADTypes.jacobian_sparsity). This allows for
+automatic declaration of Jacobian sparsity types. To see this in action, we can give an
+example `du` and `u` and call `jacobian_sparsity` on our function with the example
+arguments, and it will kick out a sparse matrix with our pattern, that we can turn into our
+`jac_prototype`.
 
 !!! tip
 

src/algorithms/extension_algs.jl

@@ -317,7 +317,7 @@ NLSolversJL(; method, autodiff = nothing) = NLSolversJL(method, autodiff)
     SpeedMappingJL(; σ_min = 0.0, stabilize::Bool = false, check_obj::Bool = false,
         orders::Vector{Int} = [3, 3, 2], time_limit::Real = 1000)
 
-Wrapper over [SpeedMapping.jl](https://nicolasl-s.github.io/SpeedMapping.jl) for solving
+Wrapper over [SpeedMapping.jl](https://nicolasl-s.github.io/SpeedMapping.jl/) for solving
 Fixed Point Problems. We allow using this algorithm to solve root finding problems as well.
 
 ### Keyword Arguments