View source: R/family.basics.R

lerch | R Documentation |

Computes the Lerch Phi function.

```
lerch(x, s, v, tolerance = 1.0e-10, iter = 100)
```

`x, s, v` |
Numeric.
This function recyles values of |

`tolerance` |
Numeric. Accuracy required, must be positive and less than 0.01. |

`iter` |
Maximum number of iterations allowed to obtain convergence.
If |

Also known as the Lerch transcendent, it can be defined by an integral involving analytical continuation. An alternative definition is the series

`\Phi(x,s,v) = \sum_{n=0}^{\infty} \frac{x^n}{(n+v)^s}`

which converges for `|x|<1`

as well as for `|x|=1`

with `s>1`

.
The series is undefined for integers `v <= 0`

.
Actually, `x`

may be complex but this function only works
for real `x`

.
The algorithm used is based on the relation

```
\Phi(x,s,v) = x^m \Phi(x,s,v+m) + \sum_{n=0}^{m-1}
\frac{x^n}{(n+v)^s} .
```

See the URL below for more information. This function is a wrapper function for the C code described below.

Returns the value of the function evaluated at the values of
`x`

, `s`

, `v`

.
If the above ranges of `x`

and `v`

are not satisfied,
or some numeric problems occur, then
this function will return an `NA`

for those values.
(The C code returns 6 possible return codes, but this is
not passed back up to the R level.)

This function has not been thoroughly tested and contains
limitations,
for example,
the zeta function cannot be computed with this function even
though
`\zeta(s) = \Phi(x=1,s,v=1)`

.
Several numerical problems can arise,
such as lack of convergence, overflow
and underflow, especially near singularities.
If any problems occur then an `NA`

will be returned.
For example,
if `|x|=1`

and `s>1`

then
convergence may be so slow that
changing `tolerance`

and/or `iter`

may be needed
to get an answer (that is treated cautiously).

There are a number of special cases, e.g.,
the Riemann zeta-function is
`\zeta(s) = \Phi(x=1,s,v=1)`

.
Another example is the Hurwitz zeta function
`\zeta(s, v) = \Phi(x=1,s,v=v)`

.
The special case of `s=1`

corresponds to the hypergeometric
2F1,
and this is implemented in the gsl package.
The Lerch Phi function should not be confused with the
Lerch zeta function though they are quite similar.

S. V. Aksenov and U. D. Jentschura wrote the C code (called Version 1.00). The R wrapper function was written by T. Yee.

Originally the code was found at
`http://aksenov.freeshell.org/lerchphi/source/lerchphi.c`

.

Bateman, H. (1953).
*Higher Transcendental Functions*.
Volume 1. McGraw-Hill, NY, USA.

`zeta`

.

```
## Not run:
s <- 2; v <- 1; x <- seq(-1.1, 1.1, length = 201)
plot(x, lerch(x, s = s, v = v), type = "l", col = "blue",
las = 1, main = paste0("lerch(x, s = ", s,", v = ", v, ")"))
abline(v = 0, h = 1, lty = "dashed", col = "gray")
## End(Not run)
```

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.