Add Index-64 API as extended API with _64 suffix for LAPACKE

CMakeLists.txt

@@ -107,8 +107,10 @@ else()
  set(LAPACKELIB "lapacke")
  set(TMGLIB "tmglib")
 endif()
-# By default build standard API and extended _64 API
+# By default build extended _64 API for supported compilers only
+set(INDEX64_EXT_API_COMPILERS "Intel|GNU")
 option(BUILD_INDEX64_EXT_API "Build Index-64 API as extended API with _64 suffix" ON)
+message(STATUS "Build Index-64 API as extended API with _64 suffix: ${BUILD_INDEX64_EXT_API}")
 
 include(GNUInstallDirs)
 

INSTALL/droundup_lwork.f

@@ -76,7 +76,8 @@ DOUBLE PRECISION FUNCTION DROUNDUP_LWORK( LWORK )
 *
  IF( INT( DROUNDUP_LWORK ) .LT. LWORK ) THEN
 * Force round up of LWORK
- DROUNDUP_LWORK = DROUNDUP_LWORK * ( 1.0D+0 + EPSILON(0.0D+0) )
+ DROUNDUP_LWORK = DROUNDUP_LWORK *
+ $ ( 1.0D+0 + EPSILON(0.0D+0) )
  ENDIF
 *
  RETURN

INSTALL/sroundup_lwork.f

@@ -76,7 +76,8 @@ REAL FUNCTION SROUNDUP_LWORK( LWORK )
 *
  IF( INT( SROUNDUP_LWORK ) .LT. LWORK ) THEN
 * Force round up of LWORK
- SROUNDUP_LWORK = SROUNDUP_LWORK * ( 1.0E+0 + EPSILON(0.0E+0) )
+ SROUNDUP_LWORK = SROUNDUP_LWORK *
+ $ ( 1.0E+0 + EPSILON(0.0E+0) )
  ENDIF
 *
  RETURN

LAPACKE/CMakeLists.txt

@@ -67,12 +67,35 @@ if(LAPACKE_WITH_TMG)
 endif()
 list(APPEND SOURCES ${UTILS})
 
