add constructor to README

Author: ChrisRackauckas

README.md

@@ -28,12 +28,56 @@ the speed of computations. If they don't exist, the solvers will ignore them. Si
 `ParameterizedFunction` is a subtype of `Function`, these can be used anywhere that
 a function can be used, just with the extra functionality ignored.
 
-## Basic Usage via Macros
+## Basic Usage
 
-### ODEs
+### ParameterizedFunction Constructor
 
-A helper macro is provided to make it easier to define a `ParameterizedFunction`.
-For example, to define the previous `LotkaVolterra`, you can use the following command:
+The easiest way to make a `ParameterizedFunction` is to use the constructor:
+
+```julia
+pf = ParameterizedFunction(f,params)
+```
+
+The form for `f` is `f(t,u,params,du)`
+where `params` is any type which defines the parameters. The
+resulting `ParameterizedFunction` has the function call `pf(t,u,params,du)`
+which matches the original function, and a call `pf(t,u,du)` which uses internal
+parmaeters which can be used with a differential equation solver. Note that the
+internal parameters can be modified at any time via the field: `pf.p = ...`.
+
+An additional version exists for `f(t,u,params)` which will then act as the
+not inplace version `f(t,u)` in the differential equation solvers.
+
+#### Example
+
+```julia
+pf_func = function (t,u,p,du)
+  du[1] = p[1] * u[1] - p[2] * u[1]*u[2]
+  du[2] = -3 * u[2] + u[1]*u[2]
+end
+
+pf = ParameterizedFunction(pf_func,[1.5,1.0])
+```
+
+And now `pf` can be used in the differential equation solvers and the ecosystem
+functionality which requires explicit parameters (parameter estimation, etc.).
+
+Note that the not inplace version works the same:
+
+```julia
+pf_func2 = function (t,u,p)
+  [p[1] * u[1] - p[2] * u[1]*u[2];-3 * u[2] + u[1]*u[2]]
+end
+
+pf2 = ParameterizedFunction(pf_func2,[1.5,1.0])
+```
+
+### ODE Macros
+
+A helper macro is provided to make it easier to define a `ParameterizedFunction`,
+and it will symbolically compute a bunch of extra functions to make the differential
+equation solvers run faster. For example, to define the previous `LotkaVolterra`,
+you can use the following command:
 
 ```julia
 f = @ode_def LotkaVolterra begin
@@ -194,11 +238,9 @@ way when a function (usually an ODE/SDE solver) is dispatched on `f`. It is
 requested that solvers should only use the explicit functions when they exist
 to help with performance.
 
-## Manually Defining `ParameterizedFunction`s
+## Internals: How it Works
 
-It's recommended that for simple uses you use the macros. However, in many cases
-the macros will not suffice, but you may still wish to provide Jacobians to the
-solvers. This shows how to manually build a ParameterizedFunction to give to
+This shows how to manually build a ParameterizedFunction to give to
 a solver.
 
 ### Template