Merge pull request #1711 from SciML/docstrings

Fix docstrings and docs

Author: ChrisRackauckas

docs/src/systems/JumpSystem.md

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

docs/src/systems/NonlinearSystem.md

@@ -38,11 +38,19 @@ jacobian_sparsity
 ## Problem Constructors
 
 ```@docs
-NonlinearProblem
+NonlinearFunction(sys::ModelingToolkit.NonlinearSystem, args...)
+NonlinearProblem(sys::ModelingToolkit.NonlinearSystem, args...)
 ```
 
 ## Torn Problem Constructors
 
 ```@docs
 BlockNonlinearProblem
 ```
+
+## Expression Constructors
+
+```@docs
+NonlinearFunctionExpr
+NonlinearProblemExpr
+```

docs/src/systems/ODESystem.md

@@ -47,14 +47,21 @@ jacobian_sparsity
 ## Standard Problem Constructors
 
 ```@docs
-ODEFunction{iip}(sys::ModelingToolkit.AbstractODESystem, args...)
-ODEProblem{iip}(sys::ModelingToolkit.AbstractODESystem, args...)
-SteadyStateFunction{iip}(sys::ModelingToolkit.AbstractODESystem, args...)
-SteadyStateProblem{iip}(sys::ModelingToolkit.AbstractODESystem, args...)
+ODEFunction(sys::ModelingToolkit.AbstractODESystem, args...)
+ODEProblem(sys::ModelingToolkit.AbstractODESystem, args...)
+SteadyStateProblem(sys::ModelingToolkit.AbstractODESystem, args...)
 ```
 
 ## Torn Problem Constructors
 
 ```@docs
-ODAEProblem{iip}(sys::ModelingToolkit.AbstractODESystem, args...)
+ODAEProblem(sys::ModelingToolkit.AbstractODESystem, args...)
+```
+
+## Expression Constructors
+
+```@docs
+ODEFunctionExpr
+DAEFunctionExpr
+SteadyStateProblemExpr
 ```

docs/src/systems/OptimizationSystem.md

@@ -29,5 +29,11 @@ hessian_sparsity
 ## Problem Constructors
 
 ```@docs
-OptimizationProblem
+OptimizationProblem(sys::ModelingToolkit.OptimizationSystem, args...)
+```
+
+## Expression Constructors
+
+```@docs
+OptimizationProblemExpr
 ```

docs/src/systems/SDESystem.md

@@ -44,6 +44,13 @@ jacobian_sparsity
 ## Problem Constructors
 
 ```@docs
-SDEFunction
-SDEProblem
+SDEFunction(sys::ModelingToolkit.SDESystem, args...)
+SDEProblem(sys::ModelingToolkit.SDESystem, args...)
+```
+
+## Expression Constructors
+
+```@docs
+SDEFunctionExpr
+SDEProblemExpr
 ```

src/systems/diffeqs/abstractodesystem.jl

@@ -230,12 +230,6 @@ function isautonomous(sys::AbstractODESystem)
     all(iszero, tgrad)
 end
 
-for F in [:ODEFunction, :DAEFunction]
-    @eval function DiffEqBase.$F(sys::AbstractODESystem, args...; kwargs...)
-        $F{true}(sys, args...; kwargs...)
-    end
-end
-
 """
 ```julia
 function DiffEqBase.ODEFunction{iip}(sys::AbstractODESystem, dvs = states(sys),
@@ -250,6 +244,10 @@ Create an `ODEFunction` from the [`ODESystem`](@ref). The arguments `dvs` and `p
 are used to set the order of the dependent variable and parameter vectors,
 respectively.
 """
