add AbstractProblemType

Author: prbzrg

src/SciMLBase.jl

@@ -688,6 +688,8 @@ include("operators/common_defaults.jl")
 include("symbolic_utils.jl")
 include("performance_warnings.jl")
 
+abstract type AbstractProblemType end
+
 include("problems/discrete_problems.jl")
 include("problems/implicit_discrete_problems.jl")
 include("problems/steady_state_problems.jl")

src/problems/basic_problems.jl

@@ -60,7 +60,7 @@ struct LinearProblem{uType, isinplace, F, bType, P, K} <:
     p::P
     kwargs::K
     @add_kwonly function LinearProblem{iip}(A, b, p = NullParameters(); u0 = nothing,
-        kwargs...) where {iip}
+            kwargs...) where {iip}
         warn_paramtype(p)
         new{typeof(u0), iip, typeof(A), typeof(b), typeof(p), typeof(kwargs)}(A, b, u0, p,
             kwargs)
@@ -82,7 +82,7 @@ TruncatedStacktraces.@truncate_stacktrace LinearProblem 1
 """
 $(TYPEDEF)
 """
-struct StandardNonlinearProblem end
+struct StandardNonlinearProblem <: AbstractProblemType end
 
 @doc doc"""
 
@@ -134,20 +134,20 @@ every solve call.
 * `p`: The parameters for the problem. Defaults to `NullParameters`.
 * `kwargs`: The keyword arguments passed on to the solvers.
 """
-struct IntervalNonlinearProblem{isinplace, tType, P, F, K, PT} <:
+struct IntervalNonlinearProblem{isinplace, tType, P, F, K, PT <: AbstractProblemType} <:
        AbstractIntervalNonlinearProblem{nothing, isinplace}
     f::F
     tspan::tType
     p::P
     problem_type::PT
     kwargs::K
     @add_kwonly function IntervalNonlinearProblem{iip}(f::AbstractIntervalNonlinearFunction{
-            iip,
-        },
-        tspan,
-        p = NullParameters(),
-        problem_type = StandardNonlinearProblem();
-        kwargs...) where {iip}
+                iip,
+            },
+            tspan,
+            p = NullParameters(),
+            problem_type = StandardNonlinearProblem();
+            kwargs...) where {iip}
         warn_paramtype(p)
         new{iip, typeof(tspan), typeof(p), typeof(f),
             typeof(kwargs), typeof(problem_type)}(f,
@@ -177,7 +177,7 @@ Define a nonlinear problem using an instance of
 [`IntervalNonlinearFunction`](@ref IntervalNonlinearFunction).
 """
 function IntervalNonlinearProblem(f::AbstractIntervalNonlinearFunction, tspan,
-    p = NullParameters(); kwargs...)
+        p = NullParameters(); kwargs...)
     IntervalNonlinearProblem{isinplace(f)}(f, tspan, p; kwargs...)
 end
 
@@ -233,17 +233,17 @@ page.
 * `p`: The parameters for the problem. Defaults to `NullParameters`.
 * `kwargs`: The keyword arguments passed on to the solvers.
 """
-struct NonlinearProblem{uType, isinplace, P, F, K, PT} <:
+struct NonlinearProblem{uType, isinplace, P, F, K, PT <: AbstractProblemType} <:
        AbstractNonlinearProblem{uType, isinplace}
     f::F
     u0::uType
     p::P
     problem_type::PT
     kwargs::K
     @add_kwonly function NonlinearProblem{iip}(f::AbstractNonlinearFunction{iip}, u0,
-        p = NullParameters(),
-        problem_type = StandardNonlinearProblem();
-        kwargs...) where {iip}
+            p = NullParameters(),
+            problem_type = StandardNonlinearProblem();
+            kwargs...) where {iip}
         warn_paramtype(p)
         new{typeof(u0), iip, typeof(p), typeof(f),
             typeof(kwargs), typeof(problem_type)}(f,
@@ -364,7 +364,7 @@ struct NonlinearLeastSquaresProblem{uType, isinplace, P, F, K} <:
     kwargs::K
 
     @add_kwonly function NonlinearLeastSquaresProblem{iip}(f::AbstractNonlinearFunction{
-            iip}, u0, p = NullParameters(); kwargs...) where {iip}
+                iip}, u0, p = NullParameters(); kwargs...) where {iip}
         warn_paramtype(p)
         return new{typeof(u0), iip, typeof(p), typeof(f), typeof(kwargs)}(f, u0, p, kwargs)
     end
