error when no derivative

Author: ChrisRackauckas

README.md

@@ -126,6 +126,49 @@ opts = Dict{Symbol,Bool}(
 and calls the function `ode_def_opts(name::Symbol,opts,ex::Expr,params)`. Note that
 params is an iterator holding expressions for the parameters.
 
+#### Extra Little Tricks
+
+There are some extra little tricks you can do. Since `@ode_def` is a macro,
+you cannot directly make the parameters something that requires a runtime value.
+Thus the following will error:
+
+```julia
+vec = rand(1,4)
+f = @ode_def LotkaVolterraExample begin
+dx = ax - bxy
+dy = -cy + dxy
+end a=>vec[1] b=>vec[2] c=>vec[3] d=vec[4]
+```
+
+To do the same thing, instead initialize it with values of the same type, and simply
+replace them:
+
+```julia
+vec = rand(1,4)
+f = @ode_def LotkaVolterraExample begin
+dx = ax - bxy
+dy = -cy + dxy
+end a=>1.0 b=>1.0 c=>1.0 d=vec[4]
+f.a,f.b,f.c = vec[1:3]
+```
+
+Notice that when using `=`, it can inline expressions. It can even inline expressions
+of time, like `d=3*t` or `d=2π`. However, do not use something like `d=3*x` as that will
+fail to transform the `x`.
+
+In addition, one can also use their own function inside of the macro. For example:
+
+```julia
+f(x,y,d) = erf(x*y/d)
+NJ = @ode_def FuncTest begin
+  dx = a*x - b*x*y
+  dy = -c*y + f(x,y,d)
+end a=>1.5 b=>1 c=3 d=4
+```
+
+will do fine. The symbolic derivatives will not work unless you define a derivative
+for `f`.
+
 #### Extra Macros
 
 Instead of using `ode_def_opts` directly, one can use one of the following macros

src/ode_def_opts.jl

@@ -108,12 +108,14 @@ function ode_def_opts(name::Symbol,opts::Dict{Symbol,Bool},ex::Expr,params...;M=
 
           # Build the Julia function
           Jex = build_jac_func(symjac,indvar_dict,param_dict,inline_dict)
+          bad_derivative(Jex)
           jac_exists = true
 
           if opts[:build_expjac]
             try
               expjac = expm(γ*symjac) # This does not work, which is why disabled
               expJex = build_jac_func(expjac,indvar_dict,param_dict,inline_dict)
+              bad_derivative(expJex)
               expjac_exists = true
             catch
               warn("Jacobian could not exponentiate")
@@ -124,6 +126,7 @@ function ode_def_opts(name::Symbol,opts::Dict{Symbol,Bool},ex::Expr,params...;M=
             try # Jacobian Inverse
               invjac = inv(symjac)
               invJex = build_jac_func(invjac,indvar_dict,param_dict,inline_dict)
+              bad_derivative(invJex)
               invjac_exists = true
             catch err
               warn("Jacobian could not invert")
@@ -134,8 +137,10 @@ function ode_def_opts(name::Symbol,opts::Dict{Symbol,Bool},ex::Expr,params...;M=
               syminvW = inv(M - γ*symjac)
               syminvW_t = inv(M/γ - symjac)
               invWex = build_jac_func(syminvW,indvar_dict,param_dict,inline_dict)
+              bad_derivative(invWex)
               invW_exists = true
               invWex_t = build_jac_func(syminvW_t,indvar_dict,param_dict,inline_dict)
+              bad_derivative(invWex_t)
               invW_t_exists = true
             catch err
               warn("Rosenbrock-W could not invert")
@@ -149,11 +154,13 @@ function ode_def_opts(name::Symbol,opts::Dict{Symbol,Bool},ex::Expr,params...;M=
               end
               # Build the Julia function
               Hex = build_jac_func(symhes,indvar_dict,param_dict,inline_dict)
+              bad_derivative(Hex)
               hes_exists = true
               if opts[:build_invhes]
                 try # Hessian Inverse
                   invhes = inv(symhes)
                   invHex = build_jac_func(invhes,indvar_dict,param_dict,inline_dict)
+                  bad_derivative(invHex)
                   invhes_exists = true
                 catch err
                   warn("Hessian could not invert")

src/ode_findrep.jl

@@ -26,6 +26,17 @@ function ode_findreplace(ex,symex,indvar_dict,param_dict,inline_dict;params_from
   end
 end
 
+function bad_derivative(ex)
+  for (i,arg) in enumerate(ex.args)
+    if isa(arg,Expr)
+      bad_derivative(arg)
+    elseif arg == :Derivative
+      warn("Undefined derivative found. If you are using a non-elementary function, you must define the derivative in order to calculate Jacobians et. al. Please refer to the documentation.")
+      error("Failed")
+    end
+  end
+end
+
 
 
 function ode_symbol_findreplace(ex,indvar_dict,param_dict,inline_dict;params_from_function=true)