elpa_generic.h

Go to the documentation of this file.

#pragma once
 
#define elpa_set(e, name, value, error) _Generic((value), \
                int: \
                  elpa_set_integer, \
                \
                double: \
                  elpa_set_double \
        )(e, name, value, error)
 
 
#define elpa_get(e, name, value, error) _Generic((value), \
                int*: \
                  elpa_get_integer, \
                \
                double*: \
                  elpa_get_double \
        )(e, name, value, error)
 
 
#define elpa_eigenvectors(handle, a, ev, q, error) _Generic((a), \
                double*: \
                  elpa_eigenvectors_a_h_a_d, \
                \
                float*: \
                  elpa_eigenvectors_a_h_a_f, \
                \
                double complex*: \
                  elpa_eigenvectors_a_h_a_dc, \
                \
                float complex*: \
                  elpa_eigenvectors_a_h_a_fc \
        )(handle, a, ev, q, error)
 
#define elpa_eigenvectors_double(handle, a, ev, q, error) _Generic((a), \
                double*: \
                  elpa_eigenvectors_d_ptr_d \
        )(handle, a, ev, q, error)
 
#define elpa_eigenvectors_float(handle, a, ev, q, error) _Generic((a), \
                float*: \
                  elpa_eigenvectors_d_ptr_f \
        )(handle, a, ev, q, error)
 
#define elpa_eigenvectors_double_complex(handle, a, ev, q, error) _Generic((a), \
                double complex*: \
                  elpa_eigenvectors_d_ptr_dc \
        )(handle, a, ev, q, error)
 
#define elpa_eigenvectors_float_complex(handle, a, ev, q, error) _Generic((a), \
                float complex*: \
                  elpa_eigenvectors_d_ptr_fc \
        )(handle, a, ev, q, error)
 
#define elpa_skew_eigenvectors(handle, a, ev, q, error) _Generic((a), \
                double*: \
                  elpa_eigenvectors_a_h_a_d, \
                \
                float*: \
                  elpa_eigenvectors_a_h_a_f \
        )(handle, a, ev, q, error)
 
#define elpa_skew_eigenvectors_double(handle, a, ev, q, error) _Generic((a), \
                double*: \
                  elpa_eigenvectors_d_ptr_d \
        )(handle, a, ev, q, error)
 
#define elpa_skew_eigenvectors_float(handle, a, ev, q, error) _Generic((a), \
                float*: \
                  elpa_eigenvectors_d_ptr_f \
        )(handle, a, ev, q, error)
 
#define elpa_generalized_eigenvectors(handle, a, b, ev, q, is_already_decomposed, error) _Generic((a), \
                double*: \
                  elpa_generalized_eigenvectors_d, \
                \
                float*: \
                  elpa_generalized_eigenvectors_f, \
                \
                double complex*: \
                  elpa_generalized_eigenvectors_dc, \
                \
                float complex*: \
                  elpa_generalized_eigenvectors_fc \
        )(handle, a, b, ev, q, is_already_decomposed, error)
 
 
#define elpa_eigenvalues(handle, a, ev, error) _Generic((a), \
                double*: \
                  elpa_eigenvalues_a_h_a_d, \
                \
                float*: \
                  elpa_eigenvalues_a_h_a_f, \
                \
                double complex*: \
                  elpa_eigenvalues_a_h_a_dc, \
                \
                float complex*: \
                  elpa_eigenvalues_a_h_a_fc \
        )(handle, a, ev, error)
 
#define elpa_eigenvalues_double(handle, a, ev, error) _Generic((a), \
                double*: \
                  elpa_eigenvalues_d_ptr_d \
        )(handle, a, ev, error)
 
#define elpa_eigenvalues_float(handle, a, ev, error) _Generic((a), \
                float*: \
                  elpa_eigenvalues_d_ptr_f \
        )(handle, a, ev, error)
 
#define elpa_eigenvalues_double_complex(handle, a, ev, error) _Generic((a), \
                double complex*: \
                  elpa_eigenvalues_d_ptr_dc \
        )(handle, a, ev, error)
 
#define elpa_eigenvalues_float_complex(handle, a, ev, error) _Generic((a), \
                float complex*: \
                  elpa_eigenvalues_d_ptr_fc \
        )(handle, a, ev, error)
 
#define elpa_skew_eigenvalues(handle, a, ev, error) _Generic((a), \
                double*: \
                  elpa_eigenvalues_a_h_a_d, \
                \
                float*: \
                  elpa_eigenvalues_a_h_a_f, \
        )(handle, a, ev, error)
 
#define elpa_skew_eigenvalues_double(handle, a, ev, error) _Generic((a), \
                double*: \
                  elpa_eigenvalues_d_ptr_d \
        )(handle, a, ev, error)
 
#define elpa_skew_eigenvalues_float(handle, a, ev, error) _Generic((a), \
                float*: \
                  elpa_eigenvalues_d_ptr_f \
        )(handle, a, ev, error)
 
 
/*  \brief generic C method for elpa_cholesky
 *
 *  \details
 *  \param  handle  handle of the ELPA object, which defines the problem
 *  \param  a       float/double float complex/double complex pointer to matrix a, for which
 *                  the cholesky factorizaion will be computed
 *  \param  error   on return the error code, which can be queried with elpa_strerr()
 *  \result void
 */
#define elpa_cholesky(handle, a, error) _Generic((a), \
                double*: \
                  elpa_cholesky_d, \
                \
                float*: \
                  elpa_cholesky_f, \
                \
                double complex*: \
                  elpa_cholesky_dc, \
                \
                float complex*: \
                  elpa_cholesky_fc \
        )(handle, a, error)
 
 
#define elpa_hermitian_multiply(handle, uplo_a, uplo_c, ncb, a, b, nrows_b, ncols_b, c, nrows_c, ncols_c, error) _Generic((a), \
                double*: \
                  elpa_hermitian_multiply_d, \
                \
                float*: \
                  elpa_hermitian_multiply_f, \
                \
                double complex*: \
                  elpa_hermitian_multiply_dc, \
                \
                float complex*: \
                  elpa_hermitian_multiply_fc \
        )(handle, a, error)
 
 
#define elpa_invert_triangular(handle, a, error) _Generic((a), \
                double*: \
                  elpa_invert_trm_d, \
                \
                float*: \
                  elpa_invert_trm_f, \
                \
                double complex*: \
                  elpa_invert_trm_dc, \
                \
                float complex*: \
                  elpa_invert_trm_fc \
        )(handle, a, error)