This version is not tested yet

ELPA2 can now be build (as ELPA1) for single precision calculations.
The ELPA2 kernles which are implemented in assembler, C, or C++ have NOT
yet been ported.

Thus at the moment only the GENERIC and GENERIC_SIMPLE kernels support
single precision calculations

With the configure option "--enable-single-precision" ELPA1 is build
with single-precision (half-words) only.

The best precision in single-precision (float or complex) is
2^-23 ~ 1.2e-7. The accuracy of the error residual of ELPA1 in
single-precision mode is of the order 1e-4 to 1e-5. The orthogonality of
the EV's is fullfilled up to about ~1e-6.

Thus the precision of ELPA1 in single-precision mode is roughly 100 -
1000 times less than the best achievable precison. This is consistent
with the double-precision mode, where also a factor of 100 - 1000 less
precision than the theoretical best one is found.

The float EVs are identical to the double EVs to at least 1e-2, the
precision of the EVs is thus about 1e-7/1e-2 = 1e5 times lower than the
best theoretical precision. If the same holds for the double precision
calculations, this implies that the double precision results can also
be only trusted on the level 1e-11 (5 orders of magnitude larger
than the best theoretical precision)

The best speed-up compared to the double precision calculation is
a factor of two. This is by far not achieved yet, since the singl
precision version is not at all optimized at the moment

As always the debug messages appear if the environment variable
is set

This commit is performance critical and has to be timed carefully.
Thus one can switch back to the old implementation. The new one,
however is more safe and better to debug

This commit might be performance critical, it has to be timed
carefully. Thus one can switch back to the old implementation.
The new one, however, is more safe and better to debug

This change might be performance critical and has to be timed
carefully. Thus it is possible to switch back to the old
implementation. The new one, however, can actually be debbuged

The generic real kernel is now contained in a module, this allows
strict interface checking! It also does not use assumed size arrays
anymore. Both points increase the possibility to debug and find errors.

However, this might be performance critical! It is possible to
switch back to the old implementation if that turns out to
be beneficial w.r.t. performance. Timings with gfortran 4.9 on Intel
Haswell showed that the new implementation is about 30 percent faster
then the previous one

Now all functions, which were "contained" in anoter one are moved
to seperate modules. This allows for strict interface checking and
debugging

This routine has been contained in a subroutine.
It has been moved to a module and and renamed to
"single_hh_trafo_real" to make it's intention more clear

The assumed size definitions are not needed, and are removed.
This will imply a chnage of the so-Versioning number

All variables (real, integer, complex) are now declecared with the
appropiate kind statement. The definition of the kind types is done
in src/mod_precision.f90

To ensure interoperability with C, the kind types are decleared via
iso_c_binding to C variables

In some C test programs the function declaration header files
have been missing

The Fortran variable declerations "variable type*[4,8,16]" is non
Fortran standard. It might cause problem in the future.
Furthermore, the usage of Fortran and C togehther is more clean
if variables are defined according to C variable types.

This is done, now for all the test programs

Similiar to commits 2998fac3 and 9710bf08 split elpa1.F90 and elpa2.F90
to make merge easier