+function DiffEqBase.ODEFunction(sys::AbstractODESystem, args...; kwargs...)
+    ODEFunction{true}(sys, args...; kwargs...)
+end
+
 function DiffEqBase.ODEFunction{iip}(sys::AbstractODESystem, dvs = states(sys),
                                      ps = parameters(sys), u0 = nothing;
                                      version = nothing, tgrad = false,
@@ -365,6 +363,10 @@ Create an `DAEFunction` from the [`ODESystem`](@ref). The arguments `dvs` and
 `ps` are used to set the order of the dependent variable and parameter vectors,
 respectively.
 """
+function DiffEqBase.DAEFunction(sys::AbstractODESystem, args...; kwargs...)
+    DAEFunction{true}(sys, args...; kwargs...)
+end
+
 function DiffEqBase.DAEFunction{iip}(sys::AbstractODESystem, dvs = states(sys),
                                      ps = parameters(sys), u0 = nothing;
                                      ddvs = map(diff2term ∘ Differential(get_iv(sys)), dvs),
@@ -606,12 +608,6 @@ function DAEFunctionExpr(sys::AbstractODESystem, args...; kwargs...)
     DAEFunctionExpr{true}(sys, args...; kwargs...)
 end
 
-for P in [:ODEProblem, :DAEProblem]
-    @eval function DiffEqBase.$P(sys::AbstractODESystem, args...; kwargs...)
-        $P{true}(sys, args...; kwargs...)
-    end
-end
-
 """
 ```julia
 function DiffEqBase.ODEProblem{iip}(sys::AbstractODESystem,u0map,tspan,
@@ -627,6 +623,10 @@ function DiffEqBase.ODEProblem{iip}(sys::AbstractODESystem,u0map,tspan,
 Generates an ODEProblem from an ODESystem and allows for automatically
 symbolically calculating numerical enhancements.
 """
+function DiffEqBase.ODEProblem(sys::AbstractODESystem, args...; kwargs...)
+    ODEProblem{true}(sys, args...; kwargs...)
+end
+
 function DiffEqBase.ODEProblem{iip}(sys::AbstractODESystem, u0map, tspan,
                                     parammap = DiffEqBase.NullParameters();
                                     callback = nothing,
@@ -660,6 +660,10 @@ function DiffEqBase.DAEProblem{iip}(sys::AbstractODESystem,du0map,u0map,tspan,
 Generates an DAEProblem from an ODESystem and allows for automatically
 symbolically calculating numerical enhancements.
 """
+function DiffEqBase.DAEProblem(sys::AbstractODESystem, args...; kwargs...)
+    DAEProblem{true}(sys, args...; kwargs...)
+end
+
 function DiffEqBase.DAEProblem{iip}(sys::AbstractODESystem, du0map, u0map, tspan,
                                     parammap = DiffEqBase.NullParameters();
                                     check_length = true, kwargs...) where {iip}
@@ -774,11 +778,6 @@ function DAEProblemExpr(sys::AbstractODESystem, args...; kwargs...)
     DAEProblemExpr{true}(sys, args...; kwargs...)
 end
 
-### Enables Steady State Problems ###
-function DiffEqBase.SteadyStateProblem(sys::AbstractODESystem, args...; kwargs...)
-    SteadyStateProblem{true}(sys, args...; kwargs...)
-end
-
 """
 ```julia
 function DiffEqBase.SteadyStateProblem(sys::AbstractODESystem,u0map,
@@ -792,6 +791,10 @@ 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...)
+    SteadyStateProblem{true}(sys, args...; kwargs...)
+end
+
 function DiffEqBase.SteadyStateProblem{iip}(sys::AbstractODESystem, u0map,
                                             parammap = DiffEqBase.NullParameters();
                                             check_length = true, kwargs...) where {iip}

src/systems/diffeqs/sdesystem.jl

@@ -313,17 +313,6 @@ function Girsanov_transform(sys::SDESystem, u; θ0 = 1.0)
               name = name, checks = false)
 end
 
-"""
-```julia
-function DiffEqBase.SDEFunction{iip}(sys::SDESystem, dvs = sys.states, ps = sys.ps;
-                                     version = nothing, tgrad=false, sparse = false,
-                                     jac = false, Wfact = false, kwargs...) where {iip}
-```
-
-Create an `SDEFunction` from the [`SDESystem`](@ref). The arguments `dvs` and `ps`
-are used to set the order of the dependent variable and parameter vectors,
-respectively.
-"""
 function DiffEqBase.SDEFunction{iip}(sys::SDESystem, dvs = states(sys),
                                      ps = parameters(sys),
                                      u0 = nothing;
@@ -409,6 +398,17 @@ function DiffEqBase.SDEFunction{iip}(sys::SDESystem, dvs = states(sys),
                      observed = observedfun)
 end
 
+"""
+```julia
+function DiffEqBase.SDEFunction{iip}(sys::SDESystem, dvs = sys.states, ps = sys.ps;
+                                     version = nothing, tgrad=false, sparse = false,
+                                     jac = false, Wfact = false, kwargs...) where {iip}
+```
+
+Create an `SDEFunction` from the [`SDESystem`](@ref). The arguments `dvs` and `ps`
+are used to set the order of the dependent variable and parameter vectors,
+respectively.
+"""
 function DiffEqBase.SDEFunction(sys::SDESystem, args...; kwargs...)
     SDEFunction{true}(sys, args...; kwargs...)
 end
@@ -488,21 +488,6 @@ function SDEFunctionExpr(sys::SDESystem, args...; kwargs...)
     SDEFunctionExpr{true}(sys, args...; kwargs...)
 end
 
-"""
-```julia
-function DiffEqBase.SDEProblem{iip}(sys::SDESystem,u0map,tspan,p=parammap;
-                                    version = nothing, tgrad=false,
-                                    jac = false, Wfact = false,
-                                    checkbounds = false, sparse = false,
-                                    sparsenoise = sparse,
-                                    skipzeros = true, fillzeros = true,
-                                    linenumbers = true, parallel=SerialForm(),
-                                    kwargs...)
-```
-
-Generates an SDEProblem from an SDESystem and allows for automatically
-symbolically calculating numerical enhancements.
-"""
 function DiffEqBase.SDEProblem{iip}(sys::SDESystem, u0map, tspan,
                                     parammap = DiffEqBase.NullParameters();
                                     sparsenoise = nothing, check_length = true,
@@ -525,6 +510,21 @@ function DiffEqBase.SDEProblem{iip}(sys::SDESystem, u0map, tspan,
                     kwargs...)
 end
 
+"""
+```julia
+function DiffEqBase.SDEProblem{iip}(sys::SDESystem,u0map,tspan,p=parammap;
+                                    version = nothing, tgrad=false,
+                                    jac = false, Wfact = false,
+                                    checkbounds = false, sparse = false,
+                                    sparsenoise = sparse,
+                                    skipzeros = true, fillzeros = true,
+                                    linenumbers = true, parallel=SerialForm(),
+                                    kwargs...)
+```
+
+Generates an SDEProblem from an SDESystem and allows for automatically
+symbolically calculating numerical enhancements.
+"""
 function DiffEqBase.SDEProblem(sys::SDESystem, args...; kwargs...)
     SDEProblem{true}(sys, args...; kwargs...)
 end

src/systems/nonlinear/nonlinearsystem.jl

@@ -181,10 +181,6 @@ function hessian_sparsity(sys::NonlinearSystem)
                       states(sys)) for eq in equations(sys)]
 end
 
