big doc update

Author: ChrisRackauckas

docs/src/assets/favicon.ico

@@ -98,6 +98,7 @@ include("build_function.jl")
 
 export ODESystem, ODEFunction
 export SDESystem, SDEFunction
+export ODEProblem, SDEProblem, NonlinearProblem, OptimizationProblem
 export NonlinearSystem, OptimizationSystem
 export ode_order_lowering
 export PDESystem
@@ -111,10 +112,12 @@ export Operation, Expression, Variable
 export calculate_jacobian, generate_jacobian, generate_function
 export calculate_tgrad, generate_tgrad
 export calculate_gradient, generate_gradient
+export calculate_factorized_W, generate_factorized_W
 export calculate_hessian, generate_hessian
 export calculate_massmatrix, generate_diffusion_function
 export independent_variable, states, parameters, equations
-export simplified_expr
+export simplified_expr, rename, get_variables, substitute_expr!
+export build_function
 export @register
 export modelingtoolkitize
 export @variables, @parameters

src/ModelingToolkit.jl

@@ -1,5 +1,7 @@
 """
+```julia
 calculate_tgrad(sys::AbstractSystem)
+```
 
 Calculate the time gradient of a system.
 
@@ -9,7 +11,9 @@ call will be cached in the system object.
 function calculate_tgrad end
 
 """
+```julia
 calculate_gradient(sys::AbstractSystem)
+```
 
 Calculate the gradient of a scalar system.
 
@@ -19,7 +23,9 @@ call will be cached in the system object.
 function calculate_gradient end
 
 """
+```julia
 calculate_jacobian(sys::AbstractSystem)
+```
 
 Calculate the jacobian matrix of a system.
 
@@ -29,7 +35,9 @@ call will be cached in the system object.
 function calculate_jacobian end
 
 """
+```julia
 calculate_factorized_W(sys::AbstractSystem)
+```
 
 Calculate the factorized W-matrix of a system.
 
@@ -39,7 +47,9 @@ call will be cached in the system object.
 function calculate_factorized_W end
 
 """
+```julia
 calculate_hessian(sys::AbstractSystem)
+```
 
 Calculate the hessian matrix of a scalar system.
 
@@ -49,47 +59,59 @@ call will be cached in the system object.
 function calculate_hessian end
 
 """
+```julia
 generate_tgrad(sys::AbstractSystem, dvs = states(sys), ps = parameters(sys), expression = Val{true}; kwargs...)
+```
 
 Generates a function for the time gradient of a system. Extra arguments control
 the arguments to the internal [`build_function`](@ref) call.
 """
 function generate_tgrad end
 
 """
+```julia
 generate_gradient(sys::AbstractSystem, dvs = states(sys), ps = parameters(sys), expression = Val{true}; kwargs...)
+```
 
 Generates a function for the gradient of a system. Extra arguments control
 the arguments to the internal [`build_function`](@ref) call.
 """
 function generate_gradient end
 
 """
+```julia
 generate_jacobian(sys::AbstractSystem, dvs = states(sys), ps = parameters(sys), expression = Val{true}; sparse = false, kwargs...)
+```
 
 Generates a function for the jacobian matrix matrix of a system. Extra arguments control
 the arguments to the internal [`build_function`](@ref) call.
 """
 function generate_jacobian end
 
 """
+```julia
 generate_factorized_W(sys::AbstractSystem, dvs = states(sys), ps = parameters(sys), expression = Val{true}; sparse = false, kwargs...)
+```
 
 Generates a function for the factorized W-matrix matrix of a system. Extra arguments control
 the arguments to the internal [`build_function`](@ref) call.
 """
 function generate_factorized_W end
 
 """
+```julia
 generate_hessian(sys::AbstractSystem, dvs = states(sys), ps = parameters(sys), expression = Val{true}; sparse = false, kwargs...)
+```
 
 Generates a function for the hessian matrix matrix of a system. Extra arguments control
 the arguments to the internal [`build_function`](@ref) call.
 """
 function generate_hessian end
 
 """
