Model2String: Inserts parameter values into equations
In bmarkslash7/QPot: Quasi-Potential Analysis for Stochastic Differential Equations

Description Usage Arguments Value Examples

Converts differential equations from string-format (or function-format) with parameters (e.g. "a*x+b) to string-format with parameter values (e.g. 2*x+3). Specifically, Model2String reads in the equations, searches for the differential equations within the function (if required), and replaces the parameters with numerical values given by the user. Returns an array of strings containing the differential equations. This code is specifically given so that any problems can be found in R as opposed to receiving terse errors from the C code if this was built into the QPotential() function.

Model2String(
  model = NULL,
  parms = NULL,
  deSolve.form = FALSE,
  x.lhs.term = "dx",
  y.lhs.term = "dy",
  supress.print = FALSE,
  width.cutoff = 500
)

`model`	contains the differential equations as given to `TSTraj`. Can either be a string or a function used by the package `deSolve` (see third example).
`parms`	a named vector of paramters and their respective values for the deterministic equations. If inputing a function and parms is empty, Model2String will return the equation as a string.
`deSolve.form`	if FALSE (default) interprets model as a string containing the rhs of the equation. If TRUE, treats model as the function input into the package `deSolve`.
`x.lhs.term`	string containing the left hand side of the first equation to search for if deSolve.form is TRUE. Default is 'dx'.
`y.lhs.term`	string containing the left hand side of the second equation to search for if deSolve.form is TRUE. Default is 'dy'.
`supress.print`	if FALSE (default), suppress output. TRUE prints out equations converted to strings with parameters replaced with values.
`width.cutoff`	parameter width.cutoff from `deparse` in package:base. Determines the cutoff in bytes at which line breaking is tried. Default is 500 with possible range of 2 to 500.

equations: an array with strings of the equations with substituted parameter values. If deSolve.form is TRUE, the first is the x equation, the second is the y equation.

# First example with the right hand side of an equation
test.eqn.x = "(alpha*x)*(1-(x/beta)) - ((delta*(x^2)*y)/(kappa + (x^2)))"
model.parms <- c(alpha=1.54, beta=10.14, delta=1, kappa=1)
equations.as.strings.x <- Model2String(test.eqn.x, parms = model.parms)

# Second example with individual strings with left and right hand sides
# Note the use deSolve.form = TRUE to remove the dx and dy
test.eqn.x = "dx = (alpha*x)*(1-(x/beta)) - ((delta*(x^2)*y)/(kappa + (x^2)))"
test.eqn.y = "dy = ((gamma*(x^2)*y)/(kappa + (x^2))) - mu*(y^2)"
model.parms <- c(alpha=1.54, beta=10.14, delta=1, kappa=1, gamma=0.476, mu=0.112509)
equations.as.strings.x <- Model2String(test.eqn.x, parms = model.parms, 
 deSolve.form = TRUE, x.lhs.term = 'dx', y.lhs.term = 'dy')
equations.as.strings.y <- Model2String(test.eqn.y, parms = model.parms, 
 deSolve.form = TRUE, x.lhs.term = 'dx', y.lhs.term = 'dy')

# Third example with deSolve-style function call:
model.parms <- c(alpha=1.54, beta=10.14, delta=1, kappa=1, gamma=0.476, mu=0.112509)
ModelEquations <- function(t, state, parms) {
	with(as.list(c(state, parms)), {
dx <- (alpha*x)*(1-(x/beta)) - ((delta*(x^2)*y)/(kappa + (x^2)))
dy <- ((gamma*(x^2)*y)/(kappa + (x^2))) - mu*(y^2)
list(c(dx,dy))
})
}

Model2String(ModelEquations, parms = model.parms, deSolve.form = TRUE, 
 x.lhs.term = 'dx', y.lhs.term = 'dy')