Skip to content

Commit 71fa0f9

Browse files
ErikQQYErikQQY
authored
Merge pull request #292 from ErikQQY/qqy/split_mirkn
Split MIRKN bc and collocation parts
2 parents 215c54b + 84bfdc5 commit 71fa0f9

File tree

8 files changed

+217
-49
lines changed

8 files changed

+217
-49
lines changed

‎lib/BoundaryValueDiffEqAscher/src/ascher.jl‎

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -310,6 +310,7 @@ end
310310

311311
function __construct_nlproblem(cache::AscherCache{iip, T}) where {iip, T}
312312
(; alg, pt) = cache
313+
(; jac_alg) = alg
313314
loss = if iip
314315
@closure (res, z, p) -> @views Φ!(cache, z, res, pt)
315316
else
@@ -318,14 +319,14 @@ function __construct_nlproblem(cache::AscherCache{iip, T}) where {iip, T}
318319

319320
lz = reduce(vcat, cache.z)
320321
resid_prototype = zero(lz)
321-
diffmode = if alg.jac_alg.diffmode isa AutoSparse
322-
#AutoSparse(get_dense_ad(alg.jac_alg.diffmode);
323-
# sparsity_detector = SparseConnectivityTracer.TracerSparsityDetector(),
324-
# coloring_algorithm = GreedyColoringAlgorithm(LargestFirst()))
322+
diffmode = if jac_alg.diffmode isa AutoSparse
323+
#AutoSparse(get_dense_ad(jac_alg.diffmode);
324+
# sparsity_detector = __default_sparsity_detector(jac_alg.diffmode),
325+
# coloring_algorithm = __default_coloring_algorithm(jac_alg.diffmode))
325326
# Ascher collocation need more generalized collocation to support AutoSparse
326-
get_dense_ad(alg.jac_alg.diffmode)
327+
get_dense_ad(jac_alg.diffmode)
327328
else
328-
alg.jac_alg.diffmode
329+
jac_alg.diffmode
329330
end
330331

331332
jac_cache = if iip

‎lib/BoundaryValueDiffEqCore/src/types.jl‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -119,6 +119,13 @@ end
119119
coloring_algorithm = GreedyColoringAlgorithm())
120120
end
121121

122+
@inline __default_coloring_algorithm(diffmode::AutoSparse) = isnothing(diffmode) ?
123+
GreedyColoringAlgorithm() :
124+
diffmode.coloring_algorithm
125+
@inline __default_sparsity_detector(diffmode::AutoSparse) = isnothing(diffmode) ?
126+
TracerLocalSparsityDetector() :
127+
diffmode.sparsity_detector
128+
122129
@inline function __default_nonsparse_ad(x::AbstractArray{T}) where {T}
123130
return isbitstype(T) ? __default_nonsparse_ad(T) : __default_nonsparse_ad(first(x))
124131
end

‎lib/BoundaryValueDiffEqCore/src/utils.jl‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -126,6 +126,12 @@ end
126126
function eval_bc_residual!(
127127
resid, ::StandardSecondOrderBVProblem, bc!::BC, sol, dsol, p, t) where {BC}
128128
M = length(sol[1])
129+
bc!(resid, dsol, sol, p, t)
130+
end
131+
132+
function eval_bc_residual!(resid::AbstractArray{<:AbstractArray},
133+
::StandardSecondOrderBVProblem, bc!::BC, sol, dsol, p, t) where {BC}
134+
M = length(sol[1])
129135
res_bc = vcat(resid[1], resid[2])
130136
bc!(res_bc, dsol, sol, p, t)
131137
copyto!(resid[1], res_bc[1:M])

‎lib/BoundaryValueDiffEqFIRK/src/BoundaryValueDiffEqFIRK.jl‎

