Fix tag checking

Author: avik-pal

Manifest.toml

@@ -31,9 +31,9 @@ version = "0.2.0"
 
 [[deps.ArrayInterface]]
 deps = ["Adapt", "LinearAlgebra", "Requires", "SparseArrays", "SuiteSparse"]
-git-tree-sha1 = "f83ec24f76d4c8f525099b2ac475fc098138ec31"
+git-tree-sha1 = "eba0af42241f0cb648806604222bab1e064edb67"
 uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
-version = "7.4.11"
+version = "7.5.0"
 
     [deps.ArrayInterface.extensions]
     ArrayInterfaceBandedMatricesExt = "BandedMatrices"
@@ -59,9 +59,9 @@ version = "0.1.29"
 
 [[deps.ArrayLayouts]]
 deps = ["FillArrays", "LinearAlgebra"]
-git-tree-sha1 = "9a731850434825d183af39c6e6cd0a1c32dd7e20"
+git-tree-sha1 = "af43df5704827c8618afd36eb56fcab20d3041ee"
 uuid = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
-version = "1.4.2"
+version = "1.4.3"
 weakdeps = ["SparseArrays"]
 
     [deps.ArrayLayouts.extensions]
@@ -184,9 +184,11 @@ uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"
 
 [[deps.DiffEqBase]]
 deps = ["ArrayInterface", "ChainRulesCore", "DataStructures", "DocStringExtensions", "EnumX", "EnzymeCore", "FastBroadcast", "ForwardDiff", "FunctionWrappers", "FunctionWrappersWrappers", "LinearAlgebra", "Logging", "Markdown", "MuladdMacro", "Parameters", "PreallocationTools", "PrecompileTools", "Printf", "RecursiveArrayTools", "Reexport", "Requires", "SciMLBase", "SciMLOperators", "Setfield", "SparseArrays", "Static", "StaticArraysCore", "Statistics", "Tricks", "TruncatedStacktraces", "ZygoteRules"]
-git-tree-sha1 = "59842b690c2ed12428a741c1334f3c68d1377fb6"
+git-tree-sha1 = "53ad089996089756cae5a098b1a0542aeaab466f"
+repo-rev = "master"
+repo-url = "https://github.com/SciML/DiffEqBase.jl.git"
 uuid = "2b5f629d-d688-5b77-993f-72d75c75574e"
-version = "6.135.0"
+version = "6.136.0"
 
     [deps.DiffEqBase.extensions]
     DiffEqBaseDistributionsExt = "Distributions"
@@ -443,9 +445,9 @@ uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 
 [[deps.LinearSolve]]
 deps = ["ArrayInterface", "ConcreteStructs", "DocStringExtensions", "EnumX", "EnzymeCore", "FastLapackInterface", "GPUArraysCore", "InteractiveUtils", "KLU", "Krylov", "Libdl", "LinearAlgebra", "MKL_jll", "PrecompileTools", "Preferences", "RecursiveFactorization", "Reexport", "Requires", "SciMLBase", "SciMLOperators", "Setfield", "SparseArrays", "Sparspak", "SuiteSparse", "UnPack"]
-git-tree-sha1 = "a563cd835c9ed5295c35a7d140e0bf0a514bb10a"
+git-tree-sha1 = "9f807ca41005f9a8f092716e48022ee5b36cf5b1"
 uuid = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae"
-version = "2.13.0"
+version = "2.14.1"
 
     [deps.LinearSolve.extensions]
     LinearSolveBandedMatricesExt = "BandedMatrices"
@@ -559,7 +561,7 @@ version = "1.2.0"
 
 [[deps.NonlinearSolve]]
 deps = ["ADTypes", "ArrayInterface", "ConcreteStructs", "DiffEqBase", "EnumX", "FiniteDiff", "ForwardDiff", "LineSearches", "LinearAlgebra", "LinearSolve", "PrecompileTools", "RecursiveArrayTools", "Reexport", "SciMLBase", "SimpleNonlinearSolve", "SparseArrays", "SparseDiffTools", "StaticArraysCore", "UnPack"]
