%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%
%%  bi_bf_lattice_gensys.tex       LiDIA documentation
%%
%%  This file contains the documentation of the lattice classes
%%
%%  Copyright   (c)   1995   by  LiDIA-Group
%%
%%  Authors: Thorsten Lauer, Susanne Wetzel
%%

\begin{lidia_man}
\markright{\BF{bigint\_lattice\_gensys},\BF{bigfloat\_lattice\_gensys}}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\NAME
\BF{bigint\_lattice\_gensys,}\\
\BF{bigfloat\_lattice\_gensys} \DOTFILL  computing lattice bases from generating systems

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\ABSTRACT
\BF{bigint\_lattice\_gensys} and \BF{bigfloat\_lattice\_gensys} 
are derived from the class \BF{math\_matrix} and therefore inherit 
all their functions. In addition the classes \BF{bigint\_lattice\_gensys} 
and \BF{bigfloat\_lattice\_gensys} can be used to solve the following 
problems:

Let \MATH{A=(a_0, \LDOTS, a_{k-1}) \IN M^{n \TIMES k}} (\MATH{n,k \IN \N}) 
be a generating system of a lattice \MATH{L}, where \MATH{M} consists 
of elements of type \BF{bigint} or \BF{bigfloat}. Find a relation, i.e., 
\MATH{x_0, \LDOTS , x_{k-1} \IN \Z~} such that
\MATH{\SUM{i=0}{k-1}{x_ia_i =0}} and find a basis of the lattice~\MATH{L}. 
For details see \cite{BUK,SEN,ZAS}.

In this release the classes are supported only to
guarantee the compatibility to previous versions of \LiDIA\ and will not 
be available in future
versions. We recommend to use the classes \BF{bigfloat\_lattice}
and \BF{bigint\_lattice} instead.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\DESCRIPTION
Let \MATH{A} be of class \BF{bigint\_lattice\_gensys} or 
\BF{bigfloat\_lattice\_gensys}. In the present version of
\LiDIA\ the following algorithms are implemented:
\begin{itemize}
\item The Buchmann-Kessler algorithm \cite{BUK} which computes the 
rank \MATH{r} of \MATH{L} (represented by \MATH{A}) and a matrix 
\MATH{T \IN \Z^{k \TIMES k}} such that
\latex{\centerline{\MATH{A \CDOT T=(\underbrace{0, \LDOTS , 0}_{k-r},
\underbrace{b_0,\LDOTS , b_{r-1}}_{=B})},}}
\html{
 A \CDOT T = ( 0, ..., 0, b_0, ..., b_r-1),
               \__  ___/  \_____  ______/
	          \/            \/
		  k-r           =B
}
where \MATH{B} is a basis of \MATH{L}. The first \MATH{k-r} columns of 
\MATH{T} are relations of the above mentioned type.
\item The Schnorr-Euchner algorithm \cite{SEN} which computes an LLL 
reduced basis of the lattice \MATH{L} which is represented by \MATH{A}.

\item The MLLL algorithm \cite{ZAS} which computes for a \MATH{k-1}-dimensional 
lattice \MATH{L} represented by
\MATH{A=(a_0, \LDOTS, a_{k-1}) \IN M^{n \TIMES k}} a basis 
\MATH{B=(b_0, \LDOTS, b_{k-2})} as well as integers 
\MATH{x_0, \LDOTS , x_{k-1} \IN \Z~} satisfying \MATH{\SUM{i=0}{k-1}{x_ia_i =0}}.    

\item For the class \BF{bigfloat\_lattice\_gensys} a variation of 
the original Schnorr-Euchner algorithm is implemented \cite{SEN} 
where after suitable transformations most of the computations are 
done by using \BF{bigint}s instead of \BF{bigfloat}s. 
\end{itemize}
In the following we will explain the constructors, destructors and 
basic functions of the classes \BF{bigint\_lattice\_gensys} and 
\BF{bigfloat\_lattice\_gensys}. We will use the parameter \BF{type}
to describe the fact that the corresponding function exists in both 
classes and has the same functionality in both cases. Differences 
in the classes will be explained separately. The following description 
is done in respect to column oriented lattices. For row oriented 
lattices you will can change the representation. The corresponding 
computations will then be adjusted automatically.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\CONS
For the following constructors the variable \MATH{A} is assumed to 
represent a lattice. If in the following constructors \MATH{n\LE 1},  
\MATH{k\LE 1},  \MATH{A=NULL} or the dimension of \MATH{A} does not 
correspond to the input parameters which declare the dimension, the 
\TT{lidia\_error\_handler} will be invoked. 

