Merge pull request #742 from SciML/sm/simplify

Don't simplify by default

Author: ChrisRackauckas

src/differentials.jl

@@ -154,14 +154,14 @@ function expand_derivatives(O::Symbolic, simplify=false; occurances=nothing)
     end
 end
 
-function expand_derivatives(n::Num, simplify=true; occurances=nothing)
+function expand_derivatives(n::Num, simplify=false; occurances=nothing)
     Num(expand_derivatives(value(n), simplify; occurances=occurances))
 end
 
 _iszero(x) = false
 _isone(x) = false
 
-expand_derivatives(x, simplify=true;occurances=nothing) = x
+expand_derivatives(x, simplify=false;occurances=nothing) = x
 
 # Don't specialize on the function here
 """

src/direct.jl

@@ -1,12 +1,12 @@
 """
 ```julia
-derivative(O, v; simplify = true)
+derivative(O, v; simplify=false)
 ```
 
 A helper function for computing the derivative of an expression with respect to
 `var`.
 """
-function derivative(O, v; simplify = true)
+function derivative(O, v; simplify=false)
     if O isa AbstractArray
         Num[Num(expand_derivatives(Differential(v)(value(o)), simplify)) for o in O]
     else
@@ -16,37 +16,37 @@ end
 
 """
 ```julia
-gradient(O, vars::AbstractVector; simplify = true)
+gradient(O, vars::AbstractVector; simplify=false)
 ```
 
 A helper function for computing the gradient of an expression with respect to
 an array of variable expressions.
 """
-function gradient(O, vars::AbstractVector; simplify = true)
+function gradient(O, vars::AbstractVector; simplify=false)
     Num[Num(expand_derivatives(Differential(v)(value(O)),simplify)) for v in vars]
 end
 
 """
 ```julia
-jacobian(ops::AbstractVector, vars::AbstractVector; simplify = true)
+jacobian(ops::AbstractVector, vars::AbstractVector; simplify=false)
 ```
 
 A helper function for computing the Jacobian of an array of expressions with respect to
 an array of variable expressions.
 """
-function jacobian(ops::AbstractVector, vars::AbstractVector; simplify = true)
+function jacobian(ops::AbstractVector, vars::AbstractVector; simplify=false)
     Num[Num(expand_derivatives(Differential(value(v))(value(O)),simplify)) for O in ops, v in vars]
 end
 
 """
 ```julia
-sparsejacobian(ops::AbstractVector, vars::AbstractVector; simplify = true)
+sparsejacobian(ops::AbstractVector, vars::AbstractVector; simplify=false)
 ```
 
 A helper function for computing the sparse Jacobian of an array of expressions with respect to
 an array of variable expressions.
 """
-function sparsejacobian(ops::AbstractVector, vars::AbstractVector; simplify = true)
+function sparsejacobian(ops::AbstractVector, vars::AbstractVector; simplify=false)
     I = Int[]
     J = Int[]
     du = Num[]
@@ -107,13 +107,13 @@ end
 
 """
 ```julia
-hessian(O, vars::AbstractVector; simplify = true)
+hessian(O, vars::AbstractVector; simplify=false)
 ```
 
 A helper function for computing the Hessian of an expression with respect to
 an array of variable expressions.
 """
-function hessian(O, vars::AbstractVector; simplify = true)
+function hessian(O, vars::AbstractVector; simplify=false)
     vars = map(value, vars)
     first_derivs = map(value, vec(jacobian([values(O)], vars, simplify=simplify)))
     n = length(vars)
@@ -200,13 +200,13 @@ end
 
 """
 ```julia
-sparsehessian(O, vars::AbstractVector; simplify = true)
+sparsehessian(O, vars::AbstractVector; simplify=false)
 ```
 
 A helper function for computing the sparse Hessian of an expression with respect to
 an array of variable expressions.
 """
-function sparsehessian(O, vars::AbstractVector; simplify = true)
+function sparsehessian(O, vars::AbstractVector; simplify=false)
     O = value(O)
     vars = map(value, vars)
     S = hessian_sparsity(O, vars)

src/equations.jl

@@ -63,6 +63,6 @@ function _eq_unordered(a, b)
     return true
 end
 
-function expand_derivatives(eq::Equation, simplify=true)
+function expand_derivatives(eq::Equation, simplify=false)
     return Equation(expand_derivatives(eq.lhs, simplify), expand_derivatives(eq.rhs, simplify))
 end

src/systems/diffeqs/abstractodesystem.jl

@@ -1,5 +1,5 @@
 function calculate_tgrad(sys::AbstractODESystem;
-                         simplify=true)
+                         simplify=false)
   isempty(sys.tgrad[]) || return sys.tgrad[]  # use cached tgrad, if possible
 
   # We need to remove explicit time dependence on the state because when we
@@ -18,7 +18,7 @@ function calculate_tgrad(sys::AbstractODESystem;
 end
 
 function calculate_jacobian(sys::AbstractODESystem;
-                            sparse=false, simplify=true)
+                            sparse=false, simplify=false)
     isempty(sys.jac[]) || return sys.jac[]  # use cached Jacobian, if possible
     rhs = [eq.rhs for eq ∈ equations(sys)]
 
@@ -52,14 +52,14 @@ end
 (f::ODEToExpr)(x) = toexpr(x)
 
 function generate_tgrad(sys::AbstractODESystem, dvs = states(sys), ps = parameters(sys);
-                        simplify = true, kwargs...)
+                        simplify=false, kwargs...)
     tgrad = calculate_tgrad(sys,simplify=simplify)
     return build_function(tgrad, dvs, ps, sys.iv;
                           conv = ODEToExpr(sys), kwargs...)
 end
 
 function generate_jacobian(sys::AbstractODESystem, dvs = states(sys), ps = parameters(sys);
-                           simplify = true, sparse = false, kwargs...)
+                           simplify=false, sparse = false, kwargs...)
     jac = calculate_jacobian(sys;simplify=simplify,sparse=sparse)
     sub = Dict(value.(dvs) .=> makesym.(value.(dvs)))
     jac = map(d->substitute(d, sub), jac)
@@ -79,7 +79,7 @@ function generate_function(sys::AbstractODESystem, dvs = states(sys), ps = param
                           conv = ODEToExpr(sys),kwargs...)
 end
 
-function calculate_massmatrix(sys::AbstractODESystem; simplify=true)
+function calculate_massmatrix(sys::AbstractODESystem; simplify=false)
     eqs = equations(sys)
     dvs = states(sys)
     M = zeros(length(eqs),length(eqs))
@@ -123,7 +123,7 @@ function DiffEqBase.ODEFunction{iip}(sys::AbstractODESystem, dvs = states(sys),
                                      version = nothing, tgrad=false,
                                      jac = false,
                                      eval_expression = true,
-                                     sparse = false, simplify = true,
+                                     sparse = false, simplify=false,
                                      kwargs...) where {iip}
 
     f_gen = generate_function(sys, dvs, ps; expression=Val{eval_expression}, kwargs...)
@@ -186,7 +186,7 @@ function ODEFunctionExpr{iip}(sys::AbstractODESystem, dvs = states(sys),
                                      version = nothing, tgrad=false,
                                      jac = false,
                                      linenumbers = false,
-                                     sparse = false, simplify = true,
+                                     sparse = false, simplify=false,
                                      kwargs...) where {iip}
 
     idx = iip ? 2 : 1
@@ -245,7 +245,7 @@ function DiffEqBase.ODEProblem{iip}(sys::AbstractODESystem,u0map,tspan,
                                     version = nothing, tgrad=false,
                                     jac = false,
                                     checkbounds = false, sparse = false,
-                                    simplify = true,
+                                    simplify=false,
                                     linenumbers = true, parallel=SerialForm(),
                                     kwargs...) where iip
 ```
@@ -258,7 +258,7 @@ function DiffEqBase.ODEProblem{iip}(sys::AbstractODESystem,u0map,tspan,
                                     version = nothing, tgrad=false,
                                     jac = false,
                                     checkbounds = false, sparse = false,
-                                    simplify = true,
+                                    simplify=false,
                                     linenumbers = true, parallel=SerialForm(),
                                     eval_expression = true,
                                     kwargs...) where iip
@@ -289,7 +289,7 @@ function DiffEqBase.ODEProblemExpr{iip}(sys::AbstractODESystem,u0map,tspan,
                                     checkbounds = false, sparse = false,
                                     linenumbers = true, parallel=SerialForm(),
                                     skipzeros=true, fillzeros=true,
-                                    simplify = true,
+                                    simplify=false,
                                     kwargs...) where iip
 ```
 
@@ -304,7 +304,7 @@ function ODEProblemExpr{iip}(sys::AbstractODESystem,u0map,tspan,
                                     version = nothing, tgrad=false,
                                     jac = false,
                                     checkbounds = false, sparse = false,
-                                    simplify = true,
+                                    simplify=false,
                                     linenumbers = false, parallel=SerialForm(),
                                     kwargs...) where iip
 

src/systems/diffeqs/sdesystem.jl

@@ -100,7 +100,7 @@ function stochastic_integral_transform(sys::SDESystem, correction_factor)
         eqs = vcat([sys.eqs[i].lhs ~ sys.noiseeqs[i] for i in eachindex(sys.states)]...)
         de = ODESystem(eqs,sys.iv,sys.states,sys.ps)
 
-        jac = calculate_jacobian(de, sparse=false, simplify=true)
+        jac = calculate_jacobian(de, sparse=false, simplify=false)
         ∇σσ′ = simplify.(jac*sys.noiseeqs)
 
         deqs = vcat([sys.eqs[i].lhs ~ sys.eqs[i].rhs+ correction_factor*∇σσ′[i] for i in eachindex(sys.states)]...)
@@ -109,13 +109,13 @@ function stochastic_integral_transform(sys::SDESystem, correction_factor)
         eqs = vcat([sys.eqs[i].lhs ~ sys.noiseeqs[i] for i in eachindex(sys.states)]...)
         de = ODESystem(eqs,sys.iv,sys.states,sys.ps)
 
-        jac = calculate_jacobian(de, sparse=false, simplify=true)
+        jac = calculate_jacobian(de, sparse=false, simplify=false)
         ∇σσ′ = simplify.(jac*sys.noiseeqs[:,1])
         for k = 2:m
             eqs = vcat([sys.eqs[i].lhs ~ sys.noiseeqs[Int(i+(k-1)*dimstate)] for i in eachindex(sys.states)]...)
             de = ODESystem(eqs,sys.iv,sys.states,sys.ps)
 
-            jac = calculate_jacobian(de, sparse=false, simplify=true)
+            jac = calculate_jacobian(de, sparse=false, simplify=false)
             ∇σσ′ = ∇σσ′ + simplify.(jac*sys.noiseeqs[:,k])
         end
 

src/systems/nonlinear/nonlinearsystem.jl

@@ -45,7 +45,7 @@ function NonlinearSystem(eqs, states, ps;
     NonlinearSystem(eqs, value.(states), value.(ps), value.(pins), observed, name, systems)
 end
 
-function calculate_jacobian(sys::NonlinearSystem;sparse=false,simplify=true)
+function calculate_jacobian(sys::NonlinearSystem;sparse=false,simplify=false)
     rhs = [eq.rhs for eq ∈ equations(sys)]
     vals = [dv for dv in states(sys)]
     if sparse
@@ -57,7 +57,7 @@ function calculate_jacobian(sys::NonlinearSystem;sparse=false,simplify=true)
 end
 
 function generate_jacobian(sys::NonlinearSystem, vs = states(sys), ps = parameters(sys);
-                           sparse = false, simplify = true, kwargs...)
+                           sparse = false, simplify=false, kwargs...)
     jac = calculate_jacobian(sys,sparse=sparse, simplify=simplify)
     return build_function(jac, vs, ps;
                           conv = AbstractSysToExpr(sys), kwargs...)