+```julia
 generate_function(sys::AbstractSystem, dvs = states(sys), ps = parameters(sys), expression = Val{true}; kwargs...)
+```
 
 Generate a function to evaluate the system's equations.
 """

src/systems/abstractsystem.jl

@@ -117,7 +117,14 @@ function DiffEqBase.ODEFunction(sys::AbstractODESystem, args...; kwargs...)
 end
 
 """
-$(SIGNATURES)
+```julia
+function DiffEqBase.ODEFunction{iip}(sys::AbstractODESystem, dvs = states(sys),
+                                     ps = parameters(sys);
+                                     version = nothing, tgrad=false,
+                                     jac = false, Wfact = false,
+                                     sparse = false,
+                                     kwargs...) where {iip}
+```
 
 Create an `ODEFunction` from the [`ODESystem`](@ref). The arguments `dvs` and `ps`
 are used to set the order of the dependent variable and parameter vectors,
@@ -177,7 +184,15 @@ function DiffEqBase.ODEProblem(sys::AbstractODESystem, args...; kwargs...)
 end
 
 """
-$(TYPEDEF)
+```julia
+function DiffEqBase.ODEProblem{iip}(sys::AbstractODESystem,u0map,tspan,
+                                    parammap=DiffEqBase.NullParameters();
+                                    version = nothing, tgrad=false,
+                                    jac = false, Wfact = false,
+                                    checkbounds = false, sparse = false,
+                                    linenumbers = true, multithread=false,
+                                    kwargs...) where iip
+```
 
 Generates an ODEProblem from an ODESystem and allows for automatically
 symbolically calculating numerical enhancements.

src/systems/diffeqs/abstractodesystem.jl

@@ -87,7 +87,11 @@ function generate_diffusion_function(sys::SDESystem, dvs = sys.states, ps = sys.
 end
 
 """
-$(SIGNATURES)
+```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,
@@ -151,7 +155,14 @@ function rename(sys::SDESystem,name)
 end
 
 """
-$(SIGNATURES)
+```julia
+function DiffEqBase.SDEProblem{iip}(sys::SDESystem,u0map,tspan,p=parammap;
+                                    version = nothing, tgrad=false,
+                                    jac = false, Wfact = false,
+                                    checkbounds = false, sparse = false,
+                                    linenumbers = true, multithread=false,
+                                    kwargs...)
+```
 
 Generates an SDEProblem from an SDESystem and allows for automatically
 symbolically calculating numerical enhancements.

src/systems/diffeqs/sdesystem.jl

@@ -64,7 +64,14 @@ function generate_function(sys::NonlinearSystem, vs = states(sys), ps = paramete
 end
 
 """
-$(TYPEDEF)
+```julia
+function DiffEqBase.NonlinearProblem{iip}(sys::NonlinearSystem,u0map,tspan,
+                                          parammap=DiffEqBase.NullParameters();
+                                          jac = false, sparse=false,
+                                          checkbounds = false,
+                                          linenumbers = true, multithread=false,
+                                          kwargs...) where iip
+```
 
 Generates an NonlinearProblem from a NonlinearSystem and allows for automatically
 symbolically calculating numerical enhancements.

src/systems/nonlinear/nonlinearsystem.jl

@@ -71,7 +71,15 @@ equations(sys::OptimizationSystem) = isempty(sys.systems) ? sys.op : sys.op + re
 namespace_operation(sys::OptimizationSystem) = namespace_operation(sys.op,sys.name,nothing)
 
 """
-$(TYPEDEF)
+```julia
+function DiffEqBase.OptimizationProblem{iip}(sys::OptimizationSystem,
+                                          parammap=DiffEqBase.NullParameters();
+                                          u0=nothing, lb=nothing, ub=nothing,
+                                          hes = false, sparse = false,
+                                          checkbounds = false,
+                                          linenumbers = true, multithread=false,
+                                          kwargs...) where iip
+```
 
 Generates an OptimizationProblem from an OptimizationSystem and allows for automatically
 symbolically calculating numerical enhancements.

src/systems/optimization/optimizationsystem.jl

@@ -76,8 +76,6 @@ end
 $(TYPEDEF)
 
 An expression which wraps a constant numerical value.
-
-The value of the constant can be extracted with [`Base.get`](@ref).
 """
 struct Constant <: Expression
     """The constant's numerical value"""