\fcode{ct}{type\_lattice\_gensys}{}
{
constructs a \BF{type\_lattice\_gensys} of size
\MATH{1 \TIMES 1} initialized with zero.
}

\fcode{ct}{type\_lattice\_gensys}{lidia\_size\_t n}
{
constructs a \BF{type\_lattice\_gensys} of size
\MATH{n \TIMES 1} initialized with zero.
}

\fcode{ct}{type\_lattice\_gensys}{lidia\_size\_t n\k lidia\_size\_t k}
{
constructs a \BF{type\_lattice\_gensys} of \MATH{k} vectors embedded 
in an \MATH{n}-dimensional vectorspace initialized with zero.
}

\fcode{ct}{type\_lattice\_gensys}{const type\_lattice\_gensys \& A}
{
constructs a copy of \MATH{A}.
}

\fcode{ct}{type\_lattice\_gensys}{lidia\_size\_t n\k lidia\_size\_t k\k type** \& A}
{
constructs an \MATH{n\TIMES k}-\BF{type\_lattice\_gensys} initialized 
with the values of the 2-dimensional array \MATH{A} where *\MATH{A} 
is a row vector.
}

\fcode{ct}{type\_lattice\_gensys}{const math\_matrix<type>\& A}
{
constructs a \BF{type\_lattice\_gensys} initialized with the values 
of the given \BF{math\_matrix} \MATH{A}.
}

\fcode{dt}{\SIM type\_lattice\_gensys}{}{}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\INIT
Let \MATH{A} be of type \BF{type\_lattice\_gensys}.

\fcode{void}{A.set\_reduction\_parameter}{double y}
{
sets the reduction parameter \MATH{y~(\FRAC{1}{2}< y\LE 1)}. If 
\MATH{y} is not in the range ]\MATH{\FRAC{1}{2},1}], \MATH{y}
is set to the default \MATH{y=0.99}.\\
Warning: It is not guaranteed that the LLL algorithm terminates 
for \MATH{y=1}.
}

\fcode{void}{A.set\_reduction\_parameter}{sdigit p\k sdigit q}
{
sets the reduction parameter \MATH{(\FRAC{1}{2}< \FRAC{p}{q} \LE 1)}. 
The default is taken as in \TT{A.set\_reduction\_parameter(double y)}.
}

\fcode{void}{A.set\_representation\_columns}{}
{
sets the representation such that the reduction will be done column 
oriented. By default the representation is taken as column oriented.
}

\fcode{void}{A.set\_representation\_rows}{}
{
sets the representation such that the reduction will be done row 
oriented. By default the representation is taken as column oriented.
}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\ASGN
Let \MATH{A} be of type \BF{type\_lattice\_gensys}.

The operator \TT{=} is overloaded. For  efficiency reasons the 
following functions are also implemented:

\fcode{void}{A.assign}{const type\_lattice\_gensys \& B}
{
\MATH{A = B}.
}

\fcode{void}{assign}{type\_lattice\_gensys\& A\k const type\_lattice\_gensys\& B}
{
\MATH{A = B}.
}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\BASIC
Let \MATH{A} be of type \BF{type\_lattice\_gensys}.

