deriv {base} | R Documentation

## Symbolic and Algorithmic Derivatives of Simple Expressions

### Description

Compute derivatives of simple expressions, symbolically.

### Usage

       D (expr, name)
    deriv(expr, namevec, function.arg = NULL, tag = ".expr")

### Arguments

`expr` | `expression` or `call` which should be differentiated.
`name,namevec` | character vector, giving the variable names (only one for `D(.)`) with respect to which derivatives will be computed.
`function.arg` | If specified, a character vector of arguments for a function return. Note: this is incompatible with S.
`tag` | character; the prefix to be used for the locally created variables in result.

### 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''.

Currently, `deriv.formula` just calls `deriv.default` after extracting the expression to the right of `~`.

### Value

`D` returns a call and therefore can easily be iterated for higher derivatives.
`deriv` normally returns an `expression` object. Its evaluation returns the function values with a `".gradient"` attribute containing the gradient matrix. If `function.arg` is specified, it returns a function.

### Note

This help page should be fixed up by one of R&R or someone else who fluently speaks the language in ``$R_HOME/src/main/deriv.c`'.

Its author, MM, has only got a vague idea and thinks that a help page is better than none.

### References

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

### See Also

`nlm` and `optim` for numeric minimization which could make use of derivatives, `nls` in package `nls`.

### Examples

    ## formula argument :
    dx2x <- deriv(~ x^2, "x") ; dx2x
    expression({
             .value <- x^2
             .grad <- array(0, c(length(.value), 1), list(NULL, c("x")))
             .grad[, "x"] <- 2 * x
             attr(.value, "gradient") <- .grad
             .value
    })
    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)
    stopifnot(eval(D.sc) ==
              attr(eval(dxy),"gradient")[,"x"])

    ## function returned:
    deriv(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()" :

    -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)