Merge pull request #1712 from SciML/docstrings

fix some more docstrings

Author: ChrisRackauckas

docs/src/systems/JumpSystem.md

@@ -24,6 +24,6 @@ structural_simplify
 ## Problem Constructors
 
 ```@docs
-DiscreteProblem(::JumpSystem,args...)
-JumpProblem(::JumpSystem,args...)
+SciMLBase.DiscreteProblem(sys::JumpSystem,args...)
+JumpProcesses.JumpProblem(sys::JumpSystem,args...)
 ```

src/ModelingToolkit.jl

@@ -160,11 +160,12 @@ export AbstractTimeDependentSystem, AbstractTimeIndependentSystem,
        AbstractMultivariateSystem
 export ODESystem, ODEFunction, ODEFunctionExpr, ODEProblemExpr, convert_system
 export DAEFunctionExpr, DAEProblemExpr
-export SDESystem, SDEFunction, SDEFunctionExpr, SDESystemExpr
+export SDESystem, SDEFunction, SDEFunctionExpr, SDEProblemExpr
 export SystemStructure
 export JumpSystem
 export ODEProblem, SDEProblem
-export NonlinearProblem, NonlinearProblemExpr
+export NonlinearFunction, NonlinearFunctionExpr
+export NonlinearProblem, BlockNonlinearProblem, NonlinearProblemExpr
 export OptimizationProblem, OptimizationProblemExpr
 export AutoModelingToolkit
 export SteadyStateProblem, SteadyStateProblemExpr

src/structural_transformation/codegen.jl