\fcode{void}{A.compute\_basis}{const math\_matrix < type > \& B\k const math\_matrix < type > \& T}
{
computes 
\latex{\MATH{A = B \CDOT T = (\underbrace{0, \LDOTS , 0}_{k-r}, 
\underbrace{c_0, \LDOTS , c_{r-1}}_{=C})}}
\html{
 A = B \CDOT T = ( 0, ..., 0, c_0, ..., c_r-1),
                   \__  ___/  \_____  ______/
		      \/            \/
		      k-r           =C
} where \MATH{C} is a basis of the lattice.
In order to extract the actual Basis \MATH{C} use the function 
\TT{C.extract\_basis(A, r)} of the class \BF{type\_lattice\_basis}.
The \TT{lidia\_error\_handler} will be invoked, if \MATH{A},\MATH{B} 
or \MATH{T} do not have appropriate dimension.
}

\fcode{sdigit}{A.get\_no\_of\_corrections}{}
{
returns the number of corrections needed for reducing the lattice 
by using the Schnorr-Euchner variation.
}

\fcode{sdigit}{A.get\_no\_of\_reduction\_steps}{}
{
returns the number of reduction steps needed for reducing the lattice.
}

\fcode{sdigit}{A.get\_no\_of\_swaps}{}
{
returns the number of swaps needed for reducing the lattice.
}

\fcode{double}{A.get\_reduction\_parameter}{}
{
returns \MATH{y} as described in \TT{A.set\_reduction\_parameter(y)}.
}

\fcode{void}{A.get\_reduction\_parameter}{sdigit \& p\k sdigit \& q}
{
returns \MATH{\FRAC{p}{q}} as described in 
\TT{A.set\_reduction\_parameter(p,q)}.
}

\fcode{bool}{A.get\_representation}{}
{
returns \TRUE\ if the representation is column oriented,
\FALSE\ otherwise.}

\fcode{void}{A.lin\_gen\_system}{math\_matrix<type> \& T\k lidia\_size\_t \& r}{}

\fcode{type\_lattice\_gensys}{lin\_gen\_system}{const type\_lattice\_gensys \& A\k lidia\_size\_t \& r}
{
computes the transformation matrix \MATH{T} such that 
\latex{\MATH{A \CDOT T=(\underbrace{0, \LDOTS , 0}_{k-r}, 
\underbrace{b_0, \LDOTS , b_{r-1}}_{=B})}} 
\html{
 A \CDOT T = ( 0, ..., 0, b_0, ..., b_r-1),
               \__  ___/  \_____  ______/
                  \/            \/
                  k-r           =B
} as well as the rank \MATH{r} of the basis \MATH{B} by using the 
Buchmann-Kessler algorithm \cite{BUK}.
}

\fcode{void}{A.lll\_gensys}{lidia\_size\_t \& r\k sdigit factor = 1}{}

\fcode{type\_lattice\_gensys}{lll\_gensys}{const type\_lattice\_gensys \& A\k lidia\_size\_t \& r\k sdigit factor = 1}
{
computes 
\latex{\MATH{A =(\underbrace{b_0, \LDOTS , b_{r-1}}_{=B},
\underbrace{0, \LDOTS , 0}_{k-r})}} 
\html{
 A = ( b_0, ..., b_r-1, 0, ..., 0),
       \_____  ______/  \__  ___/
             \/            \/
             =B            k-r
} where \MATH{B} is reduced and the rank \MATH{r} of the lattice 
by using the Schnorr-Euchner algorithm \cite{SEN}. With \MATH{factor} 
the precision will be determined as (\MATH{factor \CDOT}~double precision).
Therefore for \MATH{factor \LT 2} the approximations are done by using 
doubles, otherwise \BF{bigfloat}s with the appropriate precision will be 
used.
}

\fcode{void}{A.lll\_gensys}{const math\_matrix<type>\& B\k lidia\_size\_t \& r\k sdigit factor = 1}
{
assigns \MATH{B} to \MATH{A} and performs \TT{A.lin\_gensys(r)}.
}

\fcode{void}{A.lll\_trans\_gensys}{math\_matrix<type>\& T\k lidia\_size\_t \& r\k sdigit factor = 1}{}

