elpa_impl Module Reference

Fortran module which provides the actual implementation of the API. Do not use directly! Use the module "elpa". More...

Data Types
type	elpa_impl_t
	Definition of the extended elpa_impl_t type. More...

Functions/Subroutines
type(elpa_impl_t) function, pointer, public	elpa_impl_allocate (error)
	the implementation of the generic methods More...
type(c_ptr) function	elpa_impl_allocate_c (error)
subroutine	elpa_impl_deallocate_c (handle)
integer function	elpa_setup (self)
	function to setup an ELPA object and to store the MPI communicators internally Parameters More...
integer(kind=c_int) function	elpa_setup_c (handle)
subroutine	elpa_set_integer_c (handle, name_p, value, error)
subroutine	elpa_get_integer_c (handle, name_p, value, error)
integer function	elpa_is_set (self, name)
	function to check whether a key/value pair is set Parameters More...
integer function	elpa_can_set (self, name, value)
	function to check whether a key/value pair can be set Parameters More...
character(kind=c_char, len=elpa_index_int_value_to_strlen_c(self%index, option_name//c_null_char)) function, pointer	elpa_value_to_string (self, option_name, error)
subroutine	elpa_set_double_c (handle, name_p, value, error)
subroutine	elpa_get_double_c (handle, name_p, value, error)
integer(kind=c_int) function, pointer	elpa_associate_int (self, name)
real(kind=c_double) function	elpa_get_time (self, name1, name2, name3, name4, name5, name6)
subroutine	elpa_print_times (self, name1, name2, name3, name4)
subroutine	elpa_timer_start (self, name)
subroutine	elpa_timer_stop (self, name)
subroutine	elpa_eigenvectors_d (self, a, ev, q, error)
	elpa_eigenvectors_d: class method to solve the eigenvalue problem for double real matrices More...
subroutine	elpa_eigenvectors_d_c (handle, a_p, ev_p, q_p, error)
subroutine	elpa_eigenvectors_f (self, a, ev, q, error)
	elpa_eigenvectors_f: class method to solve the eigenvalue problem for float real matrices More...
subroutine	elpa_eigenvectors_f_c (handle, a_p, ev_p, q_p, error)
subroutine	elpa_eigenvectors_dc (self, a, ev, q, error)
	elpa_eigenvectors_dc: class method to solve the eigenvalue problem for double complex matrices More...
subroutine	elpa_eigenvectors_dc_c (handle, a_p, ev_p, q_p, error)
subroutine	elpa_eigenvectors_fc (self, a, ev, q, error)
	elpa_eigenvectors_fc: class method to solve the eigenvalue problem for float complex matrices More...
subroutine	elpa_eigenvectors_fc_c (handle, a_p, ev_p, q_p, error)
subroutine	elpa_eigenvalues_d (self, a, ev, error)
	elpa_eigenvalues_d: class method to solve the eigenvalue problem for double real matrices More...
subroutine	elpa_eigenvalues_d_c (handle, a_p, ev_p, error)
subroutine	elpa_eigenvalues_f (self, a, ev, error)
	elpa_eigenvectors_f: class method to solve the eigenvalue problem for float real matrices More...
subroutine	elpa_eigenvalues_f_c (handle, a_p, ev_p, error)
subroutine	elpa_eigenvalues_dc (self, a, ev, error)
	elpa_eigenvalues_dc: class method to solve the eigenvalue problem for double complex matrices More...
subroutine	elpa_eigenvalues_dc_c (handle, a_p, ev_p, error)
subroutine	elpa_eigenvalues_fc (self, a, ev, error)
	elpa_eigenvalues_fc: class method to solve the eigenvalue problem for float complex matrices More...
subroutine	elpa_eigenvalues_fc_c (handle, a_p, ev_p, error)
subroutine	elpa_hermitian_multiply_d (self, uplo_a, uplo_c, ncb, a, b, nrows_b, ncols_b, c, nrows_c, ncols_c, error)
	elpa_hermitian_multiply_d: class method to perform C : = A**T * B for double real matrices where A is a square matrix (selfna,selfna) which is optionally upper or lower triangular B is a (selfna,ncb) matrix C is a (selfna,ncb) matrix where optionally only the upper or lower triangle may be computed More...
subroutine	elpa_hermitian_multiply_d_c (handle, uplo_a, uplo_c, ncb, a_p, b, nrows_b, ncols_b, c, nrows_c, ncols_c, error)
subroutine	elpa_hermitian_multiply_f (self, uplo_a, uplo_c, ncb, a, b, nrows_b, ncols_b, c, nrows_c, ncols_c, error)
	elpa_hermitian_multiply_f: class method to perform C : = A**T * B for float real matrices where A is a square matrix (selfna,selfna) which is optionally upper or lower triangular B is a (selfna,ncb) matrix C is a (selfna,ncb) matrix where optionally only the upper or lower triangle may be computed More...
subroutine	elpa_hermitian_multiply_f_c (handle, uplo_a, uplo_c, ncb, a_p, b, nrows_b, ncols_b, c, nrows_c, ncols_c, error)
subroutine	elpa_hermitian_multiply_dc (self, uplo_a, uplo_c, ncb, a, b, nrows_b, ncols_b, c, nrows_c, ncols_c, error)
	elpa_hermitian_multiply_dc: class method to perform C : = A**H * B for double complex matrices where A is a square matrix (selfna,selfna) which is optionally upper or lower triangular B is a (selfna,ncb) matrix C is a (selfna,ncb) matrix where optionally only the upper or lower triangle may be computed More...
subroutine	elpa_hermitian_multiply_dc_c (handle, uplo_a, uplo_c, ncb, a_p, b, nrows_b, ncols_b, c, nrows_c, ncols_c, error)
subroutine	elpa_hermitian_multiply_fc (self, uplo_a, uplo_c, ncb, a, b, nrows_b, ncols_b, c, nrows_c, ncols_c, error)
	elpa_hermitian_multiply_fc: class method to perform C : = A**H * B for float complex matrices where A is a square matrix (selfna,selfna) which is optionally upper or lower triangular B is a (selfna,ncb) matrix C is a (selfna,ncb) matrix where optionally only the upper or lower triangle may be computed More...
subroutine	elpa_hermitian_multiply_fc_c (handle, uplo_a, uplo_c, ncb, a_p, b, nrows_b, ncols_b, c, nrows_c, ncols_c, error)
subroutine	elpa_cholesky_d (self, a, error)
	elpa_choleksy_d: class method to do a cholesky factorization for a double real matrix More...
subroutine	elpa_choleksy_d_c (handle, a_p, error)
subroutine	elpa_cholesky_f (self, a, error)
	elpa_choleksy_f: class method to do a cholesky factorization for a float real matrix More...
subroutine	elpa_choleksy_f_c (handle, a_p, error)
subroutine	elpa_cholesky_dc (self, a, error)
	elpa_choleksy_d: class method to do a cholesky factorization for a double complex matrix More...
subroutine	elpa_choleksy_dc_c (handle, a_p, error)
subroutine	elpa_cholesky_fc (self, a, error)
	elpa_choleksy_fc: class method to do a cholesky factorization for a float complex matrix More...
subroutine	elpa_choleksy_fc_c (handle, a_p, error)
subroutine	elpa_invert_trm_d (self, a, error)
	elpa_invert_trm_d: class method to invert a triangular double real matrix More...
subroutine	elpa_invert_trm_d_c (handle, a_p, error)
subroutine	elpa_invert_trm_f (self, a, error)
	elpa_invert_trm_f: class method to invert a triangular float real matrix More...
subroutine	elpa_invert_trm_f_c (handle, a_p, error)
subroutine	elpa_invert_trm_dc (self, a, error)
	elpa_invert_trm_dc: class method to invert a triangular double complex matrix More...
subroutine	elpa_invert_trm_dc_c (handle, a_p, error)
subroutine	elpa_invert_trm_fc (self, a, error)
	elpa_invert_trm_fc: class method to invert a triangular float complex matrix More...
subroutine	elpa_invert_trm_fc_c (handle, a_p, error)
subroutine	elpa_solve_tridiagonal_d (self, d, e, q, error)
	elpa_solve_tridiagonal_d: class method to solve the eigenvalue problem for a double real tridiagonal matrix a More...
subroutine	elpa_solve_tridiagonal_f (self, d, e, q, error)
	elpa_solve_tridiagonal_f: class method to solve the eigenvalue problem for a float real tridiagonal matrix a More...
subroutine	elpa_destroy (self)

Detailed Description

Fortran module which provides the actual implementation of the API. Do not use directly! Use the module "elpa".

Function/Subroutine Documentation

elpa_associate_int()

integer(kind=c_int) function, pointer elpa_impl::elpa_associate_int ( class(elpa_impl_t)  self, character(*), intent(in)  name  )

private

elpa_can_set()

integer function elpa_impl::elpa_can_set	(	class(elpa_impl_t)	self,
		character(*), intent(in)	name,
		integer(kind=c_int), intent(in)	value
	)

function to check whether a key/value pair can be set Parameters

Parameters

self	class(elpa_impl_t) the allocated ELPA object
name	string, the key
value	integer, value

Returns

error integer, error code

elpa_choleksy_d_c()

subroutine elpa_impl::elpa_choleksy_d_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_choleksy_dc_c()

subroutine elpa_impl::elpa_choleksy_dc_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_choleksy_f_c()

subroutine elpa_impl::elpa_choleksy_f_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_choleksy_fc_c()

subroutine elpa_impl::elpa_choleksy_fc_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_cholesky_d()

subroutine elpa_impl::elpa_cholesky_d ( class(elpa_impl_t)  self, real(kind=rk8), dimension(self%local_nrows,*)  a, integer, optional  error  )

private

elpa_choleksy_d: class method to do a cholesky factorization for a double real matrix

The dimensions of the matrix a (locally ditributed and global), the block-cylic-distribution block size, and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_cholesky_dc()

subroutine elpa_impl::elpa_cholesky_dc ( class(elpa_impl_t)  self, complex(kind=ck8), dimension(self%local_nrows,*)  a, integer, optional  error  )

private

elpa_choleksy_d: class method to do a cholesky factorization for a double complex matrix

The dimensions of the matrix a (locally ditributed and global), the block-cylic-distribution block size, and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_cholesky_f()

subroutine elpa_impl::elpa_cholesky_f ( class(elpa_impl_t)  self, real(kind=rk4), dimension(self%local_nrows,*)  a, integer, optional  error  )

private

elpa_choleksy_f: class method to do a cholesky factorization for a float real matrix

The dimensions of the matrix a (locally ditributed and global), the block-cylic-distribution block size, and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_cholesky_fc()

subroutine elpa_impl::elpa_cholesky_fc ( class(elpa_impl_t)  self, complex(kind=c_float_complex), dimension(self%local_nrows,*)  a, integer, optional  error  )

private

elpa_choleksy_fc: class method to do a cholesky factorization for a float complex matrix

The dimensions of the matrix a (locally ditributed and global), the block-cylic-distribution block size, and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_destroy()

subroutine elpa_impl::elpa_destroy

(

class(elpa_impl_t)

self

)

elpa_eigenvalues_d()

subroutine elpa_impl::elpa_eigenvalues_d ( class(elpa_impl_t)  self, real(kind=c_double), dimension(self%local_nrows, *)  a, real(kind=c_double), dimension(self%na)  ev, integer, optional  error  )

private

elpa_eigenvalues_d: class method to solve the eigenvalue problem for double real matrices

The dimensions of the matrix a (locally ditributed and global), the block-cyclic distribution blocksize, the number of eigenvectors to be computed and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
ev	On output: eigenvalues of a, every processor gets the complete set
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_eigenvalues_d_c()

subroutine elpa_impl::elpa_eigenvalues_d_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		type(c_ptr), intent(in), value	ev_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_eigenvalues_dc()

subroutine elpa_impl::elpa_eigenvalues_dc ( class(elpa_impl_t)  self, complex(kind=c_double_complex), dimension(self%local_nrows, *)  a, real(kind=c_double), dimension(self%na)  ev, integer, optional  error  )

private

elpa_eigenvalues_dc: class method to solve the eigenvalue problem for double complex matrices

The dimensions of the matrix a (locally ditributed and global), the block-cyclic distribution blocksize, the number of eigenvectors to be computed and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
ev	On output: eigenvalues of a, every processor gets the complete set
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_eigenvalues_dc_c()

subroutine elpa_impl::elpa_eigenvalues_dc_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		type(c_ptr), intent(in), value	ev_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_eigenvalues_f()

subroutine elpa_impl::elpa_eigenvalues_f ( class(elpa_impl_t)  self, real(kind=c_float), dimension(self%local_nrows, *)  a, real(kind=c_float), dimension(self%na)  ev, integer, optional  error  )

private

elpa_eigenvectors_f: class method to solve the eigenvalue problem for float real matrices

The dimensions of the matrix a (locally ditributed and global), the block-cyclic distribution blocksize, the number of eigenvectors to be computed and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
ev	On output: eigenvalues of a, every processor gets the complete set
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_eigenvalues_f_c()

subroutine elpa_impl::elpa_eigenvalues_f_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		type(c_ptr), intent(in), value	ev_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_eigenvalues_fc()

subroutine elpa_impl::elpa_eigenvalues_fc ( class(elpa_impl_t)  self, complex(kind=c_float_complex), dimension(self%local_nrows, *)  a, real(kind=c_float), dimension(self%na)  ev, integer, optional  error  )

private

elpa_eigenvalues_fc: class method to solve the eigenvalue problem for float complex matrices

The dimensions of the matrix a (locally ditributed and global), the block-cyclic distribution blocksize, the number of eigenvectors to be computed and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
ev	On output: eigenvalues of a, every processor gets the complete set
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_eigenvalues_fc_c()

subroutine elpa_impl::elpa_eigenvalues_fc_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		type(c_ptr), intent(in), value	ev_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_eigenvectors_d()

subroutine elpa_impl::elpa_eigenvectors_d ( class(elpa_impl_t)  self, real(kind=c_double), dimension(self%local_nrows, *)  a, real(kind=c_double), dimension(self%na)  ev, real(kind=c_double), dimension(self%local_nrows, *)  q, integer, optional  error  )

private

elpa_eigenvectors_d: class method to solve the eigenvalue problem for double real matrices

The dimensions of the matrix a (locally ditributed and global), the block-cyclic distribution blocksize, the number of eigenvectors to be computed and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
ev	On output: eigenvalues of a, every processor gets the complete set
q	On output: Eigenvectors of a Distribution is like in Scalapack. Must be always dimensioned to the full size (corresponding to (na,na)) even if only a part of the eigenvalues is needed.
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_eigenvectors_d_c()

subroutine elpa_impl::elpa_eigenvectors_d_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		type(c_ptr), intent(in), value	ev_p,
		type(c_ptr), intent(in), value	q_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_eigenvectors_dc()

subroutine elpa_impl::elpa_eigenvectors_dc ( class(elpa_impl_t)  self, complex(kind=c_double_complex), dimension(self%local_nrows, *)  a, real(kind=c_double), dimension(self%na)  ev, complex(kind=c_double_complex), dimension(self%local_nrows, *)  q, integer, optional  error  )

private

elpa_eigenvectors_dc: class method to solve the eigenvalue problem for double complex matrices

The dimensions of the matrix a (locally ditributed and global), the block-cyclic distribution blocksize, the number of eigenvectors to be computed and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
ev	On output: eigenvalues of a, every processor gets the complete set
q	On output: Eigenvectors of a Distribution is like in Scalapack. Must be always dimensioned to the full size (corresponding to (na,na)) even if only a part of the eigenvalues is needed.
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_eigenvectors_dc_c()

subroutine elpa_impl::elpa_eigenvectors_dc_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		type(c_ptr), intent(in), value	ev_p,
		type(c_ptr), intent(in), value	q_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_eigenvectors_f()

subroutine elpa_impl::elpa_eigenvectors_f ( class(elpa_impl_t)  self, real(kind=c_float), dimension(self%local_nrows, *)  a, real(kind=c_float), dimension(self%na)  ev, real(kind=c_float), dimension(self%local_nrows, *)  q, integer, optional  error  )

private

elpa_eigenvectors_f: class method to solve the eigenvalue problem for float real matrices

The dimensions of the matrix a (locally ditributed and global), the block-cyclic distribution blocksize, the number of eigenvectors to be computed and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
ev	On output: eigenvalues of a, every processor gets the complete set
q	On output: Eigenvectors of a Distribution is like in Scalapack. Must be always dimensioned to the full size (corresponding to (na,na)) even if only a part of the eigenvalues is needed.
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_eigenvectors_f_c()

subroutine elpa_impl::elpa_eigenvectors_f_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		type(c_ptr), intent(in), value	ev_p,
		type(c_ptr), intent(in), value	q_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_eigenvectors_fc()

subroutine elpa_impl::elpa_eigenvectors_fc ( class(elpa_impl_t)  self, complex(kind=c_float_complex), dimension(self%local_nrows, *)  a, real(kind=c_float), dimension(self%na)  ev, complex(kind=c_float_complex), dimension(self%local_nrows, *)  q, integer, optional  error  )

private

elpa_eigenvectors_fc: class method to solve the eigenvalue problem for float complex matrices

The dimensions of the matrix a (locally ditributed and global), the block-cyclic distribution blocksize, the number of eigenvectors to be computed and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
ev	On output: eigenvalues of a, every processor gets the complete set
q	On output: Eigenvectors of a Distribution is like in Scalapack. Must be always dimensioned to the full size (corresponding to (na,na)) even if only a part of the eigenvalues is needed.
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_eigenvectors_fc_c()

subroutine elpa_impl::elpa_eigenvectors_fc_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		type(c_ptr), intent(in), value	ev_p,
		type(c_ptr), intent(in), value	q_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_get_double_c()

subroutine elpa_impl::elpa_get_double_c ( type(c_ptr), intent(in), value  handle, type(c_ptr), intent(in), value  name_p, real(kind=c_double)  value, integer(kind=c_int), intent(inout), optional  error  )

private

elpa_get_integer_c()

subroutine elpa_impl::elpa_get_integer_c ( type(c_ptr), intent(in), value  handle, type(c_ptr), intent(in), value  name_p, integer(kind=c_int)  value, integer(kind=c_int), intent(inout), optional  error  )

private

elpa_get_time()

real(kind=c_double) function elpa_impl::elpa_get_time	(	class(elpa_impl_t), intent(in)	self,
		character(len=*), intent(in), optional	name1,
		character(len=*), intent(in), optional	name2,
		character(len=*), intent(in), optional	name3,
		character(len=*), intent(in), optional	name4,
		character(len=*), intent(in), optional	name5,
		character(len=*), intent(in), optional	name6
	)

elpa_hermitian_multiply_d()

subroutine elpa_impl::elpa_hermitian_multiply_d ( class(elpa_impl_t)  self, character*1  uplo_a, character*1  uplo_c, integer(kind=c_int), intent(in)  ncb, real(kind=c_double), dimension(self%local_nrows,self%local_ncols)  a, real(kind=c_double), dimension(nrows_b,ncols_b)  b, integer(kind=c_int), intent(in)  nrows_b, integer(kind=c_int), intent(in)  ncols_b, real(kind=c_double), dimension(nrows_c,ncols_c)  c, integer(kind=c_int), intent(in)  nrows_c, integer(kind=c_int), intent(in)  ncols_c, integer, optional  error  )

private

elpa_hermitian_multiply_d: class method to perform C : = A**T * B for double real matrices where A is a square matrix (selfna,selfna) which is optionally upper or lower triangular B is a (selfna,ncb) matrix C is a (selfna,ncb) matrix where optionally only the upper or lower triangle may be computed

the MPI commicators and the block-cyclic distribution block size are already known to the type. Thus the class method "setup" must be called BEFORE this method is used

Parameters

self	class(elpa_t), the ELPA object
uplo_a	'U' if A is upper triangular 'L' if A is lower triangular anything else if A is a full matrix Please note: This pertains to the original A (as set in the calling program) whereas the transpose of A is used for calculations If uplo_a is 'U' or 'L', the other triangle is not used at all, i.e. it may contain arbitrary numbers
uplo_c	'U' if only the upper diagonal part of C is needed 'L' if only the upper diagonal part of C is needed anything else if the full matrix C is needed Please note: Even when uplo_c is 'U' or 'L', the other triangle may be written to a certain extent, i.e. one shouldn't rely on the content there!
ncb	Number of columns of global matrices B and C
a	matrix a
local_nrows	number of rows of local (sub) matrix a, set with class method set("local_nrows",value)
local_ncols	number of columns of local (sub) matrix a, set with class method set("local_ncols",value)
b	matrix b
nrows_b	number of rows of local (sub) matrix b
ncols_b	number of columns of local (sub) matrix b
c	matrix c
nrows_c	number of rows of local (sub) matrix c
ncols_c	number of columns of local (sub) matrix c
error	optional argument, error code which can be queried with elpa_strerr

elpa_hermitian_multiply_d_c()

subroutine elpa_impl::elpa_hermitian_multiply_d_c	(	type(c_ptr), intent(in), value	handle,
		character(1,c_char), value	uplo_a,
		character(1,c_char), value	uplo_c,
		integer(kind=c_int), value	ncb,
		type(c_ptr), intent(in), value	a_p,
		real(kind=c_double), dimension(nrows_b,ncols_b)	b,
		integer(kind=c_int), value	nrows_b,
		integer(kind=c_int), value	ncols_b,
		real(kind=c_double), dimension(nrows_c,ncols_c)	c,
		integer(kind=c_int), value	nrows_c,
		integer(kind=c_int), value	ncols_c,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_hermitian_multiply_dc()

subroutine elpa_impl::elpa_hermitian_multiply_dc ( class(elpa_impl_t)  self, character*1  uplo_a, character*1  uplo_c, integer(kind=c_int), intent(in)  ncb, complex(kind=c_double_complex), dimension(self%local_nrows,self%local_ncols)  a, complex(kind=c_double_complex), dimension(nrows_b,ncols_b)  b, integer(kind=c_int), intent(in)  nrows_b, integer(kind=c_int), intent(in)  ncols_b, complex(kind=c_double_complex), dimension(nrows_c,ncols_c)  c, integer(kind=c_int), intent(in)  nrows_c, integer(kind=c_int), intent(in)  ncols_c, integer, optional  error  )

private

elpa_hermitian_multiply_dc: class method to perform C : = A**H * B for double complex matrices where A is a square matrix (selfna,selfna) which is optionally upper or lower triangular B is a (selfna,ncb) matrix C is a (selfna,ncb) matrix where optionally only the upper or lower triangle may be computed

the MPI commicators and the block-cyclic distribution block size are already known to the type. Thus the class method "setup" must be called BEFORE this method is used

Parameters

self	class(elpa_t), the ELPA object
uplo_a	'U' if A is upper triangular 'L' if A is lower triangular anything else if A is a full matrix Please note: This pertains to the original A (as set in the calling program) whereas the transpose of A is used for calculations If uplo_a is 'U' or 'L', the other triangle is not used at all, i.e. it may contain arbitrary numbers
uplo_c	'U' if only the upper diagonal part of C is needed 'L' if only the upper diagonal part of C is needed anything else if the full matrix C is needed Please note: Even when uplo_c is 'U' or 'L', the other triangle may be written to a certain extent, i.e. one shouldn't rely on the content there!
ncb	Number of columns of global matrices B and C
a	matrix a
self%local_nrows	number of rows of local (sub) matrix a, set with class method set("local_nows",value)
self%local_ncols	number of columns of local (sub) matrix a, set with class method set("local_ncols",value)
b	matrix b
nrows_b	number of rows of local (sub) matrix b
ncols_b	number of columns of local (sub) matrix b
c	matrix c
nrows_c	number of rows of local (sub) matrix c
ncols_c	number of columns of local (sub) matrix c
error	optional argument, returns an error code, which can be queried with elpa_strerr

elpa_hermitian_multiply_dc_c()

subroutine elpa_impl::elpa_hermitian_multiply_dc_c	(	type(c_ptr), intent(in), value	handle,
		character(1,c_char), value	uplo_a,
		character(1,c_char), value	uplo_c,
		integer(kind=c_int), value	ncb,
		type(c_ptr), intent(in), value	a_p,
		complex(kind=c_double_complex), dimension(nrows_b,ncols_b)	b,
		integer(kind=c_int), value	nrows_b,
		integer(kind=c_int), value	ncols_b,
		complex(kind=c_double_complex), dimension(nrows_c,ncols_c)	c,
		integer(kind=c_int), value	nrows_c,
		integer(kind=c_int), value	ncols_c,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_hermitian_multiply_f()

subroutine elpa_impl::elpa_hermitian_multiply_f ( class(elpa_impl_t)  self, character*1  uplo_a, character*1  uplo_c, integer(kind=c_int), intent(in)  ncb, real(kind=c_float), dimension(self%local_nrows,*)  a, real(kind=c_float), dimension(self%local_nrows,*)  b, integer(kind=c_int), intent(in)  nrows_b, integer(kind=c_int), intent(in)  ncols_b, real(kind=c_float), dimension(nrows_c,*)  c, integer(kind=c_int), intent(in)  nrows_c, integer(kind=c_int), intent(in)  ncols_c, integer, optional  error  )

private

elpa_hermitian_multiply_f: class method to perform C : = A**T * B for float real matrices where A is a square matrix (selfna,selfna) which is optionally upper or lower triangular B is a (selfna,ncb) matrix C is a (selfna,ncb) matrix where optionally only the upper or lower triangle may be computed

the MPI commicators and the block-cyclic distribution block size are already known to the type. Thus the class method "setup" must be called BEFORE this method is used

Parameters

self	class(elpa_t), the ELPA object
uplo_a	'U' if A is upper triangular 'L' if A is lower triangular anything else if A is a full matrix Please note: This pertains to the original A (as set in the calling program) whereas the transpose of A is used for calculations If uplo_a is 'U' or 'L', the other triangle is not used at all, i.e. it may contain arbitrary numbers
uplo_c	'U' if only the upper diagonal part of C is needed 'L' if only the upper diagonal part of C is needed anything else if the full matrix C is needed Please note: Even when uplo_c is 'U' or 'L', the other triangle may be written to a certain extent, i.e. one shouldn't rely on the content there!
ncb	Number of columns of global matrices B and C
a	matrix a
self%local_nrows	number of rows of local (sub) matrix a, set with class method set("local_nrows",value)
self%local_ncols	number of columns of local (sub) matrix a, set with class method set("local_ncols",value)
b	matrix b
nrows_b	number of rows of local (sub) matrix b
ncols_b	number of columns of local (sub) matrix b
c	matrix c
nrows_c	number of rows of local (sub) matrix c
ncols_c	number of columns of local (sub) matrix c
error	optional argument, returns an error code, which can be queried with elpa_strerr

elpa_hermitian_multiply_f_c()

subroutine elpa_impl::elpa_hermitian_multiply_f_c	(	type(c_ptr), intent(in), value	handle,
		character(1,c_char), value	uplo_a,
		character(1,c_char), value	uplo_c,
		integer(kind=c_int), value	ncb,
		type(c_ptr), intent(in), value	a_p,
		real(kind=c_float), dimension(nrows_b,*)	b,
		integer(kind=c_int), value	nrows_b,
		integer(kind=c_int), value	ncols_b,
		real(kind=c_float), dimension(nrows_c,*)	c,
		integer(kind=c_int), value	nrows_c,
		integer(kind=c_int), value	ncols_c,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_hermitian_multiply_fc()

subroutine elpa_impl::elpa_hermitian_multiply_fc ( class(elpa_impl_t)  self, character*1  uplo_a, character*1  uplo_c, integer(kind=c_int), intent(in)  ncb, complex(kind=c_float_complex), dimension(self%local_nrows,*)  a, complex(kind=c_float_complex), dimension(nrows_b,*)  b, integer(kind=c_int), intent(in)  nrows_b, integer(kind=c_int), intent(in)  ncols_b, complex(kind=c_float_complex), dimension(nrows_c,*)  c, integer(kind=c_int), intent(in)  nrows_c, integer(kind=c_int), intent(in)  ncols_c, integer, optional  error  )

private

elpa_hermitian_multiply_fc: class method to perform C : = A**H * B for float complex matrices where A is a square matrix (selfna,selfna) which is optionally upper or lower triangular B is a (selfna,ncb) matrix C is a (selfna,ncb) matrix where optionally only the upper or lower triangle may be computed

the MPI commicators and the block-cyclic distribution block size are already known to the type. Thus the class method "setup" must be called BEFORE this method is used

Parameters

self	class(elpa_t), the ELPA object
uplo_a	'U' if A is upper triangular 'L' if A is lower triangular anything else if A is a full matrix Please note: This pertains to the original A (as set in the calling program) whereas the transpose of A is used for calculations If uplo_a is 'U' or 'L', the other triangle is not used at all, i.e. it may contain arbitrary numbers
uplo_c	'U' if only the upper diagonal part of C is needed 'L' if only the upper diagonal part of C is needed anything else if the full matrix C is needed Please note: Even when uplo_c is 'U' or 'L', the other triangle may be written to a certain extent, i.e. one shouldn't rely on the content there!
ncb	Number of columns of global matrices B and C
a	matrix a
self%local_nrows	number of rows of local (sub) matrix a, set with class method set("local_nrows",value)
self%local_ncols	number of columns of local (sub) matrix a, set with class method set("local_ncols",value)
b	matrix b
nrows_b	number of rows of local (sub) matrix b
ncols_b	number of columns of local (sub) matrix b
c	matrix c
nrows_c	number of rows of local (sub) matrix c
ncols_c	number of columns of local (sub) matrix c
error	optional argument, returns an error code, which can be queried with elpa_strerr

elpa_hermitian_multiply_fc_c()

subroutine elpa_impl::elpa_hermitian_multiply_fc_c	(	type(c_ptr), intent(in), value	handle,
		character(1,c_char), value	uplo_a,
		character(1,c_char), value	uplo_c,
		integer(kind=c_int), value	ncb,
		type(c_ptr), intent(in), value	a_p,
		complex(kind=c_float_complex), dimension(nrows_b,*)	b,
		integer(kind=c_int), value	nrows_b,
		integer(kind=c_int), value	ncols_b,
		complex(kind=c_float_complex), dimension(nrows_c,*)	c,
		integer(kind=c_int), value	nrows_c,
		integer(kind=c_int), value	ncols_c,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_impl_allocate()

type(elpa_impl_t) function, pointer, public elpa_impl::elpa_impl_allocate

(

integer, optional

error

)

the implementation of the generic methods

function to allocate an ELPA object Parameters

Parameters

error

integer, optional to get an error code

Returns

obj class(elpa_impl_t) allocated ELPA object

elpa_impl_allocate_c()

type(c_ptr) function elpa_impl::elpa_impl_allocate_c

(

integer(kind=c_int)

error

)

elpa_impl_deallocate_c()

subroutine elpa_impl::elpa_impl_deallocate_c ( type(c_ptr), value  handle )

private

elpa_invert_trm_d()

subroutine elpa_impl::elpa_invert_trm_d ( class(elpa_impl_t)  self, real(kind=c_double), dimension(self%local_nrows,*)  a, integer, optional  error  )

private

elpa_invert_trm_d: class method to invert a triangular double real matrix

The dimensions of the matrix a (locally ditributed and global), the block-cylic-distribution block size, and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_invert_trm_d_c()

subroutine elpa_impl::elpa_invert_trm_d_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_invert_trm_dc()

subroutine elpa_impl::elpa_invert_trm_dc ( class(elpa_impl_t)  self, complex(kind=ck8), dimension(self%local_nrows,*)  a, integer, optional  error  )

private

elpa_invert_trm_dc: class method to invert a triangular double complex matrix

The dimensions of the matrix a (locally ditributed and global), the block-cylic-distribution block size, and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_invert_trm_dc_c()

subroutine elpa_impl::elpa_invert_trm_dc_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_invert_trm_f()

subroutine elpa_impl::elpa_invert_trm_f ( class(elpa_impl_t)  self, real(kind=c_float), dimension(self%local_nrows,*)  a, integer, optional  error  )

private

elpa_invert_trm_f: class method to invert a triangular float real matrix

The dimensions of the matrix a (locally ditributed and global), the block-cylic-distribution block size, and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_invert_trm_f_c()

subroutine elpa_impl::elpa_invert_trm_f_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_invert_trm_fc()

subroutine elpa_impl::elpa_invert_trm_fc ( class(elpa_impl_t)  self, complex(kind=c_float_complex), dimension(self%local_nrows,*)  a, integer, optional  error  )

private

elpa_invert_trm_fc: class method to invert a triangular float complex matrix

The dimensions of the matrix a (locally ditributed and global), the block-cylic-distribution block size, and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

a	Distributed matrix for which eigenvalues are to be computed. Distribution is like in Scalapack. The full matrix must be set (not only one half like in scalapack). Destroyed on exit (upper and lower half).
error	integer, optional: returns an error code, which can be queried with elpa_strerr

elpa_invert_trm_fc_c()

subroutine elpa_impl::elpa_invert_trm_fc_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	a_p,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_is_set()

integer function elpa_impl::elpa_is_set ( class(elpa_impl_t)  self, character(*), intent(in)  name  )

private

function to check whether a key/value pair is set Parameters

Parameters

self	class(elpa_impl_t) the allocated ELPA object
name	string, the key

Returns

state integer, the state of the key/value pair

elpa_print_times()

subroutine elpa_impl::elpa_print_times ( class(elpa_impl_t), intent(in)  self, character(len=*), intent(in), optional  name1, character(len=*), intent(in), optional  name2, character(len=*), intent(in), optional  name3, character(len=*), intent(in), optional  name4  )

private

elpa_set_double_c()

subroutine elpa_impl::elpa_set_double_c	(	type(c_ptr), intent(in), value	handle,
		type(c_ptr), intent(in), value	name_p,
		real(kind=c_double), intent(in), value	value,
		integer(kind=c_int), intent(in), optional	error
	)

elpa_set_integer_c()

subroutine elpa_impl::elpa_set_integer_c ( type(c_ptr), intent(in), value  handle, type(c_ptr), intent(in), value  name_p, integer(kind=c_int), intent(in), value  value, integer(kind=c_int), intent(in), optional  error  )

private

elpa_setup()

integer function elpa_impl::elpa_setup ( class(elpa_impl_t), intent(inout)  self )

private

function to setup an ELPA object and to store the MPI communicators internally Parameters

Parameters

self	class(elpa_impl_t), the allocated ELPA object

Returns

error integer, the error code

elpa_setup_c()

integer(kind=c_int) function elpa_impl::elpa_setup_c

(

type(c_ptr), intent(in), value

handle

)

elpa_solve_tridiagonal_d()

subroutine elpa_impl::elpa_solve_tridiagonal_d ( class(elpa_impl_t)  self, real(kind=rk8), dimension(self%na)  d, real(kind=rk8), dimension(self%na)  e, real(kind=rk8), dimension(self%local_nrows,*)  q, integer, optional  error  )

private

elpa_solve_tridiagonal_d: class method to solve the eigenvalue problem for a double real tridiagonal matrix a

The dimensions of the matrix a (locally ditributed and global), the block-cylic-distribution block size, and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

d	array d on input diagonal elements of tridiagonal matrix, on output the eigenvalues in ascending order
e	array e on input subdiagonal elements of matrix, on exit destroyed
q	matrix on exit : contains the eigenvectors
error	integer, optional: returns an error code, which can be queried with elpa_strerr

Todo:

e should have dimension (na - 1)

elpa_solve_tridiagonal_f()

subroutine elpa_impl::elpa_solve_tridiagonal_f	(	class(elpa_impl_t)	self,
		real(kind=rk4), dimension(self%na)	d,
		real(kind=rk4), dimension(self%na)	e,
		real(kind=rk4), dimension(self%local_nrows,*)	q,
		integer, optional	error
	)

elpa_solve_tridiagonal_f: class method to solve the eigenvalue problem for a float real tridiagonal matrix a

The dimensions of the matrix a (locally ditributed and global), the block-cylic-distribution block size, and the MPI communicators are already known to the object and MUST be set BEFORE with the class method "setup"

It is possible to change the behaviour of the method by setting tunable parameters with the class method "set"

Parameters

Parameters

d	array d on input diagonal elements of tridiagonal matrix, on output the eigenvalues in ascending order
e	array e on input subdiagonal elements of matrix, on exit destroyed
q	matrix on exit : contains the eigenvectors
error	integer, optional: returns an error code, which can be queried with elpa_strerr

Todo:

e should have dimension (na - 1)

elpa_timer_start()

subroutine elpa_impl::elpa_timer_start ( class(elpa_impl_t), intent(inout)  self, character(len=*), intent(in)  name  )

private

elpa_timer_stop()

subroutine elpa_impl::elpa_timer_stop ( class(elpa_impl_t), intent(inout)  self, character(len=*), intent(in)  name  )

private

elpa_value_to_string()

character(kind=c_char, len=elpa_index_int_value_to_strlen_c(self%index, option_name // c_null_char)) function, pointer elpa_impl::elpa_value_to_string	(	class(elpa_impl_t), intent(in)	self,
		character(kind=c_char, len=*), intent(in)	option_name,
		integer, intent(out), optional	error
	)