Lines changed: 6 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -11,11 +11,12 @@ using BoundaryValueDiffEqCore: BoundaryValueDiffEqAlgorithm, BVPJacobianAlgorith
1111
concrete_jacobian_algorithm, eval_bc_residual,
1212
eval_bc_residual!, get_tmp, __maybe_matmul!, __resize!,
1313
__extract_problem_details, __initial_guess,
14-
__maybe_allocate_diffcache, __restructure_sol,
15-
__get_bcresid_prototype, __similar, __vec, __vec_f, __vec_f!,
16-
__vec_bc, __vec_bc!, recursive_flatten_twopoint!,
17-
__internal_nlsolve_problem, MaybeDiffCache, __extract_mesh,
18-
__extract_u0, __has_initial_guess, __initial_guess_length,
14+
__default_coloring_algorithm, __maybe_allocate_diffcache,
15+
__restructure_sol, __get_bcresid_prototype, __similar, __vec,
16+
__vec_f, __vec_f!, __vec_bc, __vec_bc!,
17+
recursive_flatten_twopoint!, __internal_nlsolve_problem,
18+
MaybeDiffCache, __extract_mesh, __extract_u0,
19+
__has_initial_guess, __initial_guess_length,
1920
__initial_guess_on_mesh, __flatten_initial_guess,
2021
__build_solution, __Fix3, _sparse_like, get_dense_ad
2122

‎lib/BoundaryValueDiffEqMIRK/src/BoundaryValueDiffEqMIRK.jl‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ using BoundaryValueDiffEqCore: BoundaryValueDiffEqAlgorithm, BVPJacobianAlgorith
2020
__build_solution, __Fix3, get_dense_ad, _sparse_like,
2121
AbstractErrorControl, DefectControl, GlobalErrorControl,
2222
SequentialErrorControl, HybridErrorControl, HOErrorControl,
23-
__use_both_error_control
23+
__use_both_error_control, __default_coloring_algorithm
2424

2525
using ConcreteStructs: @concrete
2626
using DiffEqBase: DiffEqBase

‎lib/BoundaryValueDiffEqMIRKN/src/BoundaryValueDiffEqMIRKN.jl‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,8 @@ using BoundaryValueDiffEqCore: BoundaryValueDiffEqAlgorithm, BVPJacobianAlgorith
1818
__initial_guess_length, __initial_guess_on_mesh,
1919
__flatten_initial_guess, __build_solution, __Fix3,
2020
__default_sparse_ad, __default_nonsparse_ad, get_dense_ad,
21-
concrete_jacobian_algorithm
21+
concrete_jacobian_algorithm, __default_coloring_algorithm,
22+
__default_sparsity_detector
2223

2324
using ConcreteStructs: @concrete
2425
using DiffEqBase: DiffEqBase

‎lib/BoundaryValueDiffEqMIRKN/src/mirkn.jl‎

Lines changed: 187 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -107,53 +107,163 @@ function SciMLBase.solve!(cache::MIRKNCache{iip, T}) where {iip, T}
107107
end
108108

109109
function __perform_mirkn_iteration(cache::MIRKNCache; nlsolve_kwargs = (;), kwargs...)
110-
nlprob::NonlinearProblem = __construct_nlproblem(cache, vec(cache.y₀))
110+
nlprob::NonlinearProblem = __construct_nlproblem(cache, vec(cache.y₀), copy(cache.y₀))
111111
nlsolve_alg = __concrete_nonlinearsolve_algorithm(nlprob, cache.alg.nlsolve)
112112
sol_nlprob = __solve(nlprob, nlsolve_alg; kwargs..., nlsolve_kwargs..., alias_u0 = true)
113113
recursive_unflatten!(cache.y₀, sol_nlprob.u)
114114

115115
return sol_nlprob, sol_nlprob.retcode
116116
end
117117

118-
function __construct_nlproblem(cache::MIRKNCache{iip}, y) where {iip}
119-
(; jac_alg) = cache.alg
120-
(; diffmode) = jac_alg
118+
# Constructing the Nonlinear Problem
119+
function __construct_nlproblem(
120+
cache::MIRKNCache{iip}, y::AbstractVector, y₀::AbstractVectorOfArray) where {iip}
121121
pt = cache.problem_type
122122

