docs: remove Symbolics and SparseDiffTools

Author: avik-pal

docs/Project.toml

@@ -1,4 +1,5 @@
 [deps]
+ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b"
 AlgebraicMultigrid = "2169fc97-5a83-5252-b627-83903c6c433c"
 ArrayInterface = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
 BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
@@ -18,13 +19,12 @@ SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462"
 SciMLJacobianOperators = "19f34311-ddf3-4b8b-af20-060888a46c0e"
 SimpleNonlinearSolve = "727e6d20-b764-4bd8-a329-72de5adea6c7"
 SparseConnectivityTracer = "9f842d2f-2579-4b1d-911e-f412cf18a3f5"
-SparseDiffTools = "47a9eef4-7e08-11e9-0b38-333d64bd3804"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 SteadyStateDiffEq = "9672c7b4-1e72-59bd-8a11-6ac3964bc41f"
 Sundials = "c3572dad-4567-51f8-b174-8c6c989267f4"
-Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7"
 
 [compat]
+ADTypes = "1.9.0"
 AlgebraicMultigrid = "0.5, 0.6"
 ArrayInterface = "6, 7"
 BenchmarkTools = "1"
@@ -44,8 +44,6 @@ SciMLBase = "2.4"
 SciMLJacobianOperators = "0.1"
 SimpleNonlinearSolve = "1"
 SparseConnectivityTracer = "0.6.5"
-SparseDiffTools = "2.14"
 StaticArrays = "1"
 SteadyStateDiffEq = "2"
 Sundials = "4.11"
-Symbolics = "4, 5, 6"

docs/make.jl

@@ -12,6 +12,10 @@ include("pages.jl")
 
 bib = CitationBibliography(joinpath(@__DIR__, "src", "refs.bib"))
 
