diff --git a/modules/RulesPrecisions.cmake b/modules/RulesPrecisions.cmake
index 0b8c0956fd7bb645eb94685a205c3dc929fd062b..341b348d20088942563f9bb57a644604b9f0514c 100644
--- a/modules/RulesPrecisions.cmake
+++ b/modules/RulesPrecisions.cmake
@@ -240,10 +240,9 @@ MACRO(precisions_rules_py)
COMMAND ${CMAKE_COMMAND} -E remove -f ${_dependency_OUTPUT} && ${pythoncmd} && chmod a-w ${_dependency_OUTPUT}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${_dependency_INPUT} ${RP_CODEGEN} ${RP_${CMAKE_PROJECT_NAME}_DICTIONNARY})
- set_SOURCE_FILES_PROPERTIES(${_dependency_OUTPUT} PROPERTIES COMPILE_FLAGS "-DPRECISION_${_dependency_PREC}" GENERATED 1 IS_IN_BINARY_DIR 1 )
-
+ set_source_files_properties(${_dependency_OUTPUT} PROPERTIES COMPILE_FLAGS "-DPRECISION_${_dependency_PREC}" GENERATED 1 IS_IN_BINARY_DIR 1 )
else( generate_out )
- set_SOURCE_FILES_PROPERTIES(${_dependency_OUTPUT} PROPERTIES COMPILE_FLAGS "-DPRECISION_${_dependency_PREC}" GENERATED 0 )
+ set_source_files_properties(${_dependency_OUTPUT} PROPERTIES COMPILE_FLAGS "-DPRECISION_${_dependency_PREC}" GENERATED 0 )
endif( generate_out )
list(APPEND ${OUTPUTLIST} ${_dependency_OUTPUT})
diff --git a/modules/find/FindMETIS.cmake b/modules/find/FindMETIS.cmake
index da2f1f1d7b056f97a185b9da672bfc2cd4cbb220..537f31a4030caf14deef0f16fcfaa3c09503c58a 100644
--- a/modules/find/FindMETIS.cmake
+++ b/modules/find/FindMETIS.cmake
@@ -20,6 +20,7 @@
# METIS_INCLUDE_DIRS - metis include directories
# METIS_LIBRARY_DIRS - Link directories for metis libraries
# METIS_LIBRARIES - metis component libraries to be linked
+# METIX_INTSIZE - Number of octets occupied by a idx_t (IDXTYPEWIDTH)
#
# The user can give specific paths where to find the libraries adding cmake
# options at configure (ex: cmake path/to/project -DMETIS_DIR=path/to/metis):
@@ -253,6 +254,48 @@ endif()
mark_as_advanced(METIS_DIR)
mark_as_advanced(METIS_DIR_FOUND)
+# Check the size of METIS_Idx
+# ---------------------------------
+set(CMAKE_REQUIRED_INCLUDES ${METIS_INCLUDE_DIRS})
+
+include(CheckCSourceRuns)
+#stdio.h and stdint.h should be included by metis.h directly
+set(METIS_C_TEST_METIS_Idx_4 "
+#include <stdio.h>
+#include <stdint.h>
+#include <metis.h>
+int main(int argc, char **argv) {
+ if (sizeof(idx_t) == 4)
+ return 0;
+ else
+ return 1;
+}
+")
+
+set(METIS_C_TEST_METIS_Idx_8 "
+#include <stdio.h>
+#include <stdint.h>
+#include <metis.h>
+int main(int argc, char **argv) {
+ if (sizeof(idx_t) == 8)
+ return 0;
+ else
+ return 1;
+}
+")
+check_c_source_runs("${METIS_C_TEST_METIS_Idx_4}" METIS_Idx_4)
+if(NOT METIS_Idx_4)
+ check_c_source_runs("${METIS_C_TEST_METIS_Idx_8}" METIS_Idx_8)
+ if(NOT METIS_Idx_8)
+ set(METIS_INTSIZE -1)
+ else()
+ set(METIS_INTSIZE 8)
+ endif()
+else()
+ set(METIS_INTSIZE 4)
+endif()
+set(CMAKE_REQUIRED_INCLUDES "")
+
# check that METIS has been found
# ---------------------------------
include(FindPackageHandleStandardArgs)
diff --git a/modules/find/FindPARSEC.cmake b/modules/find/FindPARSEC.cmake
index d1daf48d3cb46c0e4a96e45c22f2192c933d10ee..0cdb474b7cb364b607266bbc3340e7b948c1584b 100644
--- a/modules/find/FindPARSEC.cmake
+++ b/modules/find/FindPARSEC.cmake
@@ -37,8 +37,8 @@
# PARSEC_INCLUDE_DIRS_DEP - parsec + dependencies include directories
# PARSEC_LIBRARY_DIRS_DEP - parsec + dependencies link directories
# PARSEC_LIBRARIES_DEP - parsec libraries + dependencies
-# PARSEC_daguepp_BIN_DIR - path to parsec driver daguepp
-# PARSEC_DAGUEPP - parsec jdf compiler
+# PARSEC_parsec_ptgpp_BIN_DIR - path to parsec driver parsec_ptgpp
+# PARSEC_PARSEC_PTGPP - parsec jdf compiler
# The user can give specific paths where to find the libraries adding cmake
# options at configure (ex: cmake path/to/project -DPARSEC=path/to/parsec):
# PARSEC_DIR - Where to find the base directory of parsec
@@ -125,7 +125,7 @@ if(UNIX OR WIN32)
else()
if (PARSEC_FIND_REQUIRED)
message(FATAL_ERROR "Could NOT find libm on your system."
- "Are you sure to a have a C compiler installed?")
+ "Are you sure to a have a C compiler installed?")
endif()
endif()
endif()
@@ -231,8 +231,8 @@ if(PKG_CONFIG_EXECUTABLE AND NOT PARSEC_GIVEN_BY_USER)
#endif()
else()
message(STATUS "${Magenta}Looking for PARSEC - not found using PkgConfig."
- "\n Perhaps you should add the directory containing libparsec.pc"
- "\n to the PKG_CONFIG_PATH environment variable.${ColourReset}")
+ "\n Perhaps you should add the directory containing libparsec.pc"
+ "\n to the PKG_CONFIG_PATH environment variable.${ColourReset}")
endif()
endif()
@@ -241,16 +241,16 @@ if(PKG_CONFIG_EXECUTABLE AND NOT PARSEC_GIVEN_BY_USER)
set(PARSEC_LIBRARIES_DEP "${PARSEC_LIBRARIES}")
# create list of binaries to find
- set(PARSEC_bins_to_find "daguepp")
+ set(PARSEC_bins_to_find "parsec_ptgpp")
# call cmake macro to find the bin path
if(PARSEC_PREFIX)
foreach(parsec_bin ${PARSEC_bins_to_find})
set(PARSEC_${parsec_bin}_BIN_DIR "PARSEC_${parsec_bin}_BIN_DIR-NOTFOUND")
find_path(PARSEC_${parsec_bin}_BIN_DIR
- NAMES ${parsec_bin}
- HINTS ${PARSEC_PREFIX}
- PATH_SUFFIXES "bin")
+ NAMES ${parsec_bin}
+ HINTS ${PARSEC_PREFIX}
+ PATH_SUFFIXES "bin")
endforeach()
else()
if (PARSEC_FIND_REQUIRED)
@@ -275,7 +275,7 @@ if( (NOT PKG_CONFIG_EXECUTABLE) OR (PKG_CONFIG_EXECUTABLE AND NOT PARSEC_FOUND)
elseif(ENV_PARSEC_DIR)
list(APPEND _inc_env "${ENV_PARSEC_DIR}")
list(APPEND _inc_env "${ENV_PARSEC_DIR}/include")
- list(APPEND _inc_env "${ENV_PARSEC_DIR}/include/dague")
+ list(APPEND _inc_env "${ENV_PARSEC_DIR}/include/parsec")
else()
if(WIN32)
string(REPLACE ":" ";" _inc_env "$ENV{INCLUDE}")
@@ -294,36 +294,35 @@ if( (NOT PKG_CONFIG_EXECUTABLE) OR (PKG_CONFIG_EXECUTABLE AND NOT PARSEC_FOUND)
list(APPEND _inc_env "${CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES}")
list(REMOVE_DUPLICATES _inc_env)
-
# Try to find the parsec headers in the given paths
# -------------------------------------------------
# create list of headers to find
- set(PARSEC_hdrs_to_find "dague_config.h" "dague.h")
+ set(PARSEC_hdrs_to_find "parsec_config.h" "parsec.h")
# call cmake macro to find the header path
if(PARSEC_INCDIR)
foreach(parsec_hdr ${PARSEC_hdrs_to_find})
set(PARSEC_${parsec_hdr}_INCLUDE_DIRS "PARSEC_${parsec_hdr}_INCLUDE_DIRS-NOTFOUND")
find_path(PARSEC_${parsec_hdr}_INCLUDE_DIRS
- NAMES ${parsec_hdr}
- HINTS ${PARSEC_INCDIR})
+ NAMES ${parsec_hdr}
+ HINTS ${PARSEC_INCDIR})
endforeach()
else()
if(PARSEC_DIR)
set(PARSEC_${parsec_hdr}_INCLUDE_DIRS "PARSEC_${parsec_hdr}_INCLUDE_DIRS-NOTFOUND")
foreach(parsec_hdr ${PARSEC_hdrs_to_find})
- find_path(PARSEC_${parsec_hdr}_INCLUDE_DIRS
- NAMES ${parsec_hdr}
- HINTS ${PARSEC_DIR}
- PATH_SUFFIXES "include")
+ find_path(PARSEC_${parsec_hdr}_INCLUDE_DIRS
+ NAMES ${parsec_hdr}
+ HINTS ${PARSEC_DIR}
+ PATH_SUFFIXES "include")
endforeach()
else()
foreach(parsec_hdr ${PARSEC_hdrs_to_find})
- set(PARSEC_${parsec_hdr}_INCLUDE_DIRS "PARSEC_${parsec_hdr}_INCLUDE_DIRS-NOTFOUND")
- find_path(PARSEC_${parsec_hdr}_INCLUDE_DIRS
- NAMES ${parsec_hdr}
- HINTS ${_inc_env})
+ set(PARSEC_${parsec_hdr}_INCLUDE_DIRS "PARSEC_${parsec_hdr}_INCLUDE_DIRS-NOTFOUND")
+ find_path(PARSEC_${parsec_hdr}_INCLUDE_DIRS
+ NAMES ${parsec_hdr}
+ HINTS ${_inc_env})
endforeach()
endif()
endif()
@@ -338,7 +337,7 @@ if( (NOT PKG_CONFIG_EXECUTABLE) OR (PKG_CONFIG_EXECUTABLE AND NOT PARSEC_FOUND)
list(APPEND PARSEC_INCLUDE_DIRS "${PARSEC_${parsec_hdr}_INCLUDE_DIRS}" )
else ()
if(NOT PARSEC_FIND_QUIETLY)
- message(STATUS "Looking for parsec -- ${parsec_hdr} not found")
+ message(STATUS "Looking for parsec -- ${parsec_hdr} not found")
endif()
endif ()
mark_as_advanced(PARSEC_${parsec_hdr}_INCLUDE_DIRS)
@@ -369,9 +368,9 @@ if( (NOT PKG_CONFIG_EXECUTABLE) OR (PKG_CONFIG_EXECUTABLE AND NOT PARSEC_FOUND)
string(REPLACE ":" ";" _lib_env "$ENV{LIB}")
else()
if(APPLE)
- string(REPLACE ":" ";" _lib_env "$ENV{DYLD_LIBRARY_PATH}")
+ string(REPLACE ":" ";" _lib_env "$ENV{DYLD_LIBRARY_PATH}")
else()
- string(REPLACE ":" ";" _lib_env "$ENV{LD_LIBRARY_PATH}")
+ string(REPLACE ":" ";" _lib_env "$ENV{LD_LIBRARY_PATH}")
endif()
list(APPEND _lib_env "${CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES}")
list(APPEND _lib_env "${CMAKE_C_IMPLICIT_LINK_DIRECTORIES}")
@@ -383,31 +382,31 @@ if( (NOT PKG_CONFIG_EXECUTABLE) OR (PKG_CONFIG_EXECUTABLE AND NOT PARSEC_FOUND)
# ----------------------------------------------
# create list of libs to find
- set(PARSEC_libs_to_find "dague" "dague-base" "dague_distribution" "dague_distribution_matrix")
+ set(PARSEC_libs_to_find "parsec" "parsec-base" "parsec_distribution" "parsec_distribution_matrix")
# call cmake macro to find the lib path
if(PARSEC_LIBDIR)
foreach(parsec_lib ${PARSEC_libs_to_find})
set(PARSEC_${parsec_lib}_LIBRARY "PARSEC_${parsec_lib}_LIBRARY-NOTFOUND")
find_library(PARSEC_${parsec_lib}_LIBRARY
- NAMES ${parsec_lib}
- HINTS ${PARSEC_LIBDIR})
+ NAMES ${parsec_lib}
+ HINTS ${PARSEC_LIBDIR})
endforeach()
else()
if(PARSEC_DIR)
foreach(parsec_lib ${PARSEC_libs_to_find})
- set(PARSEC_${parsec_lib}_LIBRARY "PARSEC_${parsec_lib}_LIBRARY-NOTFOUND")
- find_library(PARSEC_${parsec_lib}_LIBRARY
- NAMES ${parsec_lib}
- HINTS ${PARSEC_DIR}
- PATH_SUFFIXES lib lib32 lib64)
+ set(PARSEC_${parsec_lib}_LIBRARY "PARSEC_${parsec_lib}_LIBRARY-NOTFOUND")
+ find_library(PARSEC_${parsec_lib}_LIBRARY
+ NAMES ${parsec_lib}
+ HINTS ${PARSEC_DIR}
+ PATH_SUFFIXES lib lib32 lib64)
endforeach()
else()
foreach(parsec_lib ${PARSEC_libs_to_find})
- set(PARSEC_${parsec_lib}_LIBRARY "PARSEC_${parsec_lib}_LIBRARY-NOTFOUND")
- find_library(PARSEC_${parsec_lib}_LIBRARY
- NAMES ${parsec_lib}
- HINTS ${_lib_env})
+ set(PARSEC_${parsec_lib}_LIBRARY "PARSEC_${parsec_lib}_LIBRARY-NOTFOUND")
+ find_library(PARSEC_${parsec_lib}_LIBRARY
+ NAMES ${parsec_lib}
+ HINTS ${_lib_env})
endforeach()
endif()
endif()
@@ -426,7 +425,7 @@ if( (NOT PKG_CONFIG_EXECUTABLE) OR (PKG_CONFIG_EXECUTABLE AND NOT PARSEC_FOUND)
else (PARSEC_${parsec_lib}_LIBRARY)
if(NOT PARSEC_FIND_QUIETLY)
- message(STATUS "Looking for parsec -- lib ${parsec_lib} not found")
+ message(STATUS "Looking for parsec -- lib ${parsec_lib} not found")
endif()
endif (PARSEC_${parsec_lib}_LIBRARY)
@@ -455,32 +454,32 @@ if( (NOT PKG_CONFIG_EXECUTABLE) OR (PKG_CONFIG_EXECUTABLE AND NOT PARSEC_FOUND)
list(REMOVE_DUPLICATES _bin_env)
# create list of binaries to find
- set(PARSEC_bins_to_find "daguepp")
+ set(PARSEC_bins_to_find "parsec_ptgpp")
# call cmake macro to find the bin path
if(PARSEC_DIR)
foreach(parsec_bin ${PARSEC_bins_to_find})
set(PARSEC_${parsec_bin}_BIN_DIR "PARSEC_${parsec_bin}_BIN_DIR-NOTFOUND")
find_path(PARSEC_${parsec_bin}_BIN_DIR
- NAMES ${parsec_bin}
- HINTS ${PARSEC_DIR}
- PATH_SUFFIXES "bin")
+ NAMES ${parsec_bin}
+ HINTS ${PARSEC_DIR}
+ PATH_SUFFIXES "bin")
endforeach()
else()
foreach(parsec_bin ${PARSEC_bins_to_find})
set(PARSEC_${parsec_bin}_BIN_DIR "PARSEC_${parsec_bin}_BIN_DIR-NOTFOUND")
find_path(PARSEC_${parsec_bin}_BIN_DIR
- NAMES ${parsec_bin}
- HINTS ${_bin_env})
+ NAMES ${parsec_bin}
+ HINTS ${_bin_env})
endforeach()
endif()
- if (PARSEC_daguepp_BIN_DIR)
+ if (PARSEC_parsec_ptgpp_BIN_DIR)
if (NOT PARSEC_FIND_QUIETLY)
- message(STATUS "Look for PARSEC - compiler daguepp found in ${PARSEC_daguepp_BIN_DIR}")
+ message(STATUS "Look for PARSEC - compiler parsec_ptgpp found in ${PARSEC_parsec_ptgpp_BIN_DIR}")
endif()
else()
if (PARSEC_FIND_REQUIRED)
- message(FATAL_ERROR "Look for PARSEC - compiler daguepp not found while required")
+ message(FATAL_ERROR "Look for PARSEC - compiler parsec_ptgpp not found while required")
endif()
endif()
@@ -500,69 +499,69 @@ if( (NOT PKG_CONFIG_EXECUTABLE) OR (PKG_CONFIG_EXECUTABLE AND NOT PARSEC_FOUND)
set(CMAKE_REQUIRED_FLAGS)
foreach(libdir ${PARSEC_LIBRARY_DIRS})
if (libdir)
- list(APPEND REQUIRED_LIBDIRS "${libdir}")
+ list(APPEND REQUIRED_LIBDIRS "${libdir}")
endif()
endforeach()
set(REQUIRED_LIBS "${PARSEC_LIBRARIES}")
# HWLOC
if (HWLOC_FOUND AND PARSEC_LOOK_FOR_HWLOC)
if (HWLOC_INCLUDE_DIRS)
- list(APPEND REQUIRED_INCDIRS "${HWLOC_INCLUDE_DIRS}")
+ list(APPEND REQUIRED_INCDIRS "${HWLOC_INCLUDE_DIRS}")
endif()
if (HWLOC_LIBRARY_DIRS)
- list(APPEND REQUIRED_LIBDIRS "${HWLOC_LIBRARY_DIRS}")
+ list(APPEND REQUIRED_LIBDIRS "${HWLOC_LIBRARY_DIRS}")
endif()
foreach(lib ${HWLOC_LIBRARIES})
- if (EXISTS ${lib} OR ${lib} MATCHES "^-")
- list(APPEND REQUIRED_LIBS "${lib}")
- else()
- list(APPEND REQUIRED_LIBS "-l${lib}")
- endif()
+ if (EXISTS ${lib} OR ${lib} MATCHES "^-")
+ list(APPEND REQUIRED_LIBS "${lib}")
+ else()
+ list(APPEND REQUIRED_LIBS "-l${lib}")
+ endif()
endforeach()
endif()
# MPI
if (MPI_FOUND AND PARSEC_LOOK_FOR_MPI)
if (MPI_C_INCLUDE_PATH)
- list(APPEND REQUIRED_INCDIRS "${MPI_C_INCLUDE_PATH}")
+ list(APPEND REQUIRED_INCDIRS "${MPI_C_INCLUDE_PATH}")
endif()
if (MPI_C_LINK_FLAGS)
- if (${MPI_C_LINK_FLAGS} MATCHES " -")
- string(REGEX REPLACE " -" "-" MPI_C_LINK_FLAGS ${MPI_C_LINK_FLAGS})
- endif()
- list(APPEND REQUIRED_LDFLAGS "${MPI_C_LINK_FLAGS}")
+ if (${MPI_C_LINK_FLAGS} MATCHES " -")
+ string(REGEX REPLACE " -" "-" MPI_C_LINK_FLAGS ${MPI_C_LINK_FLAGS})
+ endif()
+ list(APPEND REQUIRED_LDFLAGS "${MPI_C_LINK_FLAGS}")
endif()
list(APPEND REQUIRED_LIBS "${MPI_C_LIBRARIES}")
endif()
# CUDA
if (CUDA_FOUND AND PARSEC_LOOK_FOR_CUDA)
if (CUDA_INCLUDE_DIRS)
- list(APPEND REQUIRED_INCDIRS "${CUDA_INCLUDE_DIRS}")
+ list(APPEND REQUIRED_INCDIRS "${CUDA_INCLUDE_DIRS}")
endif()
if (CUDA_LIBRARY_DIRS)
- list(APPEND REQUIRED_LIBDIRS "${CUDA_LIBRARY_DIRS}")
+ list(APPEND REQUIRED_LIBDIRS "${CUDA_LIBRARY_DIRS}")
endif()
list(APPEND REQUIRED_LIBS "${CUDA_CUBLAS_LIBRARIES};${CUDA_CUDART_LIBRARY};${CUDA_CUDA_LIBRARY}")
endif()
# Fortran
if (CMAKE_C_COMPILER_ID MATCHES "GNU")
find_library(
- FORTRAN_gfortran_LIBRARY
- NAMES gfortran
- HINTS ${_lib_env}
- )
+ FORTRAN_gfortran_LIBRARY
+ NAMES gfortran
+ HINTS ${_lib_env}
+ )
mark_as_advanced(FORTRAN_gfortran_LIBRARY)
if (FORTRAN_gfortran_LIBRARY)
- list(APPEND REQUIRED_LIBS "${FORTRAN_gfortran_LIBRARY}")
+ list(APPEND REQUIRED_LIBS "${FORTRAN_gfortran_LIBRARY}")
endif()
elseif (CMAKE_C_COMPILER_ID MATCHES "Intel")
find_library(
- FORTRAN_ifcore_LIBRARY
- NAMES ifcore
- HINTS ${_lib_env}
- )
+ FORTRAN_ifcore_LIBRARY
+ NAMES ifcore
+ HINTS ${_lib_env}
+ )
mark_as_advanced(FORTRAN_ifcore_LIBRARY)
if (FORTRAN_ifcore_LIBRARY)
- list(APPEND REQUIRED_LIBS "${FORTRAN_ifcore_LIBRARY}")
+ list(APPEND REQUIRED_LIBS "${FORTRAN_ifcore_LIBRARY}")
endif()
endif()
# EXTRA LIBS such that pthread, m, rt, dl
@@ -582,15 +581,15 @@ if( (NOT PKG_CONFIG_EXECUTABLE) OR (PKG_CONFIG_EXECUTABLE AND NOT PARSEC_FOUND)
# test link
unset(PARSEC_WORKS CACHE)
include(CheckFunctionExists)
- check_function_exists(dague_init PARSEC_WORKS)
+ check_function_exists(parsec_init PARSEC_WORKS)
mark_as_advanced(PARSEC_WORKS)
if(PARSEC_WORKS)
# save link with dependencies
if (REQUIRED_FLAGS)
- set(PARSEC_LIBRARIES_DEP "${REQUIRED_FLAGS};${REQUIRED_LIBS}")
+ set(PARSEC_LIBRARIES_DEP "${REQUIRED_FLAGS};${REQUIRED_LIBS}")
else()
- set(PARSEC_LIBRARIES_DEP "${REQUIRED_LIBS}")
+ set(PARSEC_LIBRARIES_DEP "${REQUIRED_LIBS}")
endif()
set(PARSEC_LIBRARY_DIRS_DEP "${REQUIRED_LIBDIRS}")
set(PARSEC_INCLUDE_DIRS_DEP "${REQUIRED_INCDIRS}")
@@ -600,13 +599,13 @@ if( (NOT PKG_CONFIG_EXECUTABLE) OR (PKG_CONFIG_EXECUTABLE AND NOT PARSEC_FOUND)
list(REMOVE_DUPLICATES PARSEC_LINKER_FLAGS)
else()
if(NOT PARSEC_FIND_QUIETLY)
- message(STATUS "Looking for parsec : test of dague_init fails")
- message(STATUS "CMAKE_REQUIRED_LIBRARIES: ${CMAKE_REQUIRED_LIBRARIES}")
- message(STATUS "CMAKE_REQUIRED_INCLUDES: ${CMAKE_REQUIRED_INCLUDES}")
- message(STATUS "Check in CMakeFiles/CMakeError.log to figure out why it fails")
- message(STATUS "Maybe PARSEC is linked with specific libraries. "
- "Have you tried with COMPONENTS (HWLOC, CUDA, MPI)? "
- "See the explanation in FindPARSEC.cmake.")
+ message(STATUS "Looking for parsec : test of parsec_init fails")
+ message(STATUS "CMAKE_REQUIRED_LIBRARIES: ${CMAKE_REQUIRED_LIBRARIES}")
+ message(STATUS "CMAKE_REQUIRED_INCLUDES: ${CMAKE_REQUIRED_INCLUDES}")
+ message(STATUS "Check in CMakeFiles/CMakeError.log to figure out why it fails")
+ message(STATUS "Maybe PARSEC is linked with specific libraries. "
+ "Have you tried with COMPONENTS (HWLOC, CUDA, MPI)? "
+ "See the explanation in FindPARSEC.cmake.")
endif()
endif()
set(CMAKE_REQUIRED_INCLUDES)
@@ -620,7 +619,7 @@ if (PARSEC_LIBRARIES)
if (PARSEC_LIBRARY_DIRS)
foreach(dir ${PARSEC_LIBRARY_DIRS})
if ("${dir}" MATCHES "parsec")
- set(first_lib_path "${dir}")
+ set(first_lib_path "${dir}")
endif()
endforeach()
else()
@@ -643,18 +642,18 @@ include(FindPackageHandleStandardArgs)
if (PKG_CONFIG_EXECUTABLE AND PARSEC_FOUND)
find_package_handle_standard_args(PARSEC DEFAULT_MSG
PARSEC_LIBRARIES
- PARSEC_daguepp_BIN_DIR)
+ PARSEC_parsec_ptgpp_BIN_DIR)
else()
find_package_handle_standard_args(PARSEC DEFAULT_MSG
PARSEC_LIBRARIES
- PARSEC_daguepp_BIN_DIR
+ PARSEC_parsec_ptgpp_BIN_DIR
PARSEC_WORKS)
endif()
-if ( PARSEC_daguepp_BIN_DIR )
- find_program(PARSEC_DAGUEPP
- NAMES daguepp
- HINTS ${PARSEC_daguepp_BIN_DIR})
+if ( PARSEC_parsec_ptgpp_BIN_DIR )
+ find_program(PARSEC_PARSEC_PTGPP
+ NAMES parsec_ptgpp
+ HINTS ${PARSEC_parsec_ptgpp_BIN_DIR})
else()
- set(PARSEC_DAGUEPP "PARSEC_DAGUEPP-NOTFOUND")
+ set(PARSEC_PARSEC_PTGPP "PARSEC_PARSEC_PTGPP-NOTFOUND")
endif()
diff --git a/modules/find/RulesJDF.cmake b/modules/find/RulesJDF.cmake
index 2251edd5dd4c9c49be7af08a84a551c41f5896dd..d3a7e5314041116159a196bad5f166fa9ec6e3c3 100644
--- a/modules/find/RulesJDF.cmake
+++ b/modules/find/RulesJDF.cmake
@@ -1,5 +1,5 @@
#
-# Internal module for DAGuE.
+# Internal module for PaRSEC.
# Setup the minimal environment to compile and generate .JDF files.
#
@@ -14,7 +14,7 @@ macro(jdf_rules jdf_rules_OUTPUTLIST jdf_rules_SOURCES)
string(REGEX REPLACE ".jdf" "" jdf_rules_SRC ${jdf_rules_SOURCE})
string(REGEX REPLACE "^(.*/)*(.+)\\.*.*" "\\2" jdf_rules_BSRC ${jdf_rules_SRC})
set(jdf_rules_OSRC "${jdf_rules_BSRC}")
- GET_PROPERTY(ADDITIONAL_DAGUEPP_CFLAGS SOURCE ${jdf_rules_SOURCE} PROPERTY ADDITIONAL_DAGUEPP_CFLAGS)
+ GET_PROPERTY(ADDITIONAL_PARSEC_PTGPP_CFLAGS SOURCE ${jdf_rules_SOURCE} PROPERTY ADDITIONAL_PARSEC_PTGPP_CFLAGS)
get_source_file_property(jdf_rules_IsInBinaryDir ${jdf_rules_SOURCE} IS_IN_BINARY_DIR )
@@ -24,31 +24,33 @@ macro(jdf_rules jdf_rules_OUTPUTLIST jdf_rules_SOURCES)
if( jdf_rules_IsInBinaryDir )
add_custom_command(
- OUTPUT ${jdf_rules_OSRC}.h ${jdf_rules_OSRC}.c
- COMMAND ${PARSEC_DAGUEPP} ${DAGUEPP_CFLAGS} ${ADDITIONAL_DAGUEPP_CFLAGS} -E -i ${jdf_rules_SRC}.jdf -o ${jdf_rules_OSRC} -f ${jdf_rules_BSRC}
- MAIN_DEPENDENCY ${CMAKE_CURRENT_BINARY_DIR}/${jdf_rules_SRC}.jdf
- DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${jdf_rules_SRC}.jdf ${PARSEC_DAGUEPP})
+ OUTPUT ${jdf_rules_OSRC}.h ${jdf_rules_OSRC}.c
+ COMMAND ${PARSEC_PARSEC_PTGPP} ${PARSEC_PTGPP_CFLAGS} ${ADDITIONAL_PARSEC_PTGPP_CFLAGS} -E -i ${jdf_rules_SRC}.jdf -o ${jdf_rules_OSRC} -f ${jdf_rules_BSRC}
+ MAIN_DEPENDENCY ${CMAKE_CURRENT_BINARY_DIR}/${jdf_rules_SRC}.jdf
+ DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${jdf_rules_SRC}.jdf ${PARSEC_PARSEC_PTGPP})
else( jdf_rules_IsInBinaryDir )
add_custom_command(
- OUTPUT ${jdf_rules_OSRC}.h ${jdf_rules_OSRC}.c
- COMMAND ${PARSEC_DAGUEPP} ${DAGUEPP_CFLAGS} ${ADDITIONAL_DAGUEPP_CFLAGS} -E -i ${jdf_rules_SRC}.jdf -o ${jdf_rules_OSRC} -f ${jdf_rules_BSRC}
- MAIN_DEPENDENCY ${jdf_rules_SRC}.jdf
- DEPENDS ${jdf_rules_SRC}.jdf ${PARSEC_DAGUEPP})
+ OUTPUT ${jdf_rules_OSRC}.h ${jdf_rules_OSRC}.c
+ COMMAND ${PARSEC_PARSEC_PTGPP} ${PARSEC_PTGPP_CFLAGS} ${ADDITIONAL_PARSEC_PTGPP_CFLAGS} -E -i ${jdf_rules_SRC}.jdf -o ${jdf_rules_OSRC} -f ${jdf_rules_BSRC}
+ MAIN_DEPENDENCY ${jdf_rules_SRC}.jdf
+ DEPENDS ${jdf_rules_SRC}.jdf ${PARSEC_PARSEC_PTGPP})
endif( jdf_rules_IsInBinaryDir )
- set_source_files_properties(${jdf_rules_OSRC}.c PROPERTIES COMPILE_FLAGS "-I${PARSEC_DIR_FOUND}/include/daguepp")
+ set_source_files_properties(${jdf_rules_OSRC}.c PROPERTIES COMPILE_FLAGS "-I${PARSEC_DIR_FOUND}/include/parsec")
list(APPEND ${jdf_rules_OUTPUTLIST} "${CMAKE_CURRENT_BINARY_DIR}/${jdf_rules_OSRC}.h;${CMAKE_CURRENT_BINARY_DIR}/${jdf_rules_OSRC}.c")
+
+ # Mark generated files as such.
+ set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${jdf_rules_OSRC}.h ${CMAKE_CURRENT_BINARY_DIR}/${jdf_rules_OSRC}.c
+ PROPERTIES GENERATED 1)
+
get_source_file_property(jdf_rules_CompileFlags ${jdf_rules_SOURCE} COMPILE_FLAGS )
if( jdf_rules_CompileFlags )
- set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${jdf_rules_OSRC}.c PROPERTIES COMPILE_FLAGS ${jdf_rules_CompileFlags} )
+ set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${jdf_rules_OSRC}.c PROPERTIES COMPILE_FLAGS ${jdf_rules_CompileFlags} )
endif()
endforeach()
#
- # Mark all generated files as such.
- #
- set_source_files_properties(${jdf_rules_OUTPUTLIST} PROPERTIES GENERATED 1)
endmacro(jdf_rules)
diff --git a/modules/precision_generator/subs.py b/modules/precision_generator/subs.py
index 6c438681ab73a7e246bc3340ccd9787a3221ed6d..4d99a9d3db4748ce9301e932c212c75b28fa47c6 100644
--- a/modules/precision_generator/subs.py
+++ b/modules/precision_generator/subs.py
@@ -20,976 +20,684 @@ subs = {
[None, None]
],
- # ------------------------------------------------------------
- # replacements applied to mixed precision files.
- 'mixed' : [
- # ----- Special line indicating column types
- ['ds', 'zc' ],
-
- # ----- Mixed precisions
- ('DS', 'ZC' ),
- ('ds', 'zc' ),
-
- # ----- Preprocessor
- ('#define PRECISION_d', '#define PRECISION_z' ),
- ('#define PRECISION_s', '#define PRECISION_c' ),
- ('#undef PRECISION_d', '#undef PRECISION_z' ),
- ('#undef PRECISION_s', '#undef PRECISION_c' ),
-
- # ----- Fortran Types
- ('real\(kind=c_double\)', 'complex\(kind=c_double_complex\)' ),
- ('real\(kind=c_float\)', 'real\(kind=c_float_complex\)' ),
-
- # ----- Data types
- ('double', 'double2' ),
- ('float', 'float2' ),
- ('double', 'cuDoubleComplex' ),
- ('float', 'cuFloatComplex' ),
- ('DOUBLE PRECISION', 'COMPLEX_16' ),
- ('SINGLE PRECISION', 'COMPLEX' ),
- ('real', 'complex' ),
- ('float', 'MORSE_Complex32_t' ),
- ('double', 'MORSE_Complex64_t' ),
- ('float', 'MORSE_voidComplex32_t' ),
- ('double', 'MORSE_voidComplex64_t' ),
- ('MorseRealFloat', 'MorseComplexFloat' ),
- ('MorseRealDouble', 'MorseComplexDouble' ),
-
- # ----- CBLAS
- ('', 'CBLAS_SADDR' ),
-
- # ----- Prefixes
- ('blasf77_d', 'blasf77_z' ),
- ('blasf77_s', 'blasf77_c' ),
- ('cublasIdamax', 'cublasIzamax' ),
- ('cublasD', 'cublasZ' ),
- ('cublasS', 'cublasC' ),
- ('lapackf77_d', 'lapackf77_z' ),
- ('lapackf77_s', 'lapackf77_c' ),
- ('MAGMA_D', 'MAGMA_Z' ),
- ('MAGMA_S', 'MAGMA_C' ),
- ('magmablas_d', 'magmablas_z' ),
- ('magmablas_s', 'magmablas_c' ),
- ('magma_d', 'magma_z' ),
- ('magma_s', 'magma_c' ),
- ('magma_get_d', 'magma_get_z' ),
- ('magma_get_s', 'magma_get_c' ),
-
- # ----- Prefixes MORSE
- ('MORSE_D', 'MORSE_Z' ),
- ('MORSE_S', 'MORSE_C' ),
- ('morse_get_d', 'morse_get_z' ),
- ('morse_get_s', 'morse_get_c' ),
- ('TASK_S', 'TASK_C' ),
- ('TASK_D', 'TASK_Z' ),
- ('RUNTIME_S', 'RUNTIME_C' ),
- ('RUNTIME_D', 'RUNTIME_Z' ),
-
- # ----- Complex numbers
- ('(double)', 'cuComplexFloatToDouble' ),
- ('(float)', 'cuComplexDoubleToFloat' ),
- ('', 'cuCrealf' ),
- ('', 'cuCimagf' ),
- ('', 'cuCreal' ),
- ('', 'cuCimag' ),
- ('', 'cuConj' ),
- ('abs', 'cuCabs' ),
- ('absf', 'cuCabsf' ),
-
- # ----- PLASMA / MAGMA
- ('magma_sdgetrs', 'magma_czgetrs' ),
-
- # ----- MORSE
- ('morse_sdgetrs', 'morse_czgetrs' ),
-
- # ----- Constants
- ('CblasTrans', 'CblasConjTrans' ),
- ('MagmaTrans', 'MagmaConjTrans' ),
- ('MorseTrans', 'MorseConjTrans' ),
-
- # ----- BLAS and LAPACK, lowercase, alphabetic order
- # copy & paste these to uppercase below and fix case.
- # mixed precision
- ('dsaxpy', 'zcaxpy' ),
- ('dslaswp', 'zclaswp' ),
-
- # regular
- ('daxpy', 'zaxpy' ),
- ('dgemm', 'zgemm' ),
- ('dgesv', 'zgesv' ),
- ('dlacpy', 'zlacpy' ),
- ('dlange', 'zlange' ),
- ('dlansy', 'zlansy' ),
- ('dlarnv', 'zlarnv' ),
- ('dpotrf', 'zpotrf' ),
- ('dsytrf', 'zsytrf' ),
- ('dtrmm', 'ztrmm' ),
- ('dtrsm', 'ztrsm' ),
- ('dtrsv', 'ztrsv' ),
- ('idamax', 'izamax' ),
- ('spotrf', 'cpotrf' ),
- ('ssytrf', 'csytrf' ),
- ('strmm', 'ctrmm' ),
- ('strsm', 'ctrsm' ),
- ('strsv', 'ctrsv' ),
-
- # ----- BLAS and LAPACK, where complex base name != real base name
- # with precision
- ('dlag2s', 'zlag2c' ),
- ('dlagsy', 'zlaghe' ),
- ('dlansy', 'zlanhe' ),
- ('dlat2s', 'zlat2c' ),
- ('dormqr', 'zunmqr' ),
- ('dsymm', 'zhemm' ),
- ('dsymv', 'zhemv' ),
- ('dsyrk', 'zherk' ),
- ('slag2d', 'clag2z' ),
- ('slansy', 'clanhe' ),
- ('slat2d', 'clat2z' ),
-
- # without precision
- ('lag2s', 'lag2c' ),
- ('lagsy', 'laghe' ),
- ('lansy', 'lanhe' ),
- ('lat2s', 'lat2c' ),
- ('ormqr', 'unmqr' ),
- ('symm', 'hemm' ),
- ('symv', 'hemv' ),
- ('syrk', 'herk' ),
- ('lag2d', 'lag2z' ),
- ('lansy', 'lanhe' ),
- ('lat2d', 'lat2z' ),
-
- # QUARK codelets protection (to prevent conversion with LAPACK WITH PRECISION)
- ('DAG_CORE_L-AG2C', 'DAG_CORE_LAG2C' ),
-
- # ----- BLAS AND LAPACK, UPPERCASE, ALPHABETIC ORDER
- # COPY & PASTE THESE TO UPPERCASE BELOW AND FIX CASE.
- # MIXED PRECISION
- ('DSAXPY', 'ZCAXPY' ),
- ('DSLASWP', 'ZCLASWP' ),
-
- # REGULAR
- ('DAXPY', 'ZAXPY' ),
- ('DGEMM', 'ZGEMM' ),
- ('DGESV', 'ZGESV' ),
- ('DLACPY', 'ZLACPY' ),
- ('DLANGE', 'ZLANGE' ),
- ('DLANSY', 'ZLANSY' ),
- ('DLARNV', 'ZLARNV' ),
- ('DPOTRF', 'ZPOTRF' ),
- ('DSYTRF', 'ZSYTRF' ),
- ('DTRMM', 'ZTRMM' ),
- ('DTRSM', 'ZTRSM' ),
- ('DTRSV', 'ZTRSV' ),
- ('IDAMAX', 'IZAMAX' ),
- ('SPOTRF', 'CPOTRF' ),
- ('SSYTRF', 'CSYTRF' ),
- ('STRMM', 'CTRMM' ),
- ('STRSM', 'CTRSM' ),
- ('STRSV', 'CTRSV' ),
-
- # ----- BLAS AND LAPACK, WHERE COMPLEX BASE NAME != REAL BASE NAME
- # WITH PRECISION
- ('DLAG2S', 'ZLAG2C' ),
- ('DLAGSY', 'ZLAGHE' ),
- ('DLANSY', 'ZLANHE' ),
- ('DLAT2S', 'ZLAT2C' ),
- ('DORMQR', 'ZUNMQR' ),
- ('DSYMM', 'ZHEMM' ),
- ('DSYMV', 'ZHEMV' ),
- ('DSYRK', 'ZHERK' ),
- ('SLAG2D', 'CLAG2Z' ),
- ('SLANSY', 'CLANHE' ),
- ('SLAT2D', 'CLAT2Z' ),
-
- # WITHOUT PRECISION
- ('LAG2S', 'LAG2C' ),
- ('LAGSY', 'LAGHE' ),
- ('LANSY', 'LANHE' ),
- ('LAT2S', 'LAT2C' ),
- ('ORMQR', 'UNMQR' ),
- ('SYMM', 'HEMM' ),
- ('SYMV', 'HEMV' ),
- ('SYRK', 'HERK' ),
- ('LAG2D', 'LAG2Z' ),
- ('LANSY', 'LANHE' ),
- ('LAT2D', 'LAT2Z' ),
-
- # QUARK codelets protection (to prevent conversion with LAPACK WITH PRECISION)
- ('DAG_CORE_LAG2C', 'DAG_CORE_L-AG2C' ),
-],
-
# ------------------------------------------------------------
# replacements applied to most files.
'normal' : [
# ----- Special line indicating column types
# old python (2.4) requires this line to be list [] rather than tuple () to use index() function.
- ['s', 'd', 'c', 'z' ],
-
-
- # TODO clean; shouldn't be added this way
- ('cblas_sscal', ' cblas_dscal', 'cblas_csscal', 'cblas_zdscal'),
- ('stsmqr_hetra1', 'dtsmqr_hetra1', 'ctsmqr_hetra1', 'ztsmqr_hetra1'),
- ('stsmlq_hetra1', 'dtsmlq_hetra1', 'ctsmlq_hetra1', 'ztsmlq_hetra1'),
- ('codelet_ssyrfb', 'codelet_dsyrfb', 'codelet_cherfb', 'codelet_zherfb'),
- ('cl_ssyrfb', 'cl_dsyrfb', 'cl_cherfb', 'cl_zherfb'),
- ('she2ge', 'dhe2ge', 'che2ge', 'zhe2ge'),
- ('sgbcpy', 'dgbcpy', 'cgbcpy', 'zgbcpy'),
-
-
- # ----- Preprocessor
- ('#define PRECISION_s', '#define PRECISION_d', '#define PRECISION_c', '#\s*define PRECISION_z' ),
- ('#undef PRECISION_s', '#undef PRECISION_d', '#undef PRECISION_c', '#undef PRECISION_z' ),
- ('#define REAL', '#define REAL', '#define COMPLEX', '#define COMPLEX' ),
- ('#undef COMPLEX', '#undef COMPLEX', '#undef REAL', '#undef REAL' ),
- ('#define SINGLE', '#define DOUBLE', '#define SINGLE', '#define DOUBLE' ),
- ('#undef DOUBLE', '#undef SINGLE', '#undef DOUBLE', '#undef SINGLE' ),
+ ['p', 's', 'd', 'c', 'z' ],
# ----- Fortran Types
- ('real\(kind=c_float\)', 'real\(kind=c_double\)', 'complex\(kind=c_float_complex\)', 'complex\(kind=c_double_complex\)' ),
- ('real(kind=c_float\)', 'real\(kind=c_double\)', 'real\(kind=c_float\)', 'real\(kind=c_double\)' ),
- ('real', 'double precision', 'complex', 'complex\(kind=wp\)' ),
+ ('', 'real\(kind=c_float\)', 'real\(kind=c_double\)', 'complex\(kind=c_float_complex\)', 'complex\(kind=c_double_complex\)' ),
+ ('', 'real(kind=c_float\)', 'real\(kind=c_double\)', 'real\(kind=c_float\)', 'real\(kind=c_double\)' ),
+ ('', 'real', 'double precision', 'complex', 'complex\(kind=wp\)' ),
+ ('', 'real', 'double precision', 'real', r'\bdouble precision' ), # before double
# ----- Data types
- ('real', 'double precision', 'real', r'\bdouble precision' ), # before double
- ('float', 'double', 'float _Complex', r'\bdouble _Complex' ),
- ('float', 'double', 'cuFloatComplex', r'\bcuDoubleComplex' ),
- ('float', 'double', 'make_cuFloatComplex', 'make_cuDoubleComplex' ),
- ('float', 'double', 'magmaFloatComplex', r'\bmagmaDoubleComplex' ),
- ('float', 'double', 'PLASMA_Complex32_t', r'\bPLASMA_Complex64_t' ),
- ('float', 'double', 'PLASMA_voidComplex32_t', r'\bPLASMA_voidComplex64_t' ),
- ('PlasmaRealFloat', 'PlasmaRealDouble', 'PlasmaComplexFloat', r'\bPlasmaComplexDouble' ),
- ('float', 'double', 'MORSE_Complex32_t', r'\bMORSE_Complex64_t' ),
- ('float', 'double', 'MORSE_voidComplex32_t', r'\bMORSE_voidComplex64_t' ),
- ('MorseRealFloat', 'MorseRealDouble', 'MorseComplexFloat', r'\bMorseComplexDouble' ),
- ('real', 'double precision', 'complex', r'\bcomplex\*16' ),
- ('REAL', 'DOUBLE_PRECISION', 'COMPLEX', r'\bCOMPLEX_16' ),
- ('REAL', 'DOUBLE PRECISION', 'COMPLEX', r'\bDOUBLE COMPLEX' ),
- ('REAL', 'DOUBLE PRECISION', 'REAL', r'\bDOUBLE PRECISION' ),
- ('sizeof_real', 'sizeof_double', 'sizeof_complex', r'\bsizeof_complex_16' ), # before complex
- ('float', 'double', 'pastix_complex32_t', r'\bpastix_complex64_t' ),
- ('real', 'real', 'complex', r'\bcomplex' ),
- ('float', 'double', 'float2', r'\bdouble2' ),
- ('float', 'double', 'float', r'\bdouble' ),
- ('ipt_s', 'ipt_d', 'ipt_c', 'ipt_z' ),
+ ('', 'float', 'double', 'float _Complex', r'\bdouble _Complex' ),
+ ('', 'float', 'double', 'cuFloatComplex', r'\bcuDoubleComplex' ),
+ ('', 'float', 'double', 'make_cuFloatComplex', 'make_cuDoubleComplex' ),
+ ('', 'float', 'double', 'magmaFloatComplex', r'\bmagmaDoubleComplex' ),
+ ('', 'float', 'double', 'PLASMA_Complex32_t', r'\bPLASMA_Complex64_t' ),
+ ('', 'float', 'double', 'PLASMA_voidComplex32_t', r'\bPLASMA_voidComplex64_t' ),
+ ('', 'PlasmaRealFloat', 'PlasmaRealDouble', 'PlasmaComplexFloat', r'\bPlasmaComplexDouble' ),
+ ('', 'real', 'double precision', 'complex', r'\bcomplex\*16' ),
+ ('', 'REAL', 'DOUBLE_PRECISION', 'COMPLEX', r'\bCOMPLEX_16' ),
+ ('', 'REAL', 'DOUBLE PRECISION', 'COMPLEX', r'\bDOUBLE COMPLEX' ),
+ ('', 'REAL', 'DOUBLE PRECISION', 'REAL', r'\bDOUBLE PRECISION' ),
+ ('', 'sizeof_real', 'sizeof_double', 'sizeof_complex', r'\bsizeof_complex_16' ), # before complex
+ ('', 'real', 'real', 'complex', r'\bcomplex' ),
+ ('', 'float', 'double', 'float2', r'\bdouble2' ),
+
+ ('int', 'float', 'double', 'pastix_complex32_t', r'\bpastix_complex64_t'),
+ ('int', 'float', 'double', 'float', r'\bdouble' ),
+ ('PastixPattern', 'PastixFloat', 'PastixDouble', 'PastixComplex32', r'\bPastixComplex64' ),
+ ('PastixPattern', 'PastixFloat', 'PastixDouble', 'PastixFloat', r'\bPastixDouble' ),
+ ('PastixSymmetric', 'PastixSymmetric', 'PastixSymmetric', 'PastixHermitian', r'\bPastixHermitian' ),
+ ('PastixTrans', 'PastixTrans', 'PastixTrans', 'PastixConjTrans', r'\bPastixConjTrans' ),
# ----- Text
- ('symmetric', 'symmetric', 'Hermitian', 'Hermitian' ),
- ('\*\*T', '\*\*T', '\*\*H', '\*\*H' ),
- ('%f', '%lf', '%f', '%lf' ), # for scanf
- ('%g', '%lg', '%g', '%lg' ), # for scanf
+ ('', 'symmetric', 'symmetric', 'Hermitian', 'Hermitian' ),
+ ('', '\*\*T', '\*\*T', '\*\*H', '\*\*H' ),
+ ('', '%f', '%lf', '%f', '%lf' ), # for scanf
+ ('', '%g', '%lg', '%g', '%lg' ), # for scanf
# ----- CBLAS
- ('cblas_sasum', 'cblas_dasum', 'cblas_scasum', 'cblas_dzasum' ),
- ('cblas_snrm2', 'cblas_dnrm2', 'cblas_scnrm2', 'cblas_dznrm2' ),
- ('', '', 'CBLAS_SADDR', 'CBLAS_SADDR' ),
- ('cblas_ssyr', 'cblas_dsyr', 'cblas_cher', 'cblas_zher' ),
+ ('', 'cblas_sasum', 'cblas_dasum', 'cblas_scasum', 'cblas_dzasum' ),
+ ('', 'cblas_snrm2', 'cblas_dnrm2', 'cblas_scnrm2', 'cblas_dznrm2' ),
+ ('', '', '', 'CBLAS_SADDR', 'CBLAS_SADDR' ),
+ ('', 'cblas_ssyr', 'cblas_dsyr', 'cblas_cher', 'cblas_zher' ),
+ ('', 'cblas_sscal', 'cblas_dscal', 'cblas_csscal', 'cblas_zdscal' ),
# ----- Core BLAS
- ('CORE_sasum', 'CORE_dasum', 'CORE_scasum', 'CORE_dzasum' ),
- ('core_sasum', 'core_dasum', 'core_scasum', 'core_dzasum' ),
- ('CORE_ssyrfb', 'CORE_dsyrfb', 'CORE_cherfb', 'CORE_zherfb' ),
- ('core_ssyrfb', 'core_dsyrfb', 'core_cherfb', 'core_zherfb' ),
- ('CORE_stsmlq_sy', 'CORE_dtsmlq_sy', 'CORE_ctsmlq_he', 'CORE_ztsmlq_he' ),
- ('core_stsmlq_sy', 'core_dtsmlq_sy', 'core_ctsmlq_he', 'core_ztsmlq_he' ),
- ('CORE_stsmqr_sy', 'CORE_dtsmqr_sy', 'CORE_ctsmqr_he', 'CORE_ztsmqr_he' ),
- ('core_stsmqr_sy', 'core_dtsmqr_sy', 'core_ctsmqr_he', 'core_ztsmqr_he' ),
+ ('', 'CORE_sasum', 'CORE_dasum', 'CORE_scasum', 'CORE_dzasum' ),
+ ('', 'core_sasum', 'core_dasum', 'core_scasum', 'core_dzasum' ),
+ ('', 'CORE_ssyrfb', 'CORE_dsyrfb', 'CORE_cherfb', 'CORE_zherfb' ),
+ ('', 'core_ssyrfb', 'core_dsyrfb', 'core_cherfb', 'core_zherfb' ),
+ ('', 'CORE_stsmlq_sy', 'CORE_dtsmlq_sy', 'CORE_ctsmlq_he', 'CORE_ztsmlq_he' ),
+ ('', 'core_stsmlq_sy', 'core_dtsmlq_sy', 'core_ctsmlq_he', 'core_ztsmlq_he' ),
+ ('', 'CORE_stsmqr_sy', 'CORE_dtsmqr_sy', 'CORE_ctsmqr_he', 'CORE_ztsmqr_he' ),
+ ('', 'core_stsmqr_sy', 'core_dtsmqr_sy', 'core_ctsmqr_he', 'core_ztsmqr_he' ),
# ----- Prefixes
# Changing prefixes first requires some calls to be fixed without precision,
# e.g., her2k -> syr2k instead of zher2k -> ssyr2k.
# See BLAS and LAPACK without precision, below.
- ('blasf77_s', 'blasf77_d', 'blasf77_c', 'blasf77_z' ),
- ('blasf77_s', 'blasf77_d', 'blasf77_s', 'blasf77_d' ),
- ('BLAS_S', 'BLAS_D', 'BLAS_C', 'BLAS_Z' ),
- ('BLAS_s', 'BLAS_d', 'BLAS_c', 'BLAS_z' ),
- ('BLAS_s', 'BLAS_d', 'BLAS_s', 'BLAS_d' ),
- ('blas_is', 'blas_id', 'blas_ic', 'blas_iz' ),
- ('blas_s', 'blas_d', 'blas_c', 'blas_z' ),
- ('cl_ps', 'cl_pd', 'cl_pc', 'cl_pz' ),
- ('cl_s', 'cl_d', 'cl_c', 'cl_z' ),
- ('cl_s', 'cl_d', 'cl_sc', 'cl_dz' ),
- ('CODELETS_S', 'CODELETS_D', 'CODELETS_C', 'CODELETS_Z' ),
- ('codelet_s', 'codelet_d', 'codelet_c', 'codelet_z' ),
- ('compute_s', 'compute_d', 'compute_c', 'compute_z' ),
- ('control_s', 'control_d', 'control_c', 'control_z' ),
- ('coreblas_s', 'coreblas_d', 'coreblas_c', 'coreblas_z' ),
- ('CORE_S', 'CORE_D', 'CORE_C', 'CORE_Z' ),
- ('CORE_s', 'CORE_d', 'CORE_c', 'CORE_z' ),
- ('core_s', 'core_d', 'core_c', 'core_z' ),
- ('CORE_s', 'CORE_d', 'CORE_s', 'CORE_d' ),
- ('cpu_gpu_s', 'cpu_gpu_d', 'cpu_gpu_c', 'cpu_gpu_z' ),
- ('cublasS', 'cublasD', 'cublasC', 'cublasZ' ),
- ('CUDA_S', 'CUDA_D', 'CUDA_C', 'CUDA_Z' ),
- ('CUDA_s', 'CUDA_d', 'CUDA_c', 'CUDA_z' ),
- ('example_s', 'example_d', 'example_c', 'example_z' ),
- ('ipt_s', 'ipt_d', 'ipt_c', 'ipt_z' ),
- ('LAPACKE_s', 'LAPACKE_d', 'LAPACKE_c', 'LAPACKE_z' ),
- ('lapackf77_s', 'lapackf77_d', 'lapackf77_c', 'lapackf77_z' ),
- ('lapackf77_s', 'lapackf77_d', 'lapackf77_s', 'lapackf77_d' ),
- ('lapack_s', 'lapack_d', 'lapack_c', 'lapack_z' ),
- ('lapack_s', 'lapack_d', 'lapack_s', 'lapack_d' ),
- ('MAGMABLAS_S', 'MAGMABLAS_D', 'MAGMABLAS_C', 'MAGMABLAS_Z' ),
- ('magmablas_s', 'magmablas_d', 'magmablas_c', 'magmablas_z' ),
- ('magmaf_s', 'magmaf_d', 'magmaf_c', 'magmaf_z' ),
- ('magma_get_s', 'magma_get_d', 'magma_get_c', 'magma_get_z' ),
- ('magma_ps', 'magma_pd', 'magma_pc', 'magma_pz' ),
- ('MAGMA_S', 'MAGMA_D', 'MAGMA_C', 'MAGMA_Z' ),
- ('MAGMA_s', 'MAGMA_d', 'MAGMA_c', 'MAGMA_z' ),
- ('magma_s', 'magma_d', 'magma_c', 'magma_z' ),
- ('QUARK_S', 'QUARK_D', 'QUARK_C', 'QUARK_Z' ),
- ('QUARK_s', 'QUARK_d', 'QUARK_c', 'QUARK_z' ),
- ('quark_s', 'quark_d', 'quark_c', 'quark_z' ),
- ('QUARK_s', 'QUARK_d', 'QUARK_s', 'QUARK_d' ),
- ('plasma_ps', 'plasma_pd', 'plasma_pc', 'plasma_pz' ),
- ('PLASMA_S', 'PLASMA_D', 'PLASMA_C', 'PLASMA_Z' ),
- ('PLASMA_sor', 'PLASMA_dor', 'PLASMA_cun', 'PLASMA_zun' ),
- ('PLASMA_s', 'PLASMA_d', 'PLASMA_c', 'PLASMA_z' ),
- ('plasma_s', 'plasma_d', 'plasma_c', 'plasma_z' ),
- ('PROFILE_S', 'PROFILE_D', 'PROFILE_C', 'PROFILE_Z' ),
- ('profile_s', 'profile_d', 'profile_c', 'profile_z' ),
- ('SCHED_s', 'SCHED_d', 'SCHED_c', 'SCHED_z' ),
- ('starpu_s', 'starpu_d', 'starpu_c', 'starpu_z' ),
- ('testing_ds', 'testing_ds', 'testing_zc', 'testing_zc' ),
- ('TESTING_S', 'TESTING_D', 'TESTING_C', 'TESTING_Z' ),
- ('testing_s', 'testing_d', 'testing_c', 'testing_z' ),
- ('time_s', 'time_d', 'time_c', 'time_z' ),
- ('WRAPPER_S', 'WRAPPER_D', 'WRAPPER_C', 'WRAPPER_Z' ),
- ('wrapper_s', 'wrapper_d', 'wrapper_c', 'wrapper_z' ),
- ('Workspace_s', 'Workspace_d', 'Workspace_c', 'Workspace_z' ),
- ('workspace_s', 'workspace_d', 'workspace_c', 'workspace_z' ),
-
- ('csc_s', 'csc_d', 'csc_c', 'csc_z' ),
- ('sequential_s', 'sequential_d', 'sequential_c', 'sequential_z' ),
- ('coeftab_s', 'coeftab_d', 'coeftab_c', 'coeftab_z' ),
-
- # ----- Prefixes MORSE
- ('MORSE_S', 'MORSE_D', 'MORSE_C', 'MORSE_Z' ),
- ('MORSE_sor', 'MORSE_dor', 'MORSE_cun', 'MORSE_zun' ),
- ('MORSE_s', 'MORSE_d', 'MORSE_c', 'MORSE_z' ),
- ('morse_get_s', 'morse_get_d', 'morse_get_c', 'morse_get_z' ),
- ('morse_ps', 'morse_pd', 'morse_pc', 'morse_pz' ),
- ('morse_s', 'morse_d', 'morse_c', 'morse_z' ),
- ('morse_sdesc', 'morse_ddesc', 'morse_sdesc', 'morse_ddesc' ),
- ('TASK_sasum', 'TASK_dasum', 'TASK_scasum', 'TASK_dzasum' ),
- ('TASK_ssyrfb', 'TASK_dsyrfb', 'TASK_cherfb', 'TASK_zherfb' ),
- ('TASK_stsmlq_sy', 'TASK_dtsmlq_sy', 'TASK_ctsmlq_he', 'TASK_ztsmlq_he' ),
- ('TASK_stsmqr_sy', 'TASK_dtsmqr_sy', 'TASK_ctsmqr_he', 'TASK_ztsmqr_he' ),
- ('TASK_sor', 'TASK_dor', 'TASK_cun', 'TASK_zun' ),
- ('TASK_s', 'TASK_d', 'TASK_c', 'TASK_z' ),
- ('TASK_slan', 'TASK_dlan', 'TASK_slan', 'TASK_dlan' ),
- ('RUNTIME_S', 'RUNTIME_D', 'RUNTIME_C', 'RUNTIME_Z' ),
- ('RUNTIME_s', 'RUNTIME_d', 'RUNTIME_c', 'RUNTIME_z' ),
-
- ('TASK_s', 'TASK_d', 'TASK_s', 'TASK_d' ),
- ('dataflush', 'dataflush', 'dataflush', 'sataflush' ), # Correct previous line
+ ('', 'blasf77_s', 'blasf77_d', 'blasf77_c', 'blasf77_z' ),
+ ('', 'blasf77_s', 'blasf77_d', 'blasf77_s', 'blasf77_d' ),
+ ('', 'BLAS_S', 'BLAS_D', 'BLAS_C', 'BLAS_Z' ),
+ ('', 'BLAS_s', 'BLAS_d', 'BLAS_c', 'BLAS_z' ),
+ ('', 'BLAS_s', 'BLAS_d', 'BLAS_s', 'BLAS_d' ),
+ ('', 'blas_is', 'blas_id', 'blas_ic', 'blas_iz' ),
+ ('', 'blas_s', 'blas_d', 'blas_c', 'blas_z' ),
+ ('', 'cl_ps', 'cl_pd', 'cl_pc', 'cl_pz' ),
+ ('', 'cl_s', 'cl_d', 'cl_c', 'cl_z' ),
+ ('', 'cl_s', 'cl_d', 'cl_sc', 'cl_dz' ),
+ ('', 'CODELETS_S', 'CODELETS_D', 'CODELETS_C', 'CODELETS_Z' ),
+ ('', 'codelet_s', 'codelet_d', 'codelet_c', 'codelet_z' ),
+ ('', 'compute_s', 'compute_d', 'compute_c', 'compute_z' ),
+ ('', 'control_s', 'control_d', 'control_c', 'control_z' ),
+ ('', 'coreblas_s', 'coreblas_d', 'coreblas_c', 'coreblas_z' ),
+ ('', 'CORE_S', 'CORE_D', 'CORE_C', 'CORE_Z' ),
+ ('', 'CORE_s', 'CORE_d', 'CORE_c', 'CORE_z' ),
+ ('', 'core_s', 'core_d', 'core_c', 'core_z' ),
+ ('', 'CORE_s', 'CORE_d', 'CORE_s', 'CORE_d' ),
+ ('', 'cpu_gpu_s', 'cpu_gpu_d', 'cpu_gpu_c', 'cpu_gpu_z' ),
+ ('', 'cublasS', 'cublasD', 'cublasC', 'cublasZ' ),
+ ('', 'example_s', 'example_d', 'example_c', 'example_z' ),
+ ('', 'ipt_s', 'ipt_d', 'ipt_c', 'ipt_z' ),
+ ('', 'LAPACKE_s', 'LAPACKE_d', 'LAPACKE_c', 'LAPACKE_z' ),
+ ('', 'lapackf77_s', 'lapackf77_d', 'lapackf77_c', 'lapackf77_z' ),
+ ('', 'lapackf77_s', 'lapackf77_d', 'lapackf77_s', 'lapackf77_d' ),
+ ('', 'lapack_s', 'lapack_d', 'lapack_c', 'lapack_z' ),
+ ('', 'lapack_s', 'lapack_d', 'lapack_s', 'lapack_d' ),
+ ('', 'MAGMABLAS_S', 'MAGMABLAS_D', 'MAGMABLAS_C', 'MAGMABLAS_Z' ),
+ ('', 'magmablas_s', 'magmablas_d', 'magmablas_c', 'magmablas_z' ),
+ ('', 'magmaf_s', 'magmaf_d', 'magmaf_c', 'magmaf_z' ),
+ ('', 'magma_get_s', 'magma_get_d', 'magma_get_c', 'magma_get_z' ),
+ ('', 'magma_ps', 'magma_pd', 'magma_pc', 'magma_pz' ),
+ ('', 'MAGMA_S', 'MAGMA_D', 'MAGMA_C', 'MAGMA_Z' ),
+ ('', 'MAGMA_s', 'MAGMA_d', 'MAGMA_c', 'MAGMA_z' ),
+ ('', 'magma_s', 'magma_d', 'magma_c', 'magma_z' ),
+ ('', 'QUARK_S', 'QUARK_D', 'QUARK_C', 'QUARK_Z' ),
+ ('', 'QUARK_s', 'QUARK_d', 'QUARK_c', 'QUARK_z' ),
+ ('', 'quark_s', 'quark_d', 'quark_c', 'quark_z' ),
+ ('', 'QUARK_s', 'QUARK_d', 'QUARK_s', 'QUARK_d' ),
+ ('', 'plasma_ps', 'plasma_pd', 'plasma_pc', 'plasma_pz' ),
+ ('', 'PLASMA_S', 'PLASMA_D', 'PLASMA_C', 'PLASMA_Z' ),
+ ('', 'PLASMA_sor', 'PLASMA_dor', 'PLASMA_cun', 'PLASMA_zun' ),
+ ('', 'PLASMA_s', 'PLASMA_d', 'PLASMA_c', 'PLASMA_z' ),
+ ('', 'plasma_s', 'plasma_d', 'plasma_c', 'plasma_z' ),
+ ('', 'PROFILE_S', 'PROFILE_D', 'PROFILE_C', 'PROFILE_Z' ),
+ ('', 'profile_s', 'profile_d', 'profile_c', 'profile_z' ),
+ ('', 'SCHED_s', 'SCHED_d', 'SCHED_c', 'SCHED_z' ),
+ ('', 'starpu_s', 'starpu_d', 'starpu_c', 'starpu_z' ),
+ ('', 'testing_ds', 'testing_ds', 'testing_zc', 'testing_zc' ),
+ ('', 'TESTING_S', 'TESTING_D', 'TESTING_C', 'TESTING_Z' ),
+ ('', 'testing_s', 'testing_d', 'testing_c', 'testing_z' ),
+ ('', 'time_s', 'time_d', 'time_c', 'time_z' ),
+ ('', 'WRAPPER_S', 'WRAPPER_D', 'WRAPPER_C', 'WRAPPER_Z' ),
+ ('', 'wrapper_s', 'wrapper_d', 'wrapper_c', 'wrapper_z' ),
+ ('', 'Workspace_s', 'Workspace_d', 'Workspace_c', 'Workspace_z' ),
+ ('', 'workspace_s', 'workspace_d', 'workspace_c', 'workspace_z' ),
+
+ ('p_spm', 's_spm', 'd_spm', 'c_spm', 'z_spm' ),
+ ('p_bcsc', 's_bcsc', 'd_bcsc', 'c_bcsc', 'z_bcsc' ),
+ ('', 'csc_s', 'csc_d', 'csc_c', 'csc_z' ),
+ ('', 'sequential_s', 'sequential_d', 'sequential_c', 'sequential_z' ),
+ ('', 'coeftab_s', 'coeftab_d', 'coeftab_c', 'coeftab_z' ),
+ ('', 'thread_s', 'thread_d', 'thread_c', 'thread_z' ),
+ ('', 'thread_ps', 'thread_pd', 'thread_pc', 'thread_pz' ),
# ----- Complex numbers
# \b regexp here avoids conjugate -> conjfugate,
# assuming we always translate from z, not to z.
- ('', '', 'conjf', 'conj\b' ),
- ('fabsf', 'fabs', 'cabsf', 'cabs' ),
- ('', '', 'cuCrealf', 'cuCreal' ),
- ('', '', 'cuCimagf', 'cuCimag' ),
- ('', '', 'cuConjf', 'cuConj' ),
- ('fabsf', 'fabs', 'cuCabsf', 'cuCabs' ),
- ('', '', 'crealf', 'creal' ),
- ('sqrtf', 'sqrt', 'csqrtf', 'csqrt' ),
+ ('', '', '', 'conjf', 'conj\b' ),
+ ('', 'fabsf', 'fabs', 'cabsf', 'cabs' ),
+ ('', '', '', 'cuCrealf', 'cuCreal' ),
+ ('', '', '', 'cuCimagf', 'cuCimag' ),
+ ('', '', '', 'cuConjf', 'cuConj' ),
+ ('', 'fabsf', 'fabs', 'cuCabsf', 'cuCabs' ),
+ ('', '', '', 'crealf', 'creal' ),
+ ('', 'sqrtf', 'sqrt', 'csqrtf', 'csqrt' ),
# ----- CUDA
- ('cublasIsamax', 'cublasIdamax', 'cublasIcamax', 'cublasIzamax' ),
- ('cublasIsamax', 'cublasIdamax', 'cublasIsamax', 'cublasIdamax' ),
- ('cublasSnrm2', 'cublasDnrm2', 'cublasScnrm2', 'cublasDznrm2' ),
+ ('', 'cublasIsamax', 'cublasIdamax', 'cublasIcamax', 'cublasIzamax' ),
+ ('', 'cublasIsamax', 'cublasIdamax', 'cublasIsamax', 'cublasIdamax' ),
+ ('', 'cublasSnrm2', 'cublasDnrm2', 'cublasScnrm2', 'cublasDznrm2' ),
# ----- PLASMA / MAGMA / MORSE
- ('bsy2trc', 'bsy2trc', 'bhe2trc', 'bhe2trc' ),
- ('magma_ssqrt', 'magma_dsqrt', 'magma_ssqrt', 'magma_dsqrt' ),
- ('morse_ssqrt', 'morse_dsqrt', 'morse_ssqrt', 'morse_dsqrt' ),
- ('SAUXILIARY', 'DAUXILIARY', 'CAUXILIARY', 'ZAUXILIARY' ),
- ('sauxiliary', 'dauxiliary', 'cauxiliary', 'zauxiliary' ),
- ('sbcyclic', 'dbcyclic', 'cbcyclic', 'zbcyclic' ),
- ('sbulge', 'dbulge', 'cbulge', 'zbulge' ),
- ('SCODELETS', 'DCODELETS', 'CCODELETS', 'ZCODELETS' ),
- ('sgetmatrix', 'dgetmatrix', 'cgetmatrix', 'zgetmatrix' ),
- ('sinplace', 'dinplace', 'cinplace', 'zinplace' ),
- ('slocality', 'dlocality', 'clocality', 'zlocality' ),
- ('slapack', 'dlapack', 'clapack', 'zlapack' ),
- ('SLAPACK', 'DLAPACK', 'CLAPACK', 'ZLAPACK' ),
- ('smalloc', 'dmalloc', 'cmalloc', 'zmalloc' ),
- ('smalloc', 'dmalloc', 'smalloc', 'dmalloc' ),
- ('spanel_to_q', 'dpanel_to_q', 'cpanel_to_q', 'zpanel_to_q' ),
- ('spermute', 'dpermute', 'cpermute', 'zpermute' ),
- ('sprint', 'dprint', 'cprint', 'zprint' ),
- ('sprint', 'dprint', 'sprint', 'dprint' ),
- ('sprofiling', 'dprofiling', 'cprofiling', 'zprofiling' ),
- ('sq_to_panel', 'dq_to_panel', 'cq_to_panel', 'zq_to_panel' ),
- ('sset', 'dset', 'cset', 'zset' ),
- ('ssetmatrix', 'dsetmatrix', 'csetmatrix', 'zsetmatrix' ),
- ('SSIZE', 'DSIZE', 'CSIZE', 'ZSIZE' ),
- ('ssplit', 'dsplit', 'csplit', 'zsplit' ),
- ('stile', 'dtile', 'ctile', 'ztile' ),
- ('STILE', 'DTILE', 'CTILE', 'ZTILE' ),
- ('stranspose', 'dtranspose', 'ctranspose', 'ztranspose' ),
- ('szero', 'dzero', 'czero', 'zzero' ),
- ('sy2sb', 'sy2sb', 'he2hb', 'he2hb' ),
+ ('', 'bsy2trc', 'bsy2trc', 'bhe2trc', 'bhe2trc' ),
+ ('', 'magma_ssqrt', 'magma_dsqrt', 'magma_ssqrt', 'magma_dsqrt' ),
+ ('', 'morse_ssqrt', 'morse_dsqrt', 'morse_ssqrt', 'morse_dsqrt' ),
+ ('', 'SAUXILIARY', 'DAUXILIARY', 'CAUXILIARY', 'ZAUXILIARY' ),
+ ('', 'sauxiliary', 'dauxiliary', 'cauxiliary', 'zauxiliary' ),
+ ('', 'sbcyclic', 'dbcyclic', 'cbcyclic', 'zbcyclic' ),
+ ('', 'sbulge', 'dbulge', 'cbulge', 'zbulge' ),
+ ('', 'SCODELETS', 'DCODELETS', 'CCODELETS', 'ZCODELETS' ),
+ ('', 'sgetmatrix', 'dgetmatrix', 'cgetmatrix', 'zgetmatrix' ),
+ ('', 'sinplace', 'dinplace', 'cinplace', 'zinplace' ),
+ ('', 'slocality', 'dlocality', 'clocality', 'zlocality' ),
+ ('', 'slapack', 'dlapack', 'clapack', 'zlapack' ),
+ ('', 'SLAPACK', 'DLAPACK', 'CLAPACK', 'ZLAPACK' ),
+ ('', 'smalloc', 'dmalloc', 'cmalloc', 'zmalloc' ),
+ ('', 'smalloc', 'dmalloc', 'smalloc', 'dmalloc' ),
+ ('', 'spanel_to_q', 'dpanel_to_q', 'cpanel_to_q', 'zpanel_to_q' ),
+ ('', 'spermute', 'dpermute', 'cpermute', 'zpermute' ),
+ ('', 'sprint', 'dprint', 'cprint', 'zprint' ),
+ ('', 'sprint', 'dprint', 'sprint', 'dprint' ),
+ ('', 'sprofiling', 'dprofiling', 'cprofiling', 'zprofiling' ),
+ ('', 'sq_to_panel', 'dq_to_panel', 'cq_to_panel', 'zq_to_panel' ),
+ ('', 'sset', 'dset', 'cset', 'zset' ),
+ ('', 'ssetmatrix', 'dsetmatrix', 'csetmatrix', 'zsetmatrix' ),
+ ('', 'SSIZE', 'DSIZE', 'CSIZE', 'ZSIZE' ),
+ ('', 'ssplit', 'dsplit', 'csplit', 'zsplit' ),
+ ('', 'stile', 'dtile', 'ctile', 'ztile' ),
+ ('', 'STILE', 'DTILE', 'CTILE', 'ZTILE' ),
+ ('', 'stranspose', 'dtranspose', 'ctranspose', 'ztranspose' ),
+ ('', 'szero', 'dzero', 'czero', 'zzero' ),
+ ('', 'sy2sb', 'sy2sb', 'he2hb', 'he2hb' ),
# ----- Constants
- ('CblasTrans', 'CblasTrans', 'CblasConjTrans', 'CblasConjTrans' ),
- ('MagmaTrans', 'MagmaTrans', 'MagmaConjTrans', 'MagmaConjTrans' ),
- ('MorseTrans', 'MorseTrans', 'MorseConjTrans', 'MorseConjTrans' ),
- ('PlasmaTrans', 'PlasmaTrans', 'PlasmaConjTrans','PlasmaConjTrans' ),
- ('symmetric', 'symmetric', 'Hermitian', 'Hermitian' ),
+ ('', 'CblasTrans', 'CblasTrans', 'CblasConjTrans', 'CblasConjTrans' ),
+ ('', 'MagmaTrans', 'MagmaTrans', 'MagmaConjTrans', 'MagmaConjTrans' ),
+ ('', 'PlasmaTrans', 'PlasmaTrans', 'PlasmaConjTrans','PlasmaConjTrans' ),
+ ('', 'symmetric', 'symmetric', 'Hermitian', 'Hermitian' ),
# ----- BLAS and LAPACK, lowercase, alphabetic order
# copy & paste these to uppercase below and fix case.
# used for filenames lacking magma_z, etc. prefix
- ('isamax', 'idamax', 'icamax', 'izamax' ),
- ('isamax', 'idamax', 'isamax', 'idamax' ),
- ('saxpy', 'daxpy', 'caxpy', 'zaxpy' ),
- ('scopy', 'dcopy', 'ccopy', 'zcopy' ),
- ('sgeadd', 'dgeadd', 'cgeadd', 'zgeadd' ),
- ('sgecfi', 'dgecfi', 'cgecfi', 'zgecfi' ),
- ('sgemdm', 'dgemdm', 'cgemdm', 'zgemdm' ),
- ('sgemm', 'dgemm', 'cgemm', 'zgemm' ),
- ('sgemv', 'dgemv', 'cgemv', 'zgemv' ),
- ('sscal', 'dscal', 'cscal', 'zscal' ),
- ('sscal', 'dscal', 'csscal', 'zdscal' ),
- ('sscal', 'dscal', 'sscal', 'dscal' ), # zdscal -> csscal
- ('slascal', 'dlascal', 'clascal', 'zlascal' ),
- ('slascal', 'dlascal', 'slascal', 'dlascal' ),
- ('sswap', 'dswap', 'cswap', 'zswap' ),
- ('ssymm', 'dsymm', 'csymm', 'zsymm' ),
- ('ssymv', 'dsymv', 'csymv', 'zsymv' ),
- ('ssyr2k', 'dsyr2k', 'csyr2k', 'zsyr2k' ),
- ('ssyrk', 'dsyrk', 'csyrk', 'zsyrk' ),
- ('stradd', 'dtradd', 'ctradd', 'ztradd' ),
- ('strmm', 'dtrmm', 'ctrmm', 'ztrmm' ),
- ('strmv', 'dtrmv', 'ctrmv', 'ztrmv' ),
- ('strsm', 'dtrsm', 'ctrsm', 'ztrsm' ),
- ('strsv', 'dtrsv', 'ctrsv', 'ztrsv' ),
+ ('', 'isamax', 'idamax', 'icamax', 'izamax' ),
+ ('', 'isamax', 'idamax', 'isamax', 'idamax' ),
+ ('', 'saxpy', 'daxpy', 'caxpy', 'zaxpy' ),
+ ('', 'scopy', 'dcopy', 'ccopy', 'zcopy' ),
+ ('', 'sdiag', 'ddiag', 'cdiag', 'zdiag' ),
+ ('', 'sgecfi', 'dgecfi', 'cgecfi', 'zgecfi' ),
+ ('', 'sgemm', 'dgemm', 'cgemm', 'zgemm' ),
+ ('', 'sgemdm', 'dgemdm', 'cgemdm', 'zgemdm' ),
+ ('', 'SGEMDM', 'DGEMDM', 'CGEMDM', 'ZGEMDM' ),
+ ('', 'sgemv', 'dgemv', 'cgemv', 'zgemv' ),
+ ('', 'sscal', 'dscal', 'cscal', 'zscal' ),
+ ('', 'sscal', 'dscal', 'csscal', 'zdscal' ),
+ ('', 'sscal', 'dscal', 'sscal', 'dscal' ), # zdscal -> csscal
+ ('', 'sswap', 'dswap', 'cswap', 'zswap' ),
+ ('', 'ssymm', 'dsymm', 'csymm', 'zsymm' ),
+ ('', 'ssymv', 'dsymv', 'csymv', 'zsymv' ),
+ ('', 'ssyr2k', 'dsyr2k', 'csyr2k', 'zsyr2k' ),
+ ('', 'ssyrk', 'dsyrk', 'csyrk', 'zsyrk' ),
+ ('', 'strmm', 'dtrmm', 'ctrmm', 'ztrmm' ),
+ ('', 'strmv', 'dtrmv', 'ctrmv', 'ztrmv' ),
+ ('', 'strsm', 'dtrsm', 'ctrsm', 'ztrsm' ),
+ ('', 'strsv', 'dtrsv', 'ctrsv', 'ztrsv' ),
# ADD FOR NEW VERSION OF CHAMELEON
- ('shbcpy', 'dhbcpy', 'chbcpy', 'zhbcpy' ),
- ('ssyrbt', 'dsyrbt', 'cherbt', 'zherbt' ),
- ('ssygv', 'dsygv', 'chegv', 'zhegv' ),
+ ('', 'sgeadd', 'dgeadd', 'cgeadd', 'zgeadd' ),
+ ('', 'shbcpy', 'dhbcpy', 'chbcpy', 'zhbcpy' ),
+ ('', 'ssyrbt', 'dsyrbt', 'cherbt', 'zherbt' ),
+ ('', 'ssygv', 'dsygv', 'chegv', 'zhegv' ),
# END ADD
# LAPACK
- ('sbarrier', 'dbarrier', 'cbarrier', 'zbarrier' ),
- ('sbdsqr', 'dbdsqr', 'cbdsqr', 'zbdsqr' ),
- ('sbdt01', 'dbdt01', 'cbdt01', 'zbdt01' ),
- ('scheck', 'dcheck', 'ccheck', 'zcheck' ),
- ('sgebak', 'dgebak', 'cgebak', 'zgebak' ),
- ('sgebal', 'dgebal', 'cgebal', 'zgebal' ),
- ('sgebd2', 'dgebd2', 'cgebd2', 'zgebd2' ),
- ('sgebrd', 'dgebrd', 'cgebrd', 'zgebrd' ),
- ('sgeev', 'dgeev', 'cgeev', 'zgeev' ),
- ('sgehd2', 'dgehd2', 'cgehd2', 'zgehd2' ),
- ('sgehrd', 'dgehrd', 'cgehrd', 'zgehrd' ),
- ('sgelq2', 'dgelq2', 'cgelq2', 'zgelq2' ),
- ('sgelqf', 'dgelqf', 'cgelqf', 'zgelqf' ),
- ('sgelqs', 'dgelqs', 'cgelqs', 'zgelqs' ),
- ('sgelqt', 'dgelqt', 'cgelqt', 'zgelqt' ),
- ('sgels', 'dgels', 'cgels', 'zgels' ),
- ('sgeqlf', 'dgeqlf', 'cgeqlf', 'zgeqlf' ),
- ('sgeqp3', 'dgeqp3', 'cgeqp3', 'zgeqp3' ),
- ('sgeqr2', 'dgeqr2', 'cgeqr2', 'zgeqr2' ),
- ('sgeqrf', 'dgeqrf', 'cgeqrf', 'zgeqrf' ),
- ('sgeqrs', 'dgeqrs', 'cgeqrs', 'zgeqrs' ),
- ('sgeqrt', 'dgeqrt', 'cgeqrt', 'zgeqrt' ),
- ('sgessm', 'dgessm', 'cgessm', 'zgessm' ),
- ('sgessq', 'dgessq', 'cgessq', 'zgessq' ),
- ('sgesv', 'dgesv', 'cgesv', 'zgesv' ),
- ('sgesvd', 'dgesvd', 'cgesvd', 'zgesvd' ),
- ('sgesv', 'sgesv', 'cgesv', 'cgesv' ),
- ('sget22', 'dget22', 'cget22', 'zget22' ),
- ('sgetf2', 'dgetf2', 'cgetf2', 'zgetf2' ),
- ('sgetmi', 'dgetmi', 'cgetmi', 'zgetmi' ),
- ('sgetmo', 'dgetmo', 'cgetmo', 'zgetmo' ),
- ('sgetrf', 'dgetrf', 'cgetrf', 'zgetrf' ),
- ('sgetri', 'dgetri', 'cgetri', 'zgetri' ),
- ('sgetrl', 'dgetrl', 'cgetrl', 'zgetrl' ),
- ('sgetrs', 'dgetrs', 'cgetrs', 'zgetrs' ),
- ('shseqr', 'dhseqr', 'chseqr', 'zhseqr' ),
- ('shst01', 'dhst01', 'chst01', 'zhst01' ),
- ('slabad', 'dlabad', 'slabad', 'dlabad' ),
- ('slabrd', 'dlabrd', 'clabrd', 'zlabrd' ),
- ('slacgv', 'dlacgv', 'clacgv', 'zlacgv' ),
- ('slacpy', 'dlacpy', 'clacpy', 'zlacpy' ),
- ('slaed', 'dlaed', 'slaed', 'dlaed' ),
- ('slaex', 'dlaex', 'slaex', 'dlaex' ),
- ('slagsy', 'dlagsy', 'clagsy', 'zlagsy' ),
- ('slahr', 'dlahr', 'clahr', 'zlahr' ),
- ('slamc3', 'dlamc3', 'slamc3', 'dlamc3' ),
- ('slamch', 'dlamch', 'slamch', 'dlamch' ),
- ('slamrg', 'dlamrg', 'slamrg', 'dlamrg' ),
- ('slange', 'dlange', 'clange', 'zlange' ),
- ('slanst', 'dlanst', 'clanht', 'zlanht' ),
- ('slansy', 'dlansy', 'clansy', 'zlansy' ),
- ('slantr', 'dlantr', 'clantr', 'zlantr' ),
- ('slaqps', 'dlaqps', 'claqps', 'zlaqps' ),
- ('slaqp2', 'dlaqp2', 'claqp2', 'zlaqp2' ),
- ('slarfb', 'dlarfb', 'clarfb', 'zlarfb' ),
- ('slarfg', 'dlarfg', 'clarfg', 'zlarfg' ),
- ('slarft', 'dlarft', 'clarft', 'zlarft' ),
- ('slarfx', 'dlarfx', 'clarfx', 'zlarfx' ),
- ('slarfy', 'dlarfy', 'clarfy', 'zlarfy' ),
- ('slarnv', 'dlarnv', 'clarnv', 'zlarnv' ),
- ('slarnv', 'dlarnv', 'slarnv', 'dlarnv' ),
- ('slartg', 'dlartg', 'clartg', 'zlartg' ),
- ('slascl', 'dlascl', 'clascl', 'zlascl' ),
- ('slaset', 'dlaset', 'claset', 'zlaset' ),
- ('slaswp', 'dlaswp', 'claswp', 'zlaswp' ),
- ('slatro', 'dlatro', 'clatro', 'zlatro' ),
- ('slatrd', 'dlatrd', 'clatrd', 'zlatrd' ),
- ('slauum', 'dlauum', 'clauum', 'zlauum' ),
- ('spack', 'dpack', 'cpack', 'zpack' ),
- ('splgsy', 'dplgsy', 'cplgsy', 'zplgsy' ),
- ('splrnt', 'dplrnt', 'cplrnt', 'zplrnt' ),
- ('splssq', 'dplssq', 'cplssq', 'zplssq' ),
- ('sposv', 'dposv', 'cposv', 'zposv' ),
- ('ssysv', 'dsysv', 'csysv', 'zsysv' ),
- ('sposv', 'sposv', 'cposv', 'cposv' ),
- ('spotrf', 'dpotrf', 'cpotrf', 'zpotrf' ),
- ('ssytrf', 'dsytrf', 'csytrf', 'zsytrf' ),
- ('spotri', 'dpotri', 'cpotri', 'zpotri' ),
- ('spotrs', 'dpotrs', 'cpotrs', 'zpotrs' ),
- ('ssytrs', 'dsytrs', 'csytrs', 'zsytrs' ),
- ('sqpt01', 'dqpt01', 'cqpt01', 'zqpt01' ),
- ('sqrt02', 'dqrt02', 'cqrt02', 'zqrt02' ),
- ('sshift', 'dshift', 'cshift', 'zshift' ),
- ('sssssm', 'dssssm', 'cssssm', 'zssssm' ),
- ('sstebz', 'dstebz', 'sstebz', 'dstebz' ),
- ('sstedc', 'dstedc', 'cstedc', 'zstedc' ),
- ('sstedx', 'dstedx', 'cstedx', 'zstedx' ),
- ('sstedx', 'dstedx', 'sstedx', 'dstedx' ),
- ('sstein', 'dstein', 'cstein', 'zstein' ),
- ('sstemr', 'dstemr', 'cstemr', 'zstemr' ),
- ('ssteqr', 'dsteqr', 'csteqr', 'zsteqr' ),
- ('ssterf', 'dsterf', 'ssterf', 'dsterf' ),
- ('ssterm', 'dsterm', 'csterm', 'zsterm' ),
- ('sstt21', 'dstt21', 'cstt21', 'zstt21' ),
- ('strasm', 'dtrasm', 'ctrasm', 'ztrasm' ),
- ('strevc', 'dtrevc', 'ctrevc', 'ztrevc' ),
- ('strsmpl', 'dtrsmpl', 'ctrsmpl', 'ztrsmpl' ),
- ('strssq', 'dtrssq', 'ctrssq', 'ztrssq' ),
- ('strtri', 'dtrtri', 'ctrtri', 'ztrtri' ),
- ('stslqt', 'dtslqt', 'ctslqt', 'ztslqt' ),
- ('stsmlq_sy', 'dtsmlq_sy', 'ctsmlq_he', 'ztsmlq_he' ),
- ('stsmqr_sy', 'dtsmqr_sy', 'ctsmqr_he', 'ztsmqr_he' ),
- ('stsmqr', 'dtsmqr', 'ctsmqr', 'ztsmqr' ),
- ('stsmlq', 'dtsmlq', 'ctsmlq', 'ztsmlq' ),
- ('stsqrt', 'dtsqrt', 'ctsqrt', 'ztsqrt' ),
- ('stpgqrt', 'dtpgqrt', 'ctpgqrt', 'ztpgqrt' ),
- ('stpqrt', 'dtpqrt', 'ctpqrt', 'ztpqrt' ),
- ('stpmqrt', 'dtpmqrt', 'ctpmqrt', 'ztpmqrt' ),
- ('stslqt', 'dtslqt', 'ctslqt', 'ztslqt' ),
- ('ststrf', 'dtstrf', 'ctstrf', 'ztstrf' ),
- ('sttlqt', 'dttlqt', 'cttlqt', 'zttlqt' ),
- ('sttmlq', 'dttmlq', 'cttmlq', 'zttmlq' ),
- ('sttmqr', 'dttmqr', 'cttmqr', 'zttmqr' ),
- ('sttqrt', 'dttqrt', 'cttqrt', 'zttqrt' ),
- ('sungesv', 'sungesv', 'cungesv', 'cungesv' ),
- ('sstegr', 'dstegr', 'cstegr', 'zstegr' ),
- ('ssyssq', 'dsyssq', 'csyssq', 'zsyssq' ),
-
- # ----- LAPACK Eigenvalues
- ('slatms', 'dlatms', 'slatms', 'dlatms' ),
- ('slasrt', 'dlasrt', 'slasrt', 'dlasrt' ),
+ ('', 'sbarrier', 'dbarrier', 'cbarrier', 'zbarrier' ),
+ ('', 'sbdsqr', 'dbdsqr', 'cbdsqr', 'zbdsqr' ),
+ ('', 'sbdt01', 'dbdt01', 'cbdt01', 'zbdt01' ),
+ ('', 'scheck', 'dcheck', 'ccheck', 'zcheck' ),
+ ('', 'sgebak', 'dgebak', 'cgebak', 'zgebak' ),
+ ('', 'sgebal', 'dgebal', 'cgebal', 'zgebal' ),
+ ('', 'sgebd2', 'dgebd2', 'cgebd2', 'zgebd2' ),
+ ('', 'sgebrd', 'dgebrd', 'cgebrd', 'zgebrd' ),
+ ('', 'sgeev', 'dgeev', 'cgeev', 'zgeev' ),
+ ('', 'sgehd2', 'dgehd2', 'cgehd2', 'zgehd2' ),
+ ('', 'sgehrd', 'dgehrd', 'cgehrd', 'zgehrd' ),
+ ('', 'sgelq2', 'dgelq2', 'cgelq2', 'zgelq2' ),
+ ('', 'sgelqf', 'dgelqf', 'cgelqf', 'zgelqf' ),
+ ('', 'sgelqs', 'dgelqs', 'cgelqs', 'zgelqs' ),
+ ('', 'sgelqt', 'dgelqt', 'cgelqt', 'zgelqt' ),
+ ('', 'sgels', 'dgels', 'cgels', 'zgels' ),
+ ('', 'sgeqlf', 'dgeqlf', 'cgeqlf', 'zgeqlf' ),
+ ('', 'sgeqp3', 'dgeqp3', 'cgeqp3', 'zgeqp3' ),
+ ('', 'sgeqr2', 'dgeqr2', 'cgeqr2', 'zgeqr2' ),
+ ('', 'sgeqrf', 'dgeqrf', 'cgeqrf', 'zgeqrf' ),
+ ('', 'sgeqrs', 'dgeqrs', 'cgeqrs', 'zgeqrs' ),
+ ('', 'sgeqrt', 'dgeqrt', 'cgeqrt', 'zgeqrt' ),
+ ('', 'sgessm', 'dgessm', 'cgessm', 'zgessm' ),
+ ('', 'sgessq', 'dgessq', 'cgessq', 'zgessq' ),
+ ('', 'sgesv', 'dgesv', 'cgesv', 'zgesv' ),
+ ('', 'sgesv', 'sgesv', 'cgesv', 'cgesv' ),
+ ('', 'sget22', 'dget22', 'cget22', 'zget22' ),
+ ('', 'sgetf2', 'dgetf2', 'cgetf2', 'zgetf2' ),
+ ('', 'sgetmi', 'dgetmi', 'cgetmi', 'zgetmi' ),
+ ('', 'sgetmo', 'dgetmo', 'cgetmo', 'zgetmo' ),
+ ('', 'sgetrf', 'dgetrf', 'cgetrf', 'zgetrf' ),
+ ('', 'sgetri', 'dgetri', 'cgetri', 'zgetri' ),
+ ('', 'sgetrl', 'dgetrl', 'cgetrl', 'zgetrl' ),
+ ('', 'sgetrs', 'dgetrs', 'cgetrs', 'zgetrs' ),
+ ('', 'shseqr', 'dhseqr', 'chseqr', 'zhseqr' ),
+ ('', 'shst01', 'dhst01', 'chst01', 'zhst01' ),
+ ('', 'slabad', 'dlabad', 'slabad', 'dlabad' ),
+ ('', 'slabrd', 'dlabrd', 'clabrd', 'zlabrd' ),
+ ('', 'slacgv', 'dlacgv', 'clacgv', 'zlacgv' ),
+ ('', 'slacpy', 'dlacpy', 'clacpy', 'zlacpy' ),
+ ('', 'slaed', 'dlaed', 'slaed', 'dlaed' ),
+ ('', 'slaex', 'dlaex', 'slaex', 'dlaex' ),
+ ('', 'slagsy', 'dlagsy', 'clagsy', 'zlagsy' ),
+ ('', 'slahr', 'dlahr', 'clahr', 'zlahr' ),
+ ('', 'slamc3', 'dlamc3', 'slamc3', 'dlamc3' ),
+ ('', 'slamch', 'dlamch', 'slamch', 'dlamch' ),
+ ('', 'slamrg', 'dlamrg', 'slamrg', 'dlamrg' ),
+ ('', 'slange', 'dlange', 'clange', 'zlange' ),
+ ('', 'slanst', 'dlanst', 'clanht', 'zlanht' ),
+ ('', 'slansy', 'dlansy', 'clansy', 'zlansy' ),
+ ('', 'slantr', 'dlantr', 'clantr', 'zlantr' ),
+ ('', 'slaqps', 'dlaqps', 'claqps', 'zlaqps' ),
+ ('', 'slaqp2', 'dlaqp2', 'claqp2', 'zlaqp2' ),
+ ('', 'slarfb', 'dlarfb', 'clarfb', 'zlarfb' ),
+ ('', 'slarfg', 'dlarfg', 'clarfg', 'zlarfg' ),
+ ('', 'slarft', 'dlarft', 'clarft', 'zlarft' ),
+ ('', 'slarfx', 'dlarfx', 'clarfx', 'zlarfx' ),
+ ('', 'slarfy', 'dlarfy', 'clarfy', 'zlarfy' ),
+ ('', 'slarnv', 'dlarnv', 'clarnv', 'zlarnv' ),
+ ('', 'slarnv', 'dlarnv', 'slarnv', 'dlarnv' ),
+ ('', 'slartg', 'dlartg', 'clartg', 'zlartg' ),
+ ('', 'slascl', 'dlascl', 'clascl', 'zlascl' ),
+ ('', 'slaset', 'dlaset', 'claset', 'zlaset' ),
+ ('', 'slaswp', 'dlaswp', 'claswp', 'zlaswp' ),
+ ('', 'slatrd', 'dlatrd', 'clatrd', 'zlatrd' ),
+ ('', 'slauum', 'dlauum', 'clauum', 'zlauum' ),
+ ('', 'spack', 'dpack', 'cpack', 'zpack' ),
+ ('', 'splgsy', 'dplgsy', 'cplgsy', 'zplgsy' ),
+ ('', 'splrnt', 'dplrnt', 'cplrnt', 'zplrnt' ),
+ ('', 'splssq', 'dplssq', 'cplssq', 'zplssq' ),
+ ('', 'sposv', 'dposv', 'cposv', 'zposv' ),
+ ('', 'ssysv', 'dsysv', 'csysv', 'zsysv' ),
+ ('', 'sposv', 'sposv', 'cposv', 'cposv' ),
+ ('', 'spotrf', 'dpotrf', 'cpotrf', 'zpotrf' ),
+ ('', 'ssytrf', 'dsytrf', 'csytrf', 'zsytrf' ),
+ ('', 'spotri', 'dpotri', 'cpotri', 'zpotri' ),
+ ('', 'spotrs', 'dpotrs', 'cpotrs', 'zpotrs' ),
+ ('', 'ssytrs', 'dsytrs', 'csytrs', 'zsytrs' ),
+ ('', 'sqpt01', 'dqpt01', 'cqpt01', 'zqpt01' ),
+ ('', 'sqrt02', 'dqrt02', 'cqrt02', 'zqrt02' ),
+ ('', 'sshift', 'dshift', 'cshift', 'zshift' ),
+ ('', 'sssssm', 'dssssm', 'cssssm', 'zssssm' ),
+ ('', 'sstebz', 'dstebz', 'sstebz', 'dstebz' ),
+ ('', 'sstedc', 'dstedc', 'cstedc', 'zstedc' ),
+ ('', 'sstedx', 'dstedx', 'cstedx', 'zstedx' ),
+ ('', 'sstedx', 'dstedx', 'sstedx', 'dstedx' ),
+ ('', 'sstein', 'dstein', 'cstein', 'zstein' ),
+ ('', 'sstemr', 'dstemr', 'cstemr', 'zstemr' ),
+ ('', 'ssteqr', 'dsteqr', 'csteqr', 'zsteqr' ),
+ ('', 'ssterf', 'dsterf', 'ssterf', 'dsterf' ),
+ ('', 'ssterm', 'dsterm', 'csterm', 'zsterm' ),
+ ('', 'sstt21', 'dstt21', 'cstt21', 'zstt21' ),
+ ('', 'strasm', 'dtrasm', 'ctrasm', 'ztrasm' ),
+ ('', 'strevc', 'dtrevc', 'ctrevc', 'ztrevc' ),
+ ('', 'strsmpl', 'dtrsmpl', 'ctrsmpl', 'ztrsmpl' ),
+ ('', 'strssq', 'dtrssq', 'ctrssq', 'ztrssq' ),
+ ('', 'strtri', 'dtrtri', 'ctrtri', 'ztrtri' ),
+ ('', 'stslqt', 'dtslqt', 'ctslqt', 'ztslqt' ),
+ ('', 'stsmlq_sy', 'dtsmlq_sy', 'ctsmlq_he', 'ztsmlq_he' ),
+ ('', 'stsmqr_sy', 'dtsmqr_sy', 'ctsmqr_he', 'ztsmqr_he' ),
+ ('', 'stsmqr', 'dtsmqr', 'ctsmqr', 'ztsmqr' ),
+ ('', 'stsmlq', 'dtsmlq', 'ctsmlq', 'ztsmlq' ),
+ ('', 'stsqrt', 'dtsqrt', 'ctsqrt', 'ztsqrt' ),
+ ('', 'stslqt', 'dtslqt', 'ctslqt', 'ztslqt' ),
+ ('', 'ststrf', 'dtstrf', 'ctstrf', 'ztstrf' ),
+ ('', 'sttlqt', 'dttlqt', 'cttlqt', 'zttlqt' ),
+ ('', 'sttmlq', 'dttmlq', 'cttmlq', 'zttmlq' ),
+ ('', 'sttmqr', 'dttmqr', 'cttmqr', 'zttmqr' ),
+ ('', 'sttqrt', 'dttqrt', 'cttqrt', 'zttqrt' ),
+ ('', 'sungesv', 'sungesv', 'cungesv', 'cungesv' ),
+ ('', 'sstegr', 'dstegr', 'cstegr', 'zstegr' ),
+ ('', 'ssyssq', 'dsyssq', 'csyssq', 'zsyssq' ),
# ----- BLAS and LAPACK, where complex base name != real base name
# BLAS, with precision
- ('sasum', 'dasum', 'scasum', 'dzasum' ),
- ('sasum', 'dasum', 'casum', 'zasum' ),
- ('sdot', 'ddot', 'cdotc', 'zdotc' ),
- ('sdot_sub', 'ddot_sub', 'cdotc_sub', 'zdotc_sub' ),
- ('sdot_sub', 'ddot_sub', 'cdotu_sub', 'zdotu_sub' ),
- ('sger', 'dger', 'cgerc', 'zgerc' ),
- ('sger', 'dger', 'cgeru', 'zgeru' ),
- ('snrm2', 'dnrm2', 'scnrm2', 'dznrm2' ),
- ('ssymm', 'dsymm', 'chemm', 'zhemm' ),
- ('ssymv', 'dsymv', 'chemv', 'zhemv' ),
- ('ssyr2', 'dsyr2', 'cher2', 'zher2' ),
- ('ssyr2k', 'dsyr2k', 'cher2k', 'zher2k' ),
- ('ssyrk', 'dsyrk', 'cherk', 'zherk' ),
- ('ssyr', 'dsyr', 'cher', 'zher' ),
+ ('', 'sasum', 'dasum', 'scasum', 'dzasum' ),
+ ('', 'sasum', 'dasum', 'casum', 'zasum' ),
+ ('', 'sger', 'dger', 'cgerc', 'zgerc' ),
+ ('', 'sger', 'dger', 'cgeru', 'zgeru' ),
+ ('', 'snrm2', 'dnrm2', 'scnrm2', 'dznrm2' ),
+ ('', 'ssymm', 'dsymm', 'chemm', 'zhemm' ),
+ ('', 'ssymv', 'dsymv', 'chemv', 'zhemv' ),
+ ('', 'ssyr2', 'dsyr2', 'cher2', 'zher2' ),
+ ('', 'ssyr2k', 'dsyr2k', 'cher2k', 'zher2k' ),
+ ('', 'ssyrk', 'dsyrk', 'cherk', 'zherk' ),
+ ('', 'ssyr', 'dsyr', 'cher', 'zher' ),
# LAPACK, with precision
- ('slag2d', 'dlag2s', 'clag2z', 'zlag2c' ),
- ('slagsy', 'dlagsy', 'claghe', 'zlaghe' ),
- ('slasyf', 'dlasyf', 'clahef', 'zlahef' ),
- ('slansy', 'dlansy', 'clanhe', 'zlanhe' ),
- ('slavsy', 'dlavsy', 'clavhe', 'zlavhe' ),
- ('sorg2r', 'dorg2r', 'cung2r', 'zung2r' ),
- ('sorgbr', 'dorgbr', 'cungbr', 'zungbr' ),
- ('sorghr', 'dorghr', 'cunghr', 'zunghr' ),
- ('sorglq', 'dorglq', 'cunglq', 'zunglq' ),
- ('sorgql', 'dorgql', 'cungql', 'zungql' ),
- ('sorgqr', 'dorgqr', 'cungqr', 'zungqr' ),
- ('sorgtr', 'dorgtr', 'cungtr', 'zungtr' ),
- ('sorm2r', 'dorm2r', 'cunm2r', 'zunm2r' ),
- ('sormbr', 'dormbr', 'cunmbr', 'zunmbr' ),
- ('sormlq', 'dormlq', 'cunmlq', 'zunmlq' ),
- ('sormql', 'dormql', 'cunmql', 'zunmql' ),
- ('sormqr', 'dormqr', 'cunmqr', 'zunmqr' ),
- ('sormr2', 'dormr2', 'cunmr2', 'zunmr2' ),
- ('sormtr', 'dormtr', 'cunmtr', 'zunmtr' ),
- ('sort01', 'dort01', 'cunt01', 'zunt01' ),
- ('splgsy', 'dplgsy', 'cplghe', 'zplghe' ),
- ('ssbtrd', 'dsbtrd', 'chbtrd', 'zhbtrd' ),
- ('ssybbd', 'dsybbd', 'chebbd', 'zhebbd' ),
- ('ssyev', 'dsyev', 'cheev', 'zheev' ),
- ('ssyevd', 'dsyevd', 'cheevd', 'zheevd' ),
- ('ssygs2', 'dsygs2', 'chegs2', 'zhegs2' ),
- ('ssygst', 'dsygst', 'chegst', 'zhegst' ),
- ('ssygvd', 'dsygvd', 'chegvd', 'zhegvd' ),
- ('ssygvr', 'dsygvr', 'chegvr', 'zhegvr' ),
- ('ssygvx', 'dsygvx', 'chegvx', 'zhegvx' ),
- ('ssyssq', 'dsyssq', 'chessq', 'zhessq' ),
- ('ssyt21', 'dsyt21', 'chet21', 'zhet21' ),
- ('ssytd2', 'dsytd2', 'chetd2', 'zhetd2' ),
- ('ssytrd', 'dsytrd', 'chetrd', 'zhetrd' ),
- ('ssytrf', 'dsytrf', 'chetrf', 'zhetrf' ),
-
- # ----- Auxiliary routines with precision
- ('sgemerge', 'dgemerge', 'cgemerge', 'zgemerge' ),
- ('sparfb', 'dparfb', 'cparfb', 'zparfb' ),
+ ('', 'slag2d', 'dlag2s', 'clag2z', 'zlag2c' ),
+ ('', 'slagsy', 'dlagsy', 'claghe', 'zlaghe' ),
+ ('', 'slasyf', 'dlasyf', 'clahef', 'zlahef' ),
+ ('', 'slansy', 'dlansy', 'clanhe', 'zlanhe' ),
+ ('', 'slavsy', 'dlavsy', 'clavhe', 'zlavhe' ),
+ ('', 'sorg2r', 'dorg2r', 'cung2r', 'zung2r' ),
+ ('', 'sorgbr', 'dorgbr', 'cungbr', 'zungbr' ),
+ ('', 'sorghr', 'dorghr', 'cunghr', 'zunghr' ),
+ ('', 'sorglq', 'dorglq', 'cunglq', 'zunglq' ),
+ ('', 'sorgql', 'dorgql', 'cungql', 'zungql' ),
+ ('', 'sorgqr', 'dorgqr', 'cungqr', 'zungqr' ),
+ ('', 'sorgtr', 'dorgtr', 'cungtr', 'zungtr' ),
+ ('', 'sorm2r', 'dorm2r', 'cunm2r', 'zunm2r' ),
+ ('', 'sormbr', 'dormbr', 'cunmbr', 'zunmbr' ),
+ ('', 'sormlq', 'dormlq', 'cunmlq', 'zunmlq' ),
+ ('', 'sormql', 'dormql', 'cunmql', 'zunmql' ),
+ ('', 'sormqr', 'dormqr', 'cunmqr', 'zunmqr' ),
+ ('', 'sormr2', 'dormr2', 'cunmr2', 'zunmr2' ),
+ ('', 'sormtr', 'dormtr', 'cunmtr', 'zunmtr' ),
+ ('', 'sort01', 'dort01', 'cunt01', 'zunt01' ),
+ ('', 'splgsy', 'dplgsy', 'cplghe', 'zplghe' ),
+ ('', 'ssbtrd', 'dsbtrd', 'chbtrd', 'zhbtrd' ),
+ ('', 'ssybbd', 'dsybbd', 'chebbd', 'zhebbd' ),
+ ('', 'ssyev', 'dsyev', 'cheev', 'zheev' ),
+ ('', 'ssyevd', 'dsyevd', 'cheevd', 'zheevd' ),
+ ('', 'ssygs2', 'dsygs2', 'chegs2', 'zhegs2' ),
+ ('', 'ssygst', 'dsygst', 'chegst', 'zhegst' ),
+ ('', 'ssygvd', 'dsygvd', 'chegvd', 'zhegvd' ),
+ ('', 'ssygvr', 'dsygvr', 'chegvr', 'zhegvr' ),
+ ('', 'ssygvx', 'dsygvx', 'chegvx', 'zhegvx' ),
+ ('', 'ssyssq', 'dsyssq', 'chessq', 'zhessq' ),
+ ('', 'ssyt21', 'dsyt21', 'chet21', 'zhet21' ),
+ ('', 'ssytd2', 'dsytd2', 'chetd2', 'zhetd2' ),
+ ('', 'ssytrd', 'dsytrd', 'chetrd', 'zhetrd' ),
+ ('', 'ssytrf', 'dsytrf', 'chetrf', 'zhetrf' ),
# BLAS, without precision
# must be after BLAS with precision
# Ex: cublasZhemm -> cublasShemm -> cublasSsymm
- ('dot', 'dot', 'dotc', 'dotc' ),
- ('dot_sub', 'dot_sub', 'dotc_sub', 'dotc_sub' ),
- ('dot_sub', 'dot_sub', 'dotu_sub', 'dotu_sub' ),
- ('ger', 'ger', 'gerc', 'gerc' ),
- ('ger', 'ger', 'geru', 'geru' ),
- ('nrm2', 'nrm2', 'cnrm2', 'znrm2' ), # dznrm2 -> dnrm2
- ('symm', 'symm', 'hemm', 'hemm' ),
- ('symv', 'symv', 'hemv', 'hemv' ),
- ('syr2', 'syr2', 'her2', 'her2' ),
- ('syr2k', 'syr2k', 'her2k', 'her2k' ),
- ('syrk', 'syrk', 'herk', 'herk' ),
+ ('', 'Dot', 'Dot', 'Dotc', 'Dotc' ),
+ ('', 'Dot', 'Dot', 'Dotu', 'Dotu' ),
+ ('', 'dot', 'dot', 'dotc', 'dotc' ),
+ ('', 'dot', 'dot', 'dotu', 'dotu' ),
+ ('', 'ger', 'ger', 'gerc', 'gerc' ),
+ ('', 'ger', 'ger', 'geru', 'geru' ),
+ ('', 'nrm2', 'nrm2', 'cnrm2', 'znrm2' ), # dznrm2 -> dnrm2
+ ('', 'symm', 'symm', 'hemm', 'hemm' ),
+ ('', 'symv', 'symv', 'hemv', 'hemv' ),
+ ('', 'syr2', 'syr2', 'her2', 'her2' ),
+ ('', 'syr2k', 'syr2k', 'her2k', 'her2k' ),
+ ('', 'syrk', 'syrk', 'herk', 'herk' ),
# LAPACK, without precision
- ('lag2d', 'lag2s', 'lag2z', 'lag2c' ),
- ('lagsy', 'lagsy', 'laghe', 'laghe' ),
- ('lasyf', 'lasyf', 'lahef', 'lahef' ),
- ('lansy', 'lansy', 'lanhe', 'lanhe' ),
- ('lanst', 'lanst', 'lanht', 'lanht' ),
- ('lavsy', 'lavsy', 'lavhe', 'lavhe' ),
- ('org2r', 'org2r', 'ung2r', 'ung2r' ),
- ('orgbr', 'orgbr', 'ungbr', 'ungbr' ),
- ('orghr', 'orghr', 'unghr', 'unghr' ),
- ('orglq', 'orglq', 'unglq', 'unglq' ),
- ('orgql', 'orgql', 'ungql', 'ungql' ),
- ('orgqr', 'orgqr', 'ungqr', 'ungqr' ),
- ('orgtr', 'orgtr', 'ungtr', 'ungtr' ),
- ('orm2r', 'orm2r', 'unm2r', 'unm2r' ),
- ('ormbr', 'ormbr', 'unmbr', 'unmbr' ),
- ('ormlq', 'ormlq', 'unmlq', 'unmlq' ),
- ('ormql', 'ormql', 'unmql', 'unmql' ),
- ('ormqr', 'ormqr', 'unmqr', 'unmqr' ),
- ('ormr2', 'ormr2', 'unmr2', 'unmr2' ),
- ('ormtr', 'ormtr', 'unmtr', 'unmtr' ),
- ('ort01', 'ort01', 'unt01', 'unt01' ),
- ('plgsy', 'plgsy', 'plghe', 'plghe' ),
- ('sbtrd', 'sbtrd', 'hbtrd', 'hbtrd' ),
- ('sybbd', 'sybbd', 'hebbd', 'hebbd' ),
- ('syev', 'syev', 'heev', 'heev' ),
- ('syevd', 'syevd', 'heevd', 'heevd' ),
- ('sygs2', 'sygs2', 'hegs2', 'hegs2' ),
- ('sygst', 'sygst', 'hegst', 'hegst' ),
- ('sygvd', 'sygvd', 'hegvd', 'hegvd' ),
- ('sygvr', 'sygvr', 'hegvr', 'hegvr' ),
- ('sygvx', 'sygvx', 'hegvx', 'hegvx' ),
- ('syssq', 'syssq', 'hessq', 'hessq' ),
- ('syt21', 'syt21', 'het21', 'het21' ),
- ('sytd2', 'sytd2', 'hetd2', 'hetd2' ),
- ('sytrd', 'sytrd', 'hetrd', 'hetrd' ),
- ('sytrf', 'sytrf', 'hetrf', 'hetrf' ),
- ('syrfb', 'syrfb', 'herfb', 'herfb' ),
+ ('', 'lag2d', 'lag2s', 'lag2z', 'lag2c' ),
+ ('', 'lagsy', 'lagsy', 'laghe', 'laghe' ),
+ ('', 'lasyf', 'lasyf', 'lahef', 'lahef' ),
+ ('', 'lansy', 'lansy', 'lanhe', 'lanhe' ),
+ ('', 'lanst', 'lanst', 'lanht', 'lanht' ),
+ ('', 'lavsy', 'lavsy', 'lavhe', 'lavhe' ),
+ ('', 'org2r', 'org2r', 'ung2r', 'ung2r' ),
+ ('', 'orgbr', 'orgbr', 'ungbr', 'ungbr' ),
+ ('', 'orghr', 'orghr', 'unghr', 'unghr' ),
+ ('', 'orglq', 'orglq', 'unglq', 'unglq' ),
+ ('', 'orgql', 'orgql', 'ungql', 'ungql' ),
+ ('', 'orgqr', 'orgqr', 'ungqr', 'ungqr' ),
+ ('', 'orgtr', 'orgtr', 'ungtr', 'ungtr' ),
+ ('', 'orm2r', 'orm2r', 'unm2r', 'unm2r' ),
+ ('', 'ormbr', 'ormbr', 'unmbr', 'unmbr' ),
+ ('', 'ormlq', 'ormlq', 'unmlq', 'unmlq' ),
+ ('', 'ormql', 'ormql', 'unmql', 'unmql' ),
+ ('', 'ormqr', 'ormqr', 'unmqr', 'unmqr' ),
+ ('', 'ormr2', 'ormr2', 'unmr2', 'unmr2' ),
+ ('', 'ormtr', 'ormtr', 'unmtr', 'unmtr' ),
+ ('', 'ort01', 'ort01', 'unt01', 'unt01' ),
+ ('', 'plgsy', 'plgsy', 'plghe', 'plghe' ),
+ ('', 'sbtrd', 'sbtrd', 'hbtrd', 'hbtrd' ),
+ ('', 'sybbd', 'sybbd', 'hebbd', 'hebbd' ),
+ ('', 'syev', 'syev', 'heev', 'heev' ),
+ ('', 'syevd', 'syevd', 'heevd', 'heevd' ),
+ ('', 'sygs2', 'sygs2', 'hegs2', 'hegs2' ),
+ ('', 'sygst', 'sygst', 'hegst', 'hegst' ),
+ ('', 'sygvd', 'sygvd', 'hegvd', 'hegvd' ),
+ ('', 'sygvr', 'sygvr', 'hegvr', 'hegvr' ),
+ ('', 'sygvx', 'sygvx', 'hegvx', 'hegvx' ),
+ ('', 'syssq', 'syssq', 'hessq', 'hessq' ),
+ ('', 'syt21', 'syt21', 'het21', 'het21' ),
+ ('', 'sytd2', 'sytd2', 'hetd2', 'hetd2' ),
+ ('', 'sytrd', 'sytrd', 'hetrd', 'hetrd' ),
+ ('', 'sytrf', 'sytrf', 'hetrf', 'hetrf' ),
# ----- For norms: compute result in Real or Double
- ('slange', 'dlange', 'slange', 'dlange' ),
- ('slaset', 'dlaset', 'slaset', 'dlaset' ),
- ('splssq', 'dplssq', 'splssq', 'dplssq' ),
- ('slacpy', 'dlacpy', 'slacpy', 'dlacpy' ),
- ('saxpy', 'daxpy', 'saxpy', 'daxpy' ),
- ('MorseRealFloat', 'MorseRealDouble', 'MorseRealFloat', 'MorseRealDouble'),
-
- # QUARK codelets protection (to prevent conversion with LAPACK WITH PRECISION)
- ('DAG_CORE_U-NG2R', 'DAG_CORE_U-NG2R', 'DAG_CORE_UNG2R', 'DAG_CORE_UNG2R' ),
- ('DAG_CORE_U-NGBR', 'DAG_CORE_U-NGBR', 'DAG_CORE_UNGBR', 'DAG_CORE_UNGBR' ),
- ('DAG_CORE_U-NGHR', 'DAG_CORE_U-NGHR', 'DAG_CORE_UNGHR', 'DAG_CORE_UNGHR' ),
- ('DAG_CORE_U-NGLQ', 'DAG_CORE_U-NGLQ', 'DAG_CORE_UNGLQ', 'DAG_CORE_UNGLQ' ),
- ('DAG_CORE_U-NGQL', 'DAG_CORE_U-NGQL', 'DAG_CORE_UNGQL', 'DAG_CORE_UNGQL' ),
- ('DAG_CORE_U-NGQR', 'DAG_CORE_U-NGQR', 'DAG_CORE_UNGQR', 'DAG_CORE_UNGQR' ),
- ('DAG_CORE_U-NGTR', 'DAG_CORE_U-NGTR', 'DAG_CORE_UNGTR', 'DAG_CORE_UNGTR' ),
- ('DAG_CORE_U-NM2R', 'DAG_CORE_U-NM2R', 'DAG_CORE_UNM2R', 'DAG_CORE_UNM2R' ),
- ('DAG_CORE_U-NMBR', 'DAG_CORE_U-NMBR', 'DAG_CORE_UNMBR', 'DAG_CORE_UNMBR' ),
- ('DAG_CORE_U-NMLQ', 'DAG_CORE_U-NMLQ', 'DAG_CORE_UNMLQ', 'DAG_CORE_UNMLQ' ),
- ('DAG_CORE_U-NMQL', 'DAG_CORE_U-NMQL', 'DAG_CORE_UNMQL', 'DAG_CORE_UNMQL' ),
- ('DAG_CORE_U-NMQR', 'DAG_CORE_U-NMQR', 'DAG_CORE_UNMQR', 'DAG_CORE_UNMQR' ),
+ ('', 'sgeadd', 'dgeadd', 'sgeadd', 'dgeadd' ),
+ ('', 'slange', 'dlange', 'slange', 'dlange' ),
+ ('', 'slaset', 'dlaset', 'slaset', 'dlaset' ),
+ ('', 'splssq', 'dplssq', 'splssq', 'dplssq' ),
+ ('', 'slacpy', 'dlacpy', 'slacpy', 'dlacpy' ),
+ ('', 'saxpy', 'daxpy', 'saxpy', 'daxpy' ),
# ----- BLAS AND LAPACK, UPPERCASE, ALPHABETIC ORDER
# COPY & PASTE THESE TO UPPERCASE BELOW AND FIX CASE.
# USED FOR FILENAMES LACKING MAGMA_Z, ETC. PREFIX
- ('ISAMAX', 'IDAMAX', 'ICAMAX', 'IZAMAX' ),
- ('ISAMAX', 'IDAMAX', 'ISAMAX', 'IDAMAX' ),
- ('SAXPY', 'DAXPY', 'CAXPY', 'ZAXPY' ),
- ('SCOPY', 'DCOPY', 'CCOPY', 'ZCOPY' ),
- ('SGEADD', 'DGEADD', 'CGEADD', 'ZGEADD' ),
- ('SGECFI', 'DGECFI', 'CGECFI', 'ZGECFI' ),
- ('SGEMDM', 'DGEMDM', 'CGEMDM', 'ZGEMDM' ),
- ('SGEMM', 'DGEMM', 'CGEMM', 'ZGEMM' ),
- ('SGEMV', 'DGEMV', 'CGEMV', 'ZGEMV' ),
- ('SSCAL', 'DSCAL', 'CSCAL', 'ZSCAL' ),
- ('SSCAL', 'DSCAL', 'CSSCAL', 'ZDSCAL' ),
- ('SSCAL', 'DSCAL', 'SSCAL', 'DSCAL' ), # ZDSCAL -> CSSCAL
- ('SSWAP', 'DSWAP', 'CSWAP', 'ZSWAP' ),
- ('SSYMM', 'DSYMM', 'CSYMM', 'ZSYMM' ),
- ('SSYMV', 'DSYMV', 'CSYMV', 'ZSYMV' ),
- ('SSYR2K', 'DSYR2K', 'CSYR2K', 'ZSYR2K' ),
- ('SSYRK', 'DSYRK', 'CSYRK', 'ZSYRK' ),
- ('STRADD', 'DTRADD', 'CTRADD', 'ZTRADD' ),
- ('STRMM', 'DTRMM', 'CTRMM', 'ZTRMM' ),
- ('STRMV', 'DTRMV', 'CTRMV', 'ZTRMV' ),
- ('STRSM', 'DTRSM', 'CTRSM', 'ZTRSM' ),
- ('STRSMPL', 'DTRSMPL', 'CTRSMPL', 'ZTRSMPL' ),
- ('STRSV', 'DTRSV', 'CTRSV', 'ZTRSV' ),
+ ('', 'ISAMAX', 'IDAMAX', 'ICAMAX', 'IZAMAX' ),
+ ('', 'ISAMAX', 'IDAMAX', 'ISAMAX', 'IDAMAX' ),
+ ('', 'SAXPY', 'DAXPY', 'CAXPY', 'ZAXPY' ),
+ ('', 'SCOPY', 'DCOPY', 'CCOPY', 'ZCOPY' ),
+ ('', 'SGEMV', 'DGEMV', 'CGEMV', 'ZGEMV' ),
+ ('', 'SSCAL', 'DSCAL', 'CSCAL', 'ZSCAL' ),
+ ('', 'SSCAL', 'DSCAL', 'CSSCAL', 'ZDSCAL' ),
+ ('', 'SSCAL', 'DSCAL', 'SSCAL', 'DSCAL' ), # ZDSCAL -> CSSCAL
+ ('', 'SSWAP', 'DSWAP', 'CSWAP', 'ZSWAP' ),
+ ('', 'SSYMM', 'DSYMM', 'CSYMM', 'ZSYMM' ),
+ ('', 'SSYMV', 'DSYMV', 'CSYMV', 'ZSYMV' ),
+ ('', 'SSYR2K', 'DSYR2K', 'CSYR2K', 'ZSYR2K' ),
+ ('', 'SSYRK', 'DSYRK', 'CSYRK', 'ZSYRK' ),
+ ('', 'STRMM', 'DTRMM', 'CTRMM', 'ZTRMM' ),
+ ('', 'STRMV', 'DTRMV', 'CTRMV', 'ZTRMV' ),
+ ('', 'STRSM', 'DTRSM', 'CTRSM', 'ZTRSM' ),
+ ('', 'STRSV', 'DTRSV', 'CTRSV', 'ZTRSV' ),
# LAPACK
- ('SBDSQR', 'DBDSQR', 'CBDSQR', 'ZBDSQR' ),
- ('SBDT01', 'DBDT01', 'CBDT01', 'ZBDT01' ),
- ('SCHECK', 'DCHECK', 'CCHECK', 'ZCHECK' ),
- ('SGEBAK', 'DGEBAK', 'CGEBAK', 'ZGEBAK' ),
- ('SGEBAL', 'DGEBAL', 'CGEBAL', 'ZGEBAL' ),
- ('SGEBD2', 'DGEBD2', 'CGEBD2', 'ZGEBD2' ),
- ('SGEBRD', 'DGEBRD', 'CGEBRD', 'ZGEBRD' ),
- ('SGEEV', 'DGEEV', 'CGEEV', 'ZGEEV' ),
- ('SGEHD2', 'DGEHD2', 'CGEHD2', 'ZGEHD2' ),
- ('SGEHRD', 'DGEHRD', 'CGEHRD', 'ZGEHRD' ),
- ('SGELQ2', 'DGELQ2', 'CGELQ2', 'ZGELQ2' ),
- ('SGELQF', 'DGELQF', 'CGELQF', 'ZGELQF' ),
- ('SGELQS', 'DGELQS', 'CGELQS', 'ZGELQS' ),
- ('SGELS', 'DGELS', 'CGELS', 'ZGELS' ),
- ('SGEQLF', 'DGEQLF', 'CGEQLF', 'ZGEQLF' ),
- ('SGEQP3', 'DGEQP3', 'CGEQP3', 'ZGEQP3' ),
- ('SGEQR2', 'DGEQR2', 'CGEQR2', 'ZGEQR2' ),
- ('SGEQRF', 'DGEQRF', 'CGEQRF', 'ZGEQRF' ),
- ('SGEQRS', 'DGEQRS', 'CGEQRS', 'ZGEQRS' ),
- ('SGESSM', 'DGESSM', 'CGESSM', 'ZGESSM' ),
- ('SGESV', 'DGESV', 'CGESV', 'ZGESV' ),
- ('SGESV', 'SGESV', 'CGESV', 'CGESV' ),
- ('SGET22', 'DGET22', 'CGET22', 'ZGET22' ),
- ('SGETF2', 'DGETF2', 'CGETF2', 'ZGETF2' ),
- ('SGETRF', 'DGETRF', 'CGETRF', 'ZGETRF' ),
- ('SGETRI', 'DGETRI', 'CGETRI', 'ZGETRI' ),
- ('SGETRL', 'DGETRL', 'CGETRL', 'ZGETRL' ),
- ('SGETRS', 'DGETRS', 'CGETRS', 'ZGETRS' ),
- ('SHSEQR', 'DHSEQR', 'CHSEQR', 'ZHSEQR' ),
- ('SHST01', 'DHST01', 'CHST01', 'ZHST01' ),
- ('SLABAD', 'DLABAD', 'SLABAD', 'DLABAD' ),
- ('SLABRD', 'DLABRD', 'CLABRD', 'ZLABRD' ),
- ('SLACGV', 'DLACGV', 'CLACGV', 'ZLACGV' ),
- ('SLACPY', 'DLACPY', 'CLACPY', 'ZLACPY' ),
- ('SLAED', 'DLAED', 'SLAED', 'DLAED' ),
- ('SLAEX', 'DLAEX', 'SLAEX', 'DLAEX' ),
- ('SLAGSY', 'DLAGSY', 'CLAGSY', 'ZLAGSY' ),
- ('SLAHR', 'DLAHR', 'CLAHR', 'ZLAHR' ),
- ('SLAMC3', 'DLAMC3', 'SLAMC3', 'DLAMC3' ),
- ('SLAMCH', 'DLAMCH', 'SLAMCH', 'DLAMCH' ),
- ('SLAMRG', 'DLAMRG', 'SLAMRG', 'DLAMRG' ),
- ('SLANGE', 'DLANGE', 'CLANGE', 'ZLANGE' ),
- ('SLANST', 'DLANST', 'CLANHT', 'ZLANHT' ),
- ('SLANSY', 'DLANSY', 'CLANSY', 'ZLANSY' ),
- ('SLANTR', 'DLANTR', 'CLANTR', 'ZLANTR' ),
- ('SLAQPS', 'DLAQPS', 'CLAQPS', 'ZLAQPS' ),
- ('SLAQP2', 'DLAQP2', 'CLAQP2', 'ZLAQP2' ),
- ('SLARFB', 'DLARFB', 'CLARFB', 'ZLARFB' ),
- ('SLARFG', 'DLARFG', 'CLARFG', 'ZLARFG' ),
- ('SLARFT', 'DLARFT', 'CLARFT', 'ZLARFT' ),
- ('SLARFX', 'DLARFX', 'CLARFX', 'ZLARFX' ),
- ('SLARFY', 'DLARFY', 'CLARFY', 'ZLARFY' ),
- ('SLARNV', 'DLARNV', 'CLARNV', 'ZLARNV' ),
- ('SLARNV', 'DLARNV', 'SLARNV', 'DLARNV' ),
- ('SLARTG', 'DLARTG', 'CLARTG', 'ZLARTG' ),
- ('SLASCL', 'DLASCL', 'CLASCL', 'ZLASCL' ),
- ('SLASET', 'DLASET', 'CLASET', 'ZLASET' ),
- ('SLASWP', 'DLASWP', 'CLASWP', 'ZLASWP' ),
- ('SLATRD', 'DLATRD', 'CLATRD', 'ZLATRD' ),
- ('SLAUUM', 'DLAUUM', 'CLAUUM', 'ZLAUUM' ),
- ('SPOSV', 'DPOSV', 'CPOSV', 'ZPOSV' ),
- ('SSYSV', 'DSYSV', 'CSYSV', 'ZSYSV' ),
- ('SPOSV', 'SPOSV', 'CPOSV', 'CPOSV' ),
- ('SPOTRF', 'DPOTRF', 'CPOTRF', 'ZPOTRF' ),
- ('SSYTRF', 'DSYTRF', 'CSYTRF', 'ZSYTRF' ),
- ('SPOTRI', 'DPOTRI', 'CPOTRI', 'ZPOTRI' ),
- ('SPOTRS', 'DPOTRS', 'CPOTRS', 'ZPOTRS' ),
- ('SSYTRS', 'DSYTRS', 'CSYTRS', 'ZSYTRS' ),
- ('SQPT01', 'DQPT01', 'CQPT01', 'ZQPT01' ),
- ('SQRT02', 'DQRT02', 'CQRT02', 'ZQRT02' ),
- ('SSSSSM', 'DSSSSM', 'CSSSSM', 'ZSSSSM' ),
- ('SSTEBZ', 'DSTEBZ', 'SSTEBZ', 'DSTEBZ' ),
- ('SSTEDC', 'DSTEDC', 'CSTEDC', 'ZSTEDC' ),
- ('SSTEDX', 'DSTEDX', 'CSTEDX', 'ZSTEDX' ),
- ('SSTEDX', 'DSTEDX', 'SSTEDX', 'DSTEDX' ),
- ('SSTEIN', 'DSTEIN', 'CSTEIN', 'ZSTEIN' ),
- ('SSTEMR', 'DSTEMR', 'CSTEMR', 'ZSTEMR' ),
- ('SSTEQR', 'DSTEQR', 'CSTEQR', 'ZSTEQR' ),
- ('SSTERF', 'DSTERF', 'SSTERF', 'DSTERF' ),
- ('SSTERM', 'DSTERM', 'CSTERM', 'ZSTERM' ),
- ('SSTT21', 'DSTT21', 'CSTT21', 'ZSTT21' ),
- ('STREVC', 'DTREVC', 'CTREVC', 'ZTREVC' ),
- ('STRTRI', 'DTRTRI', 'CTRTRI', 'ZTRTRI' ),
- ('STSQRT', 'DTSQRT', 'CTSQRT', 'ZTSQRT' ),
- ('STSTRF', 'DTSTRF', 'CTSTRF', 'ZTSTRF' ),
- ('SUNGESV', 'SUNGESV', 'CUNGESV', 'CUNGESV' ),
- ('SSTEGR', 'DSTEGR', 'CSTEGR', 'ZSTEGR' ),
+ ('', 'SBDSQR', 'DBDSQR', 'CBDSQR', 'ZBDSQR' ),
+ ('', 'SBDT01', 'DBDT01', 'CBDT01', 'ZBDT01' ),
+ ('', 'SCHECK', 'DCHECK', 'CCHECK', 'ZCHECK' ),
+ ('', 'SGEBAK', 'DGEBAK', 'CGEBAK', 'ZGEBAK' ),
+ ('', 'SGEBAL', 'DGEBAL', 'CGEBAL', 'ZGEBAL' ),
+ ('', 'SGEBD2', 'DGEBD2', 'CGEBD2', 'ZGEBD2' ),
+ ('', 'SGEBRD', 'DGEBRD', 'CGEBRD', 'ZGEBRD' ),
+ ('', 'SGEEV', 'DGEEV', 'CGEEV', 'ZGEEV' ),
+ ('', 'SGEHD2', 'DGEHD2', 'CGEHD2', 'ZGEHD2' ),
+ ('', 'SGEHRD', 'DGEHRD', 'CGEHRD', 'ZGEHRD' ),
+ ('', 'SGELQ2', 'DGELQ2', 'CGELQ2', 'ZGELQ2' ),
+ ('', 'SGELQF', 'DGELQF', 'CGELQF', 'ZGELQF' ),
+ ('', 'SGELQS', 'DGELQS', 'CGELQS', 'ZGELQS' ),
+ ('', 'SGELS', 'DGELS', 'CGELS', 'ZGELS' ),
+ ('', 'SGEMM', 'DGEMM', 'CGEMM', 'ZGEMM' ),
+ ('', 'SGEQLF', 'DGEQLF', 'CGEQLF', 'ZGEQLF' ),
+ ('', 'SGEQP3', 'DGEQP3', 'CGEQP3', 'ZGEQP3' ),
+ ('', 'SGEQR2', 'DGEQR2', 'CGEQR2', 'ZGEQR2' ),
+ ('', 'SGEQRF', 'DGEQRF', 'CGEQRF', 'ZGEQRF' ),
+ ('', 'SGEQRS', 'DGEQRS', 'CGEQRS', 'ZGEQRS' ),
+ ('', 'SGESSM', 'DGESSM', 'CGESSM', 'ZGESSM' ),
+ ('', 'SGESV', 'DGESV', 'CGESV', 'ZGESV' ),
+ ('', 'SGESV', 'SGESV', 'CGESV', 'CGESV' ),
+ ('', 'SGET22', 'DGET22', 'CGET22', 'ZGET22' ),
+ ('', 'SGETF2', 'DGETF2', 'CGETF2', 'ZGETF2' ),
+ ('', 'SGETRF', 'DGETRF', 'CGETRF', 'ZGETRF' ),
+ ('', 'SGETRI', 'DGETRI', 'CGETRI', 'ZGETRI' ),
+ ('', 'SGETRL', 'DGETRL', 'CGETRL', 'ZGETRL' ),
+ ('', 'SGETRS', 'DGETRS', 'CGETRS', 'ZGETRS' ),
+ ('', 'SHSEQR', 'DHSEQR', 'CHSEQR', 'ZHSEQR' ),
+ ('', 'SHST01', 'DHST01', 'CHST01', 'ZHST01' ),
+ ('', 'SLABAD', 'DLABAD', 'SLABAD', 'DLABAD' ),
+ ('', 'SLABRD', 'DLABRD', 'CLABRD', 'ZLABRD' ),
+ ('', 'SLACGV', 'DLACGV', 'CLACGV', 'ZLACGV' ),
+ ('', 'SLACPY', 'DLACPY', 'CLACPY', 'ZLACPY' ),
+ ('', 'SLAED', 'DLAED', 'SLAED', 'DLAED' ),
+ ('', 'SLAEX', 'DLAEX', 'SLAEX', 'DLAEX' ),
+ ('', 'SLAGSY', 'DLAGSY', 'CLAGSY', 'ZLAGSY' ),
+ ('', 'SLAHR', 'DLAHR', 'CLAHR', 'ZLAHR' ),
+ ('', 'SLAMC3', 'DLAMC3', 'SLAMC3', 'DLAMC3' ),
+ ('', 'SLAMCH', 'DLAMCH', 'SLAMCH', 'DLAMCH' ),
+ ('', 'SLAMRG', 'DLAMRG', 'SLAMRG', 'DLAMRG' ),
+ ('', 'SLANGE', 'DLANGE', 'CLANGE', 'ZLANGE' ),
+ ('', 'SLANST', 'DLANST', 'CLANHT', 'ZLANHT' ),
+ ('', 'SLANSY', 'DLANSY', 'CLANSY', 'ZLANSY' ),
+ ('', 'SLANTR', 'DLANTR', 'CLANTR', 'ZLANTR' ),
+ ('', 'SLAQPS', 'DLAQPS', 'CLAQPS', 'ZLAQPS' ),
+ ('', 'SLAQP2', 'DLAQP2', 'CLAQP2', 'ZLAQP2' ),
+ ('', 'SLARFB', 'DLARFB', 'CLARFB', 'ZLARFB' ),
+ ('', 'SLARFG', 'DLARFG', 'CLARFG', 'ZLARFG' ),
+ ('', 'SLARFT', 'DLARFT', 'CLARFT', 'ZLARFT' ),
+ ('', 'SLARFX', 'DLARFX', 'CLARFX', 'ZLARFX' ),
+ ('', 'SLARFY', 'DLARFY', 'CLARFY', 'ZLARFY' ),
+ ('', 'SLARNV', 'DLARNV', 'CLARNV', 'ZLARNV' ),
+ ('', 'SLARNV', 'DLARNV', 'SLARNV', 'DLARNV' ),
+ ('', 'SLARTG', 'DLARTG', 'CLARTG', 'ZLARTG' ),
+ ('', 'SLASCL', 'DLASCL', 'CLASCL', 'ZLASCL' ),
+ ('', 'SLASET', 'DLASET', 'CLASET', 'ZLASET' ),
+ ('', 'SLASWP', 'DLASWP', 'CLASWP', 'ZLASWP' ),
+ ('', 'SLATRD', 'DLATRD', 'CLATRD', 'ZLATRD' ),
+ ('', 'SLAUUM', 'DLAUUM', 'CLAUUM', 'ZLAUUM' ),
+ ('', 'SPOSV', 'DPOSV', 'CPOSV', 'ZPOSV' ),
+ ('', 'SSYSV', 'DSYSV', 'CSYSV', 'ZSYSV' ),
+ ('', 'SPOSV', 'SPOSV', 'CPOSV', 'CPOSV' ),
+ ('', 'SPOTRF', 'DPOTRF', 'CPOTRF', 'ZPOTRF' ),
+ ('', 'SSYTRF', 'DSYTRF', 'CSYTRF', 'ZSYTRF' ),
+ ('', 'SPOTRI', 'DPOTRI', 'CPOTRI', 'ZPOTRI' ),
+ ('', 'SPOTRS', 'DPOTRS', 'CPOTRS', 'ZPOTRS' ),
+ ('', 'SSYTRS', 'DSYTRS', 'CSYTRS', 'ZSYTRS' ),
+ ('', 'SQPT01', 'DQPT01', 'CQPT01', 'ZQPT01' ),
+ ('', 'SQRT02', 'DQRT02', 'CQRT02', 'ZQRT02' ),
+ ('', 'SSSSSM', 'DSSSSM', 'CSSSSM', 'ZSSSSM' ),
+ ('', 'SSTEBZ', 'DSTEBZ', 'SSTEBZ', 'DSTEBZ' ),
+ ('', 'SSTEDC', 'DSTEDC', 'CSTEDC', 'ZSTEDC' ),
+ ('', 'SSTEDX', 'DSTEDX', 'CSTEDX', 'ZSTEDX' ),
+ ('', 'SSTEDX', 'DSTEDX', 'SSTEDX', 'DSTEDX' ),
+ ('', 'SSTEIN', 'DSTEIN', 'CSTEIN', 'ZSTEIN' ),
+ ('', 'SSTEMR', 'DSTEMR', 'CSTEMR', 'ZSTEMR' ),
+ ('', 'SSTEQR', 'DSTEQR', 'CSTEQR', 'ZSTEQR' ),
+ ('', 'SSTERF', 'DSTERF', 'SSTERF', 'DSTERF' ),
+ ('', 'SSTERM', 'DSTERM', 'CSTERM', 'ZSTERM' ),
+ ('', 'SSTT21', 'DSTT21', 'CSTT21', 'ZSTT21' ),
+ ('', 'STREVC', 'DTREVC', 'CTREVC', 'ZTREVC' ),
+ ('', 'STRSMPL', 'DTRSMPL', 'CTRSMPL', 'ZTRSMPL' ),
+ ('', 'STRTRI', 'DTRTRI', 'CTRTRI', 'ZTRTRI' ),
+ ('', 'STSQRT', 'DTSQRT', 'CTSQRT', 'ZTSQRT' ),
+ ('', 'STSTRF', 'DTSTRF', 'CTSTRF', 'ZTSTRF' ),
+ ('', 'SUNGESV', 'SUNGESV', 'CUNGESV', 'CUNGESV' ),
+ ('', 'SSTEGR', 'DSTEGR', 'CSTEGR', 'ZSTEGR' ),
# ----- BLAS AND LAPACK, WHERE COMPLEX BASE NAME != REAL BASE NAME
# BLAS, WITH PRECISION
- ('SDOT', 'DDOT', 'CDOTC', 'ZDOTC' ),
- ('SDOT_SUB', 'DDOT_SUB', 'CDOTC_SUB', 'ZDOTC_SUB' ),
- ('SDOT_SUB', 'DDOT_SUB', 'CDOTU_SUB', 'ZDOTU_SUB' ),
- ('SGER', 'DGER', 'CGERC', 'ZGERC' ),
- ('SGER', 'DGER', 'CGERU', 'ZGERU' ),
- ('SNRM2', 'DNRM2', 'SCNRM2', 'DZNRM2' ),
- ('SSYMM', 'DSYMM', 'CHEMM', 'ZHEMM' ),
- ('SSYMV', 'DSYMV', 'CHEMV', 'ZHEMV' ),
- ('SSYR2', 'DSYR2', 'CHER2', 'ZHER2' ),
- ('SSYR2K', 'DSYR2K', 'CHER2K', 'ZHER2K' ),
- ('SSYRK', 'DSYRK', 'CHERK', 'ZHERK' ),
- ('SSYR', 'DSYR', 'CHER', 'ZHER' ),
+ ('', 'SGER', 'DGER', 'CGERC', 'ZGERC' ),
+ ('', 'SGER', 'DGER', 'CGERU', 'ZGERU' ),
+ ('', 'SNRM2', 'DNRM2', 'SCNRM2', 'DZNRM2' ),
+ ('', 'SSYMM', 'DSYMM', 'CHEMM', 'ZHEMM' ),
+ ('', 'SSYMV', 'DSYMV', 'CHEMV', 'ZHEMV' ),
+ ('', 'SSYR2', 'DSYR2', 'CHER2', 'ZHER2' ),
+ ('', 'SSYR2K', 'DSYR2K', 'CHER2K', 'ZHER2K' ),
+ ('', 'SSYRK', 'DSYRK', 'CHERK', 'ZHERK' ),
+ ('', 'SSYR', 'DSYR', 'CHER', 'ZHER' ),
# LAPACK, WITH PRECISION
- ('SLAG2D', 'DLAG2S', 'CLAG2Z', 'ZLAG2C' ),
- ('SLAGSY', 'DLAGSY', 'CLAGHE', 'ZLAGHE' ),
- ('SLASYF', 'DLASYF', 'CLAHEF', 'ZLAHEF' ),
- ('SLANSY', 'DLANSY', 'CLANHE', 'ZLANHE' ),
- ('SLAVSY', 'DLAVSY', 'CLAVHE', 'ZLAVHE' ),
- ('SORG2R', 'DORG2R', 'CUNG2R', 'ZUNG2R' ),
- ('SORGBR', 'DORGBR', 'CUNGBR', 'ZUNGBR' ),
- ('SORGHR', 'DORGHR', 'CUNGHR', 'ZUNGHR' ),
- ('SORGLQ', 'DORGLQ', 'CUNGLQ', 'ZUNGLQ' ),
- ('SORGQL', 'DORGQL', 'CUNGQL', 'ZUNGQL' ),
- ('SORGQR', 'DORGQR', 'CUNGQR', 'ZUNGQR' ),
- ('SORGTR', 'DORGTR', 'CUNGTR', 'ZUNGTR' ),
- ('SORM2R', 'DORM2R', 'CUNM2R', 'ZUNM2R' ),
- ('SORMBR', 'DORMBR', 'CUNMBR', 'ZUNMBR' ),
- ('SORMLQ', 'DORMLQ', 'CUNMLQ', 'ZUNMLQ' ),
- ('SORMQL', 'DORMQL', 'CUNMQL', 'ZUNMQL' ),
- ('SORMQR', 'DORMQR', 'CUNMQR', 'ZUNMQR' ),
- ('SORMR2', 'DORMR2', 'CUNMR2', 'ZUNMR2' ),
- ('SORMTR', 'DORMTR', 'CUNMTR', 'ZUNMTR' ),
- ('SORT01', 'DORT01', 'CUNT01', 'ZUNT01' ),
- ('SPLGSY', 'DPLGSY', 'CPLGHE', 'ZPLGHE' ),
- ('SSBTRD', 'DSBTRD', 'CHBTRD', 'ZHBTRD' ),
- ('SSYBBD', 'DSYBBD', 'CHEBBD', 'ZHEBBD' ),
- ('SSYEV', 'DSYEV', 'CHEEV', 'ZHEEV' ),
- ('SSYEVD', 'DSYEVD', 'CHEEVD', 'ZHEEVD' ),
- ('SSYGS2', 'DSYGS2', 'CHEGS2', 'ZHEGS2' ),
- ('SSYGST', 'DSYGST', 'CHEGST', 'ZHEGST' ),
- ('SSYGVD', 'DSYGVD', 'CHEGVD', 'ZHEGVD' ),
- ('SSYGVR', 'DSYGVR', 'CHEGVR', 'ZHEGVR' ),
- ('SSYGVX', 'DSYGVX', 'CHEGVX', 'ZHEGVX' ),
- ('SSYT21', 'DSYT21', 'CHET21', 'ZHET21' ),
- ('SSYTD2', 'DSYTD2', 'CHETD2', 'ZHETD2' ),
- ('SSYTRD', 'DSYTRD', 'CHETRD', 'ZHETRD' ),
- ('SSYTRF', 'DSYTRF', 'CHETRF', 'ZHETRF' ),
+ ('', 'SLAG2D', 'DLAG2S', 'CLAG2Z', 'ZLAG2C' ),
+ ('', 'SLAGSY', 'DLAGSY', 'CLAGHE', 'ZLAGHE' ),
+ ('', 'SLASYF', 'DLASYF', 'CLAHEF', 'ZLAHEF' ),
+ ('', 'SLANSY', 'DLANSY', 'CLANHE', 'ZLANHE' ),
+ ('', 'SLAVSY', 'DLAVSY', 'CLAVHE', 'ZLAVHE' ),
+ ('', 'SORG2R', 'DORG2R', 'CUNG2R', 'ZUNG2R' ),
+ ('', 'SORGBR', 'DORGBR', 'CUNGBR', 'ZUNGBR' ),
+ ('', 'SORGHR', 'DORGHR', 'CUNGHR', 'ZUNGHR' ),
+ ('', 'SORGLQ', 'DORGLQ', 'CUNGLQ', 'ZUNGLQ' ),
+ ('', 'SORGQL', 'DORGQL', 'CUNGQL', 'ZUNGQL' ),
+ ('', 'SORGQR', 'DORGQR', 'CUNGQR', 'ZUNGQR' ),
+ ('', 'SORGTR', 'DORGTR', 'CUNGTR', 'ZUNGTR' ),
+ ('', 'SORM2R', 'DORM2R', 'CUNM2R', 'ZUNM2R' ),
+ ('', 'SORMBR', 'DORMBR', 'CUNMBR', 'ZUNMBR' ),
+ ('', 'SORMLQ', 'DORMLQ', 'CUNMLQ', 'ZUNMLQ' ),
+ ('', 'SORMQL', 'DORMQL', 'CUNMQL', 'ZUNMQL' ),
+ ('', 'SORMQR', 'DORMQR', 'CUNMQR', 'ZUNMQR' ),
+ ('', 'SORMR2', 'DORMR2', 'CUNMR2', 'ZUNMR2' ),
+ ('', 'SORMTR', 'DORMTR', 'CUNMTR', 'ZUNMTR' ),
+ ('', 'SORT01', 'DORT01', 'CUNT01', 'ZUNT01' ),
+ ('', 'SPLGSY', 'DPLGSY', 'CPLGHE', 'ZPLGHE' ),
+ ('', 'SSBTRD', 'DSBTRD', 'CHBTRD', 'ZHBTRD' ),
+ ('', 'SSYBBD', 'DSYBBD', 'CHEBBD', 'ZHEBBD' ),
+ ('', 'SSYEV', 'DSYEV', 'CHEEV', 'ZHEEV' ),
+ ('', 'SSYEVD', 'DSYEVD', 'CHEEVD', 'ZHEEVD' ),
+ ('', 'SSYGS2', 'DSYGS2', 'CHEGS2', 'ZHEGS2' ),
+ ('', 'SSYGST', 'DSYGST', 'CHEGST', 'ZHEGST' ),
+ ('', 'SSYGVD', 'DSYGVD', 'CHEGVD', 'ZHEGVD' ),
+ ('', 'SSYGVR', 'DSYGVR', 'CHEGVR', 'ZHEGVR' ),
+ ('', 'SSYGVX', 'DSYGVX', 'CHEGVX', 'ZHEGVX' ),
+ ('', 'SSYT21', 'DSYT21', 'CHET21', 'ZHET21' ),
+ ('', 'SSYTD2', 'DSYTD2', 'CHETD2', 'ZHETD2' ),
+ ('', 'SSYTRD', 'DSYTRD', 'CHETRD', 'ZHETRD' ),
+ ('', 'SSYTRF', 'DSYTRF', 'CHETRF', 'ZHETRF' ),
# BLAS, WITHOUT PRECISION
# MUST BE AFTER BLAS WITH PRECISION
# EX: CUBLASZHEMM -> CUBLASSHEMM -> CUBLASSSYMM
- ('DOT', 'DOT', 'DOTC', 'DOTC' ),
- ('DOT_SUB', 'DOT_SUB', 'DOTC_SUB', 'DOTC_SUB' ),
- ('DOT_SUB', 'DOT_SUB', 'DOTU_SUB', 'DOTU_SUB' ),
- ('GER', 'GER', 'GERC', 'GERC' ),
- ('GER', 'GER', 'GERU', 'GERU' ),
- ('NRM2', 'NRM2', 'CNRM2', 'ZNRM2' ), # DZNRM2 -> DNRM2
- ('SYMM', 'SYMM', 'HEMM', 'HEMM' ),
- ('SYMV', 'SYMV', 'HEMV', 'HEMV' ),
- ('SYR2', 'SYR2', 'HER2', 'HER2' ),
- ('SYR2K', 'SYR2K', 'HER2K', 'HER2K' ),
- ('SYRK', 'SYRK', 'HERK', 'HERK' ),
+ ('', 'DOT', 'DOT', 'DOTC', 'DOTC' ),
+ ('', 'DOT', 'DOT', 'DOTU', 'DOTU' ),
+ ('', 'GER', 'GER', 'GERC', 'GERC' ),
+ ('', 'GER', 'GER', 'GERU', 'GERU' ),
+ ('', 'NRM2', 'NRM2', 'CNRM2', 'ZNRM2' ), # DZNRM2 -> DNRM2
+ ('', 'SYMM', 'SYMM', 'HEMM', 'HEMM' ),
+ ('', 'SYMV', 'SYMV', 'HEMV', 'HEMV' ),
+ ('', 'SYR2', 'SYR2', 'HER2', 'HER2' ),
+ ('', 'SYR2K', 'SYR2K', 'HER2K', 'HER2K' ),
+ ('', 'SYRK', 'SYRK', 'HERK', 'HERK' ),
# LAPACK, WITHOUT PRECISION
- ('LAG2D', 'LAG2S', 'LAG2Z', 'LAG2C' ),
- ('LAGSY', 'LAGSY', 'LAGHE', 'LAGHE' ),
- ('LASYF', 'LASYF', 'LAHEF', 'LAHEF' ),
- ('LANSY', 'LANSY', 'LANHE', 'LANHE' ),
- ('LAVSY', 'LAVSY', 'LAVHE', 'LAVHE' ),
- ('ORG2R', 'ORG2R', 'UNG2R', 'UNG2R' ),
- ('ORGBR', 'ORGBR', 'UNGBR', 'UNGBR' ),
- ('ORGHR', 'ORGHR', 'UNGHR', 'UNGHR' ),
- ('ORGLQ', 'ORGLQ', 'UNGLQ', 'UNGLQ' ),
- ('ORGQL', 'ORGQL', 'UNGQL', 'UNGQL' ),
- ('ORGQR', 'ORGQR', 'UNGQR', 'UNGQR' ),
- ('ORGTR', 'ORGTR', 'UNGTR', 'UNGTR' ),
- ('ORM2R', 'ORM2R', 'UNM2R', 'UNM2R' ),
- ('ORMBR', 'ORMBR', 'UNMBR', 'UNMBR' ),
- ('ORMLQ', 'ORMLQ', 'UNMLQ', 'UNMLQ' ),
- ('ORMQL', 'ORMQL', 'UNMQL', 'UNMQL' ),
- ('ORMQR', 'ORMQR', 'UNMQR', 'UNMQR' ),
- ('ORMR2', 'ORMR2', 'UNMR2', 'UNMR2' ),
- ('ORMTR', 'ORMTR', 'UNMTR', 'UNMTR' ),
- ('ORT01', 'ORT01', 'UNT01', 'UNT01' ),
- ('PLGSY', 'PLGSY', 'PLGHE', 'PLGHE' ),
- ('SBTRD', 'SBTRD', 'HBTRD', 'HBTRD' ),
- ('SYBBD', 'SYBBD', 'HEBBD', 'HEBBD' ),
- ('SYEV', 'SYEV', 'HEEV', 'HEEV' ),
- ('SYEVD', 'SYEVD', 'HEEVD', 'HEEVD' ),
- ('SYGS2', 'SYGS2', 'HEGS2', 'HEGS2' ),
- ('SYGST', 'SYGST', 'HEGST', 'HEGST' ),
- ('SYGVD', 'SYGVD', 'HEGVD', 'HEGVD' ),
- ('SYGVR', 'SYGVR', 'HEGVR', 'HEGVR' ),
- ('SYGVX', 'SYGVX', 'HEGVX', 'HEGVX' ),
- ('SYT21', 'SYT21', 'HET21', 'HET21' ),
- ('SYTD2', 'SYTD2', 'HETD2', 'HETD2' ),
- ('SYTRD', 'SYTRD', 'HETRD', 'HETRD' ),
- ('SYTRF', 'SYTRF', 'HETRF', 'HETRF' ),
-
- # QUARK codelets protection (to prevent conversion with LAPACK WITH PRECISION)
- ('DAG_CORE_UNG2R', 'DAG_CORE_UNG2R', 'DAG_CORE_UNG2R', 'DAG_CORE_U-NG2R' ),
- ('DAG_CORE_UNGBR', 'DAG_CORE_UNGBR', 'DAG_CORE_UNGBR', 'DAG_CORE_U-NGBR' ),
- ('DAG_CORE_UNGHR', 'DAG_CORE_UNGHR', 'DAG_CORE_UNGHR', 'DAG_CORE_U-NGHR' ),
- ('DAG_CORE_UNGLQ', 'DAG_CORE_UNGLQ', 'DAG_CORE_UNGLQ', 'DAG_CORE_U-NGLQ' ),
- ('DAG_CORE_UNGQL', 'DAG_CORE_UNGQL', 'DAG_CORE_UNGQL', 'DAG_CORE_U-NGQL' ),
- ('DAG_CORE_UNGQR', 'DAG_CORE_UNGQR', 'DAG_CORE_UNGQR', 'DAG_CORE_U-NGQR' ),
- ('DAG_CORE_UNGTR', 'DAG_CORE_UNGTR', 'DAG_CORE_UNGTR', 'DAG_CORE_U-NGTR' ),
- ('DAG_CORE_UNM2R', 'DAG_CORE_UNM2R', 'DAG_CORE_UNM2R', 'DAG_CORE_U-NM2R' ),
- ('DAG_CORE_UNMBR', 'DAG_CORE_UNMBR', 'DAG_CORE_UNMBR', 'DAG_CORE_U-NMBR' ),
- ('DAG_CORE_UNMLQ', 'DAG_CORE_UNMLQ', 'DAG_CORE_UNMLQ', 'DAG_CORE_U-NMLQ' ),
- ('DAG_CORE_UNMQL', 'DAG_CORE_UNMQL', 'DAG_CORE_UNMQL', 'DAG_CORE_U-NMQL' ),
- ('DAG_CORE_UNMQR', 'DAG_CORE_UNMQR', 'DAG_CORE_UNMQR', 'DAG_CORE_U-NMQR' ),
+ ('', 'LAG2D', 'LAG2S', 'LAG2Z', 'LAG2C' ),
+ ('', 'LAGSY', 'LAGSY', 'LAGHE', 'LAGHE' ),
+ ('', 'LASYF', 'LASYF', 'LAHEF', 'LAHEF' ),
+ ('', 'LANSY', 'LANSY', 'LANHE', 'LANHE' ),
+ ('', 'LAVSY', 'LAVSY', 'LAVHE', 'LAVHE' ),
+ ('', 'ORG2R', 'ORG2R', 'UNG2R', 'UNG2R' ),
+ ('', 'ORGBR', 'ORGBR', 'UNGBR', 'UNGBR' ),
+ ('', 'ORGHR', 'ORGHR', 'UNGHR', 'UNGHR' ),
+ ('', 'ORGLQ', 'ORGLQ', 'UNGLQ', 'UNGLQ' ),
+ ('', 'ORGQL', 'ORGQL', 'UNGQL', 'UNGQL' ),
+ ('', 'ORGQR', 'ORGQR', 'UNGQR', 'UNGQR' ),
+ ('', 'ORGTR', 'ORGTR', 'UNGTR', 'UNGTR' ),
+ ('', 'ORM2R', 'ORM2R', 'UNM2R', 'UNM2R' ),
+ ('', 'ORMBR', 'ORMBR', 'UNMBR', 'UNMBR' ),
+ ('', 'ORMLQ', 'ORMLQ', 'UNMLQ', 'UNMLQ' ),
+ ('', 'ORMQL', 'ORMQL', 'UNMQL', 'UNMQL' ),
+ ('', 'ORMQR', 'ORMQR', 'UNMQR', 'UNMQR' ),
+ ('', 'ORMR2', 'ORMR2', 'UNMR2', 'UNMR2' ),
+ ('', 'ORMTR', 'ORMTR', 'UNMTR', 'UNMTR' ),
+ ('', 'ORT01', 'ORT01', 'UNT01', 'UNT01' ),
+ ('', 'PLGSY', 'PLGSY', 'PLGHE', 'PLGHE' ),
+ ('', 'SBTRD', 'SBTRD', 'HBTRD', 'HBTRD' ),
+ ('', 'SYBBD', 'SYBBD', 'HEBBD', 'HEBBD' ),
+ ('', 'SYEV', 'SYEV', 'HEEV', 'HEEV' ),
+ ('', 'SYEVD', 'SYEVD', 'HEEVD', 'HEEVD' ),
+ ('', 'SYGS2', 'SYGS2', 'HEGS2', 'HEGS2' ),
+ ('', 'SYGST', 'SYGST', 'HEGST', 'HEGST' ),
+ ('', 'SYGVD', 'SYGVD', 'HEGVD', 'HEGVD' ),
+ ('', 'SYGVR', 'SYGVR', 'HEGVR', 'HEGVR' ),
+ ('', 'SYGVX', 'SYGVX', 'HEGVX', 'HEGVX' ),
+ ('', 'SYT21', 'SYT21', 'HET21', 'HET21' ),
+ ('', 'SYTD2', 'SYTD2', 'HETD2', 'HETD2' ),
+ ('', 'SYTRD', 'SYTRD', 'HETRD', 'HETRD' ),
+ ('', 'SYTRF', 'SYTRF', 'HETRF', 'HETRF' ),
# PaStiX
- ('sutils.h', 'dutils.h', 'cutils.h', 'zutils.h' ),
- ('SMURGE_', 'DMURGE_', 'CMURGE_', 'ZMURGE_' ),
- ('smurge_', 'dmurge_', 'cmurge_', 'zmurge_' ),
- ('smurge.h', 'dmurge.h', 'cmurge.h', 'zmurge.h' ),
- ('smurge.inc', 'dmurge.inc', 'cmurge.inc', 'zmurge.inc' ),
- ('smurge.c', 'dmurge.c', 'cmurge.c', 'zmurge.c' ),
- ('ssimple', 'dsimple', 'csimple', 'zsimple' ),
- ('sstep-by-step', 'dstep-by-step', 'cstep-by-step', 'zstep-by-step' ),
- ('starpu_s', 'starpu_d', 'starpu_c', 'starpu_z' ),
- ('STARPU_S', 'STARPU_D', 'STARPU_C', 'STARPU_Z' ),
- ('pastix_s', 'pastix_d', 'pastix_c', 'pastix_z' ),
- ('s_', 'd_', 'c_', 'z_' ),
- ('S_', 'D_', 'C_', 'Z_' ),
- ('FLT_EPSILON', 'DBL_EPSILON', 'FLT_EPSILON', 'DBL_EPSILON' ),
- ('s_RAFF_FLOAT', 'd_RAFF_FLOAT', 'c_RAFF_FLOAT', 'z_RAFF_FLOAT' ),
- ('MPI_FLOAT', 'MPI_DOUBLE', 'MPI_COMPLEX', 'MPI_DOUBLE_COMPLEX'),
- ('MPI_FLOAT', 'MPI_DOUBLE', 'MPI_FLOAT', 'MPI_DOUBLE' ),
+ ('', 'sutils.h', 'dutils.h', 'cutils.h', 'zutils.h' ),
+ ('', 'SMURGE_', 'DMURGE_', 'CMURGE_', 'ZMURGE_' ),
+ ('', 'smurge_', 'dmurge_', 'cmurge_', 'zmurge_' ),
+ ('', 'smurge.h', 'dmurge.h', 'cmurge.h', 'zmurge.h' ),
+ ('', 'smurge.inc', 'dmurge.inc', 'cmurge.inc', 'zmurge.inc' ),
+ ('', 'smurge.c', 'dmurge.c', 'cmurge.c', 'zmurge.c' ),
+ ('', 'ssimple', 'dsimple', 'csimple', 'zsimple' ),
+ ('', 'sstep-by-step', 'dstep-by-step', 'cstep-by-step', 'zstep-by-step' ),
+ ('', 'starpu_s', 'starpu_d', 'starpu_c', 'starpu_z' ),
+ ('', 'STARPU_S', 'STARPU_D', 'STARPU_C', 'STARPU_Z' ),
+ ('', 'pastix_s', 'pastix_d', 'pastix_c', 'pastix_z' ),
+ ('', 'PASTIX_S', 'PASTIX_D', 'PASTIX_C', 'PASTIX_Z' ),
+ ('', 's_', 'd_', 'c_', 'z_' ),
+ ('', 'S_', 'D_', 'C_', 'Z_' ),
+ ('', 'FLT_EPSILON', 'DBL_EPSILON', 'FLT_EPSILON', 'DBL_EPSILON' ),
+ ('', 's_RAFF_FLOAT', 'd_RAFF_FLOAT', 'c_RAFF_FLOAT', 'z_RAFF_FLOAT' ),
+ ('', 'MPI_FLOAT', 'MPI_DOUBLE', 'MPI_COMPLEX', 'MPI_DOUBLE_COMPLEX'),
+ ('', 'MPI_FLOAT', 'MPI_DOUBLE', 'MPI_FLOAT', 'MPI_DOUBLE' ),
# ----- unused?
- ('s_check', 'd_check', 'c_check', 'z_check' ),
- ('s_get_idparm', 'd_get_idparm', 's_get_idparm', 'd_get_idparm', ),
+ ('', 's_check', 'd_check', 'c_check', 'z_check' ),
+ ('', 's_get_idparm', 'd_get_idparm', 's_get_idparm', 'd_get_idparm', ),
#('stesting', 'dtesting', 'ctesting', 'ztesting' ),
#('SAUXILIARY', 'DAUXILIARY', 'CAUXILIARY', 'ZAUXILIARY' ),
- # BUILD
- ('sbuild', 'dbuild', 'cbuild', 'zbuild' ),
-
],
# ------------------------------------------------------------