123+
eval_sol = EvalSol(
124+
__restructure_sol(y₀.u[1:length(cache.mesh)], cache.in_size), cache.mesh, cache)
125+
eval_dsol = EvalSol(
126+
__restructure_sol(y₀.u[(length(cache.mesh) + 1):end], cache.in_size),
127+
cache.mesh, cache)
128+
129+
loss_bc = if iip
130+
@closure (du, u, p) -> __mirkn_loss_bc!(
131+
du, u, p, pt, cache.bc, cache.y, cache.mesh, cache)
132+
else
133+
@closure (u, p) -> __mirkn_loss_bc(u, p, pt, cache.bc, cache.y, cache.mesh, cache)
134+
end
135+
136+
loss_collocation = if iip
137+
@closure (du, u, p) -> __mirkn_loss_collocation!(
138+
du, u, p, cache.y, cache.mesh, cache.residual, cache)
139+
else
140+
@closure (u, p) -> __mirkn_loss_collocation(
141+
u, p, cache.y, cache.mesh, cache.residual, cache)
142+
end
143+
123144
loss = if iip
124145
@closure (du, u, p) -> __mirkn_loss!(
125-
du, u, p, cache.y, pt, cache.bc, cache.residual, cache.mesh, cache)
146+
du, u, p, cache.y, pt, cache.bc, cache.residual,
147+
cache.mesh, cache, eval_sol, eval_dsol)
126148
else
127-
@closure (u, p) -> __mirkn_loss(u, p, cache.y, pt, cache.bc, cache.mesh, cache)
149+
@closure (u, p) -> __mirkn_loss(
150+
u, p, cache.y, pt, cache.bc, cache.mesh, cache, eval_sol, eval_dsol)
128151
end
129152

130-
resid_prototype = __similar(y)
153+
return __construct_nlproblem(cache, y, loss_bc, loss_collocation, loss, pt)
154+
end
155+
156+
function __construct_nlproblem(cache::MIRKNCache{iip}, y, loss_bc::BC, loss_collocation::C,
157+
loss::LF, ::StandardSecondOrderBVProblem) where {iip, BC, C, LF}
158+
(; jac_alg) = cache.alg
159+
N = length(cache.mesh)
131160

132-
jac_cache = if iip
133-
DI.prepare_jacobian(loss, resid_prototype, diffmode, y, Constant(cache.p))
161+
resid_bc = cache.bcresid_prototype
162+
L = length(resid_bc)
163+
resid_collocation = __similar(y, cache.M * (2 * N - 2))
164+
165+
bc_diffmode = if jac_alg.bc_diffmode isa AutoSparse
166+
AutoSparse(get_dense_ad(jac_alg.bc_diffmode);
167+
sparsity_detector = __default_sparsity_detector(jac_alg.bc_diffmode),
168+
coloring_algorithm = __default_coloring_algorithm(jac_alg.bc_diffmode))
134169
else
135-
DI.prepare_jacobian(loss, diffmode, y, Constant(cache.p))
170+
jac_alg.bc_diffmode
136171
end
137172

138-
jac_prototype = if iip
139-
DI.jacobian(loss, resid_prototype, jac_cache, diffmode, y, Constant(cache.p))
173+
cache_bc = if iip
174+
DI.prepare_jacobian(loss_bc, resid_bc, bc_diffmode, y, Constant(cache.p))
175+
else
176+
DI.prepare_jacobian(loss_bc, bc_diffmode, y, Constant(cache.p))
177+
end
178+
179+
nonbc_diffmode = if jac_alg.nonbc_diffmode isa AutoSparse
180+
AutoSparse(get_dense_ad(jac_alg.nonbc_diffmode);
181+
sparsity_detector = __default_sparsity_detector(jac_alg.nonbc_diffmode),
182+
coloring_algorithm = __default_coloring_algorithm(jac_alg.nonbc_diffmode))
140183
else
141-
DI.jacobian(loss, jac_cache, diffmode, y, Constant(cache.p))
184+
jac_alg.nonbc_diffmode
142185
end
143186

