{"id":22954961,"url":"https://github.com/hpac/mr3smp","last_synced_at":"2026-01-11T17:50:03.402Z","repository":{"id":85310951,"uuid":"46420932","full_name":"HPAC/mr3smp","owner":"HPAC","description":"The MRRR algorithm for multi-core and SMP systems","archived":false,"fork":false,"pushed_at":"2016-05-05T11:46:23.000Z","size":213,"stargazers_count":1,"open_issues_count":1,"forks_count":1,"subscribers_count":1,"default_branch":"master","last_synced_at":"2025-03-17T17:11:31.200Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"","language":"FORTRAN","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"bsd-3-clause","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/HPAC.png","metadata":{"files":{"readme":"README","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2015-11-18T13:36:38.000Z","updated_at":"2025-01-15T13:27:59.000Z","dependencies_parsed_at":null,"dependency_job_id":"a2fd3926-3168-432f-9f86-e256f5219836","html_url":"https://github.com/HPAC/mr3smp","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/HPAC%2Fmr3smp","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/HPAC%2Fmr3smp/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/HPAC%2Fmr3smp/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/HPAC%2Fmr3smp/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/HPAC","download_url":"https://codeload.github.com/HPAC/mr3smp/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":246732534,"owners_count":20824754,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-12-14T16:20:10.782Z","updated_at":"2026-01-11T17:50:03.363Z","avatar_url":"https://github.com/HPAC.png","language":"FORTRAN","funding_links":[],"categories":[],"sub_categories":[],"readme":"These files provide the routine 'mrrr'. Its purpose is to compute all \nor a subset of eigenvalues and optionally eigenvectors of a symmetric \ntridiagonal matrix. 'mrrr' is based on the algorithm of Multiple \nRelatively Robust Representations (MRRR). The routine thereby targets \nmulti-core processors and SMP systems made out of them. The \nimplementation is based on LAPACK's routine 'dstemr'.\n\n\nBuilding the archive libmrrr.a:\n--------------------------------\n1) In the folder INSTALL, depending on the compiler used, \n replace the file 'make.inc' (which assumes GNU gcc) \n with the corresponding file. \n For example if you want to use Intel's compilers: \n $cp ./INSTALL/make.inc.intel ./make.inc\n If you do not find a file matching your compiler, then use any of \n the files as a basis to edit.\n2) Edit the file 'make.inc' according to your system. Especially, set \n the variable INCLAPACK to zero if you plan to link to LAPACK and \n BLAS, instead of compiling the necessary routines and including \n them in the archive. (LAPACK 3.3 or equivalent is recommended.)\n3) Run make.\n\nKnown issues:\n-------------\n- PROBLEM: Spinlocks are not supported\n SOLUTION: Compile the library with SPINLOCK_SUPPORT=0 in 'make.inc'\n- PROBLEM: The C99 feature of complex numbers is not supported\n SOLUTION: Use a newer compiler or compile the library with\n COMPLEX_SUPPORT=0 (default) in 'make.inc'. In the latter case the \n dense Hermitian routines will not be available in the archive\n\nUsing libmrrr.a:\n----------------\nThe folder EXAMPLES contains simple examples of how to use the routine \n'mrrr' in C and Fortran code. Edit the 'Makefile' in these folders if \nyou do not use the GNU compilers and run 'make' to compile the \nexamples.\n\nIn general, the code that calls 'mrrr' needs to be linked to the \nlibrary 'libmrrr.a', which is created in the LIB folder. \n\nBelow are given the C and Fortran prototypes of the function 'mrrr'.\nFor more information please see 'INCLUDE/mrrr.h'.\n\n\n######################################################################\n# C function prototype: #\n###################################################################### \n# #\n# int mrrr(char *jobz, char *range, int *n, double *D, #\n# double *E, double *vl, double *vu, int *il, int *iu, #\n# int *tryrac, int *m, double *W, double *Z, int *ldz, #\n#\t int *Zsupp); #\n# #\n# INPUTS: #\n# ------- #\n# jobz \"N\" or \"n\" - compute only eigenvalues #\n# \"V\" or \"v\" - compute also eigenvectors #\n# \"C\" or \"c\" - count the maximal number of #\n# locally computed eigenvectors #\n# range \"A\" or \"a\" - all #\n# \"V\" or \"v\" - by interval: (VL,VU] #\n# \"I\" or \"i\" - by index: IL-IU #\n# n Matrix size #\n# ldz Leading dimension of eigenvector matrix Z; #\n# often equal to matrix size n #\n# #\n# INPUT + OUTPUT: #\n# --------------- #\n# D (double[n]) Diagonal elements of tridiagonal T. #\n# (On output the array will be overwritten). #\n# E (double[n]) Off-diagonal elements of tridiagonal T. #\n# First n-1 elements contain off-diagonals, #\n# the last element can have an abitrary value. #\n# (On output the array will be overwritten.) #\n# vl If range=\"V\", lower bound of interval #\n# (vl,vu], on output refined. #\n# If range=\"A\" or \"I\" not referenced as input. #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues. #\n# vu If range=\"V\", upper bound of interval #\n# (vl,vu], on output refined. #\n# If range=\"A\" or \"I\" not referenced as input. #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues. #\n# il If range=\"I\", lower index (1-based indexing) of #\n# the subset 'il' to 'iu'. #\n# If range=\"A\" or \"V\" not referenced as input. #\n# On output the eigenvalues with index 'il' to 'iu'#\n# are computed. #\n# iu If range=\"I\", upper index (1-based indexing) of #\n# the subset 'il' to 'iu'. #\n# If range=\"A\" or \"V\" not referenced as input. #\n# On output the eigenvalues with index 'il' to 'iu'# \n# are computed. #\n# tryrac 0 - do not try to achieve high relative accuracy.#\n# 1 - relative accuracy will be attempted; #\n# on output it is set to zero if high relative #\n# accuracy is not achieved. #\n# #\n# OUTPUT: #\n# ------- #\n# m Number of eigenvalues and eigenvectors computed. #\n# If jobz=\"C\", 'm' will be set to the number of #\n# eigenvalues/eigenvectors that will be computed. #\n# W (double[n]) Eigenvalues #\n# The first 'm' entries contain the eigenvalues. #\n# Z Eigenvectors #\n# (double[n*m]) Enough space must be provided to store the #\n# vectors. 'm' should be bigger or equal #\n# to 'n' for range=\"A\" and 'iu-il+1' for range=\"I\".#\n# For range=\"V\" the minimum 'm' can be queried #\n# using jobz=\"C\". #\n# Zsupp Support of eigenvectors, which is given by #\n# (double[2*n]) Z[2*i] to Z[2*i+1] for the i-th eigenvector #\n# stored locally (1-based indexing). #\n# #\n######################################################################\n\n\n######################################################################\n# Fortran prototype: #\n######################################################################\n# #\n# MRRR(JOBZ, RANGE, N, D, E, VL, VU, IL, IU, TRYRAC, M, W, #\n# Z, LDZ, ZSUPP, INFO) #\n# #\n# CHARACTER JOBZ, RANGE #\n# INTEGER N, IL, IU, TRYRAC, M, LDZ, ZSUPP(*), INFO #\n# DOUBLE PRECISION D(*), D(*), VL, VU, W(*), Z(*,*) #\n######################################################################\n\nThe number of threads created can be specified via the environment \nvariable PMR_NUM_THREADS. In case this variable is not \ndefined, then the routine will create as many threads as specified by \nthe variable DEFAULT_NUM_THREADS (which is set in 'mrrr.h'). \n\n\n\n\nADDITIONAL ROUTINES FOR DENSE STANDARD AND GENERALIZED EIGENPROBLEMS\n-------------------------------------------------------------------- \nFor convinience there are also routines for the standard and \ngeneralized symmetric and Hermitian eigenproblem added that make use \nof the multi-threaded MRRR. The functionality is similar to LAPACK's \nroutines for this operations. The routines using packed storage should \nbe avoided whenever possible, since their performance is much worse.\n\nThe routines are (using a LAPACK like notation):\n----------------------------------------------------------------------\nStandard eigenvector problem A*x = lambda*x:\nComputing all or a subset of eigenvalues, and optionally \neigenvectors\n----------------------------------------------------------------------\ndsyeig: A is symmetric\nzheeig: A is Hermitian\ndspeig: A is symmetric and stored in packed storage\nzhpeig: A is Hermitian and stored in packed storage\n----------------------------------------------------------------------\n----------------------------------------------------------------------\nStandard eigenvector problem A*x = lambda*B*x or A*B*x = lambda*x \nor B*A*x = lambda*x:\nComputing all or a subset of eigenvalues, and optionally \neigenvectors\n----------------------------------------------------------------------\ndsygeig: A and B are symmetric and B is definite\nzhegeig: A and B are Hermitian and B is definite\ndspgeig: A and B are symmetric, stored in packed storage, \n and B is definite\nzhpgeig: A and B are Hermitian, stored in packed storage,\n and B is definite\n----------------------------------------------------------------------\n\n\n\n\nThe dense standard eigenvalue problem:\n--------------------------------------\nFor the reduction and back-transformation the routines call the \ncorresponding LAPACK routines. Therefore LAPACK is required to run \nthe routines. Simply code snippets of how to call the functions are \nincluded in the examples folder.\nThe prototypes are similar to LAPACK's \"dsyevx\" and are as follows.\n\nThe symmetric case:\n\n######################################################################\n# C function prototype: #\n###################################################################### \n# #\n# int dsyeig(char *jobz, char *range, char *uplo, int *n, double *A, #\n# int *lda, double *vl, double *vu, int *il, int *iu, #\n#\t int *m, double *W, double *Z, int *ldz); #\n# #\n# Arguments: #\n# ---------- #\n# #\n# INPUTS: #\n# ------- #\n# jobz \"N\" - compute only eigenvalues #\n# \"V\" - compute also eigenvectors #\n# range \"A\" - all #\n# \"V\" - by interval: (VL,VU] #\n# \"I\" - by index: IL-IU #\n# uplo \"L\" - Lower triangle of A stored #\n# \"U\" - Upper triangle of A stored #\n# n Order of the matrix A #\n# lda Leading dimension of matrix A; #\n# often equal to matrix size n #\n# ldz Leading dimension of eigenvector matrix Z; #\n# often equal to matrix size n #\n# #\n# INPUT + OUTPUT: #\n# --------------- #\n# A On entry symmetric input matrix, stored #\n# (double[lda*n]) in column major ordering. Depending on the #\n# value of 'uplo' only the upper or lower #\n# triangular part is referenced. #\n# (On output the array will be overwritten). #\n# vl If range=\"V\", lower bound of interval #\n# (vl,vu], on output refined. #\n# If range=\"A\" or \"I\" not referenced as input. #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues. #\n# vu If range=\"V\", upper bound of interval #\n# (vl,vu], on output refined. #\n# If range=\"A\" or \"I\" not referenced as input. #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues. #\n# il If range=\"I\", lower index (1-based indexing) of #\n# the subset 'il' to 'iu'. #\n# If range=\"A\" or \"V\" not referenced as input. #\n# On output the eigenvalues with index il to iu #\n# are computed. #\n# iu If range=\"I\", upper index (1-based indexing) of #\n# the subset 'il' to 'iu'. #\n# If range=\"A\" or \"V\" not referenced as input. #\n# On output the eigenvalues with index il to iu #\n# are computed. #\n# #\n# OUTPUT: #\n# ------- #\n# m Number of eigenvalues and eigenvectors computed. #\n# W (double[n]) Eigenvalues #\n# The first 'm' entries contain the eigenvalues. #\n# Z Eigenvectors. #\n# (double[n*m]) Enough space must be provided to store the #\n# vectors. 'm' should be bigger or equal #\n# to 'n' for range=\"A\" or \"V\" and 'iu-il+1' for #\n# range=\"I\". #\n# #\n# RETURN VALUE: #\n# ------------- #\n# 0 - Success #\n# 1 - Wrong input parameter #\n# 2 - Misc errors #\n######################################################################\n\n\n######################################################################\n# Fortran prototype: #\n######################################################################\n# #\n# DSYEIG(JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU, M, W, #\n# Z, LDZ, INFO) #\n# #\n# CHARACTER JOBZ, RANGE, UPLO #\n# INTEGER N, IL, IU, M, LDA, LDZ, INFO #\n# DOUBLE PRECISION A(*,*), VL, VU, W(*), Z(*,*) #\n# #\n######################################################################\n\n\n\nThe symmetric case (packed storage):\n\n######################################################################\n# C function prototype: #\n###################################################################### \n# #\n# int dspeig(char *jobz, char *range, char *uplo, int *n, #\n# double *AP, double *vl, double *vu, int *il, int *iu, #\n#\t int *m, double *W, double *Z, int *ldz); #\n# #\n# Arguments: #\n# ---------- #\n# #\n# INPUTS: #\n# ------- #\n# jobz \"N\" - compute only eigenvalues #\n# \"V\" - compute also eigenvectors #\n# range \"A\" - all #\n# \"V\" - by interval: (VL,VU] #\n# \"I\" - by index: IL-IU #\n# uplo \"L\" - Lower triangle of A stored #\n# \"U\" - Upper triangle of A stored #\n# n Order of the matrix A #\n# ldz Leading dimension of eigenvector matrix Z; #\n# often equal to matrix size n #\n# #\n# INPUT + OUTPUT: #\n# --------------- #\n# AP (double[s]) On entry symmetric input matrix, stored #\n# s = (n*(n+1))/2 in column major ordering. Depending on the #\n# value of 'uplo' only the upper or lower #\n# triangular part is stored. #\n# (On output the array will be overwritten). #\n# vl If range=\"V\", lower bound of interval #\n# (vl,vu], on output refined. #\n# If range=\"A\" or \"I\" not referenced as input. #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues. #\n# vu If range=\"V\", upper bound of interval #\n# (vl,vu], on output refined. #\n# If range=\"A\" or \"I\" not referenced as input. #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues. #\n# il If range=\"I\", lower index (1-based indexing) of #\n# the subset 'il' to 'iu'. #\n# If range=\"A\" or \"V\" not referenced as input. #\n# On output the eigenvalues with index il to iu #\n# are computed. #\n# iu If range=\"I\", upper index (1-based indexing) of #\n# the subset 'il' to 'iu'. #\n# If range=\"A\" or \"V\" not referenced as input. #\n# On output the eigenvalues with index il to iu # \n# are computed. #\n# #\n# OUTPUT: #\n# ------- #\n# m Number of eigenvalues and eigenvectors computed #\n# W (double[n]) Eigenvalues #\n# The first 'm' entries contain the eigenvalues #\n# Z Eigenvectors #\n# (double[n*m]) Enough space must be provided to store the #\n# vectors. 'm' should be bigger or equal #\n# to 'n' for range=\"A\" or \"V\" and 'iu-il+1' for #\n# range=\"I\" #\n# #\n# RETURN VALUE: #\n# ------------- #\n# 0 - Success #\n# 1 - Wrong input parameter #\n# 2 - Misc errors #\n# #\n######################################################################\n\n\n######################################################################\n# Fortran prototype: #\n######################################################################\n# #\n# DSPEIG(JOBZ, RANGE, UPLO, N, AP, VL, VU, IL, IU, M, W, #\n# Z, LDZ, INFO) #\n# #\n# CHARACTER JOBZ, RANGE, UPLO #\n# INTEGER N, IL, IU, M, LDZ, INFO #\n# DOUBLE PRECISION AP(*), VL, VU, W(*), Z(*,*) #\n# #\n######################################################################\n\n\n\nThe Hermitian case (only added to 'libmrrr.a' if specified in \n'make.inc'):\n\n######################################################################\n# C function prototype: #\n###################################################################### \n# #\n# int zheeig(char *jobz, char *range, char *uplo, int *n, #\n#\t double complex *A, int *lda, double *vl, double *vu, #\n#\t int *il, int *iu, int *m, double *W, double complex *Z, #\n#\t int *ldz); #\n# #\n# Arguments: #\n# ---------- #\n# #\n# INPUTS: #\n# ------- #\n# jobz \"N\" - compute only eigenvalues #\n# \"V\" - compute also eigenvectors #\n# range \"A\" - all #\n# \"V\" - by interval: (VL,VU] #\n# \"I\" - by index: IL-IU #\n# uplo \"L\" - Lower triangle of A stored #\n# \"U\" - Upper triangle of A stored #\n# n Order of the matrix A #\n# lda Leading dimension of matrix A; #\n# often equal to matrix size n #\n# ldz Leading dimension of eigenvector matrix Z; #\n# often equal to matrix size n #\n# #\n# INPUT + OUTPUT: #\n# --------------- #\n# A On entry Hermitian input matrix, stored #\n# (double complex in column major ordering. Depending on the #\n# [lda*n]) value of 'uplo' only the upper or lower #\n# triangular part is referenced. #\n# (On output the array will be overwritten). #\n# vl If range=\"V\", lower bound of interval #\n# (vl,vu], on output refined. #\n# If range=\"A\" or \"I\" not referenced as input. #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues. #\n# vu If range=\"V\", upper bound of interval #\n# (vl,vu], on output refined. #\n# If range=\"A\" or \"I\" not referenced as input. #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues. #\n# il If range=\"I\", lower index (1-based indexing) of #\n# the subset 'il' to 'iu'. #\n# If range=\"A\" or \"V\" not referenced as input. #\n# On output the eigenvalues with index il to iu #\n# are computed. #\n# iu If range=\"I\", upper index (1-based indexing) of #\n# the subset 'il' to 'iu'. #\n# If range=\"A\" or \"V\" not referenced as input. #\n# On output the eigenvalues with index il to iu #\n# are computed. #\n# #\n# OUTPUT: #\n# ------- #\n# m Number of eigenvalues and eigenvectors computed. #\n# W (double[n]) Eigenvalues #\n# The first 'm' entries contain the eigenvalues. #\n# Z Eigenvectors. #\n# (double complex Enough space must be provided to store the #\n# [n*m]) vectors. 'm' should be bigger or equal #\n# to 'n' for range=\"A\" or \"V\" and 'iu-il+1' for #\n# range=\"I\". #\n# #\n# RETURN VALUE: #\n# ------------- #\n# 0 - Success #\n# 1 - Wrong input parameter #\n# 2 - Misc errors #\n######################################################################\n\n\n######################################################################\n# Fortran prototype: #\n######################################################################\n# #\n# DSYEIG(JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU, M, W, #\n# Z, LDZ, INFO) #\n# #\n# CHARACTER JOBZ, RANGE, UPLO #\n# INTEGER N, IL, IU, M, LDA, LDZ, INFO #\n# DOUBLE PRECISION VL, VU, W(*) #\n# COMPLEX*16 A(*,*), Z(*,*) #\n# #\n######################################################################\n\n\n\nThe Hermitian case (packed storage; only added to if specified in \n'make.inc'):\n\n######################################################################\n# C function prototype: #\n###################################################################### \n# #\n# int zhpeig(char *jobz, char *range, char *uplo, int *n, #\n#\t double complex *AP, double *vl, double *vu, #\n#\t int *il, int *iu, int *m, double *W, #\n#\t double complex *Z, int *ldz); #\n# #\n# Arguments: #\n# ---------- #\n# #\n# INPUTS: #\n# ------- #\n# jobz \"N\" - compute only eigenvalues #\n# \"V\" - compute also eigenvectors #\n# range \"A\" - all #\n# \"V\" - by interval: (VL,VU] #\n# \"I\" - by index: IL-IU #\n# uplo \"L\" - Lower triangle of A stored #\n# \"U\" - Upper triangle of A stored #\n# n Order of the matrix A #\n# ldz Leading dimension of eigenvector matrix Z; #\n# often equal to matrix size n #\n# #\n# INPUT + OUTPUT: #\n# --------------- #\n# AP (double On entry Hermitian input matrix, stored #\n# complex[s]) in packed storage by columns. Depending on the #\n# s = (n*(n+1))/2 value of 'uplo' only the upper or lower #\n# triangular part is stored. #\n# (On output the array will be overwritten). #\n# vl If range=\"V\", lower bound of interval #\n# (vl,vu], on output refined. #\n# If range=\"A\" or \"I\" not referenced as input. #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues. #\n# vu If range=\"V\", upper bound of interval #\n# (vl,vu], on output refined. #\n# If range=\"A\" or \"I\" not referenced as input. #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues. #\n# il If range=\"I\", lower index (1-based indexing) of #\n# the subset 'il' to 'iu'. #\n# If range=\"A\" or \"V\" not referenced as input. #\n# On output the eigenvalues with index il to iu # \n# are computed. #\n# iu If range=\"I\", upper index (1-based indexing) of #\n# the subset 'il' to 'iu'. #\n# If range=\"A\" or \"V\" not referenced as input. #\n# On output the eigenvalues with index il to iu #\n# are computed. #\n# #\n# OUTPUT: #\n# ------- #\n# m Number of eigenvalues and eigenvectors computed. #\n# W (double[n]) Eigenvalues #\n# The first 'm' entries contain the eigenvalues. #\n# Z Eigenvectors #\n# (double Enough space must be provided to store the #\n# complex[n*m]) vectors. 'm' should be bigger or equal #\n# to 'n' for range=\"A\" or \"V\" and 'iu-il+1' for #\n# range=\"I\". #\n# #\n# RETURN VALUE: #\n# ------------- #\n# 0 - Success #\n# 1 - Wrong input parameter #\n# 2 - Misc errors #\n# #\n######################################################################\n\n\n######################################################################\n# Fortran prototype: #\n######################################################################\n# #\n# ZHPEIG(JOBZ, RANGE, UPLO, N, AP, VL, VU, IL, IU, M, W, #\n# Z, LDZ, INFO) #\n# #\n# CHARACTER JOBZ, RANGE, UPLO #\n# INTEGER N, IL, IU, M, LDZ, INFO #\n# DOUBLE PRECISION VL, VU, W(*) #\n# COMPLEX*16 AP(*), Z(*,*) #\n# #\n######################################################################\n\n\n\n\nThe dense generalized definite eigenvalue problem:\n--------------------------------------------------\nUsing LAPACK notation the routines are called DSYGEIG and ZHEGEIG.\nSimply code snippets of how to call the functions are included in the \nexamples folder.\nThe problems that can be solved have the following form:\nA*x = lambda*B*x or A*B*x = lambda*x or B*A*x = lambda*x,\nwhere A and B are symmetric/Hermitian and B is definite.\n\nSymmetric-definite case:\n\n######################################################################\n# C function prototype: #\n###################################################################### \n# #\n# int dsygeig(int *itype, char *jobz, char *range, char *uplo, #\n# int *n, double *A, int *lda, double *B, int *ldb, #\n#\t double *vl, double *vu, int *il, int *iu, int *m, #\n#\t double *W); #\n# #\n# Arguments: #\n# ---------- #\n# #\n# INPUTS: #\n# ------- #\n# itype 1 - A*x = lambda*B*x #\n# 2 - A*B*x = lambda*x #\n# 3 - B*A*x = lambda*x #\n# jobz \"N\" - compute only eigenvalues #\n# \"V\" - compute also eigenvectors #\n# range \"A\" - all #\n# \"V\" - by interval: (VL,VU] #\n# \"I\" - by index: IL-IU #\n# uplo \"L\" - Lower triangle of A and B stored #\n# \"U\" - Upper triangle of A and B stored #\n# n Order of the matrix A and B #\n# lda Leading dimension of matrix A; #\n# often equal to matrix size n #\n# ldb Leading dimension of eigenvector matrix B; #\n# often equal to matrix size n #\n# #\n# INPUT + OUTPUT: #\n# --------------- #\n# A On entry symmetric input matrix, stored #\n# (double[lda*n]) in column major ordering. Depending on the #\n# value of 'uplo' only the upper or lower #\n# triangular part is referenced #\n# On output the array will contain the #\n# 'm' computed eigenvectors #\n# B On entry symmetric definite input matrix, #\n# (double[ldb*n]) stored in column major ordering. #\n# Depending on the value of 'uplo' only the upper #\n# or lower triangular part is referenced #\n# On output overwritten #\n# vl If range=\"V\", lower bound of interval #\n# (vl,vu], on output refined #\n# If range=\"A\" or \"I\" not referenced as input #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues #\n# vu If range=\"V\", upper bound of interval #\n# (vl,vu], on output refined #\n# If range=\"A\" or \"I\" not referenced as input. #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues #\n# il If range=\"I\", lower index (1-based indexing) of #\n# the subset 'il' to 'iu' #\n# If range=\"A\" or \"V\" not referenced as input. #\n# On output the eigenvalues with index il to iu #\n# are computed #\n# iu If range=\"I\", upper index (1-based indexing) of #\n# the subset 'il' to 'iu' #\n# If range=\"A\" or \"V\" not referenced as input #\n# On output the eigenvalues with index il to iu #\n# are computed #\n# #\n# OUTPUT: #\n# ------- #\n# m Number of eigenvalues and eigenvectors computed #\n# W (double[n]) Eigenvalues #\n# The first 'm' entries contain the eigenvalues #\n# #\n# NOTICE: The routine will allocate work space of size #\n# double[n*n] for range=\"A\" or \"V\" and double[m*n] #\n# for range=\"I\" #\n# #\n# RETURN VALUE: #\n# ------------- #\n# 0 - Success #\n# 1 - Wrong input parameter #\n# 2 - Misc errors #\n# #\n######################################################################\n\n\n######################################################################\n# Fortran prototype: #\n######################################################################\n# #\n# DSYGEIG(ITYPE, JOBZ, RANGE, UPLO, N, A, LDA, B, LDB, #\n# VL, VU, IL, IU, M, W, INFO); #\n# #\n# CHARACTER JOBZ, RANGE, UPLO #\n# INTEGER N, IL, IU, M, LDA, LDB, INFO #\n# DOUBLE PRECISION A(*,*), B(*,*), VL, VU, W(*) #\n# #\n######################################################################\n\n\n\nSymmetric-definite case (packed storage):\n\n######################################################################\n# C function prototype: #\n###################################################################### \n# #\n# int dspgeig(int *itype, char *jobz, char *range, char *uplo, #\n# int *n, double *AP, double *BP, double *vl, #\n# double *vu, int *il, int *iu, int *m, double *W, #\n# double *Z, int *ldz); #\n# #\n# Arguments: #\n# ---------- #\n# #\n# INPUTS: #\n# ------- #\n# itype 1 - A*x = lambda*B*x #\n# 2 - A*B*x = lambda*x #\n# 3 - B*A*x = lambda*x #\n# jobz \"N\" - compute only eigenvalues #\n# \"V\" - compute also eigenvectors #\n# range \"A\" - all #\n# \"V\" - by interval: (VL,VU] #\n# \"I\" - by index: IL-IU #\n# uplo \"L\" - Lower triangle of A and B stored #\n# \"U\" - Upper triangle of A and B stored #\n# n Order of the matrix A and B #\n# ldz Leading dimension of matrix Z; #\n# often equal to matrix size n #\n# #\n# INPUT + OUTPUT: #\n# --------------- #\n# AP On entry symmetric input matrix, stored in #\n# (double[s]) packed format by columns. Depending on the #\n# s = (n*(n+1))/2 value of 'uplo' only the upper or lower #\n# triangular part is stored #\n# On output the array will contain the #\n# 'm' computed eigenvectors #\n# BP On entry symmetric definite input matrix, stored #\n# (double[s]) in packed format by columns. #\n# s = (n*(n+1))/2 Depending on the value of 'uplo' only the upper #\n# or lower triangular part is stored #\n# On output overwritten #\n# vl If range=\"V\", lower bound of interval #\n# (vl,vu], on output refined #\n# If range=\"A\" or \"I\" not referenced as input #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues #\n# vu If range=\"V\", upper bound of interval #\n# (vl,vu], on output refined #\n# If range=\"A\" or \"I\" not referenced as input. #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues #\n# il If range=\"I\", lower index (1-based indexing) of #\n# the subset 'il' to 'iu' #\n# If range=\"A\" or \"V\" not referenced as input. #\n# On output the eigenvalues with index il to iu #\n# are computed #\n# iu If range=\"I\", upper index (1-based indexing) of #\n# the subset 'il' to 'iu' #\n# If range=\"A\" or \"V\" not referenced as input #\n# On output the eigenvalues with index il to iu #\n# are computed #\n# #\n# OUTPUT: #\n# ------- #\n# m Number of eigenvalues and eigenvectors computed #\n# W (double[n]) Eigenvalues #\n# The first 'm' entries contain the eigenvalues #\n# Z (double[m*n]) Eigenvectors #\n# Enough space must be provided to store the #\n# vectors. 'm' should be bigger or equal #\n# to 'n' for range=\"A\" or \"V\" and 'iu-il+1' for #\n# range=\"I\". #\n# #\n# NOTICE: The routine will allocate work space of size #\n# double[n*n] for range=\"A\" or \"V\" and double[m*n] #\n# for range=\"I\" #\n# #\n# RETURN VALUE: #\n# ------------- #\n# 0 - Success #\n# 1 - Wrong input parameter #\n# 2 - Misc errors #\n# #\n######################################################################\n\n\n######################################################################\n# Fortran prototype: #\n######################################################################\n# #\n# DSPGEIG(ITYPE, JOBZ, RANGE, UPLO, N, AP, BP, #\n# VL, VU, IL, IU, M, W, Z, LDZ, INFO) #\n# #\n# CHARACTER JOBZ, RANGE, UPLO #\n# INTEGER N, IL, IU, M, LDZ, INFO #\n# DOUBLE PRECISION AP(*), BP(*), VL, VU, W(*), Z(*,*) #\n# #\n######################################################################\n\n\n\nHermitian-definite case:\n\n######################################################################\n# C function prototype: #\n###################################################################### \n# #\n# int zhegeig(int *itype, char *jobz, char *range, char *uplo, #\n# int *n, double complex *A, int *lda, #\n#\t double complex *B, int *ldb, double *vl, double *vu, #\n#\t int *il, int *iu, int *m, double *W); #\n# #\n# Arguments: #\n# ---------- #\n# #\n# INPUTS: #\n# ------- #\n# itype 1 - A*x = lambda*B*x #\n# 2 - A*B*x = lambda*x #\n# 3 - B*A*x = lambda*x #\n# jobz \"N\" - compute only eigenvalues #\n# \"V\" - compute also eigenvectors #\n# range \"A\" - all #\n# \"V\" - by interval: (VL,VU] #\n# \"I\" - by index: IL-IU #\n# uplo \"L\" - Lower triangle of A and B stored #\n# \"U\" - Upper triangle of A and B stored #\n# n Order of the matrix A and B #\n# lda Leading dimension of matrix A; #\n# often equal to matrix size n #\n# ldb Leading dimension of eigenvector matrix B; #\n# often equal to matrix size n #\n# #\n# INPUT + OUTPUT: #\n# --------------- #\n# A On entry symmetric input matrix, stored #\n# (double in column major ordering. Depending on the #\n# complex[lda*n]) value of 'uplo' only the upper or lower #\n# triangular part is referenced #\n# On output the array will contain the #\n# 'm' computed eigenvectors #\n# B On entry symmetric definite input matrix, #\n# (double stored in column major ordering. #\n# complex[ldb*n]) Depending on the value of 'uplo' only the upper #\n# or lower triangular part is referenced #\n# On output overwritten #\n# vl If range=\"V\", lower bound of interval #\n# (vl,vu], on output refined #\n# If range=\"A\" or \"I\" not referenced as input #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues #\n# vu If range=\"V\", upper bound of interval #\n# (vl,vu], on output refined #\n# If range=\"A\" or \"I\" not referenced as input. #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues #\n# il If range=\"I\", lower index (1-based indexing) of #\n# the subset 'il' to 'iu' #\n# If range=\"A\" or \"V\" not referenced as input. #\n# On output the eigenvalues with index il to iu #\n# are computed #\n# iu If range=\"I\", upper index (1-based indexing) of #\n# the subset 'il' to 'iu' #\n# If range=\"A\" or \"V\" not referenced as input #\n# On output the eigenvalues with index il to iu #\n# are computed #\n# #\n# OUTPUT: #\n# ------- #\n# m Number of eigenvalues and eigenvectors computed #\n# W (double[n]) Eigenvalues #\n# The first 'm' entries contain the eigenvalues #\n# #\n# NOTICE: The routine will allocate work space of size #\n# double[n*n] for range=\"A\" or \"V\" and double[m*n] #\n# for range=\"I\" #\n# #\n# RETURN VALUE: #\n# ------------- #\n# 0 - Success #\n# 1 - Wrong input parameter #\n# 2 - Misc errors #\n# #\n######################################################################\n\n\n######################################################################\n# Fortran prototype: #\n######################################################################\n# #\n# ZHEGEIG(ITYPE, JOBZ, RANGE, UPLO, N, A, LDA, B, LDB, #\n# VL, VU, IL, IU, M, W, INFO); #\n# #\n# CHARACTER JOBZ, RANGE, UPLO #\n# INTEGER N, IL, IU, M, LDA, LDB, INFO #\n# DOUBLE PRECISION VL, VU, W(*) #\n# COMPLEX*16 A(*,*), B(*,*) #\n# #\n######################################################################\n \n\n\nHermitian-definite case (packed storage):\n\n######################################################################\n# C function prototype: #\n###################################################################### \n# #\n# int zhpgeig(int *itype, char *jobz, char *range, char *uplo, #\n# int *n, double complex *AP, double complex *BP, #\n#\t double *vl, double *vu, int *il, int *iu, int *m, #\n#\t double *W, double complex *Z, int *ldz); #\n# #\n# Arguments: #\n# ---------- #\n# #\n# INPUTS: #\n# ------- #\n# itype 1 - A*x = lambda*B*x #\n# 2 - A*B*x = lambda*x #\n# 3 - B*A*x = lambda*x #\n# jobz \"N\" - compute only eigenvalues #\n# \"V\" - compute also eigenvectors #\n# range \"A\" - all #\n# \"V\" - by interval: (VL,VU] #\n# \"I\" - by index: IL-IU #\n# uplo \"L\" - Lower triangle of A and B stored #\n# \"U\" - Upper triangle of A and B stored #\n# n Order of the matrix A and B #\n# ldz Leading dimension of matrix Z; #\n# often equal to matrix size n #\n# #\n# INPUT + OUTPUT: #\n# --------------- #\n# AP On entry Hermitian input matrix, stored in #\n# (double packed format by columns. Depending on the #\n# complex[s]) value of 'uplo' only the upper or lower #\n# s = (n*(n+1))/2 triangular part is stored #\n# On output the array will contain the #\n# 'm' computed eigenvectors #\n# BP On entry Hermitian definite input matrix, stored #\n# (double in packed format by columns. #\n# complex[s]) Depending on the value of 'uplo' only the upper #\n# s = (n*(n+1))/2 or lower triangular part is stored #\n# On output overwritten #\n# vl If range=\"V\", lower bound of interval #\n# (vl,vu], on output refined #\n# If range=\"A\" or \"I\" not referenced as input #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues #\n# vu If range=\"V\", upper bound of interval #\n# (vl,vu], on output refined #\n# If range=\"A\" or \"I\" not referenced as input. #\n# On output the interval (vl,vu] contains ALL #\n# the computed eigenvalues #\n# il If range=\"I\", lower index (1-based indexing) of #\n# the subset 'il' to 'iu' #\n# If range=\"A\" or \"V\" not referenced as input. #\n# On output the eigenvalues with index il to iu #\n# are computed #\n# iu If range=\"I\", upper index (1-based indexing) of #\n# the subset 'il' to 'iu' #\n# If range=\"A\" or \"V\" not referenced as input #\n# On output the eigenvalues with index il to iu #\n# are computed #\n# #\n# OUTPUT: #\n# ------- #\n# m Number of eigenvalues and eigenvectors computed #\n# W (double[n]) Eigenvalues #\n# The first 'm' entries contain the eigenvalues #\n# Z (double Eigenvectors #\n# complex[m*n]) Enough space must be provided to store the #\n# vectors. 'm' should be bigger or equal #\n# to 'n' for range=\"A\" or \"V\" and 'iu-il+1' for #\n# range=\"I\". #\n# #\n# NOTICE: The routine will allocate work space of size #\n# double[n*n] for range=\"A\" or \"V\" and double[m*n] #\n# for range=\"I\" #\n# #\n# RETURN VALUE: #\n# ------------- #\n# 0 - Success #\n# 1 - Wrong input parameter #\n# 2 - Misc errors #\n# #\n######################################################################\n\n\n######################################################################\n# Fortran prototype: #\n######################################################################\n# #\n# ZHPGEIG(ITYPE, JOBZ, RANGE, UPLO, N, AP, BP, #\n# VL, VU, IL, IU, M, W, Z, LDZ, INFO) #\n# #\n# CHARACTER JOBZ, RANGE, UPLO #\n# INTEGER N, IL, IU, M, LDZ, INFO #\n# DOUBLE PRECISION VL, VU, W(*) #\n# COMPLEX*16 AP(*), BP(*), Z(*,*) #\n# #\n######################################################################\n\n\n\nCOMMENTS AND BUGS:\npetschow@aices.rwth-aachen.de\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhpac%2Fmr3smp","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fhpac%2Fmr3smp","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhpac%2Fmr3smp/lists"}