\fcode{type\_lattice\_gensys}{lll\_trans\_gensys}{const type\_lattice\_gensys \& A\k math\_matrix<type> \& T\k lidia\_size\_t \& r\k sdigit factor = 1}
{
computes 
\latex{\MATH{A =(\underbrace{b_0, \LDOTS , b_{r-1}}_{=B},
\underbrace{0, \LDOTS , 0}_{k-r})}}
\html{
 A = ( b_0, ..., b_r-1, 0, ..., 0),
       \_____  ______/  \__  ___/
             \/            \/
             =B            k-r
} where \MATH{B} is reduced, the corresponding transformation 
matrix \MATH{T} as well as the rank \MATH{r} of the basis \MATH{B} 
by using the Schnorr-Euchner algorithm \cite{SEN}. With \MATH{factor} 
the precision will be determined as (\MATH{factor \CDOT}~double precision).
Therefore for \MATH{factor \LT 2} the approximations are done by using 
doubles, otherwise \BF{bigfloat}s with the appropriate precision will be 
used.
}

\fcode{void}{A.mlll}{type*\& v}{}

\fcode{type\_lattice\_gensys}{mlll}{const type\_lattice\_gensys \& A\k type*\& v}
{
computes a \MATH{k-2}-dimensional basis of \MATH{A=(a_0, \LDOTS, a_{k-1}) 
\IN M^{n \TIMES k}} as well as a vector \MATH{v} satisfying 
\MATH{\SUM{i=0}{k-1}{v_ia_i}=0} by using the modified LLL-algorithm 
\cite{ZAS}.
}

\fcode{void}{A.mlll}{const math\_matrix<type>\& B\k type*\& v}
{
assigns \MATH{B} to \MATH{A} and performs \TT{A.mlll(v)}.
}

\fcode{void}{A.mlll}{base\_vector<type> \& v}{}

\fcode{type\_lattice\_gensys}{mlll}{type\_lattice\_gensys \& A\k base\_vector<type> \& v}
{
computes a \MATH{k-2}-dimensional basis of \MATH{A=(a_0, \LDOTS, a_{k-1}) 
\IN M^{n \TIMES k}} as well as a vector \MATH{v} satisfying 
\MATH{\SUM{i=0}{k-1}{v_ia_i}=0} by using the modified LLL-algorithm 
\cite{ZAS}.
}

\fcode{void}{A.mlll}{const math\_matrix<type>\& B\k base\_vector<type> \& v}
{
assigns \MATH{B} to \MATH{A} and performs \TT{A.mlll(v)}.
}

\fcode{void}{A.randomize\_vectors}{}
{
permutes the vectors of the given lattice randomly.
}

\fcode{void}{A.sort\_vectors}{cmp\_func}
{
sorts the vectors of the given lattice such that their lengths 
(length in the meaning of the \MATH{cmp\_func}, which is defined 
as \TT{int (*cmp\_func)(const type*, const type*, long)}) are in 
descending order.
}

\fcode{void}{A.sort\_big\_vectors}{}
{
sorts the vectors of the given lattice such that their lengths 
(by means of the Euclidian norm) are in descending order.
}

\fcode{void}{A.sort\_small\_vectors}{}
{
sorts the vectors of the given lattice such that their lengths 
(by means of the Euclidian norm) are in ascending order.
}

%################################################################

In addition the class \BF{bigfloat\_lattice\_gensys} supports the 
following functions:\\

\fcode{void}{A.lin\_gen\_system}{math\_matrix<bigint>\& T\k lidia\_size\_t \& r}{}

\fcode{bigint\_lattice\_gensys}{lin\_gen\_system}{const bigfloat\_lattice\_gensys \& A\k lidia\_size\_t \& r}
{
computes the transformation matrix \MATH{T} such that 
\latex{\MATH{A \CDOT T=(\underbrace{0, \LDOTS , 0}_{k-r}, 
\underbrace{b_0, \LDOTS , b_{r-1}}_{=B})}}
\html{
 A \CDOT T = ( 0, ..., 0, b_0, ..., b_r-1),
               \__  ___/  \_____  ______/
	          \/            \/     
	          k-r           =B   
} as well as the rank \MATH{r} of the basis \MATH{B} by using the 
Buchmann-Kessler algorithm \cite{BUK}.
}