187+
cache_collocation = if iip
188+
DI.prepare_jacobian(
189+
loss_collocation, resid_collocation, nonbc_diffmode, y, Constant(cache.p))
190+
else
191+
DI.prepare_jacobian(loss_collocation, nonbc_diffmode, y, Constant(cache.p))
192+
end
193+
194+
J_bc = if iip
195+
DI.jacobian(loss_bc, resid_bc, cache_bc, bc_diffmode, y, Constant(cache.p))
196+
else
197+
DI.jacobian(loss_bc, cache_bc, bc_diffmode, y, Constant(cache.p))
198+
end
199+
J_c = if iip
200+
DI.jacobian(loss_collocation, resid_collocation, cache_collocation,
201+
nonbc_diffmode, y, Constant(cache.p))
202+
else
203+
DI.jacobian(
204+
loss_collocation, cache_collocation, nonbc_diffmode, y, Constant(cache.p))
205+
end
206+
207+
jac_prototype = vcat(J_bc, J_c)
208+
144209
jac = if iip
145210
@closure (J, u, p) -> __mirkn_mpoint_jacobian!(
146-
J, u, diffmode, jac_cache, loss, resid_prototype, cache.p)
211+
J, J_c, u, bc_diffmode, nonbc_diffmode, cache_bc, cache_collocation,
212+
loss_bc, loss_collocation, resid_bc, resid_collocation, L, cache.p)
147213
else
148214
@closure (u, p) -> __mirkn_mpoint_jacobian(
149-
jac_prototype, u, diffmode, jac_cache, loss, cache.p)
215+
jac_prototype, J_c, u, bc_diffmode, nonbc_diffmode, cache_bc,
216+
cache_collocation, loss_bc, loss_collocation, L, cache.p)
150217
end
151-
218+
resid_prototype = vcat(resid_bc, resid_collocation)
152219
nlf = NonlinearFunction{iip}(
153220
loss; jac = jac, resid_prototype = resid_prototype, jac_prototype = jac_prototype)
154221
__internal_nlsolve_problem(cache.prob, resid_prototype, y, nlf, y, cache.p)
155222
end
156223

224+
function __construct_nlproblem(cache::MIRKNCache{iip}, y, loss_bc::BC, loss_collocation::C,
225+
loss::LF, ::TwoPointSecondOrderBVProblem) where {iip, BC, C, LF}
226+
(; nlsolve, jac_alg) = cache.alg
227+
N = length(cache.mesh)
228+
229+
resid = vcat(@view(cache.bcresid_prototype[1:prod(cache.resid_size[1])]),
230+
__similar(y, cache.M * 2 * (N - 1)),
231+
@view(cache.bcresid_prototype[(prod(cache.resid_size[1]) + 1):end]))
232+
233+
diffmode = if jac_alg.diffmode isa AutoSparse
234+
AutoSparse(get_dense_ad(jac_alg.diffmode);
235+
sparsity_detector = __default_sparsity_detector(jac_alg.diffmode),
236+
coloring_algorithm = __default_coloring_algorithm(jac_alg.diffmode))
237+
else
238+
jac_alg.diffmode
239+
end
240+
241+
diffcache = if iip
242+
DI.prepare_jacobian(loss, resid, diffmode, y, Constant(cache.p))
243+
else
244+
DI.prepare_jacobian(loss, diffmode, y, Constant(cache.p))
245+
end
246+
247+
jac_prototype = if iip
248+
DI.jacobian(loss, resid, diffcache, diffmode, y, Constant(cache.p))
249+
else
250+
DI.jacobian(loss, diffcache, diffmode, y, Constant(cache.p))
251+
end
252+
253+
jac = if iip
254+
@closure (J, u, p) -> __mirkn_2point_jacobian!(
255+
J, u, jac_alg.diffmode, diffcache, loss, resid, p)
256+
else
257+
@closure (u, p) -> __mirkn_2point_jacobian(
258+
u, jac_prototype, jac_alg.diffmode, diffcache, loss, p)
259+
end
260+
261+
resid_prototype = copy(resid)
262+
nlf = NonlinearFunction{iip}(
263+
loss; jac = jac, resid_prototype = resid_prototype, jac_prototype = jac_prototype)
264+
return __internal_nlsolve_problem(cache.prob, resid_prototype, y, nlf, y, cache.p)
265+
end
266+
157267
function __mirkn_2point_jacobian!(J, x, diffmode, diffcache, loss_fn::L, resid, p) where {L}
158268
DI.jacobian!(loss_fn, resid, J, diffcache, diffmode, x, Constant(p))
159269
return J
@@ -164,44 +274,85 @@ function __mirkn_2point_jacobian(x, J, diffmode, diffcache, loss_fn::L, p) where
164274
return J
165275
end
166276