-add_library(${LAPACKELIB} ${SOURCES})
+add_library(${LAPACKELIB}_obj OBJECT ${SOURCES})
+set_target_properties(${LAPACKELIB}_obj PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+if(BUILD_INDEX64_EXT_API)
+ # 64bit Integer Extended Interface
+ set(SOURCES_64_C)
+ list(APPEND SOURCES_64_C ${SOURCES})
+ list(REMOVE_ITEM SOURCES_64_C src/lapacke_nancheck.c)
+ list(REMOVE_ITEM SOURCES_64_C utils/lapacke_make_complex_float.c)
+ list(REMOVE_ITEM SOURCES_64_C utils/lapacke_make_complex_double.c)
+ add_library(${LAPACKELIB}_64_obj OBJECT ${SOURCES_64_C})
+ set_target_properties(${LAPACKELIB}_64_obj PROPERTIES
+ POSITION_INDEPENDENT_CODE ON)
+ target_compile_options(${LAPACKELIB}_64_obj PRIVATE
+ -DLAPACK_ILP64
+ -DLAPACKE_API64
+ -DWeirdNEC
+ -DCBLAS_API64)
+endif()
+
+add_library(${LAPACKELIB} $<TARGET_OBJECTS:${LAPACKELIB}_obj>
+ $<$<BOOL:${BUILD_INDEX64_EXT_API}>: $<TARGET_OBJECTS:${LAPACKELIB}_64_obj>>)
+
 set_target_properties(
  ${LAPACKELIB} PROPERTIES
  LINKER_LANGUAGE C
  VERSION ${LAPACK_VERSION}
  SOVERSION ${LAPACK_MAJOR_VERSION}
+ POSITION_INDEPENDENT_CODE ON
  )
 target_include_directories(${LAPACKELIB} PUBLIC
  $<BUILD_INTERFACE:${LAPACK_BINARY_DIR}/include>

LAPACKE/example/CMakeLists.txt

@@ -3,12 +3,29 @@ add_executable(xexample_DGESV_colmajor example_DGESV_colmajor.c lapacke_example_
 add_executable(xexample_DGELS_rowmajor example_DGELS_rowmajor.c lapacke_example_aux.c lapacke_example_aux.h)
 add_executable(xexample_DGELS_colmajor example_DGELS_colmajor.c lapacke_example_aux.c lapacke_example_aux.h)
 
-target_link_libraries(xexample_DGESV_rowmajor ${LAPACKELIB})
-target_link_libraries(xexample_DGESV_colmajor ${LAPACKELIB})
-target_link_libraries(xexample_DGELS_rowmajor ${LAPACKELIB})
-target_link_libraries(xexample_DGELS_colmajor ${LAPACKELIB})
+target_link_libraries(xexample_DGESV_rowmajor ${LAPACKELIB} ${BLAS_LIBRARIES})
+target_link_libraries(xexample_DGESV_colmajor ${LAPACKELIB} ${BLAS_LIBRARIES})
+target_link_libraries(xexample_DGELS_rowmajor ${LAPACKELIB} ${BLAS_LIBRARIES})
+target_link_libraries(xexample_DGELS_colmajor ${LAPACKELIB} ${BLAS_LIBRARIES})
 
 add_test(example_DGESV_rowmajor ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/xexample_DGESV_rowmajor)
 add_test(example_DGESV_colmajor ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/xexample_DGESV_colmajor)
 add_test(example_DGELS_rowmajor ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/xexample_DGELS_rowmajor)
 add_test(example_DGELS_colmajor ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/xexample_DGELS_colmajor)
+
+if(BUILD_INDEX64_EXT_API)
+ add_executable(xexample_DGESV_rowmajor_64 example_DGESV_rowmajor_64.c lapacke_example_aux.c lapacke_example_aux.h)
+ add_executable(xexample_DGESV_colmajor_64 example_DGESV_colmajor_64.c lapacke_example_aux.c lapacke_example_aux.h)
+ add_executable(xexample_DGELS_rowmajor_64 example_DGELS_rowmajor_64.c lapacke_example_aux.c lapacke_example_aux.h)
+ add_executable(xexample_DGELS_colmajor_64 example_DGELS_colmajor_64.c lapacke_example_aux.c lapacke_example_aux.h)
+
+ target_link_libraries(xexample_DGESV_rowmajor_64 ${LAPACKELIB} ${BLAS_LIBRARIES})
+ target_link_libraries(xexample_DGESV_colmajor_64 ${LAPACKELIB} ${BLAS_LIBRARIES})
+ target_link_libraries(xexample_DGELS_rowmajor_64 ${LAPACKELIB} ${BLAS_LIBRARIES})
+ target_link_libraries(xexample_DGELS_colmajor_64 ${LAPACKELIB} ${BLAS_LIBRARIES})
+
+ add_test(example_DGESV_rowmajor_64 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/xexample_DGESV_rowmajor_64)
+ add_test(example_DGESV_colmajor_64 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/xexample_DGESV_colmajor_64)
+ add_test(example_DGELS_rowmajor_64 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/xexample_DGELS_rowmajor_64)
+ add_test(example_DGELS_colmajor_64 ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/xexample_DGELS_colmajor_64)
+endif()

LAPACKE/example/example_DGELS_colmajor_64.c

@@ -0,0 +1,93 @@
+/*
+ LAPACKE Example : Calling DGELS using col-major layout
+ =====================================================
+
+ The program computes the solution to the system of linear
+ equations with a square matrix A and multiple
+ right-hand sides B, where A is the coefficient matrix
+ and b is the right-hand side matrix:
+
+ Description
+ ===========
+
+ In this example, we wish solve the least squares problem min_x || B - Ax ||
+ for two right-hand sides using the LAPACK routine DGELS. For input we will
+ use the 5-by-3 matrix
+
+ ( 1 1 1 )
+ ( 2 3 4 )
+ A = ( 3 5 2 )
+ ( 4 2 5 )
+ ( 5 4 3 )
+ and the 5-by-2 matrix
+
+ ( -10 -3 )
+ ( 12 14 )
+ B = ( 14 12 )
+ ( 16 16 )
+ ( 18 16 )
+ We will first store the input matrix as a static C two-dimensional array,
+ which is stored in col-major layout, and let LAPACKE handle the work space
+ array allocation. The LAPACK base name for this function is gels, and we
+ will use double precision (d), so the LAPACKE function name is LAPACKE_dgels.
+
+ lda=5 and ldb=5. The output for each right hand side is stored in b as
+ consecutive vectors of length 3. The correct answer for this problem is
+ the 3-by-2 matrix
+
+ ( 2 1 )
+ ( 1 1 )
+ ( 1 2 )
+
+ A complete C program for this example is given below. Note that when the arrays
+ are passed to the LAPACK routine, they must be dereferenced, since LAPACK is
+ expecting arrays of type double *, not double **.
+
+
+ LAPACKE Interface
+ =================
+
+ LAPACKE_dgels (col-major, high-level) Example Program Results
+
+ -- LAPACKE Example routine --
+ -- LAPACK is a software package provided by Univ. of Tennessee, --
+ -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
+*/
+/* Calling DGELS using col-major layout */
+
+/* Includes */
+#include <stdio.h>
+#include <lapacke_64.h>
+#include "lapacke_example_aux.h"
+
+/* Main program */
+int main (int argc, const char * argv[])
+{
+ /* Locals */
+ double A[5][3] = {{1,2,3},{4,5,1},{3,5,2},{4,1,4},{2,5,3}};
+ double b[5][2] = {{-10,12},{14,16},{18,-3},{14,12},{16,16}};
+ int64_t info,m,n,lda,ldb,nrhs;
+
+ /* Initialization */
+ m = 5;
+ n = 3;
+ nrhs = 2;
+ lda = 5;
+ ldb = 5;
+
+ /* Print Entry Matrix */
+ print_matrix_colmajor_64( "Entry Matrix A", m, n, *A, lda );
+ /* Print Right Rand Side */
+ print_matrix_colmajor_64( "Right Hand Side b", n, nrhs, *b, ldb );
+ printf( "\n" );
+
+ /* Executable statements */
+ printf( "LAPACKE_dgels_64 (col-major, high-level) Example Program Results\n" );
+ /* Solve least squares problem*/
+ info = LAPACKE_dgels_64(LAPACK_COL_MAJOR,'N',m,n,nrhs,*A,lda,*b,ldb);
+
+ /* Print Solution */
+ print_matrix_colmajor_64( "Solution", n, nrhs, *b, ldb );
+ printf( "\n" );
+ exit( info );
+} /* End of LAPACKE_dgels Example */

LAPACKE/example/example_DGELS_rowmajor_64.c

@@ -0,0 +1,93 @@
+/*
+ LAPACKE Example : Calling DGELS using row-major layout
+ =====================================================
+
+ The program computes the solution to the system of linear
+ equations with a square matrix A and multiple
+ right-hand sides B, where A is the coefficient matrix
+ and b is the right-hand side matrix:
+
+ Description
+ ===========
+
+ In this example, we wish solve the least squares problem min_x || B - Ax ||
+ for two right-hand sides using the LAPACK routine DGELS. For input we will
+ use the 5-by-3 matrix
+
+ ( 1 1 1 )
+ ( 2 3 4 )
+ A = ( 3 5 2 )
+ ( 4 2 5 )
+ ( 5 4 3 )
+ and the 5-by-2 matrix
+
+ ( -10 -3 )
+ ( 12 14 )
+ B = ( 14 12 )
+ ( 16 16 )
+ ( 18 16 )
+ We will first store the input matrix as a static C two-dimensional array,
+ which is stored in row-major layout, and let LAPACKE handle the work space
+ array allocation. The LAPACK base name for this function is gels, and we
+ will use double precision (d), so the LAPACKE function name is LAPACKE_dgels.
+
+ thus lda=3 and ldb=2. The output for each right hand side is stored in b as
+ consecutive vectors of length 3. The correct answer for this problem is
+ the 3-by-2 matrix
+
+ ( 2 1 )
+ ( 1 1 )
+ ( 1 2 )
+
+ A complete C program for this example is given below. Note that when the arrays
+ are passed to the LAPACK routine, they must be dereferenced, since LAPACK is
+ expecting arrays of type double *, not double **.
+
+
+ LAPACKE Interface
+ =================
+
+ LAPACKE_dgels (row-major, high-level) Example Program Results
+
+ -- LAPACKE Example routine --
+ -- LAPACK is a software package provided by Univ. of Tennessee, --
+ -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
+*/
+/* Calling DGELS using row-major layout */
+
+/* Includes */
+#include <stdio.h>
+#include <lapacke_64.h>
+#include "lapacke_example_aux.h"
+
+/* Main program */
+int main (int argc, const char * argv[])
+{
+ /* Locals */
+ double A[5][3] = {{1,1,1},{2,3,4},{3,5,2},{4,2,5},{5,4,3}};
+ double b[5][2] = {{-10,-3},{12,14},{14,12},{16,16},{18,16}};
+ int64_t info,m,n,lda,ldb,nrhs;
+
+ /* Initialization */
+ m = 5;
+ n = 3;
+ nrhs = 2;
+ lda = 3;
+ ldb = 2;
+
+ /* Print Entry Matrix */
+ print_matrix_rowmajor_64( "Entry Matrix A", m, n, *A, lda );
+ /* Print Right Rand Side */
+ print_matrix_rowmajor_64( "Right Hand Side b", n, nrhs, *b, ldb );
+ printf( "\n" );
+
+ /* Executable statements */
+ printf( "LAPACKE_dgels_64 (row-major, high-level) Example Program Results\n" );
+ /* Solve least squares problem*/
+ info = LAPACKE_dgels_64(LAPACK_ROW_MAJOR,'N',m,n,nrhs,*A,lda,*b,ldb);
+
+ /* Print Solution */
+ print_matrix_rowmajor_64( "Solution", n, nrhs, *b, ldb );
+ printf( "\n" );
+ exit( 0 );
+} /* End of LAPACKE_dgels Example */

LAPACKE/example/example_DGESV_colmajor.c

@@ -41,41 +41,41 @@ int main(int argc, char **argv) {
 
  /* Locals */
  lapack_int n, nrhs, lda, ldb, info;
-int i, j;
+ int i, j;
  /* Local arrays */
-double *A, *b;
-lapack_int *ipiv;
+ double *A, *b;
+ lapack_int *ipiv;
 
  /* Default Value */
- n = 5; nrhs = 1;
+  n = 5; nrhs = 1;
 
  /* Arguments */
- for( i = 1; i < argc; i++ ) {
- if( strcmp( argv[i], "-n" ) == 0 ) {
- n = atoi(argv[i+1]);
- i++;
- }
-if( strcmp( argv[i], "-nrhs" ) == 0 ) {
-nrhs = atoi(argv[i+1]);
-i++;
-}
-}
+  for( i = 1; i < argc; i++ ) {
+  if( strcmp( argv[i], "-n" ) == 0 ) {
+  n = atoi(argv[i+1]);
+  i++;
+  }
+ if( strcmp( argv[i], "-nrhs" ) == 0 ) {
+ nrhs = atoi(argv[i+1]);
+ i++;
+ }
+ }
 
  /* Initialization */
  lda=n, ldb=n;
-A = (double *)malloc(n*n*sizeof(double)) ;
-if (A==NULL){ printf("error of memory allocation\n"); exit(0); }
-b = (double *)malloc(n*nrhs*sizeof(double)) ;
-if (b==NULL){ printf("error of memory allocation\n"); exit(0); }
-ipiv = (lapack_int *)malloc(n*sizeof(lapack_int)) ;
-if (ipiv==NULL){ printf("error of memory allocation\n"); exit(0); }
+ A = (double *)malloc(n*n*sizeof(double)) ;
+ if (A==NULL){ printf("error of memory allocation\n"); exit(0); }
+ b = (double *)malloc(n*nrhs*sizeof(double)) ;
+ if (b==NULL){ printf("error of memory allocation\n"); free(A); exit(0); }
+ ipiv = (lapack_int *)malloc(n*sizeof(lapack_int)) ;
+ if (ipiv==NULL){ printf("error of memory allocation\n"); free(A); free(b); exit(0); }
 
  for( i = 0; i < n; i++ ) {
  for( j = 0; j < n; j++ ) A[i+j*lda] = ((double) rand()) / ((double) RAND_MAX) - 0.5;
-}
+ }
 
-for(i=0;i<n*nrhs;i++)
-b[i] = ((double) rand()) / ((double) RAND_MAX) - 0.5;
+ for(i=0;i<n*nrhs;i++)
+ b[i] = ((double) rand()) / ((double) RAND_MAX) - 0.5;
 
  /* Print Entry Matrix */
  print_matrix_colmajor( "Entry Matrix A", n, n, A, lda );
@@ -91,12 +91,20 @@ int main(int argc, char **argv) {
 
  /* Check for the exact singularity */
  if( info > 0 ) {
- printf( "The diagonal element of the triangular factor of A,\n" );
- printf( "U(%" LAPACK_IFMT ",%" LAPACK_IFMT ") is zero, so that A is singular;\n", info, info );
- printf( "the solution could not be computed.\n" );
- exit( 1 );
+ printf( "The diagonal element of the triangular factor of A,\n" );
+ printf( "U(%" LAPACK_IFMT ",%" LAPACK_IFMT ") is zero, so that A is singular;\n", info, info );
+ printf( "the solution could not be computed.\n" );
+ free(A);
+ free(b);
+ free(ipiv);
+ exit( 1 );
+ }
+ if (info <0) {
+ free(A);
+ free(b);
+ free(ipiv);
+ exit( 1 );
  }
- if (info <0) exit( 1 );
  /* Print solution */
  print_matrix_colmajor( "Solution", n, nrhs, b, ldb );
  /* Print details of LU factorization */