+interlinks = InterLinks(
+    "ADTypes" => "https://sciml.github.io/ADTypes.jl/stable/",
+)
+
 makedocs(; sitename = "NonlinearSolve.jl",
     authors = "Chris Rackauckas",
     modules = [NonlinearSolve, SimpleNonlinearSolve, SteadyStateDiffEq,
@@ -23,7 +27,7 @@ makedocs(; sitename = "NonlinearSolve.jl",
         "https://link.springer.com/article/10.1007/s40096-020-00339-4"],
     checkdocs = :exports,
     warnonly = [:missing_docs],
-    plugins = [bib],
+    plugins = [bib, interlinks],
     format = Documenter.HTML(assets = ["assets/favicon.ico", "assets/citations.css"],
         canonical = "https://docs.sciml.ai/NonlinearSolve/stable/"),
     pages)

docs/src/basics/autodiff.md

@@ -1,60 +1,32 @@
 # Automatic Differentiation Backends
 
+!!! note
+
+    We support all backends supported by DifferentiationInterface.jl. Please refer to
+    the [backends page](https://gdalle.github.io/DifferentiationInterface.jl/DifferentiationInterface/stable/explanation/backends/)
+    for more information.
+
 ## Summary of Finite Differencing Backends
 
-  - [`AutoFiniteDiff`](@ref): Finite differencing, not optimal but always applicable.
+  - [`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.
 
 ## Summary of Forward Mode AD Backends
 
-  - [`AutoForwardDiff`](@ref): The best choice for dense problems.
-  - [`AutoPolyesterForwardDiff`](@ref): Might be faster than [`AutoForwardDiff`](@ref) for
-    large problems. Requires `PolyesterForwardDiff.jl` to be installed and loaded.
+  - [`AutoForwardDiff`](@extref ADTypes): The best choice for dense problems.
+  - [`AutoPolyesterForwardDiff`](@extref ADTypes): Might be faster than
+    [`AutoForwardDiff`](@extref ADTypes) for large problems. Requires
+    `PolyesterForwardDiff.jl` to be installed and loaded.
 
 ## Summary of Reverse Mode AD Backends
 
   - [`AutoZygote`](@ref): The fastest choice for non-mutating array-based (BLAS) functions.
-  - [`AutoEnzyme`](@ref): Uses `Enzyme.jl` Reverse Mode and should be considered
-    experimental.
+  - [`AutoEnzyme`](@ref): Uses `Enzyme.jl` Reverse Mode and works for both in-place and
+    out-of-place functions.
 
-!!! note
-    
-    If `PolyesterForwardDiff.jl` is installed and loaded, then `SimpleNonlinearSolve.jl`
-    will automatically use `AutoPolyesterForwardDiff` as the default AD backend.
+!!! tip
 
-!!! note
-    
-    The sparse versions of the methods refer to automated sparsity detection. These
-    methods automatically discover the sparse Jacobian form from the function `f`. Note that
-    all methods specialize the differentiation on a sparse Jacobian if the sparse Jacobian
-    is given as `prob.f.jac_prototype` in the `NonlinearFunction` definition, and the
-    `AutoSparse` here simply refers to whether this `jac_prototype` should be generated
-    automatically. For more details, see
-    [SparseDiffTools.jl](https://github.com/JuliaDiff/SparseDiffTools.jl) and
-    [Sparsity Detection Manual Entry](@ref sparsity-detection), as well as the
-    documentation of [ADTypes.jl](https://github.com/SciML/ADTypes.jl).
-
-## API Reference
-
-```@docs
-AutoSparse
-```
-
-### Finite Differencing Backends
-
-```@docs
-AutoFiniteDiff
-```
-
-### Forward Mode AD Backends
-
-```@docs
-AutoForwardDiff
-AutoPolyesterForwardDiff
-```
-
-### Reverse Mode AD Backends
-
-```@docs
-AutoZygote
-AutoEnzyme
-```
+    For sparsity detection and sparse AD take a look at
+    [sparsity detection](@ref sparsity-detection).

docs/src/tutorials/large_systems.md

@@ -161,22 +161,23 @@ is non-zeros, otherwise the overhead of sparse matrices can be higher than the g
 sparse differentiation!
 
 One of the useful companion tools for NonlinearSolve.jl is
-[Symbolics.jl](https://github.com/JuliaSymbolics/Symbolics.jl). This allows for automatic
+[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`.
 
 !!! tip
 
-    Alternatively you can use the `SparseConnectivityTracer.jl` package to automatically
-    generate a sparse Jacobian.
+    External packages like `SparseConnectivityTracer.jl` and `Symbolics.jl` provide the
+    actual implementation of sparsity detection.
 
 ```@example ill_conditioned_nlprob
-using Symbolics
+using SparseConnectivityTracer, ADTypes
 
-du0 = copy(u0)
-jac_sparsity = Symbolics.jacobian_sparsity(
-    (du, u) -> brusselator_2d_loop(du, u, p), du0, u0)
+f! = (du, u) -> brusselator_2d_loop(du, u, p)
+du0 = similar(u0)
+jac_sparsity = ADTypes.jacobian_sparsity(f!, du0, u0, TracerSparsityDetector())
 ```
 
 Notice that Julia gives a nice print out of the sparsity pattern. That's neat, and would be
@@ -322,9 +323,6 @@ sparsity detection. Let's compare the two by setting the sparsity detection algo
 ```@example ill_conditioned_nlprob
 using DifferentiationInterface, SparseConnectivityTracer
 
-prob_brusselator_2d_exact_symbolics = NonlinearProblem(
-    NonlinearFunction(brusselator_2d_loop; sparsity = SymbolicsSparsityDetector()),
-    u0, p; abstol = 1e-10, reltol = 1e-10)
 prob_brusselator_2d_exact_tracer = NonlinearProblem(
     NonlinearFunction(brusselator_2d_loop; sparsity = TracerSparsityDetector()),
     u0, p; abstol = 1e-10, reltol = 1e-10)
@@ -333,7 +331,6 @@ prob_brusselator_2d_approx_di = NonlinearProblem(
         sparsity = DenseSparsityDetector(AutoForwardDiff(); atol = 1e-4)),
     u0, p; abstol = 1e-10, reltol = 1e-10)
 
-@btime solve(prob_brusselator_2d_exact_symbolics, NewtonRaphson());
 @btime solve(prob_brusselator_2d_exact_tracer, NewtonRaphson());
 @btime solve(prob_brusselator_2d_approx_di, NewtonRaphson());
 nothing # hide

test/misc/qa_tests.jl

@@ -18,7 +18,7 @@ end
     using NonlinearSolve, ADTypes, SimpleNonlinearSolve, SciMLBase
     import BandedMatrices, FastLevenbergMarquardt, FixedPointAcceleration,
            LeastSquaresOptim, MINPACK, NLsolve, NLSolvers, SIAMFANLEquations, SpeedMapping,
-           Symbolics, Zygote
+           Zygote
 
     using ExplicitImports