Computes the numerical Laplacian of `functions`

or the symbolic Laplacian of `characters`

in arbitrary orthogonal coordinate systems.

```
laplacian(
f,
var,
params = list(),
coordinates = "cartesian",
accuracy = 4,
stepsize = NULL,
drop = TRUE
)
f %laplacian% var
```

- f
array of

`characters`

or a`function`

returning a`numeric`

array.- var
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`

.- params
`list`

of additional parameters passed to`f`

.- coordinates
coordinate system to use. One of:

`cartesian`

,`polar`

,`spherical`

,`cylindrical`

,`parabolic`

,`parabolic-cylindrical`

or a vector of scale factors for each varibale.- accuracy
degree of accuracy for numerical derivatives.

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

- drop
if

`TRUE`

, return the Laplacian as a scalar and not as an`array`

for scalar-valued functions.

Scalar for scalar-valued functions when `drop=TRUE`

, `array`

otherwise.

The Laplacian is a differential operator given by the divergence of the
gradient of a scalar-valued function \(F\), resulting in a scalar value giving
the flux density of the gradient flow of a function.
The `laplacian`

is computed in arbitrary orthogonal coordinate systems using
the scale factors \(h_i\):

$$\nabla^2F = \frac{1}{J}\sum_i\partial_i\Biggl(\frac{J}{h_i^2}\partial_iF\Biggl)$$

where \(J=\prod_ih_i\). When the function \(F\) is a tensor-valued function
\(F_{d_1\dots d_n}\), the `laplacian`

is computed for each scalar component:

$$(\nabla^2F)_{d_1\dots d_n} = \frac{1}{J}\sum_i\partial_i\Biggl(\frac{J}{h_i^2}\partial_iF_{d_1\dots d_n}\Biggl)$$

`%laplacian%`

: binary operator with default parameters.

Guidotti, E. (2020). "calculus: High dimensional numerical and symbolic calculus in R". https://arxiv.org/abs/2101.00086

Other differential operators:
`curl()`

,
`derivative()`

,
`divergence()`

,
`gradient()`

,
`hessian()`

,
`jacobian()`

```
### symbolic Laplacian
laplacian("x^3+y^3+z^3", var = c("x","y","z"))
#> [1] "3 * (2 * x) + 3 * (2 * y) + 3 * (2 * z)"
### numerical Laplacian in (x=1, y=1, z=1)
f <- function(x, y, z) x^3+y^3+z^3
laplacian(f = f, var = c(x=1, y=1, z=1))
#> [1] 18
### vectorized interface
f <- function(x) sum(x^3)
laplacian(f = f, var = c(1, 1, 1))
#> [1] 18
### symbolic vector-valued functions
f <- array(c("x^2","x*y","x*y","y^2"), dim = c(2,2))
laplacian(f = f, var = c("x","y"))
#> [,1] [,2]
#> [1,] "2" "0"
#> [2,] "0" "2"
### numerical vector-valued functions
f <- function(x, y) array(c(x^2,x*y,x*y,y^2), dim = c(2,2))
laplacian(f = f, var = c(x=0,y=0))
#> [,1] [,2]
#> [1,] 2 0
#> [2,] 0 2
### binary operator
"x^3+y^3+z^3" %laplacian% c("x","y","z")
#> [1] "3 * (2 * x) + 3 * (2 * y) + 3 * (2 * z)"
```