@@ -484,10 +484,6 @@ function build_observed_function(state, ts, var_eq_matching, var_sccs,
     expression ? ex : @RuntimeGeneratedFunction(ex)
 end
 
-struct ODAEProblem{iip} end
-
-ODAEProblem(args...; kw...) = ODAEProblem{true}(args...; kw...)
-
 """
     ODAEProblem{iip}(sys, u0map, tspan, parammap = DiffEqBase.NullParameters(); kw...)
 
@@ -497,9 +493,15 @@ already been applied to them.
 In these cases, the constructor uses the knowledge of the strongly connected
 components calculated during the process of simplification as the basis for
 building pre-simplified nonlinear systems in the implicit solving.
+
 In summary: these problems are structurally modified, but could be
-more efficient and more stable. Note, the returned object is still of type [`ODEProblem`](@ref).
+more efficient and more stable. Note, the returned object is still of type
+[`ODEProblem`](@ref).
 """
+struct ODAEProblem{iip} end
+
+ODAEProblem(args...; kw...) = ODAEProblem{true}(args...; kw...)
+
 function ODAEProblem{iip}(sys,
                           u0map,
                           tspan,

src/systems/diffeqs/abstractodesystem.jl

@@ -657,7 +657,7 @@ function DiffEqBase.DAEProblem{iip}(sys::AbstractODESystem,du0map,u0map,tspan,
                                     kwargs...) where iip
 ```
 
-Generates an DAEProblem from an ODESystem and allows for automatically
+Generates a DAEProblem from an ODESystem and allows for automatically
 symbolically calculating numerical enhancements.
 """
 function DiffEqBase.DAEProblem(sys::AbstractODESystem, args...; kwargs...)
@@ -742,7 +742,7 @@ function DAEProblemExpr{iip}(sys::AbstractODESystem,u0map,tspan,
                                     kwargs...) where iip
 ```
 
-Generates a Julia expression for constructing an ODEProblem from an
+Generates a Julia expression for constructing a DAEProblem from an
 ODESystem and allows for automatically symbolically calculating
 numerical enhancements.
 """
@@ -780,7 +780,7 @@ end
 
 """
 ```julia
-function DiffEqBase.SteadyStateProblem(sys::AbstractODESystem,u0map,
+function SciMLBase.SteadyStateProblem(sys::AbstractODESystem,u0map,
                                     parammap=DiffEqBase.NullParameters();
                                     version = nothing, tgrad=false,
                                     jac = false,
@@ -791,12 +791,12 @@ function DiffEqBase.SteadyStateProblem(sys::AbstractODESystem,u0map,
 Generates an SteadyStateProblem from an ODESystem and allows for automatically
 symbolically calculating numerical enhancements.
 """
-function DiffEqBase.SteadyStateProblem(sys::AbstractODESystem, args...; kwargs...)
+function SciMLBase.SteadyStateProblem(sys::AbstractODESystem, args...; kwargs...)
     SteadyStateProblem{true}(sys, args...; kwargs...)
 end
 
 function DiffEqBase.SteadyStateProblem{iip}(sys::AbstractODESystem, u0map,
-                                            parammap = DiffEqBase.NullParameters();
+                                            parammap = SciMLBase.NullParameters();
                                             check_length = true, kwargs...) where {iip}
     f, u0, p = process_DEProblem(ODEFunction{iip}, sys, u0map, parammap;
                                  steady_state = true,
@@ -807,7 +807,7 @@ end
 
 """
 ```julia
-function DiffEqBase.SteadyStateProblemExpr(sys::AbstractODESystem,u0map,
+function SciMLBase.SteadyStateProblemExpr(sys::AbstractODESystem,u0map,
                                     parammap=DiffEqBase.NullParameters();
                                     version = nothing, tgrad=false,
                                     jac = false,
@@ -823,7 +823,7 @@ numerical enhancements.
 struct SteadyStateProblemExpr{iip} end
 
 function SteadyStateProblemExpr{iip}(sys::AbstractODESystem, u0map,
-                                     parammap = DiffEqBase.NullParameters();
+                                     parammap = SciMLBase.NullParameters();
                                      check_length = true,
                                      kwargs...) where {iip}
     f, u0, p = process_DEProblem(ODEFunctionExpr{iip}, sys, u0map, parammap;

src/systems/discrete_system/discrete_system.jl

@@ -172,12 +172,12 @@ end
 
 Generates an DiscreteProblem from an DiscreteSystem.
 """
-function DiffEqBase.DiscreteProblem(sys::DiscreteSystem, u0map, tspan,
-                                    parammap = DiffEqBase.NullParameters();
-                                    eval_module = @__MODULE__,
-                                    eval_expression = true,
-                                    use_union = false,
-                                    kwargs...)
+function SciMLBase.DiscreteProblem(sys::DiscreteSystem, u0map, tspan,
+                                   parammap = SciMLBase.NullParameters();
+                                   eval_module = @__MODULE__,
+                                   eval_expression = true,
+                                   use_union = false,
+                                   kwargs...)
     dvs = states(sys)
     ps = parameters(sys)
     eqs = equations(sys)

src/systems/nonlinear/nonlinearsystem.jl

@@ -183,7 +183,7 @@ end
 
 """
 ```julia
-function DiffEqBase.NonlinearFunction{iip}(sys::NonlinearSystem, dvs = states(sys),
+function SciMLBase.NonlinearFunction{iip}(sys::NonlinearSystem, dvs = states(sys),
                                      ps = parameters(sys);
                                      version = nothing,
                                      jac = false,
@@ -195,17 +195,17 @@ Create an `NonlinearFunction` from the [`NonlinearSystem`](@ref). The arguments
 `dvs` and `ps` are used to set the order of the dependent variable and parameter
 vectors, respectively.
 """
-function DiffEqBase.NonlinearFunction(sys::NonlinearSystem, args...; kwargs...)
+function SciMLBase.NonlinearFunction(sys::NonlinearSystem, args...; kwargs...)
     NonlinearFunction{true}(sys, args...; kwargs...)
 end
 
-function DiffEqBase.NonlinearFunction{iip}(sys::NonlinearSystem, dvs = states(sys),
-                                           ps = parameters(sys), u0 = nothing;
-                                           version = nothing,
-                                           jac = false,
-                                           eval_expression = true,
-                                           sparse = false, simplify = false,
-                                           kwargs...) where {iip}
+function SciMLBase.NonlinearFunction{iip}(sys::NonlinearSystem, dvs = states(sys),
+                                          ps = parameters(sys), u0 = nothing;
+                                          version = nothing,
+                                          jac = false,
+                                          eval_expression = true,
+                                          sparse = false, simplify = false,
+                                          kwargs...) where {iip}
     f_gen = generate_function(sys, dvs, ps; expression = Val{eval_expression}, kwargs...)
     f_oop, f_iip = eval_expression ? (@RuntimeGeneratedFunction(ex) for ex in f_gen) : f_gen
     f(u, p) = f_oop(u, p)
@@ -242,7 +242,7 @@ end
 
 """
 ```julia
-function DiffEqBase.NonlinearFunctionExpr{iip}(sys::NonlinearSystem, dvs = states(sys),
+function SciMLBase.NonlinearFunctionExpr{iip}(sys::NonlinearSystem, dvs = states(sys),
                                      ps = parameters(sys);
                                      version = nothing,
                                      jac = false,