\fcode{void}{A.lll\_trans\_gensys}{math\_matrix<bigint>\& T\k lidia\_size\_t \& r\k sdigit factor = 1}{}

\fcode{bigfloat\_lattice\_gensys}{lll\_trans\_gensys}{const bigfloat\_lattice\_gensys \&A\k math\_matrix<bigint> \&T\k lidia\_size\_t \& r\k sdigit factor = 1}
{
computes \latex{\MATH{A =(\underbrace{b_0, \LDOTS , b_{r-1}}_{=B},
\underbrace{0, \LDOTS , 0}_{k-r})}}
\html{
 A = ( b_0, ..., b_r-1, 0, ..., 0),
       \_____  ______/  \__  ___/
             \/            \/
             =B            k-r
} where \MATH{B} is reduced, the corresponding transformation matrix 
\MATH{T} as well as the rank \MATH{r} of the basis \MATH{B} by using 
the Schnorr-Euchner algorithm \cite{SEN}. With \MATH{factor} the 
precision will be determined as (\MATH{factor \CDOT}~double precision).
Therefore for \MATH{factor \LT 2} the approximations are done by using 
doubles, otherwise \BF{bigfloat}s with the appropriate precision will be 
used.
}

\fcode{void}{A.lll\_trans\_var\_gensys}{math\_matrix<bigint>\& T\k lidia\_size\_t \& r\k sdigit factor = 1}{}

\fcode{bigfloat\_lattice\_gensys}{lll\_trans\_var\_gensys}{const bigfloat\_lattice\_gensys \&A\k math\_matrix<bigint> \&T\k lidia\_size\_t \& r\k sdigit factor = 1}
{
computes \latex{\MATH{A =(\underbrace{b_0, \LDOTS , b_{r-1}}_{=B},
\underbrace{0, \LDOTS , 0}_{k-r})}}
\html{
 A = ( b_0, ..., b_r-1, 0, ..., 0),
       \_____  ______/  \__  ___/
             \/            \/
             =B            k-r
} where \MATH{B} is reduced, the corresponding transformation matrix 
\MATH{T} as well as the rank \MATH{r} of the basis \MATH{B} by using 
a variation of the Schnorr-Euchner algorithm \cite{SEN}. With 
\MATH{factor} the precision will be determined as (\MATH{factor\CDOT}~double 
precision). Therefore for \MATH{factor \LT 2} the approximations are done 
by using doubles, otherwise \BF{bigfloat}s with the appropriate precision 
will be used.
}

\fcode{void}{A.lll\_trans\_var\_gensys}{math\_matrix<bigfloat>\& T\k lidia\_size\_t \& r\k sdigit factor = 1}{}

\fcode{bigfloat\_lattice\_gensys}{lll\_trans\_var\_gensys}{const bigfloat\_lattice\_gensys \&A\k math\_matrix<bigfloat> \&T\k lidia\_size\_t \& r\k sdigit factor = 1}
{
computes \latex{\MATH{A =(\underbrace{b_0, \LDOTS , b_{r-1}}_{=B},
\underbrace{0, \LDOTS , 0}_{k-r})}}
\html{
 A = ( b_0, ..., b_r-1, 0, ..., 0),
       \_____  ______/  \__  ___/
             \/            \/
             =B            k-r
} where \MATH{B} is reduced, the corresponding transformation matrix 
\MATH{T} as well as the rank \MATH{r} of the basis \MATH{B} by using 
a variation of the Schnorr-Euchner algorithm \cite{SEN}. With 
\MATH{factor} the precision will be determined as (\MATH{factor\CDOT}~double 
precision). Therefore for \MATH{factor \LT 2} the approximations are 
done by using doubles, otherwise \BF{bigfloat}s with the appropriate 
precision will be used.
}

\fcode{void}{A.lll\_var\_gensys}{lidia\_size\_t\& r\k sdigit factor = 1}{}

