@
@ ----------------------------------------------------------------------------
@
@ FILE: normalop.c
@
@ ----------------------------------------------------------------------------
@
@
@----------------------------------------------------------------------------
@
@ static matrix_TYP *reverse_valuation(MP_INT *val,matrix_TYP *D)
@
@ The value of val will not be changed !
@----------------------------------------------------------------------------
@
@
@ -------------------------------------------------------------------------
@
@ matrix_TYP *orbit_rep(matrix_TYP *x,matrix_TYP **N,int nanz,matrix_TYP *D,
@                       int option,char *B,MP_INT *l,int *anz,
@                       int **word,int word_flag)
@
@
@ option:       an integer controling the behaviours of the function.
@               option = 0: return the length of the orbit via anz[0] and
@                           the smallest representative via return.
@               option = 1: return straight if we found a smaller
@                           representative, and return this one.
@                           anz[0] has no defined meaning in this case.
@ char *B:
@
@ l:            the valuation of the representative returned is via
@               this pointer.
@
@ int **word:   needed only for word_flag==TRUE:
@               returns a list of integers word with the following property:
@               N[word[0][1]] * N[word[0][2]] * ... *N[word[0][word[0][0]]
@               is a word representing the smallest representative in the
@               orbit.
@ int word_flag: drives the behaviour of the function:
@                for word_flag == TRUE it calculates such a word described
@                above, otherwise it will not change word[0] (hopefully).
@
@ Neither the matrices given nor any global variable is changed.
@
@ -------------------------------------------------------------------------
@
@
@ -------------------------------------------------------------------------
@
@
@ -------------------------------------------------------------------------
@
@ matrix_TYP *normalop(matrix_TYP *cozycle,matrix_TYP *D,matrix_TYP *R,
@                      bravais_TYP *G,matrix_TYP *N)
@
@ Calculates the action of the matrix N on the cohomology group H^1(G,*)
@ described by the matrices cozycle, D, R, which are in turn output of
@ cohomology.
@
@ CAUTION: The matrix returned describes the action on rows, and it is
@          not checked whether N is realy an element of the normalizer of G!
@
@ matrix_TYP *cozycle: the first return value of cohomology for G.
@ matrix_TYP *D:       the second return value of cohomology for G.
@ matrix_TYP *R:       the third return value of cohomology for G.
@ bravais_TYP *G:      the group. only the field generator is realy needed.
@ matrix_TYP  *N:      the matrix in question.
@
@ No global variables nor the arguments are changed (hopefully).
@
@ -------------------------------------------------------------------------
@
@
@--------------------------------------------------------------------------
@
@ matrix_TYP **identify(matrix_TYP *cozycle,matrix_TYP *D,matrix_TYP *R,
@                       bravais_TYP *G,matrix_TYP **extension,MP_INT *a,
@                       int number,int transform_flag)
@
@ Identifies the space groups described by the cozycles in extension,
@ i.e. gives them different number iff they are not isomorphic.
@ The return value depends on the value of transform_flag. If
@ (transform_flag == TRUE) it will return a list of "number" matrices in
@ the normalizer of the point group which transforms each given extension
@ into it's least representative. This is usefull to calculate the
@ isomorphism between two extensions which get the same name.
@ NOTE: the name given to an extension is 0 (interpreted as MP_INT) iff
@       the extension splits.
@
@   matrix_TYP *cozykle:   1st matrix returned by cohomolgy for G.
@   matrix_TYP *D:         2nd matrix returned by cohomolgy for G.
@   matrix_TYP *R:         3rd matrix returned by cohomolgy for G.
@   bravais_TYP *G:        the group in question. Needed are the
@                          fields G->gen, G->gen_no, G->cen,G->cen_no,
@                          G->normal,G->normal_no.
@                          Important for the correctness of the result
@                          is that the matrices in G->cen, G->normal
@                          generate N_GL_n(Z) (G) /G.
@  matrix_TYP **extension: matrices discribing a cozycles for the group G.
@                          So each matrix in the list discribes a spacegroup.
@  MP_int *a:              The names for the groups will be returned
@                          via this field. The space has to be allocated
@                          via malloc and to be mpz_init-ed for each
@                          entry before calling the function.
@  int number:             The number of matrices in extension.
@  int transform_flag:     if (transform_flag) the function will return
@                          a pointer containing "number" matrices which
@                          transform each extension into it's least
@                          representative. Otherwise it will return NULL.
@--------------------------------------------------------------------------
@
@
@ -------------------------------------------------------------------------
@
@ matrix_TYP **extensions(matrix_TYP *cozycle,matrix_TYP *D,matrix_TYP *R,
@             bravais_TYP *G,int **lengths,MP_INT **names,int *number_of_orbits)
@
@ Returns the cozycles which generate the isomorphims classes of
@ extensions of G by the natural ZG-module. The split extension is
@ represented by an all zero matrix.
@
@ The arguments are:
@   matrix_TYP *cozykle:   1st matrix returned by cohomolgy for G.
@   matrix_TYP *D:         2nd matrix returned by cohomolgy for G.
@   matrix_TYP *R:         3rd matrix returned by cohomolgy for G.
@   bravais_TYP *G:        the group in question.
@   int **lengths:         length[0] returns a pointer to the lengths
@                          of the orbits respectively
@   MP_INT **names:        names[0] returns a pointer to the names of
@                          the cozycles as they would appear in a call
@                          of identify(.....).
@   int *number_of_orbits: the number of orbits the normalizer induces
@                          on the cohomology group.
@ -------------------------------------------------------------------------
@
@
@----------------------------------------------------------------------------
@
@ static void no_of_fixpoints(MP_INT *res,matrix_TYP *A,matrix_TYP *D)
@
@
@ CAUTION: A->array.SZ, A->cols WILL BE CHANGED!!!!
@----------------------------------------------------------------------------
@
@
@------------------------------------------------------------------------
@
@ void no_of_extensions(matrix_TYP *cozycle,matrix_TYP *D,
@                        matrix_TYP *R,bravais_TYP *G,MP_INT *erg)
@
@------------------------------------------------------------------------
@
@
@----------------------------------------------------------------------
@
@ matrix_TYP *reget_gen(matrix_TYP **map,int number,bravais_TYP *G,
@                              int **words,int word_flag)
@
@----------------------------------------------------------------------
@
