README

@
@-------------------------------------------------------------------------------
@  FILE: bravais_tools.h
@
@-------------------------------------------------------------------------------
@
@
@------------------------------------------------------------------------------
@
@ bravais_TYP *bravais_group(bravais_TYP *H)
@
@ Calculates the bravais group of H. the result G of this function
@ will have G->gen and G->form assigned.
@ The program relies on H->form to be correct if it is given.
@------------------------------------------------------------------------------
@
@
@----------------------------------------------------------------------------
@
@ bravais_TYP *copy_bravais(bravais_TYP *H)
@
@ copies all data form H to the result. Nothing is checked.
@----------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@ FILE: formspace.c
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@ matrix_TYP **formspace(B, Banz, sym_opt, fdim)
@ matrix_TYP **B;
@ int Banz, sym_opt, *fdim;
@
@  formspace calculates a basis of the lattice of integral matrices X with
@      B[i]^{tr} * X * B[i] = X    for 0 <= i < Banz
@  The number of basis elements is returned via (int *fdim).
@  'sym_opt' must be 0, 1 or -1.
@  sym_opt = 0:  the full lattice is calculated.
@  sym_opt = 1:  a basis for the symmetric matrices is calculated
@  sym_opt =-1:  a basis for the skewsymmetric matrices is calculated
@      
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@ FILE: init_bravais.c
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@ bravais_TYP *init_bravais(dim)
@ int dim;
@
@ returns a bravais_TYP 'B' with B->dim = dim
@ and all other pointers an integers in B are set to NULL resp. 0
@ and B->divisors[i] = 0 for 0<= i < 100
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@ FILE: invar_space.c
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@ matrix_TYP **invar_space(B, Banz, fodim, symm_opt, epsilon, anz)
@ matrix_TYP **B;
@ int Banz, fodim, symm_opt, epsilon, *anz;
@
@ calculates a basis of the lattices of integral matrices X 
@ with B[i]^{tr} * X * B[i] = X for 0<=i<Banz
@ 
@ the number of basis elements must be given to the function by the
@ integer 'fodim'
@ Then 'fodim'+1 random elements of the lattice are calculated with
@ the function 'rform' and
@ a basis of the integral matrices in the subspace generated by these
@ elements is constructed with 'long_rein_mat'.
@ This basis is the result and the number of elements is returned
@ via (int *anz)
@ The argument 'epsilon' is the only needed argument for 'rform', that
@ is called in the function.
@ the number of basis elements is returned via (int *anz).
@ 
@  'symm_opt' must be 0, 1 or -1.
@  symm_opt = 0:  the full lattice is calculated.
@  symm_opt = 1:  a basis for the symmetric matrices is calculated
@  symm_opt =-1:  a basis for the skewsymmetric matrices is calculated
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@ FILE: konj_bravais.c
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@ bravais_TYP *konj_bravais(B, T)
@ bravais_TYP *B;
@ matrix_TYP *T;
@
@  calculates the group T B T^(-1)
@  all informations of B are transformed: B->gen, B->form,....
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@ FILE: lincomb.c
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@ matrix_TYP *vec_to_form(v, F, Fanz)
@ int *v;
@ matrix_TYP **F;
@ int Fanz;
@
@ calculates the matrix v[1] F[1]  + v[2] F[2] +....+v[Fanz-1] F[Fanz-1}
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@ void form_to_vec(erg, A, F, Fanz, denominator)
@ int *erg;
@ matrix_TYP *A, **F;
@ int Fanz, *denominator;
@
@ calculates a vector v such that A = 1/d(v[0]F[0] +...+v[Fanz-1]F[Fanz-1]
@ and writes it onto the vector erg.
@ the space for erg must be allocated before using this function.
@ the integer d is returned via the pointer denominator.
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@ vertex_TYP *form_to_vertex(A, F, Fanz, denominator)
@ matrix_TYP *A, **F;
@
@ calculates a vector v such that A = 1/d(v[0]F[0] +...+v[Fanz-1]F[Fanz-1]
@ and returns it as V->v in a vertex_TYP V..
@ The integer d is returned via the pointer denominator.
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@ form_to_vec_modular(erg, A, F, Fanz)
@ matrix_TYP *A, **F;
@ int *erg, Fanz;
@
@ the same as form_to_vec, but works only if the linear combination is
@ integral, i.e. the denominator is assumed to be 1.
@ the function calculated the result modulo big primes and fits it
@ together with the chinese remainder theorem.
@ This is faster as form_to_vec and avoids overflow.
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@ FILE: normlin.c
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@ matrix_TYP *normlin(Fo, N, fdim)
@ matrix_TYP **Fo, *N;
@ int fdim;
@
@ normlin calculates a matrix fdim x fdim - matrix X such that
@ X[i], the i-th row of X, has the property
@ X[i][0] * Fo[0] + ... + X[i][fdim-1] * Fo[fdim-1] = N^{tr} * Fo[i] * N
@ That means X describes the matrix of the linear action of N on
@ the vectorspace generated by the Fo[i] by F->N^{tr}F N with respect to
@ the basis Fo[0],..,Fo[fdim-1].
@ CAUTION: The matrix describes the action on rows !
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@ FILE: p_formspace.c
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@ matrix_TYP **p_formspace(B, Banz, prime, sym_opt, fdim)
@ matrix_TYP **B;
@ int Banz, prime, sym_opt, *fdim;
@
@ The same as formspace, just module the prime.
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@ FILE:  rform.c
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@ matrix_TYP *rform(B, Banz, Fo, epsilon)
@ matrix_TYP **B;
@ int Banz;
@ matrix_TYP *Fo;
@ int epsilon;
@
@ If G denotes the group generated by B[0],...,B[Banz-1],
@ then 'rform' calculates a matrix  A that is the sum over all g in G of
@   g^{tr} * Fo * g
@ This matrix is divided by the gcd of its entries and returned.
@ The algorithm uses an appoximation and the precession is 1/epsilon.
@ If epsilon < 100, the function sets epsilon = 100.
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@ FILE:  tr_bravais.c
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@ bravais_TYP *tr_bravais(B, calcforms, invert)
@ bravais_TYP *B;
@ int calcforms;
@ int invert;
@
@  'tr_bravais' caclulates the group G =  B^{tr}
@  The matrices in B->gen, B->zentr, B->normal and B->cen are transposed
@  (if exists)
@  If calcforms == 0, then the matrices of G->form are not calculated
@  If calcforms == 1, then G->form is calculated with 'formspace'
@  If calcforms == 2, then G->form is calculated with 'invar_space'
@                     if B->form_no != 0, invar_space is started with
@                     fdim = B->form_no, otherwise the argument 'fdim'
@                     for invar_space is calculated by calculating the
@                     formspace with p_formspace modulo 101.
@  If (invert == TRUE) the matrices in G->gen,G->cen,G->normal
@  are inverted.
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@ FILE: trace_bifo.c
@---------------------------------------------------------------------------
@---------------------------------------------------------------------------
@
@---------------------------------------------------------------------------
@ Calculates S = (S[i][j]) with S[i][j] = trace(F1[i]F2[j]) for 1<= i,j <= anz.
@ Then g = gcd(S[i][j]) is calculated and  the result is S = 1/g * S.
@
@---------------------------------------------------------------------------
@