167-
function __mirkn_mpoint_jacobian!(J, x, diffmode, diffcache, loss, resid, p)
168-
DI.jacobian!(loss, resid, J, diffcache, diffmode, x, Constant(p))
277+
function __mirkn_mpoint_jacobian!(
278+
J, _, x, bc_diffmode, nonbc_diffmode, bc_diffcache, nonbc_diffcache, loss_bc::BC,
279+
loss_collocation::C, resid_bc, resid_collocation, L::Int, p) where {BC, C}
280+
DI.jacobian!(
281+
loss_bc, resid_bc, @view(J[1:L, :]), bc_diffcache, bc_diffmode, x, Constant(p))
282+
DI.jacobian!(loss_collocation, resid_collocation, @view(J[(L + 1):end, :]),
283+
nonbc_diffcache, nonbc_diffmode, x, Constant(p))
169284
return nothing
170285
end
171286

172-
function __mirkn_mpoint_jacobian(J, x, diffmode, diffcache, loss, p)
173-
DI.jacobian!(loss, J, diffcache, diffmode, x, Constant(p))
287+
function __mirkn_mpoint_jacobian(
288+
J, _, x, bc_diffmode, nonbc_diffmode, bc_diffcache, nonbc_diffcache,
289+
loss_bc::BC, loss_collocation::C, L::Int, p) where {BC, C}
290+
DI.jacobian!(loss_bc, @view(J[1:L, :]), bc_diffcache, bc_diffmode, x, Constant(p))
291+
DI.jacobian!(loss_collocation, @view(J[(L + 1):end, :]),
292+
nonbc_diffcache, nonbc_diffmode, x, Constant(p))
174293
return J
175294
end
176295

177-
@views function __mirkn_loss!(resid, u, p, y, pt::StandardSecondOrderBVProblem,
178-
bc::BC, residual, mesh, cache::MIRKNCache) where {BC}
296+
@views function __mirkn_loss!(resid, u, p, y, pt::StandardSecondOrderBVProblem, bc::BC,
297+
residual, mesh, cache::MIRKNCache, EvalSol, EvalDSol) where {BC}
179298
y_ = recursive_unflatten!(y, u)
180299
resids = [get_tmp(r, u) for r in residual]
181300
Φ!(resids[3:end], cache, y_, u, p)
182-
soly_ = EvalSol(
183-
__restructure_sol(y_[1:length(cache.mesh)], cache.in_size), cache.mesh, cache)
184-
dsoly_ = EvalSol(__restructure_sol(y_[(length(cache.mesh) + 1):end], cache.in_size),
185-
cache.mesh, cache)
186-
eval_bc_residual!(resids[1:2], pt, bc, soly_, dsoly_, p, mesh)
301+
EvalSol.u[1:end] .= __restructure_sol(y_[1:length(cache.mesh)], cache.in_size)
302+
EvalSol.cache.k_discrete[1:end] .= cache.k_discrete
303+
EvalDSol.u[1:end] .= __restructure_sol(y_[(length(cache.mesh) + 1):end], cache.in_size)
304+
EvalDSol.cache.k_discrete[1:end] .= cache.k_discrete
305+
eval_bc_residual!(resids[1:2], pt, bc, EvalSol, EvalDSol, p, mesh)
187306
recursive_flatten!(resid, resids)
188307
return nothing
189308
end
190309

