# deriv

##### Symbolic and Algorithmic Derivatives of Simple Expressions

Compute derivatives of simple expressions, symbolically.

##### Usage

```
D (expr, name) deriv(expr, ...)
deriv3(expr, ...)
"deriv"(expr, namevec, function.arg = NULL, tag = ".expr", hessian = FALSE, ...) "deriv"(expr, namevec, function.arg = NULL, tag = ".expr", hessian = FALSE, ...)
"deriv3"(expr, namevec, function.arg = NULL, tag = ".expr", hessian = TRUE, ...)
"deriv3"(expr, namevec, function.arg = NULL, tag = ".expr", hessian = TRUE, ...)
```

##### Arguments

- expr
- A
`expression`

or`call`

or (except`D`

) a formula with no lhs. - name,namevec
- character vector, giving the variable names (only
one for
`D()`

) with respect to which derivatives will be computed. - function.arg
- If specified and non-
`NULL`

, a character vector of arguments for a function return, or a function (with empty body) or`TRUE`

, the latter indicating that a function with argument names`namevec`

should be used. - tag
- character; the prefix to be used for the locally created variables in result.
- hessian
- a logical value indicating whether the second derivatives should be calculated and incorporated in the return value.
- ...
- arguments to be passed to or from methods.

##### Details

`D`

is modelled after its S namesake for taking simple symbolic
derivatives.

`deriv`

is a *generic* function with a default and a
`formula`

method. It returns a `call`

for
computing the `expr`

and its (partial) derivatives,
simultaneously. It uses so-called *algorithmic derivatives*. If
`function.arg`

is a function, its arguments can have default
values, see the `fx`

example below.

Currently, `deriv.formula`

just calls `deriv.default`

after
extracting the expression to the right of `~`

.

`deriv3`

and its methods are equivalent to `deriv`

and its
methods except that `hessian`

defaults to `TRUE`

for
`deriv3`

.

The internal code knows about the arithmetic operators `+`

,
`-`

, `*`

, `/`

and `^`

, and the single-variable
functions `exp`

, `log`

, `sin`

, `cos`

, `tan`

,
`sinh`

, `cosh`

, `sqrt`

, `pnorm`

, `dnorm`

,
`asin`

, `acos`

, `atan`

, `gamma`

, `lgamma`

,
`digamma`

and `trigamma`

, as well as `psigamma`

for one
or two arguments (but derivative only with respect to the first).
(Note that only the standard normal distribution is considered.)

##### Value

`D`

returns a call and therefore can easily be iterated
for higher derivatives.`deriv`

and `deriv3`

normally return an
`expression`

object whose evaluation returns the function
values with a `"gradient"`

attribute containing the gradient
matrix. If `hessian`

is `TRUE`

the evaluation also returns
a `"hessian"`

attribute containing the Hessian array.If `function.arg`

is not `NULL`

, `deriv`

and
`deriv3`

return a function with those arguments rather than an
expression.
##### References

Griewank, A. and Corliss, G. F. (1991)
*Automatic Differentiation of Algorithms: Theory, Implementation,
and Application*.
SIAM proceedings, Philadelphia.

Bates, D. M. and Chambers, J. M. (1992)
*Nonlinear models.*
Chapter 10 of *Statistical Models in S*
eds J. M. Chambers and T. J. Hastie, Wadsworth & Brooks/Cole.

##### See Also

`nlm`

and `optim`

for numeric minimization
which could make use of derivatives,

##### Examples

`library(stats)`

```
## formula argument :
dx2x <- deriv(~ x^2, "x") ; dx2x
## Not run: expression({
# .value <- x^2
# .grad <- array(0, c(length(.value), 1), list(NULL, c("x")))
# .grad[, "x"] <- 2 * x
# attr(.value, "gradient") <- .grad
# .value
# })## End(Not run)
mode(dx2x)
x <- -1:2
eval(dx2x)
## Something 'tougher':
trig.exp <- expression(sin(cos(x + y^2)))
( D.sc <- D(trig.exp, "x") )
all.equal(D(trig.exp[[1]], "x"), D.sc)
( dxy <- deriv(trig.exp, c("x", "y")) )
y <- 1
eval(dxy)
eval(D.sc)
## function returned:
deriv((y ~ sin(cos(x) * y)), c("x","y"), func = TRUE)
## function with defaulted arguments:
(fx <- deriv(y ~ b0 + b1 * 2^(-x/th), c("b0", "b1", "th"),
function(b0, b1, th, x = 1:7){} ) )
fx(2, 3, 4)
## Higher derivatives
deriv3(y ~ b0 + b1 * 2^(-x/th), c("b0", "b1", "th"),
c("b0", "b1", "th", "x") )
## Higher derivatives:
DD <- function(expr, name, order = 1) {
if(order < 1) stop("'order' must be >= 1")
if(order == 1) D(expr, name)
else DD(D(expr, name), name, order - 1)
}
DD(expression(sin(x^2)), "x", 3)
## showing the limits of the internal "simplify()" :
## Not run:
# -sin(x^2) * (2 * x) * 2 + ((cos(x^2) * (2 * x) * (2 * x) + sin(x^2) *
# 2) * (2 * x) + sin(x^2) * (2 * x) * 2)
# ## End(Not run)
```

*Documentation reproduced from package stats, version 3.2.5, License: Part of R 3.2.5*

### Community examples

**singhkpratham**at Jul 19, 2017 stats v3.4.0

##### Let's consider we need to find derivative of "a square" ```r # the following will return a function (derivative of a^2 is 2*a) s = deriv(~a^2,'a',func = T) # the following can be used to get result of derivative by passing in any number # for our example, it will be 2*the_no_you_pass attr(s(4),'gradient') ```