-git-tree-sha1 = "ed0c7e75b1e6fac8e87d037a366c0094d49d1904"
+git-tree-sha1 = "0821f2d1d6e4629e83cee6bce5b24049f1e95918"
 repo-rev = "ap/fixes"
 repo-url = "https://github.com/avik-pal/NonlinearSolve.jl"
 uuid = "8913a72c-1f9b-4ce2-8d82-65094dcecaec"
@@ -675,9 +677,9 @@ version = "1.3.4"
 
 [[deps.RecursiveArrayTools]]
 deps = ["Adapt", "ArrayInterface", "DocStringExtensions", "GPUArraysCore", "IteratorInterfaceExtensions", "LinearAlgebra", "RecipesBase", "Requires", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface", "Tables"]
-git-tree-sha1 = "d7087c013e8a496ff396bae843b1e16d9a30ede8"
+git-tree-sha1 = "fa453b42ba1623bd2e70260bf44dac850a3430a7"
 uuid = "731186ca-8d62-57ce-b412-fbd966d074cd"
-version = "2.38.10"
+version = "2.39.0"
 
     [deps.RecursiveArrayTools.extensions]
     RecursiveArrayToolsMeasurementsExt = "Measurements"
@@ -725,9 +727,9 @@ version = "0.1.0"
 
 [[deps.SLEEFPirates]]
 deps = ["IfElse", "Static", "VectorizationBase"]
-git-tree-sha1 = "4b8586aece42bee682399c4c4aee95446aa5cd19"
+git-tree-sha1 = "3aac6d68c5e57449f5b9b865c9ba50ac2970c4cf"
 uuid = "476501e8-09a2-5ece-8869-fb82de89a1fa"
-version = "0.6.39"
+version = "0.6.42"
 
 [[deps.SciMLBase]]
 deps = ["ADTypes", "ArrayInterface", "ChainRulesCore", "CommonSolve", "ConstructionBase", "Distributed", "DocStringExtensions", "EnumX", "FillArrays", "FunctionWrappersWrappers", "IteratorInterfaceExtensions", "LinearAlgebra", "Logging", "Markdown", "PrecompileTools", "Preferences", "RecipesBase", "RecursiveArrayTools", "Reexport", "RuntimeGeneratedFunctions", "SciMLOperators", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface", "Tables", "TruncatedStacktraces", "ZygoteRules"]
@@ -802,11 +804,11 @@ version = "1.10.0"
 
 [[deps.SparseDiffTools]]
 deps = ["ADTypes", "Adapt", "ArrayInterface", "Compat", "DataStructures", "FiniteDiff", "ForwardDiff", "Graphs", "LinearAlgebra", "PackageExtensionCompat", "Random", "Reexport", "SciMLOperators", "Setfield", "SparseArrays", "StaticArrayInterface", "StaticArrays", "Tricks", "UnPack", "VertexSafeGraphs"]
-git-tree-sha1 = "fcc87cf2750372313d0f761b7dbd75b559c646a4"
-repo-rev = "patch-1"
+git-tree-sha1 = "888937b8348e1e9ffae1c31efa61e693bc5463ba"
+repo-rev = "ap/tagging"
 repo-url = "https://github.com/avik-pal/SparseDiffTools.jl"
 uuid = "47a9eef4-7e08-11e9-0b38-333d64bd3804"
-version = "2.9.1"
+version = "2.9.2"
 
     [deps.SparseDiffTools.extensions]
     SparseDiffToolsEnzymeExt = "Enzyme"

ext/BoundaryValueDiffEqODEInterfaceExt.jl

@@ -66,7 +66,7 @@ end
 # BVPSOL
 #-------
 function __solve(prob::BVProblem, alg::BVPSOL; maxiters = 1000, reltol = 1e-3,
-    dt = 0.0, verbose = true, kwargs...)
+        dt = 0.0, verbose = true, kwargs...)
     _test_bvpm2_bvpsol_problem_criteria(prob, prob.problem_type, :BVPSOL)
     @assert isa(prob.p, SciMLBase.NullParameters) "BVPSOL only supports NullParameters!"
     @assert isa(prob.u0, AbstractVector{<:AbstractArray}) "BVPSOL requires a vector of initial guesses!"

src/adaptivity.jl

@@ -84,7 +84,7 @@ end
 Generate a new mesh based on the `ŝ`.
 """
 function redistribute!(cache::MIRKCache{iip, T}, Nsub_star, ŝ, mesh,
-    mesh_dt) where {iip, T}
+        mesh_dt) where {iip, T}
     N = length(mesh)
     ζ = sum(ŝ .* mesh_dt) / Nsub_star
     k, i = 1, 0

src/algorithms.jl

@@ -41,7 +41,7 @@ function update_nshoots(alg::MultipleShooting, nshoots::Int)
 end
 
 function MultipleShooting(nshoots::Int, ode_alg; nlsolve = NewtonRaphson(),
-    grid_coarsening = true, jac_alg = BVPJacobianAlgorithm())
+        grid_coarsening = true, jac_alg = BVPJacobianAlgorithm())
     @assert grid_coarsening isa Bool || grid_coarsening isa Function ||
             grid_coarsening isa AbstractVector{<:Integer} ||
             grid_coarsening isa NTuple{N, <:Integer} where {N}

src/collocation.jl

@@ -4,7 +4,7 @@ function Φ!(residual, cache::MIRKCache, y, u, p = cache.p)
 end
 
 @views function Φ!(residual, fᵢ_cache, k_discrete, f!, TU::MIRKTableau, y, u, p,
-    mesh, mesh_dt, stage::Int)
+        mesh, mesh_dt, stage::Int)
     @unpack c, v, x, b = TU
 
     tmp = get_tmp(fᵢ_cache, u)
@@ -35,7 +35,7 @@ function Φ(cache::MIRKCache, y, u, p = cache.p)
 end
 
 @views function Φ(fᵢ_cache, k_discrete, f, TU::MIRKTableau, y, u, p, mesh, mesh_dt,
-    stage::Int)
+        stage::Int)
     @unpack c, v, x, b = TU
     residuals = [similar(yᵢ) for yᵢ in y[1:(end - 1)]]
     tmp = get_tmp(fᵢ_cache, u)

src/interpolation.jl

@@ -19,7 +19,7 @@ end
 # FIXME: Fix the interpolation outside the tspan
 
 @inline function interpolation(tvals, id::I, idxs, deriv::D, p,
-    continuity::Symbol = :left) where {I, D}
+        continuity::Symbol = :left) where {I, D}
     @unpack t, u, cache = id
     tdir = sign(t[end] - t[1])
     idx = sortperm(tvals, rev = tdir < 0)
@@ -41,7 +41,7 @@ end
 end
 
 @inline function interpolation!(vals, tvals, id::I, idxs, deriv::D, p,
-    continuity::Symbol = :left) where {I, D}
+        continuity::Symbol = :left) where {I, D}
     @unpack t, cache = id
     tdir = sign(t[end] - t[1])
     idx = sortperm(tvals, rev = tdir < 0)
@@ -54,7 +54,7 @@ end
 end
 
 @inline function interpolation(tval::Number, id::I, idxs, deriv::D, p,
-    continuity::Symbol = :left) where {I, D}
+        continuity::Symbol = :left) where {I, D}
     z = similar(id.cache.fᵢ₂_cache)
     interp_eval!(z, id.cache, tval, id.cache.mesh, id.cache.mesh_dt)
     return z

src/solve/mirk.jl

@@ -32,7 +32,7 @@ end
 Base.eltype(::MIRKCache{iip, T}) where {iip, T} = T
 
 function SciMLBase.__init(prob::BVProblem, alg::AbstractMIRK; dt = 0.0,
-    abstol = 1e-3, adaptive = true, kwargs...)
+        abstol = 1e-3, adaptive = true, kwargs...)
     @set! alg.jac_alg = concrete_jacobian_algorithm(alg.jac_alg, prob, alg)
     iip = isinplace(prob)
     _, T, M, n, X = __extract_problem_details(prob; dt, check_positive_dt = true)
@@ -125,7 +125,7 @@ function __expand_cache!(cache::MIRKCache)
 end
 
 function __split_mirk_kwargs(; defect_threshold, MxNsub, abstol, dt, adaptive = true,
-    kwargs...)
+        kwargs...)
     return ((defect_threshold, MxNsub, abstol, adaptive, dt),
         (; abstol, adaptive, kwargs...))
 end
@@ -212,7 +212,7 @@ function __construct_nlproblem(cache::MIRKCache{iip}, y::AbstractVector) where {
 end
 
 function __mirk_loss!(resid, u, p, y, pt::StandardBVProblem, bc!::BC, residual, mesh,
-    cache) where {BC}
+        cache) where {BC}
     y_ = recursive_unflatten!(y, u)
     resids = [get_tmp(r, u) for r in residual]
     eval_bc_residual!(resids[1], pt, bc!, y_, p, mesh)
@@ -222,7 +222,7 @@ function __mirk_loss!(resid, u, p, y, pt::StandardBVProblem, bc!::BC, residual,
 end
 
 function __mirk_loss!(resid, u, p, y, pt::TwoPointBVProblem, bc!::Tuple{BC1, BC2}, residual,
-    mesh, cache) where {BC1, BC2}
+        mesh, cache) where {BC1, BC2}
     y_ = recursive_unflatten!(y, u)
     resids = [get_tmp(r, u) for r in residual]
     resida = @view resids[1][1:prod(cache.resid_size[1])]
@@ -241,7 +241,7 @@ function __mirk_loss(u, p, y, pt::StandardBVProblem, bc::BC, mesh, cache) where
 end
 
 function __mirk_loss(u, p, y, pt::TwoPointBVProblem, bc::Tuple{BC1, BC2}, mesh,
-    cache) where {BC1, BC2}
+        cache) where {BC1, BC2}
     y_ = recursive_unflatten!(y, u)
     resid_bca, resid_bcb = eval_bc_residual(pt, bc, y_, p, mesh)
     resid_co = Φ(cache, y_, u, p)
@@ -274,7 +274,7 @@ function __mirk_loss_collocation(u, p, y, mesh, residual, cache)
 end
 
 function __construct_nlproblem(cache::MIRKCache{iip}, y, loss_bc::BC, loss_collocation::C,
-    loss::L, ::StandardBVProblem) where {iip, BC, C, L}
+        loss::L, ::StandardBVProblem) where {iip, BC, C, L}
     @unpack nlsolve, jac_alg = cache.alg
     N = length(cache.mesh)
 
@@ -315,24 +315,24 @@ function __construct_nlproblem(cache::MIRKCache{iip}, y, loss_bc::BC, loss_collo
 end
 
 function __mirk_mpoint_jacobian!(J, x, p, bc_diffmode, nonbc_diffmode, bc_diffcache,
-    nonbc_diffcache, loss_bc::BC, loss_collocation::C, resid_bc, resid_collocation,
-    M::Int) where {BC, C}
+        nonbc_diffcache, loss_bc::BC, loss_collocation::C, resid_bc, resid_collocation,
+        M::Int) where {BC, C}
     sparse_jacobian!(@view(J[1:M, :]), bc_diffmode, bc_diffcache, loss_bc, resid_bc, x)
     sparse_jacobian!(@view(J[(M + 1):end, :]), nonbc_diffmode, nonbc_diffcache,
         loss_collocation, resid_collocation, x)
     return nothing
 end
 
 function __mirk_mpoint_jacobian(x, p, J, bc_diffmode, nonbc_diffmode, bc_diffcache,
-    nonbc_diffcache, loss_bc::BC, loss_collocation::C, M::Int) where {BC, C}
+        nonbc_diffcache, loss_bc::BC, loss_collocation::C, M::Int) where {BC, C}
     sparse_jacobian!(@view(J[1:M, :]), bc_diffmode, bc_diffcache, loss_bc, x)
     sparse_jacobian!(@view(J[(M + 1):end, :]), nonbc_diffmode, nonbc_diffcache,
         loss_collocation, x)
     return J
 end
 
 function __construct_nlproblem(cache::MIRKCache{iip}, y, loss_bc::BC, loss_collocation::C,
-    loss::L, ::TwoPointBVProblem) where {iip, BC, C, L}
+        loss::L, ::TwoPointBVProblem) where {iip, BC, C, L}
     @unpack nlsolve, jac_alg = cache.alg
     N = length(cache.mesh)
 

src/solve/multiple_shooting.jl

@@ -1,5 +1,5 @@
 function __solve(prob::BVProblem, _alg::MultipleShooting; odesolve_kwargs = (;),
-    nlsolve_kwargs = (;), ensemblealg = EnsembleThreads(), verbose = true, kwargs...)
+        nlsolve_kwargs = (;), ensemblealg = EnsembleThreads(), verbose = true, kwargs...)
     @unpack f, tspan = prob
 
     ig, T, N, Nig, u0 = __extract_problem_details(prob; dt = 0.1)
@@ -58,8 +58,8 @@ function __solve(prob::BVProblem, _alg::MultipleShooting; odesolve_kwargs = (;),
 end
 
 function __solve_nlproblem!(alg::MultipleShooting, bcresid_prototype, u_at_nodes, nodes,
-    cur_nshoot, N, resida_len, residb_len, iip::Val, solve_internal_odes!::S, bca::B1,
-    bcb::B2, prob, u0; kwargs...) where {B1, B2, S}
+        cur_nshoot, N, resida_len, residb_len, iip::Val, solve_internal_odes!::S, bca::B1,
+        bcb::B2, prob, u0; kwargs...) where {B1, B2, S}
     if __any_sparse_ad(alg.jac_alg)
         J_proto = __generate_sparse_jacobian_prototype(alg, prob.problem_type,
             bcresid_prototype, u0, N, cur_nshoot)
@@ -94,8 +94,8 @@ function __solve_nlproblem!(alg::MultipleShooting, bcresid_prototype, u_at_nodes
 end
 
 function __solve_nlproblem!(alg::MultipleShooting, bcresid_prototype, u_at_nodes, nodes,
-    cur_nshoot, N, resid_size, iip::Val, solve_internal_odes!::S, bc::BC,
-    prob, f::F, u0_size, u0; kwargs...) where {BC, F, S}
+        cur_nshoot, N, resid_size, iip::Val, solve_internal_odes!::S, bc::BC,
+        prob, f::F, u0_size, u0; kwargs...) where {BC, F, S}
     if __any_sparse_ad(alg.jac_alg)
         J_proto = __generate_sparse_jacobian_prototype(alg, prob.problem_type,
             bcresid_prototype, u0, N, cur_nshoot)
@@ -141,8 +141,8 @@ function __solve_nlproblem!(alg::MultipleShooting, bcresid_prototype, u_at_nodes
 end
 
 function __multiple_shooting_solve_internal_odes!(resid_nodes, us, p, ::Val{iip}, f::F,
-    cur_nshoots::Int, nodes, tspan, u0_size, N, alg::MultipleShooting,
-    ensemblealg, kwargs) where {iip, F}
+        cur_nshoots::Int, nodes, tspan, u0_size, N, alg::MultipleShooting,
+        ensemblealg, kwargs) where {iip, F}
     ts_ = Vector{Vector{typeof(first(tspan))}}(undef, cur_nshoots)
     us_ = Vector{Vector{typeof(us)}}(undef, cur_nshoots)
 
@@ -172,13 +172,13 @@ function __multiple_shooting_solve_internal_odes!(resid_nodes, us, p, ::Val{iip}
 end
 
 function __multiple_shooting_2point_jacobian!(J, us, p, jac_cache, loss_fn, resid,
-    alg::MultipleShooting)
+        alg::MultipleShooting)
     sparse_jacobian!(J, alg.jac_alg.diffmode, jac_cache, loss_fn, resid, us)
     return nothing
 end
 
 function __multiple_shooting_mpoint_jacobian!(J, us, p, resid_bc, resid_nodes,
-    ode_jac_cache, bc_jac_cache, ode_fn, bc_fn, alg::MultipleShooting, N::Int)
+        ode_jac_cache, bc_jac_cache, ode_fn, bc_fn, alg::MultipleShooting, N::Int)
     J_bc = @view(J[1:N, :])
     J_c = @view(J[(N + 1):end, :])
 
@@ -190,7 +190,8 @@ function __multiple_shooting_mpoint_jacobian!(J, us, p, resid_bc, resid_nodes,
 end
 
 @views function __multiple_shooting_2point_loss!(resid, us, p, cur_nshoots::Int, nodes,
-    ::Val{iip}, solve_internal_odes!::S, resida_len, residb_len, N, bca, bcb) where {iip, S}
+        ::Val{iip}, solve_internal_odes!::S, resida_len, residb_len, N, bca,
+        bcb) where {iip, S}
     resid_ = resid[(resida_len + 1):(end - residb_len)]
     solve_internal_odes!(resid_, us, p, cur_nshoots, nodes)
 
@@ -212,8 +213,8 @@ end
 end
 
 @views function __multiple_shooting_mpoint_loss_bc!(resid_bc, us, p, cur_nshoots::Int,
-    nodes, ::Val{iip}, solve_internal_odes!::S, N, f, bc, u0_size, tspan,
-    ode_alg, u0) where {iip, S}
+        nodes, ::Val{iip}, solve_internal_odes!::S, N, f, bc, u0_size, tspan,
+        ode_alg, u0) where {iip, S}
     _resid_nodes = similar(us, cur_nshoots * N)
 
     # NOTE: We need to recompute this to correctly propagate the dual numbers / gradients
@@ -232,8 +233,8 @@ end
 end
 
 @views function __multiple_shooting_mpoint_loss!(resid, us, p, cur_nshoots::Int, nodes,
-    ::Val{iip}, solve_internal_odes!::S, resid_len, N, f, bc, u0_size, tspan,
-    ode_alg, u0) where {iip, S}
+        ::Val{iip}, solve_internal_odes!::S, resid_len, N, f, bc, u0_size, tspan,
+        ode_alg, u0) where {iip, S}
     resid_bc = resid[1:resid_len]
     resid_nodes = resid[(resid_len + 1):end]
 
@@ -253,7 +254,7 @@ end
 
 # Problem has initial guess
 @views function __multiple_shooting_initialize!(nodes, prob, alg, ::Val{true}, nshoots;
-    kwargs...)
+        kwargs...)
     @unpack u0, tspan = prob
 
     resize!(nodes, nshoots + 1)
@@ -268,7 +269,7 @@ end
 
 # No initial guess
 @views function __multiple_shooting_initialize!(nodes, prob, alg::MultipleShooting,
-    ::Val{false}, nshoots; verbose, kwargs...)
+        ::Val{false}, nshoots; verbose, kwargs...)
     @unpack f, u0, tspan, p = prob
     @unpack ode_alg = alg
 
@@ -306,7 +307,7 @@ end
 
 # Grid coarsening
 @views function __multiple_shooting_initialize!(nodes, u_at_nodes_prev, prob, alg,
-    nshoots, old_nshoots, ig; kwargs...)
+        nshoots, old_nshoots, ig; kwargs...)
     @unpack f, u0, tspan, p = prob
     prev_nodes = copy(nodes)