GitLab

We got reports from a user that there were troubles with certain domain
decompositions. So far the tests only looked at (approximately) square
decompositions in column-major process order.

Now, a new class of tests loops over all possible decompositions
(row * col) for a given number of total tasks.

So far, we can not confirm that there are any problems, all
possibilities work as expected.

Previously we checked ortonormality of eigenvectors by comparing
the matrix S^T * S to identity matrix. The new feature is also
checking just the diagonal of the matrix S^T * S. By that we get
the information, how far are the eigenvectors from having length 1.
If it turns out to be important, we could try to normalize them
at the end of elpa, which is simple (in contrast with enforcing
better orthogonality).

- Remove all use of ELPA internal modules, the test programs now
  only use the public ELPA API. This is now enforced, by hiding the
  private modules

- Prefix all test internal modules with "test_" to make it really
  clear that these modules are not to be used by users.

The public "solve" method has been renamed "eigenvectors" since it
computes the eigenvalues and (at least parts of) the eigenvectors

Another routine "eigenvalues" will just compute the eigenvalues

This is a bit cumbersome, as it involves yet another abstract
intermediate type, but necessary due to language limitations.

The legacy API is has been (internally) ported to use the new interface.
The intent is that users of the legacy API do not have to change their
codes.

Next step is to completely adapt the .gitlab-ci.yml file

Still missing is the compatibility layer, currently it only compiles
when configure is called with

  --disable-legacy

Also, a more general solution to parameter passing via environment
variables would be nice.

Unfortunately C macros can have only 1 line and length of line is
limited ---> workaround to be able to compile

They are in a sad state, it's all copy&paste and chaos. This commit
only touches the surface so far.

This attempt at a new, more flexible API for ELPA should hopefully
result in less ABI/API breaking changes in the future.

The new API features a generic key/value system for options that can be
extended without changing any exported symbols or function signatures,
so that new, optional features do not influence existing usage of ELPA.

We hope this makes life easier for users of ELPA - at least in the long
run when they migrated to this newest of ABI changes :)

Example usage (explicit documentation to be done in a future commit):

   if (elpa_init(20170403) /= ELPA_OK) then
     error stop "ELPA API version not supported"
   endif

   e = elpa_create(na, nev, na_rows, na_cols, nblk, mpi_comm_world, my_prow, my_pcol, success)

   call e%set("solver", ELPA_SOLVER_2STAGE)
   call e%set("real_kernel", ELPA_2STAGE_REAL_GENERIC)

   call e%solve(a, ev, z, success)

   call e%destroy()

   call elpa_uninit()

Some of the file names were too long, automake then dropped these
files when doing "make distcheck"

This solves issue #14

library

It the configure option "--enable-single-precision" is specified,
ELPA will also be build for single precision usage. The double precision
and single precision will be available at the same time with names
"solve_evp_real_1stage_double" or "solve_evp_real_1stage_single" and
so on...

This change immplied some major refactoring of the ELPA code:
1.) functions/procedures had to be renamed with suffix "_double"

2.) If necessary the same functions have to be available with suffix
"_single"

3.) Variable kind definitions have to be consistent with the
intented use

To avoid uneccessary code duplication this is done (most of the time)
with preprocessor string substitution.

The documentation has been updated.

NOT SUPPORTED are at the moment:

- single precision usage of ELPA2 with kernels, others than "generic"
  and "generic_simple"

- single precision usage of GPU

files

The test programs include the same template now, the
printed messages are thus unified

The configure flag "--enable-shared-memory-only" triggers a build
of ELPA without MPI support:

- all MPI calls are skipped (or overloaded)
- all calls to scalapack functions are replaced by the corresponding
  lapack calls
- all calls to blacs are skipped

Using ELPA without MPI gives the same results as using ELPA with 1 MPI
task!

This version is not yet optimized for performance, here and there some
unecessary copies are done.

Ths version is intended for users, who do not have MPI in their
application but still would like to use ELPA on one compute node