Function: lfuninit
Section: l_functions
C-Name: lfuninit
Prototype: GGD0,L,p
Help: lfuninit(ldata,sdom,{der=0}): precompute data
 for evaluating the L function given by ldata (and its derivatives
 of order der, if set) in rectangular domain sdom = [center,w,h]
 centered on the real axis, |Re(s)-center| <= w, |Im(s)| <= h,
 where all three components of sdom are real and w,h are non-negative.
 ldata can be either explicitly created from the Dirichlet
 coefficients, gamma factors, etc... using the function
 lfuncreate, the output of other lfunxxx initialization functions,
 or directly other objects such as polynomials, elliptic curves,
 Dirichlet or Hecke characters, eta quotients, etc.
Doc: fundamental initalization function for all functions linked to the
 computation of the $L$-function $L(s)$ encoded by \kbd{ldata}, where
 $s$ belongs to the rectangular domain $\kbd{sdom} = [\var{center},w,h]$
 centered on the real axis, $|\Re(s)-\var{center}| \leq w$, $|\Im(s)| \leq h$,
 where all three components of \kbd{sdom} are real and $w$, $h$ are
 non-negative. \kbd{der} is the maximum order of derivation that will be used.
 The parameter \kbd{ldata} is either explicitly created from
 the Dirichlet coefficients, gamma factors, etc... using the function
 \kbd{lfuncreate}, the output of other \kbd{lfunxxx}
 initialization functions, or directly other objects such as polynomials,
 elliptic curves, Dirichlet or Hecke characters, eta quotients, etc.

 The height $h$ of the domain is a \emph{crucial} parameter: if you only
 need $L(s)$ for real $s$, set $h$ to 0.
 The running time is roughly proportional to
 $$(D\log(10)/d+\pi h/4)^{d/2+3}N^{1/2},$$
 where $D$ is the default accuracy in decimal digits, $d$ is the degree of the
 $L$-function, and $N$ is the conductor (the exponent $d/2+3$ is reduced
 to $d/2+2$ when $d=1$ and $d=2$). There is also a dependency on $w$,
 which is less crucial, but make sure to use the smallest rectangular
 domain that you need.
 \bprog
 ? L = lfuncreate(1); \\ Riemann zeta
 ? lfuninit(L, [1/2, 0, 100]); \\ for zeta(1/2+it), |t| < 100
 @eprog\noindent
 See \kbd{??lfuncreate} for a description of \kbd{ldata} if given explicitly.

 The output is a three-component vector \kbd{[code,ldataf,vv]}: \kbd{ldataf} is
 the same as \kbd{ldata} except that all the missing parameters (usually the
 root number and/or the residues) have been filled; ``f'' is for full (note
 that the root number will be set exactly equal to $\pm1$ if it is extremely
 close to $1$). \kbd{code} and \kbd{vv} are technical, but \kbd{vv[1]}
 is set to \kbd{[sdom,Vecsmall([der,bitprec])]}, where \kbd{sdom} and \kbd{der}
 are as given in the function call, and \kbd{bitprec} is the bit accuracy.
 This allows other programs to check that the initialization has been
 done with sufficiently large parameters.