-function DiffEqBase.NonlinearFunction(sys::NonlinearSystem, args...; kwargs...)
-    NonlinearFunction{true}(sys, args...; kwargs...)
-end
-
 """
 ```julia
 function DiffEqBase.NonlinearFunction{iip}(sys::NonlinearSystem, dvs = states(sys),
@@ -199,6 +195,10 @@ 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...)
+    NonlinearFunction{true}(sys, args...; kwargs...)
+end
+
 function DiffEqBase.NonlinearFunction{iip}(sys::NonlinearSystem, dvs = states(sys),
                                            ps = parameters(sys), u0 = nothing;
                                            version = nothing,
@@ -315,10 +315,6 @@ function process_NonlinearProblem(constructor, sys::NonlinearSystem, u0map, para
     return f, u0, p
 end
 
-function DiffEqBase.NonlinearProblem(sys::NonlinearSystem, args...; kwargs...)
-    NonlinearProblem{true}(sys, args...; kwargs...)
-end
-
 """
 ```julia
 function DiffEqBase.NonlinearProblem{iip}(sys::NonlinearSystem,u0map,
@@ -332,6 +328,10 @@ function DiffEqBase.NonlinearProblem{iip}(sys::NonlinearSystem,u0map,
 Generates an NonlinearProblem from a NonlinearSystem and allows for automatically
 symbolically calculating numerical enhancements.
 """
+function DiffEqBase.NonlinearProblem(sys::NonlinearSystem, args...; kwargs...)
+    NonlinearProblem{true}(sys, args...; kwargs...)
+end
+
 function DiffEqBase.NonlinearProblem{iip}(sys::NonlinearSystem, u0map,
                                           parammap = DiffEqBase.NullParameters();
                                           check_length = true, kwargs...) where {iip}

src/systems/optimization/optimizationsystem.jl

@@ -126,10 +126,6 @@ namespace_expr(sys::OptimizationSystem) = namespace_expr(get_op(sys), sys)
 
 hessian_sparsity(sys::OptimizationSystem) = hessian_sparsity(get_op(sys), states(sys))
 
-function DiffEqBase.OptimizationProblem(sys::OptimizationSystem, args...; kwargs...)
-    DiffEqBase.OptimizationProblem{true}(sys::OptimizationSystem, args...; kwargs...)
-end
-
 function rep_pars_vals!(e::Expr, p)
     rep_pars_vals!.(e.args, Ref(p))
     replace!(e.args, p...)
@@ -152,6 +148,10 @@ function DiffEqBase.OptimizationProblem{iip}(sys::OptimizationSystem,u0map,
 Generates an OptimizationProblem from an OptimizationSystem and allows for automatically
 symbolically calculating numerical enhancements.
 """
+function DiffEqBase.OptimizationProblem(sys::OptimizationSystem, args...; kwargs...)
+    DiffEqBase.OptimizationProblem{true}(sys::OptimizationSystem, args...; kwargs...)
+end
+
 function DiffEqBase.OptimizationProblem{iip}(sys::OptimizationSystem, u0map,
                                              parammap = DiffEqBase.NullParameters();
                                              lb = nothing, ub = nothing,