From d865705d48e6f56be1a88ff8296848654182645b Mon Sep 17 00:00:00 2001 From: Oscar Smith Date: Sun, 11 May 2025 22:22:43 -0400 Subject: [PATCH 1/4] fix isinplace inference and add inference tests --- src/problems/optimization_problems.jl | 3 +- src/scimlfunctions.jl | 6 +- src/utils.jl | 221 +-------- test/aqua.jl | 2 +- test/function_building_error_messages.jl | 548 +++++++++++------------ 5 files changed, 291 insertions(+), 489 deletions(-) diff --git a/src/problems/optimization_problems.jl b/src/problems/optimization_problems.jl index 6d6033ea9..cd3d4436b 100644 --- a/src/problems/optimization_problems.jl +++ b/src/problems/optimization_problems.jl @@ -131,8 +131,7 @@ function OptimizationProblem( OptimizationProblem{isinplace(f)}(f, args...; kwargs...) end function OptimizationProblem(f, args...; kwargs...) - isinplace(f, 2, has_two_dispatches = false) - OptimizationProblem{true}(OptimizationFunction{true}(f), args...; kwargs...) + OptimizationProblem(OptimizationFunction(f), args...; kwargs...) end function OptimizationFunction( diff --git a/src/scimlfunctions.jl b/src/scimlfunctions.jl index 1b61bd491..08f640bc5 100644 --- a/src/scimlfunctions.jl +++ b/src/scimlfunctions.jl @@ -4199,7 +4199,7 @@ IntervalNonlinearFunction(f::IntervalNonlinearFunction; kwargs...) = f struct NoAD <: AbstractADType end (f::OptimizationFunction)(args...) = f.f(args...) -OptimizationFunction(args...; kwargs...) = OptimizationFunction{true}(args...; kwargs...) +OptimizationFunction(f, args...; kwargs...) = OptimizationFunction{isinplace(f, 3)}(f, args...; kwargs...) function OptimizationFunction{iip}(f, adtype::AbstractADType = NoAD(); grad = nothing, fg = nothing, hess = nothing, hv = nothing, fgh = nothing, @@ -4251,8 +4251,8 @@ end (f::MultiObjectiveOptimizationFunction)(args...) = f.f(args...) # Convenience constructor -function MultiObjectiveOptimizationFunction(args...; kwargs...) - MultiObjectiveOptimizationFunction{true}(args...; kwargs...) +function MultiObjectiveOptimizationFunction(f, args...; kwargs...) + MultiObjectiveOptimizationFunction{isinplace(f, 3)}(f, args...; kwargs...) end # Constructor with keyword arguments diff --git a/src/utils.jl b/src/utils.jl index ecded5af1..dd1f86745 100644 --- a/src/utils.jl +++ b/src/utils.jl @@ -42,157 +42,6 @@ function num_types_in_tuple(sig::UnionAll) length(Base.unwrap_unionall(sig).parameters) end -const NO_METHODS_ERROR_MESSAGE = """ - No methods were found for the model function passed to the equation solver. - The function `f` needs to have dispatches, for example, for an ODEProblem - `f` must define either `f(u,p,t)` or `f(du,u,p,t)`. For more information - on how the model function `f` should be defined, consult the docstring for - the appropriate `AbstractSciMLFunction`. - """ - -struct NoMethodsError <: Exception - fname::String -end - -function Base.showerror(io::IO, e::NoMethodsError) - println(io, NO_METHODS_ERROR_MESSAGE) - print(io, "Offending function: ") - printstyled(io, e.fname; bold = true, color = :red) -end - -const TOO_MANY_ARGUMENTS_ERROR_MESSAGE = """ - All methods for the model function `f` had too many arguments. For example, - an ODEProblem `f` must define either `f(u,p,t)` or `f(du,u,p,t)`. This error - can be thrown if you define an ODE model for example as `f(du,u,p1,p2,t)`. - For more information on the required number of arguments for the function - you were defining, consult the documentation for the `SciMLProblem` or - `SciMLFunction` type that was being constructed. - - A common reason for this occurrence is due to following the MATLAB or SciPy - convention for parameter passing, i.e. to add each parameter as an argument. - In the SciML convention, if you wish to pass multiple parameters, use a - struct or other collection to hold the parameters. For example, here is the - parameterized Lorenz equation: - - ```julia - function lorenz(du,u,p,t) - du[1] = p[1]*(u[2]-u[1]) - du[2] = u[1]*(p[2]-u[3]) - u[2] - du[3] = u[1]*u[2] - p[3]*u[3] - end - u0 = [1.0;0.0;0.0] - p = [10.0,28.0,8/3] - tspan = (0.0,100.0) - prob = ODEProblem(lorenz,u0,tspan,p) - ``` - - Notice that `f` is defined with a single `p`, an array which matches the definition - of the `p` in the `ODEProblem`. Note that `p` can be any Julia struct. - """ - -struct TooManyArgumentsError <: Exception - fname::String - f::Any -end - -function Base.showerror(io::IO, e::TooManyArgumentsError) - println(io, TOO_MANY_ARGUMENTS_ERROR_MESSAGE) - print(io, "Offending function: ") - printstyled(io, e.fname; bold = true, color = :red) - println(io, "\nMethods:") - println(io, methods(e.f)) -end - -const TOO_FEW_ARGUMENTS_ERROR_MESSAGE_OPTIMIZATION = """ - All methods for the model function `f` had too few arguments. For example, - an OptimizationProblem `f` must define `f(u,p)` where `u` is the optimization - state and `p` are the parameters of the optimization (commonly, the hyperparameters - of the simulation). - - A common reason for this error is from defining a single-input loss function - `f(u)`. While parameters are not required, a loss function which takes parameters - is required, i.e. `f(u,p)`. If you have a function `f(u)`, ignored parameters - can be easily added using a closure, i.e. `OptimizationProblem((u,_)->f(u),...)`. - - For example, here is a parameterized optimization problem: - - ```julia - using Optimization, OptimizationOptimJL - rosenbrock(u,p) = (p[1] - u[1])^2 + p[2] * (u[2] - u[1]^2)^2 - u0 = zeros(2) - p = [1.0,100.0] - - prob = OptimizationProblem(rosenbrock,u0,p) - sol = solve(prob,NelderMead()) - ``` - - and a parameter-less example: - - ```julia - using Optimization, OptimizationOptimJL - rosenbrock(u,p) = (1 - u[1])^2 + (u[2] - u[1]^2)^2 - u0 = zeros(2) - - prob = OptimizationProblem(rosenbrock,u0) - sol = solve(prob,NelderMead()) - ``` - """ - -const TOO_FEW_ARGUMENTS_ERROR_MESSAGE = """ - All methods for the model function `f` had too few arguments. For example, - an ODEProblem `f` must define either `f(u,p,t)` or `f(du,u,p,t)`. This error - can be thrown if you define an ODE model for example as `f(u,t)`. The parameters - `p` are not optional in the definition of `f`! For more information on the required - number of arguments for the function you were defining, consult the documentation - for the `SciMLProblem` or `SciMLFunction` type that was being constructed. - - For example, here is the no parameter Lorenz equation. The two valid versions - are out of place: - - ```julia - function lorenz(u,p,t) - du1 = 10.0*(u[2]-u[1]) - du2 = u[1]*(28.0-u[3]) - u[2] - du3 = u[1]*u[2] - 8/3*u[3] - [du1,du2,du3] - end - u0 = [1.0;0.0;0.0] - tspan = (0.0,100.0) - prob = ODEProblem(lorenz,u0,tspan) - ``` - - and in-place: - - ```julia - function lorenz!(du,u,p,t) - du[1] = 10.0*(u[2]-u[1]) - du[2] = u[1]*(28.0-u[3]) - u[2] - du[3] = u[1]*u[2] - 8/3*u[3] - end - u0 = [1.0;0.0;0.0] - tspan = (0.0,100.0) - prob = ODEProblem(lorenz!,u0,tspan) - ``` - """ - -struct TooFewArgumentsError <: Exception - fname::String - f::Any - isoptimization::Bool -end - -function Base.showerror(io::IO, e::TooFewArgumentsError) - if e.isoptimization - println(io, TOO_FEW_ARGUMENTS_ERROR_MESSAGE_OPTIMIZATION) - else - println(io, TOO_FEW_ARGUMENTS_ERROR_MESSAGE) - end - print(io, "Offending function: ") - printstyled(io, e.fname; bold = true, color = :red) - println(io, "\nMethods:") - println(io, methods(e.f)) -end - const ARGUMENTS_ERROR_MESSAGE = """ Methods dispatches for the model function `f` do not match the required number. For example, an ODEProblem `f` must define either `f(u,p,t)` or `f(du,u,p,t)`. @@ -207,6 +56,12 @@ struct FunctionArgumentsError <: Exception f::Any end +# backward compat in case anyone is using these. +# TODO: remove at next major version +const TooManyArgumentsError = FunctionArgumentsError +const TooFewArgumentsError = FunctionArgumentsError +const NoMethodsError = FunctionArgumentsError + function Base.showerror(io::IO, e::FunctionArgumentsError) println(io, ARGUMENTS_ERROR_MESSAGE) print(io, "Offending function: ") @@ -246,66 +101,14 @@ form is disabled and the 2-argument signature is ensured to be matched. function isinplace(f, inplace_param_number, fname = "f", iip_preferred = true; has_two_dispatches = true, isoptimization = false, outofplace_param_number = inplace_param_number - 1) - nargs = numargs(f) - iip_dispatch = any(x -> x == inplace_param_number, nargs) - oop_dispatch = any(x -> x == outofplace_param_number, nargs) - - if length(nargs) == 0 - throw(NoMethodsError(fname)) - end - - if !iip_dispatch && !oop_dispatch && !isoptimization - if all(>(inplace_param_number), nargs) - throw(TooManyArgumentsError(fname, f)) - elseif all(<(outofplace_param_number), nargs) && has_two_dispatches - # Possible extra safety? - # Find if there's a `f(args...)` dispatch - # If so, no error - _parameters = if methods(f).ms[1].sig isa UnionAll - Base.unwrap_unionall(methods(f).ms[1].sig).parameters - else - methods(f).ms[1].sig.parameters - end - - for i in 1:length(nargs) - if nargs[i] < inplace_param_number && - any(isequal(Vararg{Any}), _parameters) - # If varargs, assume iip - return iip_preferred - end - end - - # No varargs detected, error that there are dispatches but not the right ones - - throw(TooFewArgumentsError(fname, f, isoptimization)) - else - throw(FunctionArgumentsError(fname, f)) - end - elseif oop_dispatch && !iip_dispatch && !has_two_dispatches - - # Possible extra safety? - # Find if there's a `f(args...)` dispatch - # If so, no error - for i in 1:length(nargs) - if nargs[i] < inplace_param_number && - any(isequal(Vararg{Any}), methods(f).ms[1].sig.parameters) - # If varargs, assume iip - return iip_preferred - end - end - - throw(TooFewArgumentsError(fname, f, isoptimization)) + if iip_preferred + hasmethod(f, ntuple(_->Any, inplace_param_number)) && return true + hasmethod(f, ntuple(_->Any, outofplace_param_number)) && return false else - if iip_preferred - # Equivalent to, if iip_dispatch exists, treat as iip - # Otherwise, it's oop - iip_dispatch - else - # Equivalent to, if oop_dispatch exists, treat as oop - # Otherwise, it's iip - !oop_dispatch - end + hasmethod(f, ntuple(_->Any, outofplace_param_number)) && return false + hasmethod(f, ntuple(_->Any, inplace_param_number)) && return true end + throw(FunctionArgumentsError(fname, f)) end isinplace(f::AbstractSciMLFunction{iip}) where {iip} = iip diff --git a/test/aqua.jl b/test/aqua.jl index d3bdc5240..0989ee391 100644 --- a/test/aqua.jl +++ b/test/aqua.jl @@ -29,7 +29,7 @@ end # for method_ambiguity in ambs # @show method_ambiguity # end - @warn "Number of method ambiguities: $(length(ambs))" + !isempty(ambs) &&@warn "Number of method ambiguities: $(length(ambs))" @test length(ambs) ≤ 8 end diff --git a/test/function_building_error_messages.jl b/test/function_building_error_messages.jl index ee7ee4af7..789f58c40 100644 --- a/test/function_building_error_messages.jl +++ b/test/function_building_error_messages.jl @@ -27,7 +27,7 @@ f = Foo{1}() @testset "isinplace accepts an out-of-place version with different numbers of parameters " begin f1(u) = 2 * u @test !isinplace(f1, 2) - @test_throws SciMLBase.TooFewArgumentsError SciMLBase.isinplace(f1, 4) + @test_throws SciMLBase.FunctionArgumentsError SciMLBase.isinplace(f1, 4) @test !isinplace(f1, 4; outofplace_param_number = 1) end @@ -36,10 +36,10 @@ end ftoomany(u, p, t, x, y) = 2u u0 = 0.5 tspan = (0.0, 1.0) -@test_throws SciMLBase.TooManyArgumentsError ODEProblem(ftoomany, u0, tspan) +@test_throws SciMLBase.FunctionArgumentsError ODEProblem(ftoomany, u0, tspan) ftoofew(u, t) = 2u -@test_throws SciMLBase.TooFewArgumentsError ODEProblem(ftoofew, u0, tspan) +@test_throws SciMLBase.FunctionArgumentsError ODEProblem(ftoofew, u0, tspan) fmessedup(u, t) = 2u fmessedup(u, p, t, x, y) = 2u @@ -54,84 +54,84 @@ ofboth(u, p, t) = u ofboth(du, u, p, t) = du .= u ODEFunction(ofboth) -ODEFunction{true}(ofboth) -ODEFunction{false}(ofboth) +@inferred ODEFunction{true}(ofboth) +@inferred ODEFunction{false}(ofboth) jac(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, jac = jac) -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, jac = jac) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(fiip, jac = jac) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(foop, jac = jac) jac(u, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, jac = jac) -ODEFunction(foop, jac = jac) +@inferred ODEFunction(foop, jac = jac) jac(du, u, p, t) = [1.0] -ODEFunction(fiip, jac = jac) -ODEFunction(foop, jac = jac) +@inferred ODEFunction(fiip, jac = jac) +@inferred ODEFunction(foop, jac = jac) Wfact(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, Wfact = Wfact) -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, Wfact = Wfact) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(fiip, Wfact = Wfact) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(foop, Wfact = Wfact) Wfact(u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, Wfact = Wfact) -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, Wfact = Wfact) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(fiip, Wfact = Wfact) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(foop, Wfact = Wfact) Wfact(u, p, gamma, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, Wfact = Wfact) -ODEFunction(foop, Wfact = Wfact) +@inferred ODEFunction(foop, Wfact = Wfact) Wfact(du, u, p, gamma, t) = [1.0] -ODEFunction(fiip, Wfact = Wfact) -ODEFunction(foop, Wfact = Wfact) +@inferred ODEFunction(fiip, Wfact = Wfact) +@inferred ODEFunction(foop, Wfact = Wfact) Wfact_t(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, Wfact_t = Wfact_t) -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, Wfact_t = Wfact_t) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(fiip, Wfact_t = Wfact_t) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(foop, Wfact_t = Wfact_t) Wfact_t(u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, Wfact_t = Wfact_t) -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, Wfact_t = Wfact_t) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(fiip, Wfact_t = Wfact_t) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(foop, Wfact_t = Wfact_t) Wfact_t(u, p, gamma, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, Wfact_t = Wfact_t) -ODEFunction(foop, Wfact_t = Wfact_t) +@inferred ODEFunction(foop, Wfact_t = Wfact_t) Wfact_t(du, u, p, gamma, t) = [1.0] -ODEFunction(fiip, Wfact_t = Wfact_t) -ODEFunction(foop, Wfact_t = Wfact_t) +@inferred ODEFunction(fiip, Wfact_t = Wfact_t) +@inferred ODEFunction(foop, Wfact_t = Wfact_t) tgrad(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, tgrad = tgrad) -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, tgrad = tgrad) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(fiip, tgrad = tgrad) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(foop, tgrad = tgrad) tgrad(u, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, tgrad = tgrad) ODEFunction(foop, tgrad = tgrad) tgrad(du, u, p, t) = [1.0] -ODEFunction(fiip, tgrad = tgrad) -ODEFunction(foop, tgrad = tgrad) +@inferred ODEFunction(fiip, tgrad = tgrad) +@inferred ODEFunction(foop, tgrad = tgrad) paramjac(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, paramjac = paramjac) -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, paramjac = paramjac) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(fiip, paramjac = paramjac) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(foop, paramjac = paramjac) paramjac(u, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, paramjac = paramjac) -ODEFunction(foop, paramjac = paramjac) +@inferred ODEFunction(foop, paramjac = paramjac) paramjac(du, u, p, t) = [1.0] -ODEFunction(fiip, paramjac = paramjac) -ODEFunction(foop, paramjac = paramjac) +@inferred ODEFunction(fiip, paramjac = paramjac) +@inferred ODEFunction(foop, paramjac = paramjac) jvp(u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, jvp = jvp) -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, jvp = jvp) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(fiip, jvp = jvp) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(foop, jvp = jvp) jvp(u, v, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, jvp = jvp) ODEFunction(foop, jvp = jvp) jvp(du, u, v, p, t) = [1.0] -ODEFunction(fiip, jvp = jvp) -ODEFunction(foop, jvp = jvp) +@inferred ODEFunction(fiip, jvp = jvp) +@inferred ODEFunction(foop, jvp = jvp) vjp(u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(fiip, vjp = vjp) -@test_throws SciMLBase.TooFewArgumentsError ODEFunction(foop, vjp = vjp) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(fiip, vjp = vjp) +@test_throws SciMLBase.FunctionArgumentsError ODEFunction(foop, vjp = vjp) vjp(u, v, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError ODEFunction(fiip, vjp = vjp) -ODEFunction(foop, vjp = vjp) +@inferred ODEFunction(foop, vjp = vjp) vjp(du, u, v, p, t) = [1.0] -ODEFunction(fiip, vjp = vjp) -ODEFunction(foop, vjp = vjp) +@inferred ODEFunction(fiip, vjp = vjp) +@inferred ODEFunction(foop, vjp = vjp) # SDE @@ -141,8 +141,8 @@ goop(u, p, t) = u fiip(du, u, p, t) = du .= u giip(du, u, p, t) = du .= u -SDEFunction(fiip, giip) -SDEFunction(foop, goop) +@inferred SDEFunction(fiip, giip) +@inferred SDEFunction(foop, goop) @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(foop, giip) @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, goop) @@ -151,97 +151,97 @@ sfboth(du, u, p, t) = du .= u sgboth(u, p, t) = u sgboth(du, u, p, t) = du .= u -SDEFunction(sfboth, sgboth) -SDEFunction{true}(sfboth, sgboth) -SDEFunction{false}(sfboth, sgboth) +@inferred SDEFunction(sfboth, sgboth) +@inferred SDEFunction{true}(sfboth, sgboth) +@inferred SDEFunction{false}(sfboth, sgboth) sjac(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, jac = sjac) -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, goop, jac = sjac) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(fiip, giip, jac = sjac) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(foop, goop, jac = sjac) sjac(u, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, jac = sjac) -SDEFunction(foop, goop, jac = sjac) +@inferred SDEFunction(foop, goop, jac = sjac) sjac(du, u, p, t) = [1.0] -SDEFunction(fiip, giip, jac = sjac) -SDEFunction(foop, goop, jac = sjac) +@inferred SDEFunction(fiip, giip, jac = sjac) +@inferred SDEFunction(foop, goop, jac = sjac) sWfact(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, Wfact = sWfact) -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, goop, Wfact = sWfact) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(fiip, giip, Wfact = sWfact) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(foop, goop, Wfact = sWfact) sWfact(u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, Wfact = sWfact) -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, goop, Wfact = sWfact) -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, goop, Wfact = sWfact) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(fiip, giip, Wfact = sWfact) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(fiip, goop, Wfact = sWfact) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(foop, goop, Wfact = sWfact) sWfact(u, p, gamma, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, Wfact = sWfact) @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, goop, Wfact = sWfact) -SDEFunction(foop, goop, Wfact = sWfact) +@inferred SDEFunction(foop, goop, Wfact = sWfact) sWfact(du, u, p, gamma, t) = [1.0] -SDEFunction(fiip, giip, Wfact = sWfact) -SDEFunction(foop, goop, Wfact = sWfact) +@inferred SDEFunction(fiip, giip, Wfact = sWfact) +@inferred SDEFunction(foop, goop, Wfact = sWfact) sWfact_t(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, Wfact_t = sWfact_t) -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, giip, Wfact_t = sWfact_t) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(fiip, giip, Wfact_t = sWfact_t) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(foop, giip, Wfact_t = sWfact_t) sWfact_t(u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, Wfact_t = sWfact_t) -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, giip, Wfact_t = sWfact_t) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(fiip, giip, Wfact_t = sWfact_t) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(foop, giip, Wfact_t = sWfact_t) sWfact_t(u, p, gamma, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, Wfact_t = sWfact_t) -SDEFunction(foop, goop, Wfact_t = sWfact_t) +@inferred SDEFunction(foop, goop, Wfact_t = sWfact_t) sWfact_t(du, u, p, gamma, t) = [1.0] SDEFunction(fiip, giip, Wfact_t = sWfact_t) SDEFunction(foop, goop, Wfact_t = sWfact_t) stgrad(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, tgrad = stgrad) -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, goop, tgrad = stgrad) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(fiip, giip, tgrad = stgrad) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(foop, goop, tgrad = stgrad) stgrad(u, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, tgrad = stgrad) -SDEFunction(foop, goop, tgrad = stgrad) +@inferred SDEFunction(foop, goop, tgrad = stgrad) stgrad(du, u, p, t) = [1.0] -SDEFunction(fiip, giip, tgrad = stgrad) -SDEFunction(foop, goop, tgrad = stgrad) +@inferred SDEFunction(fiip, giip, tgrad = stgrad) +@inferred SDEFunction(foop, goop, tgrad = stgrad) sparamjac(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, paramjac = sparamjac) -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, goop, paramjac = sparamjac) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(fiip, giip, paramjac = sparamjac) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(foop, goop, paramjac = sparamjac) sparamjac(u, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, paramjac = sparamjac) -SDEFunction(foop, goop, paramjac = sparamjac) +@inferred SDEFunction(foop, goop, paramjac = sparamjac) sparamjac(du, u, p, t) = [1.0] -SDEFunction(fiip, giip, paramjac = sparamjac) -SDEFunction(foop, goop, paramjac = sparamjac) +@inferred SDEFunction(fiip, giip, paramjac = sparamjac) +@inferred SDEFunction(foop, goop, paramjac = sparamjac) sjvp(u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, jvp = sjvp) -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, goop, jvp = sjvp) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(fiip, giip, jvp = sjvp) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(foop, goop, jvp = sjvp) sjvp(u, v, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, jvp = sjvp) -SDEFunction(foop, goop, jvp = sjvp) +@inferred SDEFunction(foop, goop, jvp = sjvp) sjvp(du, u, v, p, t) = [1.0] -SDEFunction(fiip, giip, jvp = sjvp) -SDEFunction(foop, goop, jvp = sjvp) +@inferred SDEFunction(fiip, giip, jvp = sjvp) +@inferred SDEFunction(foop, goop, jvp = sjvp) svjp(u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(fiip, giip, vjp = svjp) -@test_throws SciMLBase.TooFewArgumentsError SDEFunction(foop, goop, vjp = svjp) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(fiip, giip, vjp = svjp) +@test_throws SciMLBase.FunctionArgumentsError SDEFunction(foop, goop, vjp = svjp) svjp(u, v, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError SDEFunction(fiip, giip, vjp = svjp) -SDEFunction(foop, goop, vjp = svjp) +@inferred SDEFunction(foop, goop, vjp = svjp) svjp(du, u, v, p, t) = [1.0] -SDEFunction(fiip, giip, vjp = svjp) -SDEFunction(foop, goop, vjp = svjp) +@inferred SDEFunction(fiip, giip, vjp = svjp) +@inferred SDEFunction(foop, goop, vjp = svjp) # RODEFunction froop(u, p, t, W) = W friip(du, p, t, W) = (du .= W) -RODEFunction(froop) -RODEFunction(friip) +@inferred RODEFunction(froop) +@inferred RODEFunction(friip) frboth(u, p, t, W) = W frboth(du, u, p, t, W) = (du .= W) @@ -270,64 +270,64 @@ dfiip(res, du, u, p, t) = res .= du .+ u dfboth(du, u, p, t) = du .+ u dfboth(res, du, u, p, t) = res .= du .+ u -DAEFunction(dfboth) -DAEFunction{true}(dfboth) -DAEFunction{false}(dfboth) +@inferred DAEFunction(dfboth) +@inferred DAEFunction{true}(dfboth) +@inferred DAEFunction{false}(dfboth) djac(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, jac = djac) -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfoop, jac = djac) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfiip, jac = djac) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfoop, jac = djac) djac(u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, jac = djac) -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfoop, jac = djac) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfiip, jac = djac) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfoop, jac = djac) djac(du, u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, jac = djac) -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfoop, jac = djac) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfiip, jac = djac) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfoop, jac = djac) djac(du, u, p, gamma, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DAEFunction(dfiip, jac = djac) DAEFunction(dfoop, jac = djac) djac(res, du, u, p, gamma, t) = [1.0] -DAEFunction(dfiip, jac = djac) -DAEFunction(dfoop, jac = djac) +@inferred DAEFunction(dfiip, jac = djac) +@inferred DAEFunction(dfoop, jac = djac) djvp(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, jvp = djvp) -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfoop, jvp = djvp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfiip, jvp = djvp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfoop, jvp = djvp) djvp(u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, jvp = djvp) -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfoop, jvp = djvp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfiip, jvp = djvp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfoop, jvp = djvp) djvp(du, u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, jvp = djvp) -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfoop, jvp = djvp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfiip, jvp = djvp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfoop, jvp = djvp) djvp(du, u, v, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, jvp = djvp) -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfoop, jvp = djvp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfiip, jvp = djvp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfoop, jvp = djvp) djvp(du, u, v, p, gamma, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DAEFunction(dfiip, jvp = djvp) -DAEFunction(dfoop, jvp = djvp) +@inferred DAEFunction(dfoop, jvp = djvp) djvp(res, du, u, v, p, gamma, t) = [1.0] -DAEFunction(dfiip, jvp = djvp) -DAEFunction(dfoop, jvp = djvp) +@inferred DAEFunction(dfiip, jvp = djvp) +@inferred DAEFunction(dfoop, jvp = djvp) dvjp(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, vjp = dvjp) -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfoop, vjp = dvjp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfiip, vjp = dvjp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfoop, vjp = dvjp) dvjp(u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, vjp = dvjp) -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfoop, vjp = dvjp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfiip, vjp = dvjp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfoop, vjp = dvjp) dvjp(du, u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, vjp = dvjp) -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfoop, vjp = dvjp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfiip, vjp = dvjp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfoop, vjp = dvjp) dvjp(du, u, v, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfiip, vjp = dvjp) -@test_throws SciMLBase.TooFewArgumentsError DAEFunction(dfoop, vjp = dvjp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfiip, vjp = dvjp) +@test_throws SciMLBase.FunctionArgumentsError DAEFunction(dfoop, vjp = dvjp) dvjp(du, u, v, p, gamma, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DAEFunction(dfiip, vjp = dvjp) DAEFunction(dfoop, vjp = dvjp) dvjp(res, du, u, v, p, gamma, t) = [1.0] -DAEFunction(dfiip, vjp = dvjp) -DAEFunction(dfoop, vjp = dvjp) -DAEFunction{true, SciMLBase.NoSpecialize}(dfiip, observed = 1) +@inferred DAEFunction(dfiip, vjp = dvjp) +@inferred DAEFunction(dfoop, vjp = dvjp) +@inferred DAEFunction{true, SciMLBase.NoSpecialize}(dfiip, observed = 1) # DDEFunction @@ -337,60 +337,60 @@ ddefiip(du, u, h, p, t) = du .= u ddeofboth(u, h, p, t) = u ddeofboth(du, u, h, p, t) = du .= u -DDEFunction(ddeofboth) -DDEFunction{true}(ddeofboth) -DDEFunction{false}(ddeofboth) +@inferred DDEFunction(ddeofboth) +@inferred DDEFunction{true}(ddeofboth) +@inferred DDEFunction{false}(ddeofboth) ddejac(u, h, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, jac = ddejac) -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, jac = ddejac) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefiip, jac = ddejac) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefoop, jac = ddejac) ddejac(u, h, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, jac = ddejac) DDEFunction(ddefoop, jac = ddejac) ddejac(du, u, h, p, t) = [1.0] -DDEFunction(ddefiip, jac = ddejac) -DDEFunction(ddefoop, jac = ddejac) +@inferred DDEFunction(ddefiip, jac = ddejac) +@inferred DDEFunction(ddefoop, jac = ddejac) ddeWfact(u, h, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, Wfact = ddeWfact) -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, Wfact = ddeWfact) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefiip, Wfact = ddeWfact) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefoop, Wfact = ddeWfact) ddeWfact(u, h, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, Wfact = ddeWfact) -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, Wfact = ddeWfact) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefiip, Wfact = ddeWfact) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefoop, Wfact = ddeWfact) ddeWfact(u, h, p, gamma, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, Wfact = ddeWfact) -DDEFunction(ddefoop, Wfact = ddeWfact) +@inferred DDEFunction(ddefoop, Wfact = ddeWfact) ddeWfact(du, u, h, p, gamma, t) = [1.0] -DDEFunction(ddefiip, Wfact = ddeWfact) -DDEFunction(ddefoop, Wfact = ddeWfact) +@inferred DDEFunction(ddefiip, Wfact = ddeWfact) +@inferred DDEFunction(ddefoop, Wfact = ddeWfact) ddeWfact_t(u, h, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, Wfact_t = ddeWfact_t) -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, Wfact_t = ddeWfact_t) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefiip, Wfact_t = ddeWfact_t) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefoop, Wfact_t = ddeWfact_t) ddeWfact_t(u, h, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, Wfact_t = ddeWfact_t) -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, Wfact_t = ddeWfact_t) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefiip, Wfact_t = ddeWfact_t) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefoop, Wfact_t = ddeWfact_t) ddeWfact_t(u, h, p, gamma, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, Wfact_t = ddeWfact_t) -DDEFunction(ddefoop, Wfact_t = Wfact_t) +@inferred DDEFunction(ddefoop, Wfact_t = Wfact_t) ddeWfact_t(du, u, h, p, gamma, t) = [1.0] -DDEFunction(ddefiip, Wfact_t = ddeWfact_t) -DDEFunction(ddefoop, Wfact_t = ddeWfact_t) +@inferred DDEFunction(ddefiip, Wfact_t = ddeWfact_t) +@inferred DDEFunction(ddefoop, Wfact_t = ddeWfact_t) ddetgrad(u, h, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, tgrad = ddetgrad) -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, tgrad = ddetgrad) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefiip, tgrad = ddetgrad) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefoop, tgrad = ddetgrad) ddetgrad(u, h, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, tgrad = ddetgrad) -DDEFunction(ddefoop, tgrad = ddetgrad) +@inferred DDEFunction(ddefoop, tgrad = ddetgrad) ddetgrad(du, u, h, p, t) = [1.0] -DDEFunction(ddefiip, tgrad = ddetgrad) -DDEFunction(ddefoop, tgrad = ddetgrad) +@inferred DDEFunction(ddefiip, tgrad = ddetgrad) +@inferred DDEFunction(ddefoop, tgrad = ddetgrad) ddeparamjac(u, h, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, paramjac = ddeparamjac) -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, paramjac = ddeparamjac) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefiip, paramjac = ddeparamjac) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefoop, paramjac = ddeparamjac) ddeparamjac(u, h, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, paramjac = ddeparamjac) @@ -400,24 +400,24 @@ DDEFunction(ddefiip, paramjac = ddeparamjac) DDEFunction(ddefoop, paramjac = ddeparamjac) ddejvp(u, h, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, jvp = ddejvp) -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, jvp = ddejvp) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefiip, jvp = ddejvp) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefoop, jvp = ddejvp) ddejvp(u, v, h, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, jvp = ddejvp) -DDEFunction(ddefoop, jvp = ddejvp) +@inferred DDEFunction(ddefoop, jvp = ddejvp) ddejvp(du, u, v, h, p, t) = [1.0] -DDEFunction(ddefiip, jvp = ddejvp) -DDEFunction(ddefoop, jvp = ddejvp) +@inferred DDEFunction(ddefiip, jvp = ddejvp) +@inferred DDEFunction(ddefoop, jvp = ddejvp) ddevjp(u, h, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefiip, vjp = ddevjp) -@test_throws SciMLBase.TooFewArgumentsError DDEFunction(ddefoop, vjp = ddevjp) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefiip, vjp = ddevjp) +@test_throws SciMLBase.FunctionArgumentsError DDEFunction(ddefoop, vjp = ddevjp) ddevjp(u, v, h, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DDEFunction(ddefiip, vjp = ddevjp) -DDEFunction(ddefoop, vjp = ddevjp) +@inferred DDEFunction(ddefoop, vjp = ddevjp) ddevjp(du, u, v, h, p, t) = [1.0] -DDEFunction(ddefiip, vjp = ddevjp) -DDEFunction(ddefoop, vjp = ddevjp) +@inferred DDEFunction(ddefiip, vjp = ddevjp) +@inferred DDEFunction(ddefoop, vjp = ddevjp) # NonlinearFunction @@ -427,53 +427,53 @@ nfiip(du, u, p) = du .= u nfboth(u, p) = u nfboth(du, u, p) = du .= u -NonlinearFunction(nfboth) -NonlinearFunction{true}(nfboth) -NonlinearFunction{false}(nfboth) +@inferred NonlinearFunction(nfboth) +@inferred NonlinearFunction{true}(nfboth) +@inferred NonlinearFunction{false}(nfboth) njac(u) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfiip, jac = njac) -@test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfoop, jac = njac) +@test_throws SciMLBase.FunctionArgumentsError NonlinearFunction(nfiip, jac = njac) +@test_throws SciMLBase.FunctionArgumentsError NonlinearFunction(nfoop, jac = njac) njac(u, p) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError NonlinearFunction(nfiip, jac = njac) -NonlinearFunction(nfoop, jac = njac) +@inferred NonlinearFunction(nfoop, jac = njac) njac(du, u, p) = [1.0] -NonlinearFunction(nfiip, jac = njac) -NonlinearFunction(nfoop, jac = njac) +@inferred NonlinearFunction(nfiip, jac = njac) +@inferred NonlinearFunction(nfoop, jac = njac) njvp(u) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfiip, jvp = njvp) -@test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfoop, jvp = njvp) +@test_throws SciMLBase.FunctionArgumentsError NonlinearFunction(nfiip, jvp = njvp) +@test_throws SciMLBase.FunctionArgumentsError NonlinearFunction(nfoop, jvp = njvp) njvp(u, p) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfiip, jvp = njvp) -@test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfoop, jvp = njvp) +@test_throws SciMLBase.FunctionArgumentsError NonlinearFunction(nfiip, jvp = njvp) +@test_throws SciMLBase.FunctionArgumentsError NonlinearFunction(nfoop, jvp = njvp) njvp(u, v, p) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError NonlinearFunction(nfiip, jvp = njvp) -NonlinearFunction(nfoop, jvp = njvp) +@inferred NonlinearFunction(nfoop, jvp = njvp) njvp(du, u, v, p) = [1.0] -NonlinearFunction(nfiip, jvp = njvp) -NonlinearFunction(nfoop, jvp = njvp) +@inferred NonlinearFunction(nfiip, jvp = njvp) +@inferred NonlinearFunction(nfoop, jvp = njvp) nvjp(u) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfiip, vjp = nvjp) -@test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfoop, vjp = nvjp) +@test_throws SciMLBase.FunctionArgumentsError NonlinearFunction(nfiip, vjp = nvjp) +@test_throws SciMLBase.FunctionArgumentsError NonlinearFunction(nfoop, vjp = nvjp) nvjp(u, p) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfiip, vjp = nvjp) -@test_throws SciMLBase.TooFewArgumentsError NonlinearFunction(nfoop, vjp = nvjp) +@test_throws SciMLBase.FunctionArgumentsError NonlinearFunction(nfiip, vjp = nvjp) +@test_throws SciMLBase.FunctionArgumentsError NonlinearFunction(nfoop, vjp = nvjp) nvjp(u, v, p) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError NonlinearFunction(nfiip, vjp = nvjp) -NonlinearFunction(nfoop, vjp = nvjp) +@inferred NonlinearFunction(nfoop, vjp = nvjp) nvjp(du, u, v, p) = [1.0] -NonlinearFunction(nfiip, vjp = nvjp) -NonlinearFunction(nfoop, vjp = nvjp) +@inferred NonlinearFunction(nfiip, vjp = nvjp) +@inferred NonlinearFunction(nfoop, vjp = nvjp) # Integrals intfew(u) = 1.0 -@test_throws SciMLBase.TooFewArgumentsError IntegralProblem(intfew, (0.0, 1.0)) -@test_throws SciMLBase.TooFewArgumentsError IntegralFunction(intfew) -@test_throws SciMLBase.TooFewArgumentsError IntegralFunction(intfew, zeros(3)) -@test_throws SciMLBase.TooFewArgumentsError BatchIntegralFunction(intfew) -@test_throws SciMLBase.TooFewArgumentsError BatchIntegralFunction(intfew, zeros(3)) +@test_throws SciMLBase.FunctionArgumentsError IntegralProblem(intfew, (0.0, 1.0)) +@test_throws SciMLBase.FunctionArgumentsError IntegralFunction(intfew) +@test_throws SciMLBase.FunctionArgumentsError IntegralFunction(intfew, zeros(3)) +@test_throws SciMLBase.FunctionArgumentsError BatchIntegralFunction(intfew) +@test_throws SciMLBase.FunctionArgumentsError BatchIntegralFunction(intfew, zeros(3)) intf(u, p) = 1.0 p = 2.0 intfiip(y, u, p) = y .= 1.0 @@ -485,25 +485,25 @@ for (f, kws, iip) in ( (intfiip, (; nout = 3), true), (IntegralFunction(intfiip, zeros(3)), (;), true) ), domain in (((0.0, 1.0),), (([0.0], [1.0]),), (0.0, 1.0), ([0.0], [1.0])) - IntegralProblem(f, domain...; kws...) - IntegralProblem(f, domain..., p; kws...) - IntegralProblem{iip}(f, domain...; kws...) - IntegralProblem{iip}(f, domain..., p; kws...) + @inferred IntegralProblem(f, domain...; kws...) + @inferred IntegralProblem(f, domain..., p; kws...) + @inferred IntegralProblem{iip}(f, domain...; kws...) + @inferred IntegralProblem{iip}(f, domain..., p; kws...) end x = [1.0, 2.0] y = rand(2, 2) -SampledIntegralProblem(y, x) -SampledIntegralProblem(y, x; dim = 2) +@inferred SampledIntegralProblem(y, x) +@inferred SampledIntegralProblem(y, x; dim = 2) # Optimization optf(u) = 1.0 -@test_throws SciMLBase.TooFewArgumentsError OptimizationFunction(optf) -@test_throws SciMLBase.TooFewArgumentsError OptimizationProblem(optf, 1.0) +@test_throws SciMLBase.FunctionArgumentsError OptimizationFunction(optf) +@test_throws SciMLBase.FunctionArgumentsError OptimizationProblem(optf, 1.0) optf(u, p) = 1.0 -OptimizationFunction(optf) -OptimizationProblem(optf, 1.0) +@inferred OptimizationFunction(optf) +@inferred OptimizationProblem(optf, 1.0) # BVPFunction @@ -519,25 +519,25 @@ bciip(res, u, p, t) = res .= u bcfboth(u, p, t) = u bcfboth(du, u, p, t) = du .= u -BVPFunction(bfboth, bcfboth) -BVPFunction{true}(bfboth, bcfboth) -BVPFunction{false}(bfboth, bcfboth) +@inferred BVPFunction(bfboth, bcfboth) +@inferred BVPFunction{true}(bfboth, bcfboth) +@inferred BVPFunction{false}(bfboth, bcfboth) bjac(u, t) = [1.0] bcjac(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfiip, +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfiip, bciip, jac = bjac, bcjac = bcjac) -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfoop, +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfoop, bciip, jac = bjac, bcjac = bcjac) -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfiip, +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfiip, bcoop, jac = bjac, bcjac = bcjac) -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfoop, +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfoop, bcoop, jac = bjac, bcjac = bcjac) @@ -555,10 +555,10 @@ bcjac(u, p, t) = [1.0] bciip, jac = bjac, bcjac = bcjac) -BVPFunction(bfoop, bcoop, jac = bjac) +@inferred BVPFunction(bfoop, bcoop, jac = bjac) bjac(du, u, p, t) = [1.0] bcjac(du, u, p, t) = [1.0] -BVPFunction(bfiip, bciip, jac = bjac, bcjac = bcjac) +@inferred BVPFunction(bfiip, bciip, jac = bjac, bcjac = bcjac) @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, jac = bjac, @@ -567,27 +567,27 @@ BVPFunction(bfiip, bciip, jac = bjac, bcjac = bcjac) bcoop, jac = bjac, bcjac = bcjac) -BVPFunction(bfoop, bcoop, jac = bjac, bcjac = bcjac) +@inferred BVPFunction(bfoop, bcoop, jac = bjac, bcjac = bcjac) bWfact(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfiip, bciip, Wfact = bWfact) -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfoop, bciip, Wfact = bWfact) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfiip, bciip, Wfact = bWfact) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfoop, bciip, Wfact = bWfact) bWfact(u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfiip, bciip, Wfact = bWfact) -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfoop, bciip, Wfact = bWfact) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfiip, bciip, Wfact = bWfact) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfoop, bciip, Wfact = bWfact) bWfact(u, p, gamma, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfiip, bciip, Wfact = bWfact) @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, Wfact = bWfact) bWfact(du, u, p, gamma, t) = [1.0] -BVPFunction(bfiip, bciip, Wfact = bWfact) +@inferred BVPFunction(bfiip, bciip, Wfact = bWfact) @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, Wfact = bWfact) bWfact_t(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfiip, bciip, Wfact_t = bWfact_t) -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfoop, bciip, Wfact_t = bWfact_t) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfiip, bciip, Wfact_t = bWfact_t) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfoop, bciip, Wfact_t = bWfact_t) bWfact_t(u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfiip, bciip, Wfact_t = bWfact_t) -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfoop, bciip, Wfact_t = bWfact_t) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfiip, bciip, Wfact_t = bWfact_t) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfoop, bciip, Wfact_t = bWfact_t) bWfact_t(u, p, gamma, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfiip, bciip, @@ -596,24 +596,24 @@ bWfact_t(u, p, gamma, t) = [1.0] bciip, Wfact_t = bWfact_t) bWfact_t(du, u, p, gamma, t) = [1.0] -BVPFunction(bfiip, bciip, Wfact_t = bWfact_t) +@inferred BVPFunction(bfiip, bciip, Wfact_t = bWfact_t) @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, Wfact_t = bWfact_t) btgrad(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfiip, bciip, tgrad = btgrad) -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfoop, bciip, tgrad = btgrad) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfiip, bciip, tgrad = btgrad) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfoop, bciip, tgrad = btgrad) btgrad(u, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfiip, bciip, tgrad = btgrad) @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, tgrad = btgrad) btgrad(du, u, p, t) = [1.0] -BVPFunction(bfiip, bciip, tgrad = btgrad) +@inferred BVPFunction(bfiip, bciip, tgrad = btgrad) @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, tgrad = btgrad) bparamjac(u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfiip, bciip, paramjac = bparamjac) -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfoop, bciip, paramjac = bparamjac) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfiip, bciip, paramjac = bparamjac) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfoop, bciip, paramjac = bparamjac) bparamjac(u, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfiip, bciip, @@ -622,29 +622,29 @@ bparamjac(u, p, t) = [1.0] bciip, paramjac = bparamjac) bparamjac(du, u, p, t) = [1.0] -BVPFunction(bfiip, bciip, paramjac = bparamjac) +@inferred BVPFunction(bfiip, bciip, paramjac = bparamjac) @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, paramjac = bparamjac) bjvp(u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfiip, bciip, jvp = bjvp) -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfoop, bciip, jvp = bjvp) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfiip, bciip, jvp = bjvp) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfoop, bciip, jvp = bjvp) bjvp(u, v, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfiip, bciip, jvp = bjvp) @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, jvp = bjvp) bjvp(du, u, v, p, t) = [1.0] -BVPFunction(bfiip, bciip, jvp = bjvp) +@inferred BVPFunction(bfiip, bciip, jvp = bjvp) @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, jvp = bjvp) bvjp(u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfiip, bciip, vjp = bvjp) -@test_throws SciMLBase.TooFewArgumentsError BVPFunction(bfoop, bciip, vjp = bvjp) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfiip, bciip, vjp = bvjp) +@test_throws SciMLBase.FunctionArgumentsError BVPFunction(bfoop, bciip, vjp = bvjp) bvjp(u, v, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfiip, bciip, vjp = bvjp) @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, vjp = bvjp) bvjp(du, u, v, p, t) = [1.0] -BVPFunction(bfiip, bciip, vjp = bvjp) +@inferred BVPFunction(bfiip, bciip, vjp = bvjp) @test_throws SciMLBase.NonconformingFunctionsError BVPFunction(bfoop, bciip, vjp = bvjp) @@ -662,25 +662,25 @@ dbciip(res, du, u, p, t) = res .= du .- u dbcfboth(du, u, p, t) = u dbcfboth(res, du, u, p, t) = res .= du .- u -DynamicalBVPFunction(dbfboth, dbcfboth) -DynamicalBVPFunction{true}(dbfboth, dbcfboth) -DynamicalBVPFunction{false}(dbfboth, dbcfboth) +@inferred DynamicalBVPFunction(dbfboth, dbcfboth) +@inferred DynamicalBVPFunction{true}(dbfboth, dbcfboth) +@inferred DynamicalBVPFunction{false}(dbfboth, dbcfboth) dbjac(du, u, t) = [1.0] dbcjac(du, u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction(dbfiip, +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction(dbfiip, dbciip, jac = dbjac, bcjac = dbcjac) -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction(dbfoop, +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction(dbfoop, dbciip, jac = dbjac, bcjac = dbcjac) -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction(dbfiip, +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction(dbfiip, dbcoop, jac = dbjac, bcjac = dbcjac) -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction(dbfoop, +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction(dbfoop, dbcoop, jac = dbjac, bcjac = dbcjac) @@ -698,10 +698,10 @@ dbcjac(du, u, p, t) = [1.0] dbciip, jac = dbjac, bcjac = dbcjac) -DynamicalBVPFunction(dbfoop, dbcoop, jac = dbjac) +@inferred DynamicalBVPFunction(dbfoop, dbcoop, jac = dbjac) dbjac(ddu, du, u, p, t) = [1.0] dbcjac(ddu, du, u, p, t) = [1.0] -DynamicalBVPFunction(dbfiip, dbciip, jac = dbjac, bcjac = dbcjac) +@inferred DynamicalBVPFunction(dbfiip, dbciip, jac = dbjac, bcjac = dbcjac) @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(dbfoop, dbciip, jac = dbjac, @@ -710,17 +710,17 @@ DynamicalBVPFunction(dbfiip, dbciip, jac = dbjac, bcjac = dbcjac) dbcoop, jac = dbjac, bcjac = dbcjac) -DynamicalBVPFunction(dbfoop, dbcoop, jac = dbjac, bcjac = dbcjac) +@inferred DynamicalBVPFunction(dbfoop, dbcoop, jac = dbjac, bcjac = dbcjac) dbWfact(du, u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfiip, dbciip, Wfact = dbWfact) -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfoop, dbciip, Wfact = dbWfact) dbWfact(du, u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfiip, dbciip, Wfact = dbWfact) -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfoop, dbciip, Wfact = dbWfact) dbWfact(du, u, p, gamma, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction( @@ -728,19 +728,19 @@ dbWfact(du, u, p, gamma, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction( dbfoop, dbciip, Wfact = dbWfact) dbWfact(ddu, du, u, p, gamma, t) = [1.0] -DynamicalBVPFunction(dbfiip, dbciip, Wfact = dbWfact) +@inferred DynamicalBVPFunction(dbfiip, dbciip, Wfact = dbWfact) @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction( dbfoop, dbciip, Wfact = dbWfact) dbWfact_t(du, u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfiip, dbciip, Wfact_t = dbWfact_t) -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfoop, dbciip, Wfact_t = dbWfact_t) dbWfact_t(du, u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfiip, dbciip, Wfact_t = dbWfact_t) -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfoop, dbciip, Wfact_t = dbWfact_t) dbWfact_t(du, u, p, gamma, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(dbfiip, @@ -750,15 +750,15 @@ dbWfact_t(du, u, p, gamma, t) = [1.0] dbciip, Wfact_t = dbWfact_t) dbWfact_t(ddu, du, u, p, gamma, t) = [1.0] -DynamicalBVPFunction(dbfiip, dbciip, Wfact_t = dbWfact_t) +@inferred DynamicalBVPFunction(dbfiip, dbciip, Wfact_t = dbWfact_t) @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(dbfoop, dbciip, Wfact_t = dbWfact_t) dbtgrad(du, u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfiip, dbciip, tgrad = dbtgrad) -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfoop, dbciip, tgrad = dbtgrad) dbtgrad(du, u, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction( @@ -766,14 +766,14 @@ dbtgrad(du, u, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction( dbfoop, dbciip, tgrad = dbtgrad) dbtgrad(ddu, du, u, p, t) = [1.0] -DynamicalBVPFunction(dbfiip, dbciip, tgrad = dbtgrad) +@inferred DynamicalBVPFunction(dbfiip, dbciip, tgrad = dbtgrad) @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction( dbfoop, dbciip, tgrad = dbtgrad) dbparamjac(du, u, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfiip, dbciip, paramjac = dbparamjac) -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfoop, dbciip, paramjac = dbparamjac) dbparamjac(du, u, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(dbfiip, @@ -783,15 +783,15 @@ dbparamjac(du, u, p, t) = [1.0] dbciip, paramjac = dbparamjac) dbparamjac(ddu, du, u, p, t) = [1.0] -DynamicalBVPFunction(dbfiip, dbciip, paramjac = dbparamjac) +@inferred DynamicalBVPFunction(dbfiip, dbciip, paramjac = dbparamjac) @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction(dbfoop, dbciip, paramjac = dbparamjac) dbjvp(du, u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfiip, dbciip, jvp = dbjvp) -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfoop, dbciip, jvp = dbjvp) dbjvp(du, u, v, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction( @@ -799,14 +799,14 @@ dbjvp(du, u, v, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction( dbfoop, dbciip, jvp = dbjvp) dbjvp(ddu, du, u, v, p, t) = [1.0] -DynamicalBVPFunction(dbfiip, dbciip, jvp = dbjvp) +@inferred DynamicalBVPFunction(dbfiip, dbciip, jvp = dbjvp) @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction( dbfoop, dbciip, jvp = dbjvp) dbvjp(du, u, p, t) = [1.0] -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfiip, dbciip, vjp = dbvjp) -@test_throws SciMLBase.TooFewArgumentsError DynamicalBVPFunction( +@test_throws SciMLBase.FunctionArgumentsError DynamicalBVPFunction( dbfoop, dbciip, vjp = dbvjp) dbvjp(du, u, v, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction( @@ -814,7 +814,7 @@ dbvjp(du, u, v, p, t) = [1.0] @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction( dbfoop, dbciip, vjp = dbvjp) dbvjp(ddu, du, u, v, p, t) = [1.0] -DynamicalBVPFunction(dbfiip, dbciip, vjp = dbvjp) +@inferred DynamicalBVPFunction(dbfiip, dbciip, vjp = dbvjp) @test_throws SciMLBase.NonconformingFunctionsError DynamicalBVPFunction( dbfoop, dbciip, vjp = dbvjp) @@ -826,14 +826,14 @@ iiip(y, u, p) = y .= u * p i1(u) = u itoo(y, u, p, a) = y .= u * p -IntegralFunction(ioop) -IntegralFunction(ioop, 0.0) -IntegralFunction(iiip, Float64[]) +@inferred IntegralFunction(ioop) +@inferred IntegralFunction(ioop, 0.0) +@inferred IntegralFunction(iiip, Float64[]) @test_throws SciMLBase.IntegrandMismatchFunctionError IntegralFunction(iiip) -@test_throws SciMLBase.TooFewArgumentsError IntegralFunction(i1) -@test_throws SciMLBase.TooManyArgumentsError IntegralFunction(itoo) -@test_throws SciMLBase.TooManyArgumentsError IntegralFunction(itoo, Float64[]) +@test_throws SciMLBase.FunctionArgumentsError IntegralFunction(i1) +@test_throws SciMLBase.FunctionArgumentsError IntegralFunction(itoo) +@test_throws SciMLBase.FunctionArgumentsError IntegralFunction(itoo, Float64[]) # BatchIntegralFunction @@ -842,14 +842,14 @@ biip(y, u, p) = y .= p .* u bi1(u) = u bitoo(y, u, p, a) = y .= p .* u -BatchIntegralFunction(boop) -BatchIntegralFunction(boop, max_batch = 20) -BatchIntegralFunction(boop, Float64[]) -BatchIntegralFunction(boop, Float64[], max_batch = 20) -BatchIntegralFunction(biip, Float64[]) -BatchIntegralFunction(biip, Float64[], max_batch = 20) +@inferred BatchIntegralFunction(boop) +@inferred BatchIntegralFunction(boop, max_batch = 20) +@inferred BatchIntegralFunction(boop, Float64[]) +@inferred BatchIntegralFunction(boop, Float64[], max_batch = 20) +@inferred BatchIntegralFunction(biip, Float64[]) +@inferred BatchIntegralFunction(biip, Float64[], max_batch = 20) @test_throws SciMLBase.IntegrandMismatchFunctionError BatchIntegralFunction(biip) -@test_throws SciMLBase.TooFewArgumentsError BatchIntegralFunction(bi1) -@test_throws SciMLBase.TooManyArgumentsError BatchIntegralFunction(bitoo) -@test_throws SciMLBase.TooManyArgumentsError BatchIntegralFunction(bitoo, Float64[]) +@test_throws SciMLBase.FunctionArgumentsError BatchIntegralFunction(bi1) +@test_throws SciMLBase.FunctionArgumentsError BatchIntegralFunction(bitoo) +@test_throws SciMLBase.FunctionArgumentsError BatchIntegralFunction(bitoo, Float64[]) From 900abf39816ef8fa3dc62eb6de63187e4f1a28b1 Mon Sep 17 00:00:00 2001 From: Oscar Smith Date: Sun, 11 May 2025 22:36:30 -0400 Subject: [PATCH 2/4] fix BVPFunction --- src/scimlfunctions.jl | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/scimlfunctions.jl b/src/scimlfunctions.jl index 08f640bc5..a92225015 100644 --- a/src/scimlfunctions.jl +++ b/src/scimlfunctions.jl @@ -4339,7 +4339,8 @@ function BVPFunction{iip, specialize, twopoint}(f, bc; if iip_f jac = update_coefficients! #(J,u,p,t) else - jac = (u, p, t) -> update_coefficients!(deepcopy(jac_prototype), u, p, t) + jac_prototype_copy = deepcopy(jac_prototype) + jac = (u, p, t) -> update_coefficients!(jac_prototype_copy, u, p, t) end end @@ -4347,7 +4348,8 @@ function BVPFunction{iip, specialize, twopoint}(f, bc; if iip_bc bcjac = update_coefficients! #(J,u,p,t) else - bcjac = (u, p, t) -> update_coefficients!(deepcopy(bcjac_prototype), u, p, t) + bcjac_prototype_copy = deepcopy(bcjac_prototype) + bcjac = (u, p, t) -> update_coefficients!(bcjac_prototype_copy, u, p, t) end end From 912782ba125f2d374ad5a9772df7de72bcd775f5 Mon Sep 17 00:00:00 2001 From: Oscar Smith Date: Sun, 11 May 2025 22:39:10 -0400 Subject: [PATCH 3/4] fix DyanimalBVPFunction --- src/scimlfunctions.jl | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/scimlfunctions.jl b/src/scimlfunctions.jl index a92225015..ac3738e3b 100644 --- a/src/scimlfunctions.jl +++ b/src/scimlfunctions.jl @@ -4514,7 +4514,8 @@ function DynamicalBVPFunction{iip, specialize, twopoint}(f, bc; if iip_f jac = update_coefficients! #(J,u,p,t) else - jac = (u, p, t) -> update_coefficients!(deepcopy(jac_prototype), u, p, t) + jac_prototype_copy = deepcopy(jac_prototype) + jac = (u, p, t) -> update_coefficients!(jac_prototype_copy, u, p, t) end end @@ -4522,7 +4523,8 @@ function DynamicalBVPFunction{iip, specialize, twopoint}(f, bc; if iip_bc bcjac = update_coefficients! #(J,u,p,t) else - bcjac = (u, p, t) -> update_coefficients!(deepcopy(bcjac_prototype), u, p, t) + bcjac_prototype_copy = deepcopy(jac_prototype) + bcjac = (u, p, t) -> update_coefficients!(bcjac_prototype_copy, u, p, t) end end From 6f7e8c63f379bec94de147e6ec78dff5dbccead0 Mon Sep 17 00:00:00 2001 From: Oscar Smith Date: Sun, 11 May 2025 23:04:19 -0400 Subject: [PATCH 4/4] fix OptimizationFunction --- src/scimlfunctions.jl | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/scimlfunctions.jl b/src/scimlfunctions.jl index ac3738e3b..97eeeb10a 100644 --- a/src/scimlfunctions.jl +++ b/src/scimlfunctions.jl @@ -4199,7 +4199,10 @@ IntervalNonlinearFunction(f::IntervalNonlinearFunction; kwargs...) = f struct NoAD <: AbstractADType end (f::OptimizationFunction)(args...) = f.f(args...) -OptimizationFunction(f, args...; kwargs...) = OptimizationFunction{isinplace(f, 3)}(f, args...; kwargs...) +function OptimizationFunction(f, args...; kwargs...) + isinplace(f, 2, outofplace_param_number=2) + OptimizationFunction{true}(f, args...; kwargs...) +end function OptimizationFunction{iip}(f, adtype::AbstractADType = NoAD(); grad = nothing, fg = nothing, hess = nothing, hv = nothing, fgh = nothing, @@ -4252,7 +4255,8 @@ end # Convenience constructor function MultiObjectiveOptimizationFunction(f, args...; kwargs...) - MultiObjectiveOptimizationFunction{isinplace(f, 3)}(f, args...; kwargs...) + isinplace(f, 2, outofplace_param_number=2) + MultiObjectiveOptimizationFunction{true}(f, args...; kwargs...) end # Constructor with keyword arguments