\fcode{bigfloat\_lattice\_gensys}{lll\_var\_gensys}{const bigfloat\_lattice\_gensys \&A\k lidia\_size\_t \& r\k sdigit factor = 1}
{
computes \latex{\MATH{A =(\underbrace{b_0, \LDOTS , b_{r-1}}_{=B},
\underbrace{0, \LDOTS , 0}_{k-r})}}
\html{
 A = ( b_0, ..., b_r-1, 0, ..., 0),
       \_____  ______/  \__  ___/
             \/            \/
             =B            k-r
} where \MATH{B} is reduced and the rank \MATH{r} of the basis 
\MATH{B} by using a variation of the Schnorr-Euchner algorithm \cite{SEN}.
With \MATH{factor} the precision will be determined as (\MATH{factor\CDOT}~double 
precision). Therefore for \MATH{factor \LT 2} the approximations are 
done by using doubles, otherwise \BF{bigfloat}s with the appropriate 
precision will be used.
}

\fcode{void}{A.lll\_var\_gensys}{math\_matrix<bigfloat>\& B\k lidia\_size\_t \& r\k sdigit factor = 1}
{
assigns \MATH{B} to \MATH{A} and performs \TT{A.lll\_gensys(r)}.
}

\fcode{void}{A.mlll}{bigint*\& v}{}

\fcode{bigfloat\_lattice\_gensys}{mlll}{const bigfloat\_lattice\_gensys \& A\k bigint*\& v}
{
computes a \MATH{k-2}-dimensional basis of 
\MATH{A=(a_0, \LDOTS, a_{k-1}) \IN M^{n \TIMES k}} as well as a 
vector \MATH{v} satisfying \MATH{\SUM{i=0}{k-1}{v_ia_i}=0}
by using the modified LLL-algorithm \cite{ZAS}.
}

\fcode{void}{A.mlll}{const math\_matrix < bigfloat > \& B\k bigint*\& v}
{
assigns \MATH{B} to \MATH{A} and performs \TT{A.mlll(v)}.
}

\fcode{void}{A.mlll}{base\_vector<bigint>\& v}{}

\fcode{bigfloat\_lattice\_gensys}{mlll}{const bigfloat\_lattice\_gensys \& A\k base\_vector<bigint> \& v}
{
computes a \MATH{k-2}-dimensional basis of 
\MATH{A=(a_0, \LDOTS, a_{k-1}) \IN M^{n \TIMES k}} as well as a 
vector \MATH{v} satisfying \MATH{\SUM{i=0}{k-1}{v_ia_i}=0}
by using the modified LLL-algorithm \cite{ZAS}.
}

\fcode{void}{A.mlll}{const math\_matrix<type>\& B\k base\_vector<bigint>\& v}
{
assigns \MATH{B} to \MATH{A} and performs \TT{A.mlll(v)}.
}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\SEEALSO
\BF{base\_matrix}, \BF{math\_matrix}, \BF{type\_lattice\_basis}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\EXAMPLES
\begin{verbatim}
 #include <LiDIA/bi_lattice_gensys.h>  // using class bigint_lattice_gensys
 int main()
 { 
   lidia_size_t r;
   bigint_lattice_gensys A, B, T;
   cout << "\n please enter the matrix:";  
   cout << "\n (format described in the manual) \n";
   cin >> A;
   B.assign(A);
   A.lll_trans_gensys(T, r);
   A.compute_basis(B, T);
   cout << "\n reduced matrix :  \n \n" << A << "\n";   
   return (0);
 }

 #include <LiDIA/bf_lattice_gensys.h>  // using class bigfloat_lattice_gensys
 int main()
 { 
   lidia_size_t r;
   bigfloat_lattice_gensys A, T;
   cout << "\n please enter the matrix:";  
   cout << "\n (format described in the manual) \n";
   cin >> A;
   A.lin_gen_system(T, r);
   A.compute_basis(A, T);
   cout << "\n reduced matrix :  \n \n" << A << "\n";   
   return (0);
 }
\end{verbatim}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\AUTHOR
Werner Backes, Thorsten Lauer, Oliver van Sprang, Susanne Wetzel\\
(code fragments written by Jutta Bartholomes)


\end{lidia_man}
