Computes the numerical gradient of functions or the symbolic gradient of characters in arbitrary orthogonal coordinate systems.

  params = list(),
  coordinates = "cartesian",
  accuracy = 4,
  stepsize = NULL,
  drop = TRUE

f %gradient% var



array of characters or a function returning a numeric array.


vector giving the variable names with respect to which the derivatives are to be computed and/or the point where the derivatives are to be evaluated. See derivative.


list of additional parameters passed to f.


coordinate system to use. One of: cartesian, polar, spherical, cylindrical, parabolic, parabolic-cylindrical or a vector of scale factors for each varibale.


degree of accuracy for numerical derivatives.


finite differences stepsize for numerical derivatives. It is based on the precision of the machine by default.


if TRUE, return the gradient as a vector and not as an array for scalar-valued functions.


Gradient vector for scalar-valued functions when drop=TRUE, array otherwise.


The gradient of a scalar-valued function \(F\) is the vector \((\nabla F)_i\) whose components are the partial derivatives of \(F\) with respect to each variable \(i\). The gradient is computed in arbitrary orthogonal coordinate systems using the scale factors \(h_i\):

$$(\nabla F)_i = \frac{1}{h_i}\partial_iF$$

When the function \(F\) is a tensor-valued function \(F_{d_1,\dots,d_n}\), the gradient is computed for each scalar component. In particular, it becomes the Jacobian matrix for vector-valued function.

$$(\nabla F_{d_1,\dots,d_n})_i = \frac{1}{h_i}\partial_iF_{d_1,\dots,d_n}$$


  • %gradient%: binary operator with default parameters.


Guidotti, E. (2020). "calculus: High dimensional numerical and symbolic calculus in R".

See also

Other differential operators: curl(), derivative(), divergence(), hessian(), jacobian(), laplacian()


### symbolic gradient 
gradient("x*y*z", var = c("x", "y", "z"))
#> [1] "y * z" "x * z" "x * y"

### numerical gradient in (x=1, y=2, z=3)
f <- function(x, y, z) x*y*z
gradient(f = f, var = c(x=1, y=2, z=3))
#> [1] 6 3 2

### vectorized interface
f <- function(x) x[1]*x[2]*x[3]
gradient(f = f, var = c(1, 2, 3))
#> [1] 6 3 2

### symbolic vector-valued functions
f <- c("y*sin(x)", "x*cos(y)")
gradient(f = f, var = c("x","y"))
#>      [,1]         [,2]           
#> [1,] "y * cos(x)" "sin(x)"       
#> [2,] "cos(y)"     "-(x * sin(y))"

### numerical vector-valued functions
f <- function(x) c(sum(x), prod(x))
gradient(f = f, var = c(0,0,0))
#>      [,1] [,2] [,3]
#> [1,]    1    1    1
#> [2,]    0    0    0

### binary operator
"x*y^2" %gradient% c(x=1, y=3)
#> [1] 9 6