unlike elpa 2stage, scalapack computes only part of eigenvalues
if only part of eigenvectors are required. Check only those.

with obvious meaning

for easier comparisons of elpa and mkl, a test case using scalapack
function pdsyevd has been added

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.

matrices of dimension of the form 2^n * 3^m * 5^m are now allowed.
For other matrix sizes, the test is terminated. Matrix size is not
modified, as it has been the case before

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).

The functions in elpa_utilities are considered "ELPA internal",
i.e. the should not be accessible by the users and thus not
be part of the API.

Introducing new test in which matrix and its eigendecomposition is
known and thus can be easily created and checked directly, without the
need to use scalapack or any other communication (apart from reducing
error).

The test is based on the fact, that if L_A and S_A are eigenvalues and
eigenvectors of matrix A, respectively, and L_B and S_B eigenvalues and
eigenvectors of B, then kron(L_A, L_B) and kron (S_A, S_B) are
eigenvalues and eigenvectors of kron(A, B).
Since it is easy to know exact eigendecomposition of a small matrix (e.g.
2x2), and kron operator has very simple structure, we can construct
arbitrarily large matrix and its eigendecomposition. We only have to
select small matrices such that the resulting matrix has unique and
ordered eigenvalues, so that the checking of the result is than easy.
Each element of matrix, eigenvector matrix and eigenvalue vector can
be quickly computed independently, just using its global coordinates.

The test is currently limited to matrices of size 2^n, but by
storing eigendecompositions of more small matrices (e.g. 3x3 and 5x5) we
could construct any matrix of size 2^n*3^m*5^o, which would probably be
sufficient, since most often used sizes (150, 1000, 5000, 2000, 60000)
are of this form.

The routines "eigenvalues" and "solve_tridiagonal" are now
also tested directly with the new API (and not only via the
legacy API -> new API mapping)

Todo: adapt test generator script to contain some logic

In case of GPU build it is NOT sufficient to loop over all kernels:

For the GPU kernels one must ALSO set that GPUs should be used

- 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.