191-
@views function __mirkn_loss(u, p, y, pt::StandardSecondOrderBVProblem,
192-
bc::BC, mesh, cache::MIRKNCache) where {BC}
310+
@views function __mirkn_loss(u, p, y, pt::StandardSecondOrderBVProblem, bc::BC,
311+
mesh, cache::MIRKNCache, EvalSol, EvalDSol) where {BC}
193312
y_ = recursive_unflatten!(y, u)
194313
resid_co = Φ(cache, y_, u, p)
195-
soly_ = EvalSol(
196-
__restructure_sol(y_[1:length(cache.mesh)], cache.in_size), cache.mesh, cache)
314+
EvalSol.u[1:end] .= __restructure_sol(y_[1:length(cache.mesh)], cache.in_size)
315+
EvalSol.cache.k_discrete[1:end] .= cache.k_discrete
316+
EvalDSol.u[1:end] .= __restructure_sol(y_[(length(cache.mesh) + 1):end], cache.in_size)
317+
EvalDSol.cache.k_discrete[1:end] .= cache.k_discrete
318+
resid_bc = eval_bc_residual(pt, bc, EvalSol, EvalDSol, p, mesh)
319+
return vcat(resid_bc, mapreduce(vec, vcat, resid_co))
320+
end
321+
322+
@views function __mirkn_loss_bc!(
323+
resid, u, p, pt, bc!::BC, y, mesh, cache::MIRKNCache) where {BC}
324+
y_ = recursive_unflatten!(y, u)
325+
soly_ = EvalSol(__restructure_sol(y_[1:length(cache.mesh)], cache.in_size), mesh, cache)
197326
dsoly_ = EvalSol(__restructure_sol(y_[(length(cache.mesh) + 1):end], cache.in_size),
198327
cache.mesh, cache)
199-
resid_bc = eval_bc_residual(pt, bc, soly_, dsoly_, p, mesh)
200-
return vcat(resid_bc, mapreduce(vec, vcat, resid_co))
328+
eval_bc_residual!(resid, pt, bc!, soly_, dsoly_, p, mesh)
329+
return nothing
330+
end
331+
332+
@views function __mirkn_loss_bc(u, p, pt, bc!::BC, y, mesh, cache::MIRKNCache) where {BC}
333+
y_ = recursive_unflatten!(y, u)
334+
soly_ = EvalSol(__restructure_sol(y_[1:length(cache.mesh)], cache.in_size), mesh, cache)
335+
dsoly_ = EvalSol(__restructure_sol(y_[(length(cache.mesh) + 1):end], cache.in_size),
336+
cache.mesh, cache)
337+
return eval_bc_residual(pt, bc!, soly_, dsoly_, p, mesh)
338+
end
339+
340+
@views function __mirkn_loss_collocation!(resid, u, p, y, mesh, residual, cache)
341+
y_ = recursive_unflatten!(y, u)
342+
resids = [get_tmp(r, u) for r in residual[3:end]]
343+
Φ!(resids, cache, y_, u, p)
344+
recursive_flatten!(resid, resids)
345+
return nothing
346+
end
347+
348+
@views function __mirkn_loss_collocation(u, p, y, mesh, residual, cache)
349+
y_ = recursive_unflatten!(y, u)
350+
resids = Φ(cache, y_, u, p)
351+
return mapreduce(vec, vcat, resids)
201352
end
202353

203-
@views function __mirkn_loss!(resid, u, p, y, pt::TwoPointSecondOrderBVProblem,
204-
bc!::BC, residual, mesh, cache::MIRKNCache) where {BC}
354+
@views function __mirkn_loss!(resid, u, p, y, pt::TwoPointSecondOrderBVProblem, bc!::BC,
355+
residual, mesh, cache::MIRKNCache, _, _) where {BC}
205356
y_ = recursive_unflatten!(y, u)
206357
resids = [get_tmp(r, u) for r in residual]
207358
soly_ = VectorOfArray(y_)
@@ -212,7 +363,7 @@ end
212363
end
213364

214365
@views function __mirkn_loss(u, p, y, pt::TwoPointSecondOrderBVProblem,
215-
bc!::BC, mesh, cache::MIRKNCache) where {BC}
366+
bc!::BC, mesh, cache::MIRKNCache, _, _) where {BC}
216367
y_ = recursive_unflatten!(y, u)
217368
soly_ = VectorOfArray(y_)
218369
resid_co = Φ(cache, y_, u, p)

‎lib/BoundaryValueDiffEqShooting/src/BoundaryValueDiffEqShooting.jl‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@ using BoundaryValueDiffEqCore: BoundaryValueDiffEqAlgorithm, BVPJacobianAlgorith
1111
concrete_jacobian_algorithm, eval_bc_residual,
1212
eval_bc_residual!, get_tmp, __maybe_matmul!,
1313
__extract_problem_details, __initial_guess,
14+
__default_coloring_algorithm, __default_sparsity_detector,
1415
__maybe_allocate_diffcache, __get_bcresid_prototype,
1516
__similar, __vec, __vec_f, __vec_f!, __vec_bc, __vec_bc!,
1617
__materialize_jacobian_algorithm, __default_nonsparse_ad,

0 commit comments

Comments
 (0)