@@ -383,7 +383,7 @@ Define a nonlinear least squares problem using an instance of
 [`AbstractNonlinearFunction`](@ref AbstractNonlinearFunction).
 """
 function NonlinearLeastSquaresProblem(f::AbstractNonlinearFunction, u0,
-    p = NullParameters(); kwargs...)
+        p = NullParameters(); kwargs...)
     return NonlinearLeastSquaresProblem{isinplace(f)}(f, u0, p; kwargs...)
 end
 
@@ -445,8 +445,8 @@ struct IntegralProblem{isinplace, P, F, T, K} <: AbstractIntegralProblem{isinpla
     p::P
     kwargs::K
     @add_kwonly function IntegralProblem{iip}(f::AbstractIntegralFunction{iip}, domain,
-        p = NullParameters();
-        kwargs...) where {iip}
+            p = NullParameters();
+            kwargs...) where {iip}
         warn_paramtype(p)
         new{iip, typeof(p), typeof(f), typeof(domain), typeof(kwargs)}(f,
             domain, p, kwargs)
@@ -456,38 +456,40 @@ end
 TruncatedStacktraces.@truncate_stacktrace IntegralProblem 1 4
 
 function IntegralProblem(f::AbstractIntegralFunction,
-    domain,
-    p = NullParameters();
-    kwargs...)
+        domain,
+        p = NullParameters();
+        kwargs...)
     IntegralProblem{isinplace(f)}(f, domain, p; kwargs...)
 end
 
 function IntegralProblem(f::AbstractIntegralFunction,
-    lb::B,
-    ub::B,
-    p = NullParameters();
-    kwargs...) where {B}
+        lb::B,
+        ub::B,
+        p = NullParameters();
+        kwargs...) where {B}
     IntegralProblem{isinplace(f)}(f, (lb, ub), p; kwargs...)
 end
 
 function IntegralProblem(f, args...; nout = nothing, batch = nothing, kwargs...)
     if nout !== nothing || batch !== nothing
-       @warn "`nout` and `batch` keywords are deprecated in favor of inplace `IntegralFunction`s or `BatchIntegralFunction`s. See the updated Integrals.jl documentation for details."
+        @warn "`nout` and `batch` keywords are deprecated in favor of inplace `IntegralFunction`s or `BatchIntegralFunction`s. See the updated Integrals.jl documentation for details."
     end
 
     g = if isinplace(f, 3)
         if batch === nothing
-            output_prototype = nout === nothing ? Array{Float64, 0}(undef) : Vector{Float64}(undef, nout)
+            output_prototype = nout === nothing ? Array{Float64, 0}(undef) :
+                               Vector{Float64}(undef, nout)
             IntegralFunction(f, output_prototype)
         else
-            output_prototype = nout === nothing ? Float64[] : Matrix{Float64}(undef, nout, 0)
-            BatchIntegralFunction(f, output_prototype, max_batch=batch)
+            output_prototype = nout === nothing ? Float64[] :
+                               Matrix{Float64}(undef, nout, 0)
+            BatchIntegralFunction(f, output_prototype, max_batch = batch)
         end
     else
         if batch === nothing
             IntegralFunction(f)
         else
-            BatchIntegralFunction(f, max_batch=batch)
+            BatchIntegralFunction(f, max_batch = batch)
         end
     end
     IntegralProblem(g, args...; kwargs...)
@@ -506,7 +508,7 @@ function Base.getproperty(prob::IntegralProblem, name::Symbol)
     return Base.getfield(prob, name)
 end
 
-struct QuadratureProblem end
+struct QuadratureProblem <: AbstractProblemType end
 @deprecate QuadratureProblem(args...; kwargs...) IntegralProblem(args...; kwargs...)
 
 @doc doc"""
@@ -548,8 +550,8 @@ struct SampledIntegralProblem{Y, X, K} <: AbstractIntegralProblem{false}
     dim::Int
     kwargs::K
     @add_kwonly function SampledIntegralProblem(y::AbstractArray, x::AbstractVector;
-        dim = ndims(y),
-        kwargs...)
+            dim = ndims(y),
+            kwargs...)
         @assert dim<=ndims(y) "The integration dimension `dim` is larger than the number of dimensions of the integrand `y`"
         @assert length(x)==size(y, dim) "The integrand `y` must have the same length as the sampling points `x` along the integrated dimension."
         @assert axes(x, 1)==axes(y, dim) "The integrand `y` must obey the same indexing as the sampling points `x` along the integrated dimension."
@@ -612,8 +614,8 @@ They should be an `AbstractArray` matching the geometry of `u`, where `(lcons[i]
 are the lower and upper bounds for `cons[i]`.
 
 The `f` in the `OptimizationProblem` should typically be an instance of [`OptimizationFunction`](@ref)
-to specify the objective function and its derivatives either by passing 
-predefined functions for them or automatically generated using the [`ADType`](@ref). 
+to specify the objective function and its derivatives either by passing
+predefined functions for them or automatically generated using the [`ADType`](@ref).
 
 If `f` is a standard Julia function, it is automatically transformed into an
 `OptimizationFunction` with `NoAD()`, meaning the derivative functions are not
@@ -663,10 +665,10 @@ struct OptimizationProblem{iip, F, uType, P, LB, UB, I, LC, UC, S, K} <:
     sense::S
     kwargs::K
     @add_kwonly function OptimizationProblem{iip}(f::OptimizationFunction{iip}, u0,
-        p = NullParameters();
-        lb = nothing, ub = nothing, int = nothing,
-        lcons = nothing, ucons = nothing,
-        sense = nothing, kwargs...) where {iip}
+            p = NullParameters();
+            lb = nothing, ub = nothing, int = nothing,
+            lcons = nothing, ucons = nothing,
+            sense = nothing, kwargs...) where {iip}
         if xor(lb === nothing, ub === nothing)
             error("If any of `lb` or `ub` is provided, both must be provided.")
         end
@@ -688,14 +690,18 @@ function OptimizationProblem(f, args...; kwargs...)
     OptimizationProblem{true}(OptimizationFunction{true}(f), args...; kwargs...)
 end
 
-function OptimizationFunction(f::NonlinearFunction, adtype::AbstractADType = NoAD(); kwargs...)
+function OptimizationFunction(f::NonlinearFunction,
+        adtype::AbstractADType = NoAD();
+        kwargs...)
     if isinplace(f)
         throw(ArgumentError("Converting NonlinearFunction to OptimizationFunction is not supported with in-place functions yet."))
     end
     OptimizationFunction((u, p) -> sum(abs2, f(u, p)), adtype; kwargs...)
 end
 
-function OptimizationProblem(prob::NonlinearLeastSquaresProblem, adtype::AbstractADType = NoAD(); kwargs...)
+function OptimizationProblem(prob::NonlinearLeastSquaresProblem,
+        adtype::AbstractADType = NoAD();
+        kwargs...)
     if isinplace(prob)
         throw(ArgumentError("Converting NonlinearLeastSquaresProblem to OptimizationProblem is not supported with in-place functions yet."))
     end

src/problems/bvp_problems.jl

@@ -1,7 +1,7 @@
 """
 $(TYPEDEF)
 """
-struct StandardBVProblem end
+struct StandardBVProblem <: AbstractProblemType end
 
 """
 $(TYPEDEF)
@@ -105,7 +105,7 @@ every solve call.
 * `p`: The parameters for the problem. Defaults to `NullParameters`
 * `kwargs`: The keyword arguments passed onto the solves.
 """
-struct BVProblem{uType, tType, isinplace, P, F, PT, K} <:
+struct BVProblem{uType, tType, isinplace, P, F, PT <: AbstractProblemType, K} <:
        AbstractBVProblem{uType, tType, isinplace}
     f::F
     u0::uType
@@ -115,7 +115,7 @@ struct BVProblem{uType, tType, isinplace, P, F, PT, K} <:
     kwargs::K
 
     @add_kwonly function BVProblem{iip}(f::AbstractBVPFunction{iip, TP}, u0, tspan,
-        p = NullParameters(); problem_type=nothing, kwargs...) where {iip, TP}
+            p = NullParameters(); problem_type = nothing, kwargs...) where {iip, TP}
         _u0 = prepare_initial_state(u0)
         _tspan = promote_tspan(tspan)
         warn_paramtype(p)
@@ -124,10 +124,15 @@ struct BVProblem{uType, tType, isinplace, P, F, PT, K} <:
         if problem_type === nothing
             problem_type = prob_type
         else
-            @assert prob_type === problem_type "This indicates incorrect problem type specification! Users should never pass in `problem_type` kwarg, this exists exclusively for internal use."
+            @assert prob_type===problem_type "This indicates incorrect problem type specification! Users should never pass in `problem_type` kwarg, this exists exclusively for internal use."
         end
         return new{typeof(_u0), typeof(_tspan), iip, typeof(p), typeof(f),
-            typeof(problem_type), typeof(kwargs)}(f, _u0, _tspan, p, problem_type, kwargs)
+            typeof(problem_type), typeof(kwargs)}(f,
+            _u0,
+            _tspan,
+            p,
+            problem_type,
+            kwargs)
     end
 
     function BVProblem{iip}(f, bc, u0, tspan, p = NullParameters(); kwargs...) where {iip}
@@ -158,34 +163,34 @@ end
 end
 
 function TwoPointBVProblem{iip}(f, bc, u0, tspan, p = NullParameters();
-    bcresid_prototype=nothing, kwargs...) where {iip}
+        bcresid_prototype = nothing, kwargs...) where {iip}
     return TwoPointBVProblem(TwoPointBVPFunction{iip}(f, bc; bcresid_prototype), u0, tspan,
         p; kwargs...)
 end
 function TwoPointBVProblem(f, bc, u0, tspan, p = NullParameters();
-    bcresid_prototype=nothing, kwargs...)
+        bcresid_prototype = nothing, kwargs...)
     return TwoPointBVProblem(TwoPointBVPFunction(f, bc; bcresid_prototype), u0, tspan, p;
         kwargs...)
 end
 function TwoPointBVProblem{iip}(f::AbstractBVPFunction{iip, twopoint}, u0, tspan,
-    p = NullParameters(); kwargs...) where {iip, twopoint}
+        p = NullParameters(); kwargs...) where {iip, twopoint}
     @assert twopoint "`TwoPointBVProblem` can only be used with a `TwoPointBVPFunction`. Instead of using `BVPFunction`, use `TwoPointBVPFunction` or pass a kwarg `twopoint=Val(true)` during the construction of the `BVPFunction`."
     return BVProblem{iip}(f, u0, tspan, p; kwargs...)
 end
 function TwoPointBVProblem(f::AbstractBVPFunction{iip, twopoint}, u0, tspan,
-    p = NullParameters(); kwargs...) where {iip, twopoint}
+        p = NullParameters(); kwargs...) where {iip, twopoint}
     @assert twopoint "`TwoPointBVProblem` can only be used with a `TwoPointBVPFunction`. Instead of using `BVPFunction`, use `TwoPointBVPFunction` or pass a kwarg `twopoint=Val(true)` during the construction of the `BVPFunction`."
     return BVProblem{iip}(f, u0, tspan, p; kwargs...)
 end
 
 # Allow previous timeseries solution
 function TwoPointBVProblem(f::AbstractODEFunction, bc, sol::T, tspan::Tuple,
-    p = NullParameters(); kwargs...) where {T <: AbstractTimeseriesSolution}
+        p = NullParameters(); kwargs...) where {T <: AbstractTimeseriesSolution}
     return TwoPointBVProblem(f, bc, sol.u, tspan, p; kwargs...)
 end
 # Allow initial guess function for the initial guess
 function TwoPointBVProblem(f::AbstractODEFunction, bc, initialGuess, tspan::AbstractVector,
-    p = NullParameters(); kwargs...)
+        p = NullParameters(); kwargs...)
     u0 = [initialGuess(i) for i in tspan]
     return TwoPointBVProblem(f, bc, u0, (tspan[1], tspan[end]), p; kwargs...)
 end