From 64f4671e4b81364bcbca736b54a15abcf49e95a2 Mon Sep 17 00:00:00 2001 From: amcamd Date: Thu, 26 May 2022 07:47:16 -0500 Subject: [PATCH 01/12] correct CHANGELOG.md for ROCm 5.2 --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7956e0b10..d66be8e30 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,6 @@ # Change Log for hipBLAS -## (Unreleased) hipBLAS 0.51.0 +## hipBLAS 0.51.0 for ROCm 5.2.0 ### Added - Packages for test and benchmark executables on all supported OSes using CPack. - Added File/Folder Reorg Changes with backward compatibility support enabled using ROCM-CMAKE wrapper functions From ffa450555789b08899e1e0c91476f145fe34c544 Mon Sep 17 00:00:00 2001 From: daineAMD Date: Tue, 28 Jun 2022 09:19:00 -0600 Subject: [PATCH 02/12] Version for staging branch release. --- CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 227a9d89f..b0d44bfdb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -79,7 +79,7 @@ include( ROCMInstallSymlinks ) include( ROCMClients ) include( ROCMHeaderWrapper ) -set ( VERSION_STRING "0.52.0" ) +set ( VERSION_STRING "0.53.0" ) rocm_setup_version( VERSION ${VERSION_STRING} ) if( NOT DEFINED ENV{HIP_PATH}) @@ -193,7 +193,7 @@ endif( ) # Package specific CPACK vars if( NOT USE_CUDA ) - rocm_package_add_dependencies(DEPENDS "rocblas >= 2.45.0" "rocsolver >= 3.19.0") + rocm_package_add_dependencies(DEPENDS "rocblas >= 2.46.0" "rocsolver >= 3.20.0") endif( ) set( CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.md" ) From c398b2d7c026870b10a44763564efd4f4000932d Mon Sep 17 00:00:00 2001 From: Daine McNiven <51674140+daineAMD@users.noreply.github.com> Date: Tue, 12 Jul 2022 08:22:28 -0700 Subject: [PATCH 03/12] Adding hipblasXgels (#506) --- clients/benchmarks/client.cpp | 3 + clients/common/cblas_interface.cpp | 114 ++++++++++ .../hipblas_template_specialization.cpp | 130 +++++++++++ clients/gtest/CMakeLists.txt | 1 + clients/gtest/gels_gtest.cpp | 184 ++++++++++++++++ clients/include/cblas_interface.h | 4 + clients/include/flops.hpp | 21 ++ clients/include/hipblas.hpp | 14 ++ clients/include/hipblas_fortran.hpp | 49 +++++ clients/include/hipblas_fortran_solver.f90 | 85 ++++++++ clients/include/hipblas_no_fortran.hpp | 4 + clients/include/testing_gels.hpp | 157 ++++++++++++++ docs/source/functions.rst | 26 +++ library/include/hipblas.h | 118 ++++++++++ library/src/hcc_detail/hipblas.cpp | 205 ++++++++++++++++++ library/src/hipblas_module.f90 | 85 ++++++++ library/src/nvcc_detail/hipblas.cpp | 61 ++++++ 17 files changed, 1261 insertions(+) create mode 100644 clients/gtest/gels_gtest.cpp create mode 100644 clients/include/testing_gels.hpp diff --git a/clients/benchmarks/client.cpp b/clients/benchmarks/client.cpp index 4d2441f3e..272e3586e 100644 --- a/clients/benchmarks/client.cpp +++ b/clients/benchmarks/client.cpp @@ -219,6 +219,7 @@ #include "testing_trtri_strided_batched.hpp" // solver functions #ifdef __HIP_PLATFORM_SOLVER__ +#include "testing_gels.hpp" #include "testing_geqrf.hpp" #include "testing_geqrf_batched.hpp" #include "testing_geqrf_strided_batched.hpp" @@ -512,6 +513,7 @@ struct perf_blas{} || std::is_same {"getrs", testing_getrs}, {"getrs_batched", testing_getrs_batched}, {"getrs_strided_batched", testing_getrs_strided_batched}, + {"gels", testing_gels}, #endif // Aux @@ -732,6 +734,7 @@ struct perf_blas< {"getrs", testing_getrs}, {"getrs_batched", testing_getrs_batched}, {"getrs_strided_batched", testing_getrs_strided_batched}, + {"gels", testing_gels}, #endif }; run_function(map, arg); diff --git a/clients/common/cblas_interface.cpp b/clients/common/cblas_interface.cpp index 62cf594fd..c07824810 100644 --- a/clients/common/cblas_interface.cpp +++ b/clients/common/cblas_interface.cpp @@ -103,6 +103,51 @@ void zgeqrf_(int* m, int* lwork, int* info); +void sgels_(char* trans, + int* m, + int* n, + int* nrhs, + float* A, + int* lda, + float* B, + int* ldb, + float* work, + int* lwork, + int* info); +void dgels_(char* trans, + int* m, + int* n, + int* nrhs, + double* A, + int* lda, + double* B, + int* ldb, + double* work, + int* lwork, + int* info); +void cgels_(char* trans, + int* m, + int* n, + int* nrhs, + hipblasComplex* A, + int* lda, + hipblasComplex* B, + int* ldb, + hipblasComplex* work, + int* lwork, + int* info); +void zgels_(char* trans, + int* m, + int* n, + int* nrhs, + hipblasDoubleComplex* A, + int* lda, + hipblasDoubleComplex* B, + int* ldb, + hipblasDoubleComplex* work, + int* lwork, + int* info); + void spotrf_(char* uplo, int* m, float* A, int* lda, int* info); void dpotrf_(char* uplo, int* m, double* A, int* lda, int* info); void cpotrf_(char* uplo, int* m, hipblasComplex* A, int* lda, int* info); @@ -3699,3 +3744,72 @@ int cblas_geqrf(int m, zgeqrf_(&m, &n, A, &lda, tau, work, &lwork, &info); return info; } + +// gels +template <> +int cblas_gels(char trans, + int m, + int n, + int nrhs, + float* A, + int lda, + float* B, + int ldb, + float* work, + int lwork) +{ + int info; + sgels_(&trans, &m, &n, &nrhs, A, &lda, B, &ldb, work, &lwork, &info); + return info; +} + +template <> +int cblas_gels(char trans, + int m, + int n, + int nrhs, + double* A, + int lda, + double* B, + int ldb, + double* work, + int lwork) +{ + int info; + dgels_(&trans, &m, &n, &nrhs, A, &lda, B, &ldb, work, &lwork, &info); + return info; +} + +template <> +int cblas_gels(char trans, + int m, + int n, + int nrhs, + hipblasComplex* A, + int lda, + hipblasComplex* B, + int ldb, + hipblasComplex* work, + int lwork) +{ + int info; + cgels_(&trans, &m, &n, &nrhs, A, &lda, B, &ldb, work, &lwork, &info); + return info; +} + +template <> +int cblas_gels(char trans, + int m, + int n, + int nrhs, + hipblasDoubleComplex* A, + int lda, + hipblasDoubleComplex* B, + int ldb, + hipblasDoubleComplex* work, + int lwork) +{ + int info; + zgels_(&trans, &m, &n, &nrhs, A, &lda, B, &ldb, work, &lwork, &info); + return info; +} diff --git a/clients/common/hipblas_template_specialization.cpp b/clients/common/hipblas_template_specialization.cpp index 987842073..79e523ec0 100644 --- a/clients/common/hipblas_template_specialization.cpp +++ b/clients/common/hipblas_template_specialization.cpp @@ -10110,6 +10110,71 @@ hipblasStatus_t hipblasGeqrfStridedBatched(hipblasHandle_t handle, m, n, A, lda, strideA, ipiv, strideP, info, batchCount); } +// gels +template <> +hipblasStatus_t hipblasGels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* A, + const int lda, + float* B, + const int ldb, + int* info, + int* deviceInfo) +{ + return hipblasSgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo); +} + +template <> +hipblasStatus_t hipblasGels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* A, + const int lda, + double* B, + const int ldb, + int* info, + int* deviceInfo) +{ + return hipblasDgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo); +} + +template <> +hipblasStatus_t hipblasGels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* A, + const int lda, + hipblasComplex* B, + const int ldb, + int* info, + int* deviceInfo) +{ + return hipblasCgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo); +} + +template <> +hipblasStatus_t hipblasGels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* A, + const int lda, + hipblasDoubleComplex* B, + const int ldb, + int* info, + int* deviceInfo) +{ + return hipblasZgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo); +} + #endif ///////////// @@ -20297,4 +20362,69 @@ hipblasStatus_t hipblasGeqrfStridedBatched(hipblasHa handle, m, n, A, lda, strideA, ipiv, strideP, info, batchCount); } +// gels +template <> +hipblasStatus_t hipblasGels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* A, + const int lda, + float* B, + const int ldb, + int* info, + int* deviceInfo) +{ + return hipblasSgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo); +} + +template <> +hipblasStatus_t hipblasGels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* A, + const int lda, + double* B, + const int ldb, + int* info, + int* deviceInfo) +{ + return hipblasDgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo); +} + +template <> +hipblasStatus_t hipblasGels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* A, + const int lda, + hipblasComplex* B, + const int ldb, + int* info, + int* deviceInfo) +{ + return hipblasCgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo); +} + +template <> +hipblasStatus_t hipblasGels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* A, + const int lda, + hipblasDoubleComplex* B, + const int ldb, + int* info, + int* deviceInfo) +{ + return hipblasZgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo); +} + #endif diff --git a/clients/gtest/CMakeLists.txt b/clients/gtest/CMakeLists.txt index 32fad16d8..4b8507d93 100644 --- a/clients/gtest/CMakeLists.txt +++ b/clients/gtest/CMakeLists.txt @@ -105,6 +105,7 @@ if( BUILD_WITH_SOLVER ) geqrf_gtest.cpp geqrf_batched_gtest.cpp geqrf_strided_batched_gtest.cpp + gels_gtest.cpp ) endif( ) diff --git a/clients/gtest/gels_gtest.cpp b/clients/gtest/gels_gtest.cpp new file mode 100644 index 000000000..9bd79c997 --- /dev/null +++ b/clients/gtest/gels_gtest.cpp @@ -0,0 +1,184 @@ +/* ************************************************************************ + * Copyright (C) 2016-2022 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * ************************************************************************ */ + +#include "testing_gels.hpp" +#include "utility.h" +#include +#include +#include + +using std::vector; +using ::testing::Combine; +using ::testing::TestWithParam; +using ::testing::Values; +using ::testing::ValuesIn; + +typedef std::tuple, char, bool> gels_tuple; + +// {m, n, nrhs, lda, ldb} +const vector> matrix_size_range + = {{-1, -1, -1, 1, 1}, {10, 10, 10, 10, 10}, {10, 10, 10, 20, 100}, {600, 500, 400, 600, 600}}; + +const vector trans_range = { + 'N', + 'T', +}; + +const vector is_fortran = {false, true}; + +Arguments setup_gels_arguments(gels_tuple tup) +{ + vector matrix_size = std::get<0>(tup); + char trans = std::get<1>(tup); + bool fortran = std::get<2>(tup); + + Arguments arg; + + arg.M = matrix_size[0]; + arg.N = matrix_size[1]; + arg.K = matrix_size[2]; // nrhs + arg.lda = matrix_size[3]; + arg.ldb = matrix_size[4]; + + arg.transA_option = trans; + + arg.fortran = fortran; + + return arg; +} + +class gels_gtest : public ::TestWithParam +{ +protected: + gels_gtest() {} + virtual ~gels_gtest() {} + virtual void SetUp() {} + virtual void TearDown() {} +}; + +#ifndef __HIP_PLATFORM_NVCC__ + +TEST_P(gels_gtest, gels_gtest_float) +{ + // GetParam returns a tuple. The setup routine unpacks the tuple + // and initializes arg(Arguments), which will be passed to testing routine. + + Arguments arg = setup_gels_arguments(GetParam()); + + hipblasStatus_t status = testing_gels(arg); + + if(status != HIPBLAS_STATUS_SUCCESS) + { + if(arg.M < 0 || arg.N < 0 || arg.K < 0 || arg.lda < arg.M || arg.ldb < arg.M + || arg.ldb < arg.N) + { + EXPECT_EQ(HIPBLAS_STATUS_INVALID_VALUE, status); + } + else + { + EXPECT_EQ(HIPBLAS_STATUS_SUCCESS, status); // fail + } + } +} + +TEST_P(gels_gtest, gels_gtest_double) +{ + // GetParam returns a tuple. The setup routine unpacks the tuple + // and initializes arg(Arguments), which will be passed to testing routine. + + Arguments arg = setup_gels_arguments(GetParam()); + + hipblasStatus_t status = testing_gels(arg); + + if(status != HIPBLAS_STATUS_SUCCESS) + { + if(arg.M < 0 || arg.N < 0 || arg.K < 0 || arg.lda < arg.M || arg.ldb < arg.M + || arg.ldb < arg.N) + { + EXPECT_EQ(HIPBLAS_STATUS_INVALID_VALUE, status); + } + else + { + EXPECT_EQ(HIPBLAS_STATUS_SUCCESS, status); // fail + } + } +} + +TEST_P(gels_gtest, gels_gtest_float_complex) +{ + // GetParam returns a tuple. The setup routine unpacks the tuple + // and initializes arg(Arguments), which will be passed to testing routine. + + Arguments arg = setup_gels_arguments(GetParam()); + + hipblasStatus_t status = testing_gels(arg); + + if(status != HIPBLAS_STATUS_SUCCESS) + { + if(arg.M < 0 || arg.N < 0 || arg.K < 0 || arg.lda < arg.M || arg.ldb < arg.M + || arg.ldb < arg.N) + { + EXPECT_EQ(HIPBLAS_STATUS_INVALID_VALUE, status); + } + else + { + EXPECT_EQ(HIPBLAS_STATUS_SUCCESS, status); // fail + } + } +} + +TEST_P(gels_gtest, gels_gtest_double_complex) +{ + // GetParam returns a tuple. The setup routine unpacks the tuple + // and initializes arg(Arguments), which will be passed to testing routine. + + Arguments arg = setup_gels_arguments(GetParam()); + + hipblasStatus_t status = testing_gels(arg); + + if(status != HIPBLAS_STATUS_SUCCESS) + { + if(arg.M < 0 || arg.N < 0 || arg.K < 0 || arg.lda < arg.M || arg.ldb < arg.M + || arg.ldb < arg.N) + { + EXPECT_EQ(HIPBLAS_STATUS_INVALID_VALUE, status); + } + else + { + EXPECT_EQ(HIPBLAS_STATUS_SUCCESS, status); // fail + } + } +} + +// notice we are using vector of vector +// so each elment in xxx_range is a vector, +// ValuesIn takes each element (a vector), combines them, and feeds them to test_p +// The combinations are { {M, N, nrhs, lda, ldb}, trans, fortran } + +INSTANTIATE_TEST_SUITE_P(hipblasGels, + gels_gtest, + Combine(ValuesIn(matrix_size_range), + ValuesIn(trans_range), + ValuesIn(is_fortran))); + +#endif diff --git a/clients/include/cblas_interface.h b/clients/include/cblas_interface.h index a734ce7c8..92c839415 100644 --- a/clients/include/cblas_interface.h +++ b/clients/include/cblas_interface.h @@ -461,6 +461,10 @@ int cblas_getri(int n, T* A, int lda, int* ipiv, T* work, int lwork); template int cblas_geqrf(int m, int n, T* A, int lda, T* tau, T* work, int lwork); + +template +int cblas_gels( + char trans, int m, int n, int nrhs, T* A, int lda, T* B, int ldb, T* work, int lwork); /* ============================================================================================ */ #endif /* _CBLAS_INTERFACE_ */ diff --git a/clients/include/flops.hpp b/clients/include/flops.hpp index b8007b6fa..06fd253bf 100644 --- a/clients/include/flops.hpp +++ b/clients/include/flops.hpp @@ -880,4 +880,25 @@ constexpr double getrs_gflop_count(int n, int nrhs) return 4.0 * getrs_gflop_count(n, nrhs); } +/* \brief floating point counts of GELS */ +template +constexpr double gels_gflop_count(int m, int n) +{ + // Not using this for now as better to just use exe. time + int k = m >= n ? n : m; + return ((2 * m * n * n) - ((2.0 / 3.0) * k * k * k)) / 1e9; +} + +template <> +constexpr double gels_gflop_count(int m, int n) +{ + return 4 * gels_gflop_count(m, n); +} + +template <> +constexpr double gels_gflop_count(int m, int n) +{ + return 4 * gels_gflop_count(m, n); +} + #endif /* _HIPBLAS_FLOPS_H_ */ diff --git a/clients/include/hipblas.hpp b/clients/include/hipblas.hpp index 4046e0b41..a060187fe 100644 --- a/clients/include/hipblas.hpp +++ b/clients/include/hipblas.hpp @@ -1982,6 +1982,20 @@ hipblasStatus_t hipblasGeqrfStridedBatched(hipblasHandle_t handle, int* info, const int batchCount); +// gels +template +hipblasStatus_t hipblasGels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + T* A, + const int lda, + T* B, + const int ldb, + int* info, + int* deviceInfo); + // dgmm template hipblasStatus_t hipblasDgmm(hipblasHandle_t handle, diff --git a/clients/include/hipblas_fortran.hpp b/clients/include/hipblas_fortran.hpp index 0cbf8f42e..fff8b10fe 100644 --- a/clients/include/hipblas_fortran.hpp +++ b/clients/include/hipblas_fortran.hpp @@ -7158,6 +7158,55 @@ hipblasStatus_t hipblasZgeqrfStridedBatchedFortran(hipblasHandle_t handle, const hipblasStride stride_T, int* info, const int batch_count); + +// gels +hipblasStatus_t hipblasSgelsFortran(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* A, + const int lda, + float* B, + const int ldb, + int* info, + int* deviceInfo); + +hipblasStatus_t hipblasDgelsFortran(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* A, + const int lda, + double* B, + const int ldb, + int* info, + int* deviceInfo); + +hipblasStatus_t hipblasCgelsFortran(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* A, + const int lda, + hipblasComplex* B, + const int ldb, + int* info, + int* deviceInfo); + +hipblasStatus_t hipblasZgelsFortran(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* A, + const int lda, + hipblasDoubleComplex* B, + const int ldb, + int* info, + int* deviceInfo); } #endif diff --git a/clients/include/hipblas_fortran_solver.f90 b/clients/include/hipblas_fortran_solver.f90 index 694e580a2..1eea0e625 100644 --- a/clients/include/hipblas_fortran_solver.f90 +++ b/clients/include/hipblas_fortran_solver.f90 @@ -845,4 +845,89 @@ function hipblasZgeqrfStridedBatchedFortran(handle, m, n, A, lda, stride_A,& tau, stride_T, info, batch_count) end function hipblasZgeqrfStridedBatchedFortran + ! gels + function hipblasSgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) & + result(res) & + bind(c, name = 'hipblasSgelsFortran') + use iso_c_binding + use hipblas_enums + implicit none + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int) :: res + res = hipblasSgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) + end function hipblasSgelsFortran + + function hipblasDgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) & + result(res) & + bind(c, name = 'hipblasDgelsFortran') + use iso_c_binding + use hipblas_enums + implicit none + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int) :: res + res = hipblasDgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) + end function hipblasDgelsFortran + + function hipblasCgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) & + result(res) & + bind(c, name = 'hipblasCgelsFortran') + use iso_c_binding + use hipblas_enums + implicit none + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int) :: res + res = hipblasCgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) + end function hipblasCgelsFortran + + function hipblasZgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) & + result(res) & + bind(c, name = 'hipblasZgelsFortran') + use iso_c_binding + use hipblas_enums + implicit none + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int) :: res + res = hipblasZgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) + end function hipblasZgelsFortran + end module hipblas_interface \ No newline at end of file diff --git a/clients/include/hipblas_no_fortran.hpp b/clients/include/hipblas_no_fortran.hpp index aa9c14664..4ee922654 100644 --- a/clients/include/hipblas_no_fortran.hpp +++ b/clients/include/hipblas_no_fortran.hpp @@ -672,6 +672,10 @@ #define hipblasDgeqrfFortran hipblasDgeqrf #define hipblasCgeqrfFortran hipblasCgeqrf #define hipblasZgeqrfFortran hipblasZgeqrf +#define hipblasSgelsFortran hipblasSgels +#define hipblasDgelsFortran hipblasDgels +#define hipblasCgelsFortran hipblasCgels +#define hipblasZgelsFortran hipblasZgels #define hipblasSgeqrfBatchedFortran hipblasSgeqrfBatched #define hipblasDgeqrfBatchedFortran hipblasDgeqrfBatched #define hipblasCgeqrfBatchedFortran hipblasCgeqrfBatched diff --git a/clients/include/testing_gels.hpp b/clients/include/testing_gels.hpp new file mode 100644 index 000000000..f5da9bc82 --- /dev/null +++ b/clients/include/testing_gels.hpp @@ -0,0 +1,157 @@ +/* ************************************************************************ + * Copyright (C) 2016-2022 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * ************************************************************************ */ + +#include +#include +#include +#include + +#include "testing_common.hpp" + +template +hipblasStatus_t testing_gels(const Arguments& argus) +{ + using U = real_t; + bool FORTRAN = argus.fortran; + auto hipblasGelsFn = FORTRAN ? hipblasGels : hipblasGels; + + int N = argus.N; + int M = argus.M; + int nrhs = argus.K; + int lda = argus.lda; + int ldb = argus.ldb; + char transc = argus.transA_option; + if(is_complex && transc == 'T') + transc = 'C'; + else if(!is_complex && transc == 'C') + transc = 'T'; + + hipblasOperation_t trans = char2hipblas_operation(transc); + + size_t A_size = size_t(lda) * N; + size_t B_size = ldb * nrhs; + + // Check to prevent memory allocation error + if(M < 0 || N < 0 || nrhs < 0 || lda < M || ldb < M || ldb < N) + { + return HIPBLAS_STATUS_INVALID_VALUE; + } + + // Naming: dK is in GPU (device) memory. hK is in CPU (host) memory + host_vector hA(A_size); + host_vector hB(B_size); + host_vector hB_res(B_size); + int info, info_res; + int info_input(-1); + + device_vector dA(A_size); + device_vector dB(B_size); + device_vector dInfo(1); + + double gpu_time_used, hipblas_error; + hipblasLocalHandle handle(argus); + + // Initial hA, hB, hX on CPU + srand(1); + hipblas_init(hA, true); + hipblas_init(hB); + hB_res = hB; + + // scale A to avoid singularities + for(int i = 0; i < N; i++) + { + for(int j = 0; j < N; j++) + { + if(i == j) + hA[i + j * lda] += 400; + else + hA[i + j * lda] -= 4; + } + } + + // Copy data from CPU to device + CHECK_HIP_ERROR(hipMemcpy(dA, hA, A_size * sizeof(T), hipMemcpyHostToDevice)); + CHECK_HIP_ERROR(hipMemcpy(dB, hB, B_size * sizeof(T), hipMemcpyHostToDevice)); + + if(argus.unit_check || argus.norm_check) + { + /* ===================================================================== + HIPBLAS + =================================================================== */ + CHECK_HIPBLAS_ERROR( + hipblasGelsFn(handle, trans, M, N, nrhs, dA, lda, dB, ldb, &info_input, dInfo)); + + // copy output from device to CPU + CHECK_HIP_ERROR(hipMemcpy(hB_res, dB, B_size * sizeof(T), hipMemcpyDeviceToHost)); + CHECK_HIP_ERROR(hipMemcpy(&info_res, dInfo, sizeof(int), hipMemcpyDeviceToHost)); + + /* ===================================================================== + CPU LAPACK + =================================================================== */ + int sizeW = std::max(1, std::min(M, N) + std::max(std::min(M, N), nrhs)); + host_vector hW(sizeW); + + info = cblas_gels(transc, M, N, nrhs, hA.data(), lda, hB.data(), ldb, hW.data(), sizeW); + + hipblas_error + = norm_check_general('F', std::max(M, N), nrhs, ldb, hB.data(), hB_res.data()); + if(info_input != info_res) + hipblas_error++; + if(info != 0) + hipblas_error++; + + if(argus.unit_check) + { + double eps = std::numeric_limits::epsilon(); + double tolerance = N * eps * 100; + + unit_check_error(hipblas_error, tolerance); + } + } + + if(argus.timing) + { + hipStream_t stream; + CHECK_HIPBLAS_ERROR(hipblasGetStream(handle, &stream)); + + int runs = argus.cold_iters + argus.iters; + for(int iter = 0; iter < runs; iter++) + { + if(iter == argus.cold_iters) + gpu_time_used = get_time_us_sync(stream); + + CHECK_HIPBLAS_ERROR( + hipblasGelsFn(handle, trans, M, N, nrhs, dA, lda, dB, ldb, &info_input, dInfo)); + } + gpu_time_used = get_time_us_sync(stream) - gpu_time_used; + + ArgumentModel{}.log_args(std::cout, + argus, + gpu_time_used, + ArgumentLogging::NA_value, + ArgumentLogging::NA_value, + hipblas_error); + } + + return HIPBLAS_STATUS_SUCCESS; +} diff --git a/docs/source/functions.rst b/docs/source/functions.rst index a83772f51..3f9854c42 100644 --- a/docs/source/functions.rst +++ b/docs/source/functions.rst @@ -1406,6 +1406,32 @@ hipblasXgeqrf + Batched, stridedBatched :outline: .. doxygenfunction:: hipblasZgeqrfStridedBatched +hipblasXgels + Batched, StridedBatched +---------------------------------------- +.. doxygenfunction:: hipblasSgels + :outline: +.. doxygenfunction:: hipblasDgels + :outline: +.. doxygenfunction:: hipblasCgels + :outline: +.. doxygenfunction:: hipblasZgels + +.. doxygenfunction:: hipblasSgelsBatched + :outline: +.. doxygenfunction:: hipblasDgelsBatched + :outline: +.. doxygenfunction:: hipblasCgelsBatched + :outline: +.. doxygenfunction:: hipblasZgelsBatched + +.. doxygenfunction:: hipblasSgelsStridedBatched + :outline: +.. doxygenfunction:: hipblasDgelsStridedBatched + :outline: +.. doxygenfunction:: hipblasCgelsStridedBatched + :outline: +.. doxygenfunction:: hipblasZgelsStridedBatched + BLAS Extensions =============== .. contents:: List of BLAS Extension Functions diff --git a/library/include/hipblas.h b/library/include/hipblas.h index e0dc41697..f62451a31 100644 --- a/library/include/hipblas.h +++ b/library/include/hipblas.h @@ -16634,6 +16634,124 @@ HIPBLAS_EXPORT hipblasStatus_t hipblasZgetriBatched(hipblasHandle_t const int batchCount); //! @} +/*! @{ + \brief GELS solves an overdetermined (or underdetermined) linear system defined by an m-by-n + matrix A, and a corresponding matrix B, using the QR factorization computed by \ref hipblasSgeqrf "GEQRF" (or the LQ + factorization computed by "GELQF"). + + \details + Depending on the value of trans, the problem solved by this function is either of the form + + \f[ + \begin{array}{cl} + A X = B & \: \text{not transposed, or}\\ + A' X = B & \: \text{transposed if real, or conjugate transposed if complex} + \end{array} + \f] + + If m >= n (or m < n in the case of transpose/conjugate transpose), the system is overdetermined + and a least-squares solution approximating X is found by minimizing + + \f[ + || B - A X || \quad \text{(or} \: || B - A' X ||\text{)} + \f] + + If m < n (or m >= n in the case of transpose/conjugate transpose), the system is underdetermined + and a unique solution for X is chosen such that \f$|| X ||\f$ is minimal. + + - Supported precisions in rocSOLVER : s,d,c,z + - Supported precisions in cuBLAS : currently unsupported + + @param[in] + handle hipblasHandle_t. + @param[in] + trans hipblasOperation_t.\n + Specifies the form of the system of equations. + @param[in] + m int. m >= 0.\n + The number of rows of matrix A. + @param[in] + n int. n >= 0.\n + The number of columns of matrix A. + @param[in] + nrhs int. nrhs >= 0.\n + The number of columns of matrices B and X; + i.e., the columns on the right hand side. + @param[inout] + A pointer to type. Array on the GPU of dimension lda*n.\n + On entry, the matrix A. + On exit, the QR (or LQ) factorization of A as returned by "GEQRF" (or "GELQF"). + @param[in] + lda int. lda >= m.\n + Specifies the leading dimension of matrix A. + @param[inout] + B pointer to type. Array on the GPU of dimension ldb*nrhs.\n + On entry, the matrix B. + On exit, when info = 0, B is overwritten by the solution vectors (and the residuals in + the overdetermined cases) stored as columns. + @param[in] + ldb int. ldb >= max(m,n).\n + Specifies the leading dimension of matrix B. + @param[out] + info pointer to a int on the host.\n + If info = 0, successful exit. + If info = j < 0, the j-th argument is invalid. + @param[out] + deviceInfo pointer to int on the GPU.\n + If info = 0, successful exit. + If info = i > 0, the solution could not be computed because input matrix A is + rank deficient; the i-th diagonal element of its triangular factor is zero. + ********************************************************************/ + +HIPBLAS_EXPORT hipblasStatus_t hipblasSgels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* A, + const int lda, + float* B, + const int ldb, + int* info, + int* deviceInfo); + +HIPBLAS_EXPORT hipblasStatus_t hipblasDgels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* A, + const int lda, + double* B, + const int ldb, + int* info, + int* deviceInfo); + +HIPBLAS_EXPORT hipblasStatus_t hipblasCgels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* A, + const int lda, + hipblasComplex* B, + const int ldb, + int* info, + int* deviceInfo); + +HIPBLAS_EXPORT hipblasStatus_t hipblasZgels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* A, + const int lda, + hipblasDoubleComplex* B, + const int ldb, + int* info, + int* deviceInfo); +///@} + /*! @{ \brief SOLVER API diff --git a/library/src/hcc_detail/hipblas.cpp b/library/src/hcc_detail/hipblas.cpp index 76198d5f0..ed77cf23f 100644 --- a/library/src/hcc_detail/hipblas.cpp +++ b/library/src/hcc_detail/hipblas.cpp @@ -15091,6 +15091,7 @@ catch(...) } #ifdef __HIP_PLATFORM_SOLVER__ + //-------------------------------------------------------------------------------------- //rocSOLVER functions //-------------------------------------------------------------------------------------- @@ -16627,6 +16628,210 @@ catch(...) return exception_to_hipblas_status(); } +hipblasStatus_t hipblasSgels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* A, + const int lda, + float* B, + const int ldb, + int* info, + int* deviceInfo) +try +{ + if(info == NULL) + return HIPBLAS_STATUS_INVALID_VALUE; + else if(m < 0) + *info = -2; + else if(n < 0) + *info = -3; + else if(nrhs < 0) + *info = -4; + else if(A == NULL) + *info = -5; + else if(lda < m) + *info = -6; + else if(B == NULL) + *info = -7; + else if(ldb < m || ldb < n) + *info = -8; + else if(info == NULL) + *info = -9; + else + *info = 0; + + return HIPBLAS_DEMAND_ALLOC( + rocBLASStatusToHIPStatus(rocsolver_sgels((rocblas_handle)handle, + hipOperationToHCCOperation(trans), + m, + n, + nrhs, + A, + lda, + B, + ldb, + deviceInfo))); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +hipblasStatus_t hipblasDgels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* A, + const int lda, + double* B, + const int ldb, + int* info, + int* deviceInfo) +try +{ + if(info == NULL) + return HIPBLAS_STATUS_INVALID_VALUE; + else if(m < 0) + *info = -2; + else if(n < 0) + *info = -3; + else if(nrhs < 0) + *info = -4; + else if(A == NULL) + *info = -5; + else if(lda < m) + *info = -6; + else if(B == NULL) + *info = -7; + else if(ldb < m || ldb < n) + *info = -8; + else if(info == NULL) + *info = -9; + else + *info = 0; + + return HIPBLAS_DEMAND_ALLOC( + rocBLASStatusToHIPStatus(rocsolver_dgels((rocblas_handle)handle, + hipOperationToHCCOperation(trans), + m, + n, + nrhs, + A, + lda, + B, + ldb, + deviceInfo))); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +hipblasStatus_t hipblasCgels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* A, + const int lda, + hipblasComplex* B, + const int ldb, + int* info, + int* deviceInfo) +try +{ + if(info == NULL) + return HIPBLAS_STATUS_INVALID_VALUE; + else if(m < 0) + *info = -2; + else if(n < 0) + *info = -3; + else if(nrhs < 0) + *info = -4; + else if(A == NULL) + *info = -5; + else if(lda < m) + *info = -6; + else if(B == NULL) + *info = -7; + else if(ldb < m || ldb < n) + *info = -8; + else if(info == NULL) + *info = -9; + else + *info = 0; + + return HIPBLAS_DEMAND_ALLOC( + rocBLASStatusToHIPStatus(rocsolver_cgels((rocblas_handle)handle, + hipOperationToHCCOperation(trans), + m, + n, + nrhs, + (rocblas_float_complex*)A, + lda, + (rocblas_float_complex*)B, + ldb, + deviceInfo))); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +hipblasStatus_t hipblasZgels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* A, + const int lda, + hipblasDoubleComplex* B, + const int ldb, + int* info, + int* deviceInfo) +try +{ + if(info == NULL) + return HIPBLAS_STATUS_INVALID_VALUE; + else if(m < 0) + *info = -2; + else if(n < 0) + *info = -3; + else if(nrhs < 0) + *info = -4; + else if(A == NULL) + *info = -5; + else if(lda < m) + *info = -6; + else if(B == NULL) + *info = -7; + else if(ldb < m || ldb < n) + *info = -8; + else if(info == NULL) + *info = -9; + else + *info = 0; + + return HIPBLAS_DEMAND_ALLOC( + rocBLASStatusToHIPStatus(rocsolver_zgels((rocblas_handle)handle, + hipOperationToHCCOperation(trans), + m, + n, + nrhs, + (rocblas_double_complex*)A, + lda, + (rocblas_double_complex*)B, + ldb, + deviceInfo))); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + #endif // gemm diff --git a/library/src/hipblas_module.f90 b/library/src/hipblas_module.f90 index 85b5f23fc..ae523718d 100644 --- a/library/src/hipblas_module.f90 +++ b/library/src/hipblas_module.f90 @@ -13236,4 +13236,89 @@ function hipblasZgeqrfStridedBatched(handle, m, n, A, lda, stride_A,& end function hipblasZgeqrfStridedBatched end interface + ! gels + interface + function hipblasSgels(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo) & + result(c_int) & + bind(c, name = 'hipblasSgels') + use iso_c_binding + use hipblas_enums + implicit none + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + end function hipblasSgels + end interface + + interface + function hipblasDgels(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo) & + result(c_int) & + bind(c, name = 'hipblasDgels') + use iso_c_binding + use hipblas_enums + implicit none + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + end function hipblasDgels + end interface + + interface + function hipblasCgels(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo) & + result(c_int) & + bind(c, name = 'hipblasCgels') + use iso_c_binding + use hipblas_enums + implicit none + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + end function hipblasCgels + end interface + + interface + function hipblasZgels(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo) & + result(c_int) & + bind(c, name = 'hipblasZgels') + use iso_c_binding + use hipblas_enums + implicit none + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + end function hipblasZgels + end interface + end module hipblas diff --git a/library/src/nvcc_detail/hipblas.cpp b/library/src/nvcc_detail/hipblas.cpp index e64c2db2a..e950af79d 100644 --- a/library/src/nvcc_detail/hipblas.cpp +++ b/library/src/nvcc_detail/hipblas.cpp @@ -10764,6 +10764,67 @@ hipblasStatus_t hipblasZgeqrfStridedBatched(hipblasHandle_t handle, return HIPBLAS_STATUS_NOT_SUPPORTED; } +hipblasStatus_t hipblasSgels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* A, + const int lda, + float* B, + const int ldb, + int* info, + int* deviceInfo) +{ + // only batched variants of gels are supported in cuBLAS + return HIPBLAS_STATUS_NOT_SUPPORTED; +} + +hipblasStatus_t hipblasDgels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* A, + const int lda, + double* B, + const int ldb, + int* info, + int* deviceInfo) +{ + return HIPBLAS_STATUS_NOT_SUPPORTED; +} + +hipblasStatus_t hipblasCgels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* A, + const int lda, + hipblasComplex* B, + const int ldb, + int* info, + int* deviceInfo) +{ + return HIPBLAS_STATUS_NOT_SUPPORTED; +} + +hipblasStatus_t hipblasZgels(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* A, + const int lda, + hipblasDoubleComplex* B, + const int ldb, + int* info, + int* deviceInfo) +{ + return HIPBLAS_STATUS_NOT_SUPPORTED; +} + #endif // gemm From 97af86224b81a15c0bac52cca8dd6fd4484382c1 Mon Sep 17 00:00:00 2001 From: Torre Zuk Date: Tue, 12 Jul 2022 13:24:48 -0600 Subject: [PATCH 04/12] update fortran for non gfortran --- clients/include/hipblas_fortran.f90 | 6322 ++++++++++---------- clients/include/hipblas_fortran_solver.f90 | 504 +- library/src/hipblas_module.f90 | 3597 +++++------ 3 files changed, 5410 insertions(+), 5013 deletions(-) diff --git a/clients/include/hipblas_fortran.f90 b/clients/include/hipblas_fortran.f90 index c7da5bc2a..6668a3f70 100644 --- a/clients/include/hipblas_fortran.f90 +++ b/clients/include/hipblas_fortran.f90 @@ -25,46 +25,49 @@ module hipblas_interface use iso_c_binding use hipblas - contains +contains !--------! ! Aux ! !--------! function hipblasSetVectorFortran(n, elemSize, x, incx, y, incy) & - result(res) & - bind(c, name = 'hipblasSetVectorFortran') + bind(c, name='hipblasSetVectorFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetVectorFortran integer(c_int), value :: n integer(c_int), value :: elemSize type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasSetVector(n, elemSize, x, incx, y, incy) + hipblasSetVectorFortran = & + hipblasSetVector(n, elemSize, x, incx, y, incy) end function hipblasSetVectorFortran function hipblasGetVectorFortran(n, elemSize, x, incx, y, incy) & - result(res) & - bind(c, name = 'hipblasGetVectorFortran') + bind(c, name='hipblasGetVectorFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetVectorFortran integer(c_int), value :: n integer(c_int), value :: elemSize type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasGetVector(n, elemSize, x, incx, y, incy) + hipblasGetVectorFortran = & + hipblasGetVector(n, elemSize, x, incx, y, incy) end function hipblasGetVectorFortran function hipblasSetMatrixFortran(rows, cols, elemSize, A, lda, B, ldb) & - result(res) & - bind(c, name = 'hipblasSetMatrixFortran') + bind(c, name='hipblasSetMatrixFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetMatrixFortran integer(c_int), value :: rows integer(c_int), value :: cols integer(c_int), value :: elemSize @@ -72,15 +75,16 @@ function hipblasSetMatrixFortran(rows, cols, elemSize, A, lda, B, ldb) & integer(c_int), value :: lda type(c_ptr), value :: B integer(c_int), value :: ldb - integer(c_int) :: res - res = hipblasSetMatrix(rows, cols, elemSize, A, lda, B, ldb) + hipblasSetMatrixFortran = & + hipblasSetMatrix(rows, cols, elemSize, A, lda, B, ldb) end function hipblasSetMatrixFortran function hipblasGetMatrixFortran(rows, cols, elemSize, A, lda, B, ldb) & - result(res) & - bind(c, name = 'hipblasGetMatrixFortran') + bind(c, name='hipblasGetMatrixFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetMatrixFortran integer(c_int), value :: rows integer(c_int), value :: cols integer(c_int), value :: elemSize @@ -88,15 +92,16 @@ function hipblasGetMatrixFortran(rows, cols, elemSize, A, lda, B, ldb) & integer(c_int), value :: lda type(c_ptr), value :: B integer(c_int), value :: ldb - integer(c_int) :: res - res = hipblasSetMatrix(rows, cols, elemSize, A, lda, B, ldb) + hipblasGetMatrixFortran = & + hipblasSetMatrix(rows, cols, elemSize, A, lda, B, ldb) end function hipblasGetMatrixFortran function hipblasSetVectorAsyncFortran(n, elemSize, x, incx, y, incy, stream) & - result(res) & - bind(c, name = 'hipblasSetVectorAsyncFortran') + bind(c, name='hipblasSetVectorAsyncFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetVectorAsyncFortran integer(c_int), value :: n integer(c_int), value :: elemSize type(c_ptr), value :: x @@ -104,15 +109,16 @@ function hipblasSetVectorAsyncFortran(n, elemSize, x, incx, y, incy, stream) & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: stream - integer(c_int) :: res - res = hipblasSetVectorAsync(n, elemSize, x, incx, y, incy, stream) + hipblasSetVectorAsyncFortran = & + hipblasSetVectorAsync(n, elemSize, x, incx, y, incy, stream) end function hipblasSetVectorAsyncFortran function hipblasGetVectorAsyncFortran(n, elemSize, x, incx, y, incy, stream) & - result(res) & - bind(c, name = 'hipblasGetVectorAsyncFortran') + bind(c, name='hipblasGetVectorAsyncFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetVectorAsyncFortran integer(c_int), value :: n integer(c_int), value :: elemSize type(c_ptr), value :: x @@ -120,15 +126,16 @@ function hipblasGetVectorAsyncFortran(n, elemSize, x, incx, y, incy, stream) & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: stream - integer(c_int) :: res - res = hipblasGetVectorAsync(n, elemSize, x, incx, y, incy, stream) + hipblasGetVectorAsyncFortran = & + hipblasGetVectorAsync(n, elemSize, x, incx, y, incy, stream) end function hipblasGetVectorAsyncFortran function hipblasSetMatrixAsyncFortran(rows, cols, elemSize, A, lda, B, ldb, stream) & - result(res) & - bind(c, name = 'hipblasSetMatrixAsyncFortran') + bind(c, name='hipblasSetMatrixAsyncFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetMatrixAsyncFortran integer(c_int), value :: rows integer(c_int), value :: cols integer(c_int), value :: elemSize @@ -137,15 +144,16 @@ function hipblasSetMatrixAsyncFortran(rows, cols, elemSize, A, lda, B, ldb, stre type(c_ptr), value :: B integer(c_int), value :: ldb type(c_ptr), value :: stream - integer(c_int) :: res - res = hipblasSetMatrixAsync(rows, cols, elemSize, A, lda, B, ldb, stream) + hipblasSetMatrixAsyncFortran = & + hipblasSetMatrixAsync(rows, cols, elemSize, A, lda, B, ldb, stream) end function hipblasSetMatrixAsyncFortran function hipblasGetMatrixAsyncFortran(rows, cols, elemSize, A, lda, B, ldb, stream) & - result(res) & - bind(c, name = 'hipblasGetMatrixAsyncFortran') + bind(c, name='hipblasGetMatrixAsyncFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetMatrixAsyncFortran integer(c_int), value :: rows integer(c_int), value :: cols integer(c_int), value :: elemSize @@ -154,32 +162,32 @@ function hipblasGetMatrixAsyncFortran(rows, cols, elemSize, A, lda, B, ldb, stre type(c_ptr), value :: B integer(c_int), value :: ldb type(c_ptr), value :: stream - integer(c_int) :: res - res = hipblasGetMatrixAsync(rows, cols, elemSize, A, lda, B, ldb, stream) + hipblasGetMatrixAsyncFortran = & + hipblasGetMatrixAsync(rows, cols, elemSize, A, lda, B, ldb, stream) end function hipblasGetMatrixAsyncFortran function hipblasSetAtomicsModeFortran(handle, atomics_mode) & - result(res) & - bind(c, name = 'hipblasSetAtomicsModeFortran') + bind(c, name='hipblasSetAtomicsModeFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetAtomicsModeFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_ATOMICS_ALLOWED)), value :: atomics_mode - integer(c_int) :: res - res = hipblasSetAtomicsMode(handle, atomics_mode) + hipblasSetAtomicsModeFortran = & + hipblasSetAtomicsMode(handle, atomics_mode) end function hipblasSetAtomicsModeFortran function hipblasGetAtomicsModeFortran(handle, atomics_mode) & - result(res) & - bind(c, name = 'hipblasGetAtomicsModeFortran') + bind(c, name='hipblasGetAtomicsModeFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetAtomicsModeFortran type(c_ptr), value :: handle type(c_ptr), value :: atomics_mode - integer(c_int) :: res - res = hipblasGetAtomicsMode(handle, atomics_mode) + hipblasGetAtomicsModeFortran = & + hipblasGetAtomicsMode(handle, atomics_mode) end function hipblasGetAtomicsModeFortran !--------! @@ -188,198 +196,211 @@ end function hipblasGetAtomicsModeFortran ! scal function hipblasSscalFortran(handle, n, alpha, x, incx) & - result(res) & - bind(c, name = 'hipblasSscalFortran') + bind(c, name='hipblasSscalFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscalFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasSscal(handle, n, alpha, x, incx) + hipblasSscalFortran = & + hipblasSscal(handle, n, alpha, x, incx) return end function hipblasSscalFortran function hipblasDscalFortran(handle, n, alpha, x, incx) & - result(res) & - bind(c, name = 'hipblasDscalFortran') + bind(c, name='hipblasDscalFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscalFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasDscal(handle, n, alpha, x, incx) + hipblasDscalFortran = & + hipblasDscal(handle, n, alpha, x, incx) return end function hipblasDscalFortran function hipblasCscalFortran(handle, n, alpha, x, incx) & - result(res) & - bind(c, name = 'hipblasCscalFortran') + bind(c, name='hipblasCscalFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscalFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasCscal(handle, n, alpha, x, incx) + hipblasCscalFortran = & + hipblasCscal(handle, n, alpha, x, incx) return end function hipblasCscalFortran function hipblasZscalFortran(handle, n, alpha, x, incx) & - result(res) & - bind(c, name = 'hipblasZscalFortran') + bind(c, name='hipblasZscalFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscalFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasZscal(handle, n, alpha, x, incx) + hipblasZscalFortran = & + hipblasZscal(handle, n, alpha, x, incx) return end function hipblasZscalFortran function hipblasCsscalFortran(handle, n, alpha, x, incx) & - result(res) & - bind(c, name = 'hipblasCsscalFortran') + bind(c, name='hipblasCsscalFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscalFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasCsscal(handle, n, alpha, x, incx) + hipblasCsscalFortran = & + hipblasCsscal(handle, n, alpha, x, incx) return end function hipblasCsscalFortran function hipblasZdscalFortran(handle, n, alpha, x, incx) & - result(res) & - bind(c, name = 'hipblasZdscalFortran') + bind(c, name='hipblasZdscalFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscalFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasZdscal(handle, n, alpha, x, incx) + hipblasZdscalFortran = & + hipblasZdscal(handle, n, alpha, x, incx) return end function hipblasZdscalFortran ! scalBatched function hipblasSscalBatchedFortran(handle, n, alpha, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasSscalBatchedFortran') + bind(c, name='hipblasSscalBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscalBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSscalBatched(handle, n, alpha, x, incx, batch_count) + hipblasSscalBatchedFortran = & + hipblasSscalBatched(handle, n, alpha, x, incx, batch_count) return end function hipblasSscalBatchedFortran function hipblasDscalBatchedFortran(handle, n, alpha, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasDscalBatchedFortran') + bind(c, name='hipblasDscalBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscalBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDscalBatched(handle, n, alpha, x, incx, batch_count) + hipblasDscalBatchedFortran = & + hipblasDscalBatched(handle, n, alpha, x, incx, batch_count) return end function hipblasDscalBatchedFortran function hipblasCscalBatchedFortran(handle, n, alpha, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasCscalBatchedFortran') + bind(c, name='hipblasCscalBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscalBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCscalBatched(handle, n, alpha, x, incx, batch_count) + hipblasCscalBatchedFortran = & + hipblasCscalBatched(handle, n, alpha, x, incx, batch_count) return end function hipblasCscalBatchedFortran function hipblasZscalBatchedFortran(handle, n, alpha, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasZscalBatchedFortran') + bind(c, name='hipblasZscalBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscalBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZscalBatched(handle, n, alpha, x, incx, batch_count) + hipblasZscalBatchedFortran = & + hipblasZscalBatched(handle, n, alpha, x, incx, batch_count) return end function hipblasZscalBatchedFortran function hipblasCsscalBatchedFortran(handle, n, alpha, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasCsscalBatchedFortran') + bind(c, name='hipblasCsscalBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscalBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsscalBatched(handle, n, alpha, x, incx, batch_count) + hipblasCsscalBatchedFortran = & + hipblasCsscalBatched(handle, n, alpha, x, incx, batch_count) return end function hipblasCsscalBatchedFortran function hipblasZdscalBatchedFortran(handle, n, alpha, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasZdscalBatchedFortran') + bind(c, name='hipblasZdscalBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscalBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZdscalBatched(handle, n, alpha, x, incx, batch_count) + hipblasZdscalBatchedFortran = & + hipblasZdscalBatched(handle, n, alpha, x, incx, batch_count) return end function hipblasZdscalBatchedFortran ! scalStridedBatched function hipblasSscalStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasSscalStridedBatchedFortran') + bind(c, name='hipblasSscalStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscalStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -387,16 +408,17 @@ function hipblasSscalStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) + hipblasSscalStridedBatchedFortran = & + hipblasSscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) return end function hipblasSscalStridedBatchedFortran function hipblasDscalStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasDscalStridedBatchedFortran') + bind(c, name='hipblasDscalStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscalStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -404,16 +426,17 @@ function hipblasDscalStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) + hipblasDscalStridedBatchedFortran = & + hipblasDscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) return end function hipblasDscalStridedBatchedFortran function hipblasCscalStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasCscalStridedBatchedFortran') + bind(c, name='hipblasCscalStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscalStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -421,16 +444,17 @@ function hipblasCscalStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) + hipblasCscalStridedBatchedFortran = & + hipblasCscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) return end function hipblasCscalStridedBatchedFortran function hipblasZscalStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasZscalStridedBatchedFortran') + bind(c, name='hipblasZscalStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscalStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -438,16 +462,17 @@ function hipblasZscalStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) + hipblasZscalStridedBatchedFortran = & + hipblasZscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) return end function hipblasZscalStridedBatchedFortran function hipblasCsscalStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasCsscalStridedBatchedFortran') + bind(c, name='hipblasCsscalStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscalStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -455,16 +480,17 @@ function hipblasCsscalStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) + hipblasCsscalStridedBatchedFortran = & + hipblasCsscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) return end function hipblasCsscalStridedBatchedFortran function hipblasZdscalStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasZdscalStridedBatchedFortran') + bind(c, name='hipblasZdscalStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscalStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -472,82 +498,87 @@ function hipblasZdscalStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZdscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) + hipblasZdscalStridedBatchedFortran = & + hipblasZdscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) return end function hipblasZdscalStridedBatchedFortran ! copy function hipblasScopyFortran(handle, n, x, incx, y, incy) & - result(res) & - bind(c, name = 'hipblasScopyFortran') + bind(c, name='hipblasScopyFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScopyFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasScopy(handle, n, x, incx, y, incy) + hipblasScopyFortran = & + hipblasScopy(handle, n, x, incx, y, incy) return end function hipblasScopyFortran function hipblasDcopyFortran(handle, n, x, incx, y, incy) & - result(res) & - bind(c, name = 'hipblasDcopyFortran') + bind(c, name='hipblasDcopyFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDcopyFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasDcopy(handle, n, x, incx, y, incy) + hipblasDcopyFortran = & + hipblasDcopy(handle, n, x, incx, y, incy) return end function hipblasDcopyFortran function hipblasCcopyFortran(handle, n, x, incx, y, incy) & - result(res) & - bind(c, name = 'hipblasCcopyFortran') + bind(c, name='hipblasCcopyFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCcopyFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasCcopy(handle, n, x, incx, y, incy) + hipblasCcopyFortran = & + hipblasCcopy(handle, n, x, incx, y, incy) return end function hipblasCcopyFortran function hipblasZcopyFortran(handle, n, x, incx, y, incy) & - result(res) & - bind(c, name = 'hipblasZcopyFortran') + bind(c, name='hipblasZcopyFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZcopyFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasZcopy(handle, n, x, incx, y, incy) + hipblasZcopyFortran = & + hipblasZcopy(handle, n, x, incx, y, incy) return end function hipblasZcopyFortran ! copyBatched function hipblasScopyBatchedFortran(handle, n, x, incx, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasScopyBatchedFortran') + bind(c, name='hipblasScopyBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScopyBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -555,16 +586,17 @@ function hipblasScopyBatchedFortran(handle, n, x, incx, y, incy, batch_count) & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasScopyBatched(handle, n, x, incx, y, incy, batch_count) + hipblasScopyBatchedFortran = & + hipblasScopyBatched(handle, n, x, incx, y, incy, batch_count) return end function hipblasScopyBatchedFortran function hipblasDcopyBatchedFortran(handle, n, x, incx, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasDcopyBatchedFortran') + bind(c, name='hipblasDcopyBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDcopyBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -572,16 +604,17 @@ function hipblasDcopyBatchedFortran(handle, n, x, incx, y, incy, batch_count) & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDcopyBatched(handle, n, x, incx, y, incy, batch_count) + hipblasDcopyBatchedFortran = & + hipblasDcopyBatched(handle, n, x, incx, y, incy, batch_count) return end function hipblasDcopyBatchedFortran function hipblasCcopyBatchedFortran(handle, n, x, incx, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasCcopyBatchedFortran') + bind(c, name='hipblasCcopyBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCcopyBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -589,16 +622,17 @@ function hipblasCcopyBatchedFortran(handle, n, x, incx, y, incy, batch_count) & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCcopyBatched(handle, n, x, incx, y, incy, batch_count) + hipblasCcopyBatchedFortran = & + hipblasCcopyBatched(handle, n, x, incx, y, incy, batch_count) return end function hipblasCcopyBatchedFortran function hipblasZcopyBatchedFortran(handle, n, x, incx, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasZcopyBatchedFortran') + bind(c, name='hipblasZcopyBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZcopyBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -606,17 +640,18 @@ function hipblasZcopyBatchedFortran(handle, n, x, incx, y, incy, batch_count) & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZcopyBatched(handle, n, x, incx, y, incy, batch_count) + hipblasZcopyBatchedFortran = & + hipblasZcopyBatched(handle, n, x, incx, y, incy, batch_count) return end function hipblasZcopyBatchedFortran ! copyStridedBatched function hipblasScopyStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasScopyStridedBatchedFortran') + bind(c, name='hipblasScopyStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScopyStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -626,16 +661,17 @@ function hipblasScopyStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasScopyStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) + hipblasScopyStridedBatchedFortran = & + hipblasScopyStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) return end function hipblasScopyStridedBatchedFortran function hipblasDcopyStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasDcopyStridedBatchedFortran') + bind(c, name='hipblasDcopyStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDcopyStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -645,16 +681,17 @@ function hipblasDcopyStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDcopyStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) + hipblasDcopyStridedBatchedFortran = & + hipblasDcopyStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) return end function hipblasDcopyStridedBatchedFortran function hipblasCcopyStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasCcopyStridedBatchedFortran') + bind(c, name='hipblasCcopyStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCcopyStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -664,16 +701,17 @@ function hipblasCcopyStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCcopyStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) + hipblasCcopyStridedBatchedFortran = & + hipblasCcopyStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) return end function hipblasCcopyStridedBatchedFortran function hipblasZcopyStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasZcopyStridedBatchedFortran') + bind(c, name='hipblasZcopyStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZcopyStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -683,17 +721,18 @@ function hipblasZcopyStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZcopyStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) + hipblasZcopyStridedBatchedFortran = & + hipblasZcopyStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) return end function hipblasZcopyStridedBatchedFortran ! dot function hipblasSdotFortran(handle, n, x, incx, y, incy, result) & - result(res) & - bind(c, name = 'hipblasSdotFortran') + bind(c, name='hipblasSdotFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdotFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -701,16 +740,17 @@ function hipblasSdotFortran(handle, n, x, incx, y, incy, result) & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasSdot(handle, n, x, incx, y, incy, result) + hipblasSdotFortran = & + hipblasSdot(handle, n, x, incx, y, incy, result) return end function hipblasSdotFortran function hipblasDdotFortran(handle, n, x, incx, y, incy, result) & - result(res) & - bind(c, name = 'hipblasDdotFortran') + bind(c, name='hipblasDdotFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdotFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -718,16 +758,17 @@ function hipblasDdotFortran(handle, n, x, incx, y, incy, result) & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasDdot(handle, n, x, incx, y, incy, result) + hipblasDdotFortran = & + hipblasDdot(handle, n, x, incx, y, incy, result) return end function hipblasDdotFortran function hipblasHdotFortran(handle, n, x, incx, y, incy, result) & - result(res) & - bind(c, name = 'hipblasHdotFortran') + bind(c, name='hipblasHdotFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHdotFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -735,16 +776,17 @@ function hipblasHdotFortran(handle, n, x, incx, y, incy, result) & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasHdot(handle, n, x, incx, y, incy, result) + hipblasHdotFortran = & + hipblasHdot(handle, n, x, incx, y, incy, result) return end function hipblasHdotFortran function hipblasBfdotFortran(handle, n, x, incx, y, incy, result) & - result(res) & - bind(c, name = 'hipblasBfdotFortran') + bind(c, name='hipblasBfdotFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasBfdotFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -752,16 +794,17 @@ function hipblasBfdotFortran(handle, n, x, incx, y, incy, result) & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasBfdot(handle, n, x, incx, y, incy, result) + hipblasBfdotFortran = & + hipblasBfdot(handle, n, x, incx, y, incy, result) return end function hipblasBfdotFortran function hipblasCdotuFortran(handle, n, x, incx, y, incy, result) & - result(res) & - bind(c, name = 'hipblasCdotuFortran') + bind(c, name='hipblasCdotuFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotuFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -769,16 +812,17 @@ function hipblasCdotuFortran(handle, n, x, incx, y, incy, result) & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasCdotu(handle, n, x, incx, y, incy, result) + hipblasCdotuFortran = & + hipblasCdotu(handle, n, x, incx, y, incy, result) return end function hipblasCdotuFortran function hipblasCdotcFortran(handle, n, x, incx, y, incy, result) & - result(res) & - bind(c, name = 'hipblasCdotcFortran') + bind(c, name='hipblasCdotcFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotcFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -786,16 +830,17 @@ function hipblasCdotcFortran(handle, n, x, incx, y, incy, result) & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasCdotc(handle, n, x, incx, y, incy, result) + hipblasCdotcFortran = & + hipblasCdotc(handle, n, x, incx, y, incy, result) return end function hipblasCdotcFortran function hipblasZdotuFortran(handle, n, x, incx, y, incy, result) & - result(res) & - bind(c, name = 'hipblasZdotuFortran') + bind(c, name='hipblasZdotuFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotuFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -803,16 +848,17 @@ function hipblasZdotuFortran(handle, n, x, incx, y, incy, result) & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasZdotu(handle, n, x, incx, y, incy, result) + hipblasZdotuFortran = & + hipblasZdotu(handle, n, x, incx, y, incy, result) return end function hipblasZdotuFortran function hipblasZdotcFortran(handle, n, x, incx, y, incy, result) & - result(res) & - bind(c, name = 'hipblasZdotcFortran') + bind(c, name='hipblasZdotcFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotcFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -820,17 +866,18 @@ function hipblasZdotcFortran(handle, n, x, incx, y, incy, result) & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasZdotc(handle, n, x, incx, y, incy, result) + hipblasZdotcFortran = & + hipblasZdotc(handle, n, x, incx, y, incy, result) return end function hipblasZdotcFortran ! dotBatched function hipblasSdotBatchedFortran(handle, n, x, incx, y, incy, batch_count, result) & - result(res) & - bind(c, name = 'hipblasSdotBatchedFortran') + bind(c, name='hipblasSdotBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdotBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -839,16 +886,17 @@ function hipblasSdotBatchedFortran(handle, n, x, incx, y, incy, batch_count, res integer(c_int), value :: incy integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasSdotBatched(handle, n, x, incx, y, incy, batch_count, result) + hipblasSdotBatchedFortran = & + hipblasSdotBatched(handle, n, x, incx, y, incy, batch_count, result) return end function hipblasSdotBatchedFortran function hipblasDdotBatchedFortran(handle, n, x, incx, y, incy, batch_count, result) & - result(res) & - bind(c, name = 'hipblasDdotBatchedFortran') + bind(c, name='hipblasDdotBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdotBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -857,16 +905,17 @@ function hipblasDdotBatchedFortran(handle, n, x, incx, y, incy, batch_count, res integer(c_int), value :: incy integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasDdotBatched(handle, n, x, incx, y, incy, batch_count, result) + hipblasDdotBatchedFortran = & + hipblasDdotBatched(handle, n, x, incx, y, incy, batch_count, result) return end function hipblasDdotBatchedFortran function hipblasHdotBatchedFortran(handle, n, x, incx, y, incy, batch_count, result) & - result(res) & - bind(c, name = 'hipblasHdotBatchedFortran') + bind(c, name='hipblasHdotBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHdotBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -875,16 +924,17 @@ function hipblasHdotBatchedFortran(handle, n, x, incx, y, incy, batch_count, res integer(c_int), value :: incy integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasHdotBatched(handle, n, x, incx, y, incy, batch_count, result) + hipblasHdotBatchedFortran = & + hipblasHdotBatched(handle, n, x, incx, y, incy, batch_count, result) return end function hipblasHdotBatchedFortran function hipblasBfdotBatchedFortran(handle, n, x, incx, y, incy, batch_count, result) & - result(res) & - bind(c, name = 'hipblasBfdotBatchedFortran') + bind(c, name='hipblasBfdotBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasBfdotBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -893,16 +943,17 @@ function hipblasBfdotBatchedFortran(handle, n, x, incx, y, incy, batch_count, re integer(c_int), value :: incy integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasBfdotBatched(handle, n, x, incx, y, incy, batch_count, result) + hipblasBfdotBatchedFortran = & + hipblasBfdotBatched(handle, n, x, incx, y, incy, batch_count, result) return end function hipblasBfdotBatchedFortran function hipblasCdotuBatchedFortran(handle, n, x, incx, y, incy, batch_count, result) & - result(res) & - bind(c, name = 'hipblasCdotuBatchedFortran') + bind(c, name='hipblasCdotuBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotuBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -911,16 +962,17 @@ function hipblasCdotuBatchedFortran(handle, n, x, incx, y, incy, batch_count, re integer(c_int), value :: incy integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasCdotuBatched(handle, n, x, incx, y, incy, batch_count, result) + hipblasCdotuBatchedFortran = & + hipblasCdotuBatched(handle, n, x, incx, y, incy, batch_count, result) return end function hipblasCdotuBatchedFortran function hipblasCdotcBatchedFortran(handle, n, x, incx, y, incy, batch_count, result) & - result(res) & - bind(c, name = 'hipblasCdotcBatchedFortran') + bind(c, name='hipblasCdotcBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotcBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -929,16 +981,17 @@ function hipblasCdotcBatchedFortran(handle, n, x, incx, y, incy, batch_count, re integer(c_int), value :: incy integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasCdotcBatched(handle, n, x, incx, y, incy, batch_count, result) + hipblasCdotcBatchedFortran = & + hipblasCdotcBatched(handle, n, x, incx, y, incy, batch_count, result) return end function hipblasCdotcBatchedFortran function hipblasZdotuBatchedFortran(handle, n, x, incx, y, incy, batch_count, result) & - result(res) & - bind(c, name = 'hipblasZdotuBatchedFortran') + bind(c, name='hipblasZdotuBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotuBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -947,16 +1000,17 @@ function hipblasZdotuBatchedFortran(handle, n, x, incx, y, incy, batch_count, re integer(c_int), value :: incy integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasZdotuBatched(handle, n, x, incx, y, incy, batch_count, result) + hipblasZdotuBatchedFortran = & + hipblasZdotuBatched(handle, n, x, incx, y, incy, batch_count, result) return end function hipblasZdotuBatchedFortran function hipblasZdotcBatchedFortran(handle, n, x, incx, y, incy, batch_count, result) & - result(res) & - bind(c, name = 'hipblasZdotcBatchedFortran') + bind(c, name='hipblasZdotcBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotcBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -965,17 +1019,18 @@ function hipblasZdotcBatchedFortran(handle, n, x, incx, y, incy, batch_count, re integer(c_int), value :: incy integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasZdotcBatched(handle, n, x, incx, y, incy, batch_count, result) + hipblasZdotcBatchedFortran = & + hipblasZdotcBatched(handle, n, x, incx, y, incy, batch_count, result) return end function hipblasZdotcBatchedFortran ! dotStridedBatched function hipblasSdotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(res) & - bind(c, name = 'hipblasSdotStridedBatchedFortran') + bind(c, name='hipblasSdotStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdotStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -986,16 +1041,17 @@ function hipblasSdotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasSdotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) + hipblasSdotStridedBatchedFortran = & + hipblasSdotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) return end function hipblasSdotStridedBatchedFortran function hipblasDdotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(res) & - bind(c, name = 'hipblasDdotStridedBatchedFortran') + bind(c, name='hipblasDdotStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdotStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1006,16 +1062,17 @@ function hipblasDdotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasDdotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) + hipblasDdotStridedBatchedFortran = & + hipblasDdotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) return end function hipblasDdotStridedBatchedFortran function hipblasHdotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(res) & - bind(c, name = 'hipblasHdotStridedBatchedFortran') + bind(c, name='hipblasHdotStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHdotStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1026,16 +1083,17 @@ function hipblasHdotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasHdotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) + hipblasHdotStridedBatchedFortran = & + hipblasHdotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) return end function hipblasHdotStridedBatchedFortran function hipblasBfdotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(res) & - bind(c, name = 'hipblasBfdotStridedBatchedFortran') + bind(c, name='hipblasBfdotStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasBfdotStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1046,16 +1104,17 @@ function hipblasBfdotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasBfdotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) + hipblasBfdotStridedBatchedFortran = & + hipblasBfdotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) return end function hipblasBfdotStridedBatchedFortran function hipblasCdotuStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(res) & - bind(c, name = 'hipblasCdotuStridedBatchedFortran') + bind(c, name='hipblasCdotuStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotuStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1066,16 +1125,17 @@ function hipblasCdotuStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasCdotuStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) + hipblasCdotuStridedBatchedFortran = & + hipblasCdotuStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) return end function hipblasCdotuStridedBatchedFortran function hipblasCdotcStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(res) & - bind(c, name = 'hipblasCdotcStridedBatchedFortran') + bind(c, name='hipblasCdotcStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotcStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1086,16 +1146,17 @@ function hipblasCdotcStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasCdotcStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) + hipblasCdotcStridedBatchedFortran = & + hipblasCdotcStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) return end function hipblasCdotcStridedBatchedFortran function hipblasZdotuStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(res) & - bind(c, name = 'hipblasZdotuStridedBatchedFortran') + bind(c, name='hipblasZdotuStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotuStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1106,16 +1167,17 @@ function hipblasZdotuStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasZdotuStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) + hipblasZdotuStridedBatchedFortran = & + hipblasZdotuStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) return end function hipblasZdotuStridedBatchedFortran function hipblasZdotcStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(res) & - bind(c, name = 'hipblasZdotcStridedBatchedFortran') + bind(c, name='hipblasZdotcStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotcStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1126,82 +1188,87 @@ function hipblasZdotcStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasZdotcStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) + hipblasZdotcStridedBatchedFortran = & + hipblasZdotcStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) return end function hipblasZdotcStridedBatchedFortran ! swap function hipblasSswapFortran(handle, n, x, incx, y, incy) & - result(res) & - bind(c, name = 'hipblasSswapFortran') + bind(c, name='hipblasSswapFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSswapFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasSswap(handle, n, x, incx, y, incy) + hipblasSswapFortran = & + hipblasSswap(handle, n, x, incx, y, incy) return end function hipblasSswapFortran function hipblasDswapFortran(handle, n, x, incx, y, incy) & - result(res) & - bind(c, name = 'hipblasDswapFortran') + bind(c, name='hipblasDswapFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDswapFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasDswap(handle, n, x, incx, y, incy) + hipblasDswapFortran = & + hipblasDswap(handle, n, x, incx, y, incy) return end function hipblasDswapFortran function hipblasCswapFortran(handle, n, x, incx, y, incy) & - result(res) & - bind(c, name = 'hipblasCswapFortran') + bind(c, name='hipblasCswapFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCswapFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasCswap(handle, n, x, incx, y, incy) + hipblasCswapFortran = & + hipblasCswap(handle, n, x, incx, y, incy) return end function hipblasCswapFortran function hipblasZswapFortran(handle, n, x, incx, y, incy) & - result(res) & - bind(c, name = 'hipblasZswapFortran') + bind(c, name='hipblasZswapFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZswapFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasZswap(handle, n, x, incx, y, incy) + hipblasZswapFortran = & + hipblasZswap(handle, n, x, incx, y, incy) return end function hipblasZswapFortran ! swapBatched function hipblasSswapBatchedFortran(handle, n, x, incx, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasSswapBatchedFortran') + bind(c, name='hipblasSswapBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSswapBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1209,16 +1276,17 @@ function hipblasSswapBatchedFortran(handle, n, x, incx, y, incy, batch_count) & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSswapBatched(handle, n, x, incx, y, incy, batch_count) + hipblasSswapBatchedFortran = & + hipblasSswapBatched(handle, n, x, incx, y, incy, batch_count) return end function hipblasSswapBatchedFortran function hipblasDswapBatchedFortran(handle, n, x, incx, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasDswapBatchedFortran') + bind(c, name='hipblasDswapBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDswapBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1226,16 +1294,17 @@ function hipblasDswapBatchedFortran(handle, n, x, incx, y, incy, batch_count) & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDswapBatched(handle, n, x, incx, y, incy, batch_count) + hipblasDswapBatchedFortran = & + hipblasDswapBatched(handle, n, x, incx, y, incy, batch_count) return end function hipblasDswapBatchedFortran function hipblasCswapBatchedFortran(handle, n, x, incx, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasCswapBatchedFortran') + bind(c, name='hipblasCswapBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCswapBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1243,16 +1312,17 @@ function hipblasCswapBatchedFortran(handle, n, x, incx, y, incy, batch_count) & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCswapBatched(handle, n, x, incx, y, incy, batch_count) + hipblasCswapBatchedFortran = & + hipblasCswapBatched(handle, n, x, incx, y, incy, batch_count) return end function hipblasCswapBatchedFortran function hipblasZswapBatchedFortran(handle, n, x, incx, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasZswapBatchedFortran') + bind(c, name='hipblasZswapBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZswapBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1260,17 +1330,18 @@ function hipblasZswapBatchedFortran(handle, n, x, incx, y, incy, batch_count) & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZswapBatched(handle, n, x, incx, y, incy, batch_count) + hipblasZswapBatchedFortran = & + hipblasZswapBatched(handle, n, x, incx, y, incy, batch_count) return end function hipblasZswapBatchedFortran ! swapStridedBatched function hipblasSswapStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasSswapStridedBatchedFortran') + bind(c, name='hipblasSswapStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSswapStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1280,16 +1351,17 @@ function hipblasSswapStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSswapStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) + hipblasSswapStridedBatchedFortran = & + hipblasSswapStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) return end function hipblasSswapStridedBatchedFortran function hipblasDswapStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasDswapStridedBatchedFortran') + bind(c, name='hipblasDswapStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDswapStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1299,16 +1371,17 @@ function hipblasDswapStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDswapStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) + hipblasDswapStridedBatchedFortran = & + hipblasDswapStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) return end function hipblasDswapStridedBatchedFortran function hipblasCswapStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasCswapStridedBatchedFortran') + bind(c, name='hipblasCswapStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCswapStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1318,16 +1391,17 @@ function hipblasCswapStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCswapStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) + hipblasCswapStridedBatchedFortran = & + hipblasCswapStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) return end function hipblasCswapStridedBatchedFortran function hipblasZswapStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasZswapStridedBatchedFortran') + bind(c, name='hipblasZswapStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZswapStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1337,17 +1411,18 @@ function hipblasZswapStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZswapStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) + hipblasZswapStridedBatchedFortran = & + hipblasZswapStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) return end function hipblasZswapStridedBatchedFortran ! axpy function hipblasHaxpyFortran(handle, n, alpha, x, incx, y, incy) & - result(res) & - bind(c, name = 'hipblasHaxpyFortran') + bind(c, name='hipblasHaxpyFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHaxpyFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1355,16 +1430,17 @@ function hipblasHaxpyFortran(handle, n, alpha, x, incx, y, incy) & integer(c_int), value :: incx type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasHaxpy(handle, n, alpha, x, incx, y, incy) + hipblasHaxpyFortran = & + hipblasHaxpy(handle, n, alpha, x, incx, y, incy) return end function hipblasHaxpyFortran function hipblasSaxpyFortran(handle, n, alpha, x, incx, y, incy) & - result(res) & - bind(c, name = 'hipblasSaxpyFortran') + bind(c, name='hipblasSaxpyFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpyFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1372,16 +1448,17 @@ function hipblasSaxpyFortran(handle, n, alpha, x, incx, y, incy) & integer(c_int), value :: incx type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasSaxpy(handle, n, alpha, x, incx, y, incy) + hipblasSaxpyFortran = & + hipblasSaxpy(handle, n, alpha, x, incx, y, incy) return end function hipblasSaxpyFortran function hipblasDaxpyFortran(handle, n, alpha, x, incx, y, incy) & - result(res) & - bind(c, name = 'hipblasDaxpyFortran') + bind(c, name='hipblasDaxpyFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpyFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1389,16 +1466,17 @@ function hipblasDaxpyFortran(handle, n, alpha, x, incx, y, incy) & integer(c_int), value :: incx type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasDaxpy(handle, n, alpha, x, incx, y, incy) + hipblasDaxpyFortran = & + hipblasDaxpy(handle, n, alpha, x, incx, y, incy) return end function hipblasDaxpyFortran function hipblasCaxpyFortran(handle, n, alpha, x, incx, y, incy) & - result(res) & - bind(c, name = 'hipblasCaxpyFortran') + bind(c, name='hipblasCaxpyFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpyFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1406,16 +1484,17 @@ function hipblasCaxpyFortran(handle, n, alpha, x, incx, y, incy) & integer(c_int), value :: incx type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasCaxpy(handle, n, alpha, x, incx, y, incy) + hipblasCaxpyFortran = & + hipblasCaxpy(handle, n, alpha, x, incx, y, incy) return end function hipblasCaxpyFortran function hipblasZaxpyFortran(handle, n, alpha, x, incx, y, incy) & - result(res) & - bind(c, name = 'hipblasZaxpyFortran') + bind(c, name='hipblasZaxpyFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpyFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1423,17 +1502,18 @@ function hipblasZaxpyFortran(handle, n, alpha, x, incx, y, incy) & integer(c_int), value :: incx type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasZaxpy(handle, n, alpha, x, incx, y, incy) + hipblasZaxpyFortran = & + hipblasZaxpy(handle, n, alpha, x, incx, y, incy) return end function hipblasZaxpyFortran ! axpyBatched function hipblasHaxpyBatchedFortran(handle, n, alpha, x, incx, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasHaxpyBatchedFortran') + bind(c, name='hipblasHaxpyBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHaxpyBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1442,16 +1522,17 @@ function hipblasHaxpyBatchedFortran(handle, n, alpha, x, incx, y, incy, batch_co type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasHaxpyBatched(handle, n, alpha, x, incx, y, incy, batch_count) + hipblasHaxpyBatchedFortran = & + hipblasHaxpyBatched(handle, n, alpha, x, incx, y, incy, batch_count) return end function hipblasHaxpyBatchedFortran function hipblasSaxpyBatchedFortran(handle, n, alpha, x, incx, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasSaxpyBatchedFortran') + bind(c, name='hipblasSaxpyBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpyBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1460,16 +1541,17 @@ function hipblasSaxpyBatchedFortran(handle, n, alpha, x, incx, y, incy, batch_co type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSaxpyBatched(handle, n, alpha, x, incx, y, incy, batch_count) + hipblasSaxpyBatchedFortran = & + hipblasSaxpyBatched(handle, n, alpha, x, incx, y, incy, batch_count) return end function hipblasSaxpyBatchedFortran function hipblasDaxpyBatchedFortran(handle, n, alpha, x, incx, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasDaxpyBatchedFortran') + bind(c, name='hipblasDaxpyBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpyBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1478,16 +1560,17 @@ function hipblasDaxpyBatchedFortran(handle, n, alpha, x, incx, y, incy, batch_co type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDaxpyBatched(handle, n, alpha, x, incx, y, incy, batch_count) + hipblasDaxpyBatchedFortran = & + hipblasDaxpyBatched(handle, n, alpha, x, incx, y, incy, batch_count) return end function hipblasDaxpyBatchedFortran function hipblasCaxpyBatchedFortran(handle, n, alpha, x, incx, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasCaxpyBatchedFortran') + bind(c, name='hipblasCaxpyBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpyBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1496,16 +1579,17 @@ function hipblasCaxpyBatchedFortran(handle, n, alpha, x, incx, y, incy, batch_co type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCaxpyBatched(handle, n, alpha, x, incx, y, incy, batch_count) + hipblasCaxpyBatchedFortran = & + hipblasCaxpyBatched(handle, n, alpha, x, incx, y, incy, batch_count) return end function hipblasCaxpyBatchedFortran function hipblasZaxpyBatchedFortran(handle, n, alpha, x, incx, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasZaxpyBatchedFortran') + bind(c, name='hipblasZaxpyBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpyBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1514,17 +1598,18 @@ function hipblasZaxpyBatchedFortran(handle, n, alpha, x, incx, y, incy, batch_co type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZaxpyBatched(handle, n, alpha, x, incx, y, incy, batch_count) + hipblasZaxpyBatchedFortran = & + hipblasZaxpyBatched(handle, n, alpha, x, incx, y, incy, batch_count) return end function hipblasZaxpyBatchedFortran ! axpyStridedBatched function hipblasHaxpyStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasHaxpyStridedBatchedFortran') + bind(c, name='hipblasHaxpyStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHaxpyStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1535,16 +1620,17 @@ function hipblasHaxpyStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasHaxpyStridedBatched(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) + hipblasHaxpyStridedBatchedFortran = & + hipblasHaxpyStridedBatched(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) return end function hipblasHaxpyStridedBatchedFortran function hipblasSaxpyStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasSaxpyStridedBatchedFortran') + bind(c, name='hipblasSaxpyStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpyStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1555,16 +1641,17 @@ function hipblasSaxpyStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSaxpyStridedBatched(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) + hipblasSaxpyStridedBatchedFortran = & + hipblasSaxpyStridedBatched(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) return end function hipblasSaxpyStridedBatchedFortran function hipblasDaxpyStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasDaxpyStridedBatchedFortran') + bind(c, name='hipblasDaxpyStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpyStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1575,16 +1662,17 @@ function hipblasDaxpyStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDaxpyStridedBatched(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) + hipblasDaxpyStridedBatchedFortran = & + hipblasDaxpyStridedBatched(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) return end function hipblasDaxpyStridedBatchedFortran function hipblasCaxpyStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasCaxpyStridedBatchedFortran') + bind(c, name='hipblasCaxpyStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpyStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1595,16 +1683,17 @@ function hipblasCaxpyStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCaxpyStridedBatched(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) + hipblasCaxpyStridedBatchedFortran = & + hipblasCaxpyStridedBatched(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) return end function hipblasCaxpyStridedBatchedFortran function hipblasZaxpyStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasZaxpyStridedBatchedFortran') + bind(c, name='hipblasZaxpyStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpyStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1615,143 +1704,152 @@ function hipblasZaxpyStridedBatchedFortran(handle, n, alpha, x, incx, stride_x, integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZaxpyStridedBatched(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) + hipblasZaxpyStridedBatchedFortran = & + hipblasZaxpyStridedBatched(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) return end function hipblasZaxpyStridedBatchedFortran ! asum function hipblasSasumFortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasSasumFortran') + bind(c, name='hipblasSasumFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSasumFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasSasum(handle, n, x, incx, result) + hipblasSasumFortran = & + hipblasSasum(handle, n, x, incx, result) return end function hipblasSasumFortran function hipblasDasumFortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasDasumFortran') + bind(c, name='hipblasDasumFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDasumFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasDasum(handle, n, x, incx, result) + hipblasDasumFortran = & + hipblasDasum(handle, n, x, incx, result) return end function hipblasDasumFortran function hipblasScasumFortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasScasumFortran') + bind(c, name='hipblasScasumFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScasumFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasScasum(handle, n, x, incx, result) + hipblasScasumFortran = & + hipblasScasum(handle, n, x, incx, result) return end function hipblasScasumFortran function hipblasDzasumFortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasDzasumFortran') + bind(c, name='hipblasDzasumFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDzasumFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasDzasum(handle, n, x, incx, result) + hipblasDzasumFortran = & + hipblasDzasum(handle, n, x, incx, result) return end function hipblasDzasumFortran ! asumBatched function hipblasSasumBatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasSasumBatchedFortran') + bind(c, name='hipblasSasumBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSasumBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasSasumBatched(handle, n, x, incx, batch_count, result) + hipblasSasumBatchedFortran = & + hipblasSasumBatched(handle, n, x, incx, batch_count, result) return end function hipblasSasumBatchedFortran function hipblasDasumBatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasDasumBatchedFortran') + bind(c, name='hipblasDasumBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDasumBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasDasumBatched(handle, n, x, incx, batch_count, result) + hipblasDasumBatchedFortran = & + hipblasDasumBatched(handle, n, x, incx, batch_count, result) return end function hipblasDasumBatchedFortran function hipblasScasumBatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasScasumBatchedFortran') + bind(c, name='hipblasScasumBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScasumBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasScasumBatched(handle, n, x, incx, batch_count, result) + hipblasScasumBatchedFortran = & + hipblasScasumBatched(handle, n, x, incx, batch_count, result) return end function hipblasScasumBatchedFortran function hipblasDzasumBatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasDzasumBatchedFortran') + bind(c, name='hipblasDzasumBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDzasumBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasDzasumBatched(handle, n, x, incx, batch_count, result) + hipblasDzasumBatchedFortran = & + hipblasDzasumBatched(handle, n, x, incx, batch_count, result) return end function hipblasDzasumBatchedFortran ! asumStridedBatched function hipblasSasumStridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasSasumStridedBatchedFortran') + bind(c, name='hipblasSasumStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSasumStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1759,16 +1857,17 @@ function hipblasSasumStridedBatchedFortran(handle, n, x, incx, stride_x, batch_c integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasSasumStridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasSasumStridedBatchedFortran = & + hipblasSasumStridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasSasumStridedBatchedFortran function hipblasDasumStridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasDasumStridedBatchedFortran') + bind(c, name='hipblasDasumStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDasumStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1776,16 +1875,17 @@ function hipblasDasumStridedBatchedFortran(handle, n, x, incx, stride_x, batch_c integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasDasumStridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasDasumStridedBatchedFortran = & + hipblasDasumStridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasDasumStridedBatchedFortran function hipblasScasumStridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasScasumStridedBatchedFortran') + bind(c, name='hipblasScasumStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScasumStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1793,16 +1893,17 @@ function hipblasScasumStridedBatchedFortran(handle, n, x, incx, stride_x, batch_ integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasScasumStridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasScasumStridedBatchedFortran = & + hipblasScasumStridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasScasumStridedBatchedFortran function hipblasDzasumStridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasDzasumStridedBatchedFortran') + bind(c, name='hipblasDzasumStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDzasumStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1810,143 +1911,152 @@ function hipblasDzasumStridedBatchedFortran(handle, n, x, incx, stride_x, batch_ integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasDzasumStridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasDzasumStridedBatchedFortran = & + hipblasDzasumStridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasDzasumStridedBatchedFortran ! nrm2 function hipblasSnrm2Fortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasSnrm2Fortran') + bind(c, name='hipblasSnrm2Fortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSnrm2Fortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasSnrm2(handle, n, x, incx, result) + hipblasSnrm2Fortran = & + hipblasSnrm2(handle, n, x, incx, result) return end function hipblasSnrm2Fortran function hipblasDnrm2Fortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasDnrm2Fortran') + bind(c, name='hipblasDnrm2Fortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDnrm2Fortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasDnrm2(handle, n, x, incx, result) + hipblasDnrm2Fortran = & + hipblasDnrm2(handle, n, x, incx, result) return end function hipblasDnrm2Fortran function hipblasScnrm2Fortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasScnrm2Fortran') + bind(c, name='hipblasScnrm2Fortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScnrm2Fortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasScnrm2(handle, n, x, incx, result) + hipblasScnrm2Fortran = & + hipblasScnrm2(handle, n, x, incx, result) return end function hipblasScnrm2Fortran function hipblasDznrm2Fortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasDznrm2Fortran') + bind(c, name='hipblasDznrm2Fortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDznrm2Fortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasDznrm2(handle, n, x, incx, result) + hipblasDznrm2Fortran = & + hipblasDznrm2(handle, n, x, incx, result) return end function hipblasDznrm2Fortran ! nrm2Batched function hipblasSnrm2BatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasSnrm2BatchedFortran') + bind(c, name='hipblasSnrm2BatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSnrm2BatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasSnrm2Batched(handle, n, x, incx, batch_count, result) + hipblasSnrm2BatchedFortran = & + hipblasSnrm2Batched(handle, n, x, incx, batch_count, result) return end function hipblasSnrm2BatchedFortran function hipblasDnrm2BatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasDnrm2BatchedFortran') + bind(c, name='hipblasDnrm2BatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDnrm2BatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasDnrm2Batched(handle, n, x, incx, batch_count, result) + hipblasDnrm2BatchedFortran = & + hipblasDnrm2Batched(handle, n, x, incx, batch_count, result) return end function hipblasDnrm2BatchedFortran function hipblasScnrm2BatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasScnrm2BatchedFortran') + bind(c, name='hipblasScnrm2BatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScnrm2BatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasScnrm2Batched(handle, n, x, incx, batch_count, result) + hipblasScnrm2BatchedFortran = & + hipblasScnrm2Batched(handle, n, x, incx, batch_count, result) return end function hipblasScnrm2BatchedFortran function hipblasDznrm2BatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasDznrm2BatchedFortran') + bind(c, name='hipblasDznrm2BatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDznrm2BatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasDznrm2Batched(handle, n, x, incx, batch_count, result) + hipblasDznrm2BatchedFortran = & + hipblasDznrm2Batched(handle, n, x, incx, batch_count, result) return end function hipblasDznrm2BatchedFortran ! nrm2StridedBatched function hipblasSnrm2StridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasSnrm2StridedBatchedFortran') + bind(c, name='hipblasSnrm2StridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSnrm2StridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1954,16 +2064,17 @@ function hipblasSnrm2StridedBatchedFortran(handle, n, x, incx, stride_x, batch_c integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasSnrm2StridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasSnrm2StridedBatchedFortran = & + hipblasSnrm2StridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasSnrm2StridedBatchedFortran function hipblasDnrm2StridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasDnrm2StridedBatchedFortran') + bind(c, name='hipblasDnrm2StridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDnrm2StridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1971,16 +2082,17 @@ function hipblasDnrm2StridedBatchedFortran(handle, n, x, incx, stride_x, batch_c integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasDnrm2StridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasDnrm2StridedBatchedFortran = & + hipblasDnrm2StridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasDnrm2StridedBatchedFortran function hipblasScnrm2StridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasScnrm2StridedBatchedFortran') + bind(c, name='hipblasScnrm2StridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScnrm2StridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1988,16 +2100,17 @@ function hipblasScnrm2StridedBatchedFortran(handle, n, x, incx, stride_x, batch_ integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasScnrm2StridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasScnrm2StridedBatchedFortran = & + hipblasScnrm2StridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasScnrm2StridedBatchedFortran function hipblasDznrm2StridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasDznrm2StridedBatchedFortran') + bind(c, name='hipblasDznrm2StridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDznrm2StridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2005,143 +2118,152 @@ function hipblasDznrm2StridedBatchedFortran(handle, n, x, incx, stride_x, batch_ integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasDznrm2StridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasDznrm2StridedBatchedFortran = & + hipblasDznrm2StridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasDznrm2StridedBatchedFortran ! amax function hipblasIsamaxFortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasIsamaxFortran') + bind(c, name='hipblasIsamaxFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamaxFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIsamax(handle, n, x, incx, result) + hipblasIsamaxFortran = & + hipblasIsamax(handle, n, x, incx, result) return end function hipblasIsamaxFortran function hipblasIdamaxFortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasIdamaxFortran') + bind(c, name='hipblasIdamaxFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamaxFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIdamax(handle, n, x, incx, result) + hipblasIdamaxFortran = & + hipblasIdamax(handle, n, x, incx, result) return end function hipblasIdamaxFortran function hipblasIcamaxFortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasIcamaxFortran') + bind(c, name='hipblasIcamaxFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamaxFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIcamax(handle, n, x, incx, result) + hipblasIcamaxFortran = & + hipblasIcamax(handle, n, x, incx, result) return end function hipblasIcamaxFortran function hipblasIzamaxFortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasIzamaxFortran') + bind(c, name='hipblasIzamaxFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamaxFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIzamax(handle, n, x, incx, result) + hipblasIzamaxFortran = & + hipblasIzamax(handle, n, x, incx, result) return end function hipblasIzamaxFortran ! amaxBatched function hipblasIsamaxBatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIsamaxBatchedFortran') + bind(c, name='hipblasIsamaxBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamaxBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIsamaxBatched(handle, n, x, incx, batch_count, result) + hipblasIsamaxBatchedFortran = & + hipblasIsamaxBatched(handle, n, x, incx, batch_count, result) return end function hipblasIsamaxBatchedFortran function hipblasIdamaxBatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIdamaxBatchedFortran') + bind(c, name='hipblasIdamaxBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamaxBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIdamaxBatched(handle, n, x, incx, batch_count, result) + hipblasIdamaxBatchedFortran = & + hipblasIdamaxBatched(handle, n, x, incx, batch_count, result) return end function hipblasIdamaxBatchedFortran function hipblasIcamaxBatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIcamaxBatchedFortran') + bind(c, name='hipblasIcamaxBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamaxBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIcamaxBatched(handle, n, x, incx, batch_count, result) + hipblasIcamaxBatchedFortran = & + hipblasIcamaxBatched(handle, n, x, incx, batch_count, result) return end function hipblasIcamaxBatchedFortran function hipblasIzamaxBatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIzamaxBatchedFortran') + bind(c, name='hipblasIzamaxBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamaxBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIzamaxBatched(handle, n, x, incx, batch_count, result) + hipblasIzamaxBatchedFortran = & + hipblasIzamaxBatched(handle, n, x, incx, batch_count, result) return end function hipblasIzamaxBatchedFortran ! amaxStridedBatched function hipblasIsamaxStridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIsamaxStridedBatchedFortran') + bind(c, name='hipblasIsamaxStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamaxStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2149,16 +2271,17 @@ function hipblasIsamaxStridedBatchedFortran(handle, n, x, incx, stride_x, batch_ integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIsamaxStridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasIsamaxStridedBatchedFortran = & + hipblasIsamaxStridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasIsamaxStridedBatchedFortran function hipblasIdamaxStridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIdamaxStridedBatchedFortran') + bind(c, name='hipblasIdamaxStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamaxStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2166,16 +2289,17 @@ function hipblasIdamaxStridedBatchedFortran(handle, n, x, incx, stride_x, batch_ integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIdamaxStridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasIdamaxStridedBatchedFortran = & + hipblasIdamaxStridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasIdamaxStridedBatchedFortran function hipblasIcamaxStridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIcamaxStridedBatchedFortran') + bind(c, name='hipblasIcamaxStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamaxStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2183,16 +2307,17 @@ function hipblasIcamaxStridedBatchedFortran(handle, n, x, incx, stride_x, batch_ integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIcamaxStridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasIcamaxStridedBatchedFortran = & + hipblasIcamaxStridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasIcamaxStridedBatchedFortran function hipblasIzamaxStridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIzamaxStridedBatchedFortran') + bind(c, name='hipblasIzamaxStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamaxStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2200,143 +2325,152 @@ function hipblasIzamaxStridedBatchedFortran(handle, n, x, incx, stride_x, batch_ integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIzamaxStridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasIzamaxStridedBatchedFortran = & + hipblasIzamaxStridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasIzamaxStridedBatchedFortran ! amin function hipblasIsaminFortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasIsaminFortran') + bind(c, name='hipblasIsaminFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsaminFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIsamin(handle, n, x, incx, result) + hipblasIsaminFortran = & + hipblasIsamin(handle, n, x, incx, result) return end function hipblasIsaminFortran function hipblasIdaminFortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasIdaminFortran') + bind(c, name='hipblasIdaminFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdaminFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIdamin(handle, n, x, incx, result) + hipblasIdaminFortran = & + hipblasIdamin(handle, n, x, incx, result) return end function hipblasIdaminFortran function hipblasIcaminFortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasIcaminFortran') + bind(c, name='hipblasIcaminFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcaminFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIcamin(handle, n, x, incx, result) + hipblasIcaminFortran = & + hipblasIcamin(handle, n, x, incx, result) return end function hipblasIcaminFortran function hipblasIzaminFortran(handle, n, x, incx, result) & - result(res) & - bind(c, name = 'hipblasIzaminFortran') + bind(c, name='hipblasIzaminFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzaminFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIzamin(handle, n, x, incx, result) + hipblasIzaminFortran = & + hipblasIzamin(handle, n, x, incx, result) return end function hipblasIzaminFortran ! aminBatched function hipblasIsaminBatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIsaminBatchedFortran') + bind(c, name='hipblasIsaminBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsaminBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIsaminBatched(handle, n, x, incx, batch_count, result) + hipblasIsaminBatchedFortran = & + hipblasIsaminBatched(handle, n, x, incx, batch_count, result) return end function hipblasIsaminBatchedFortran function hipblasIdaminBatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIdaminBatchedFortran') + bind(c, name='hipblasIdaminBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdaminBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIdaminBatched(handle, n, x, incx, batch_count, result) + hipblasIdaminBatchedFortran = & + hipblasIdaminBatched(handle, n, x, incx, batch_count, result) return end function hipblasIdaminBatchedFortran function hipblasIcaminBatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIcaminBatchedFortran') + bind(c, name='hipblasIcaminBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcaminBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIcaminBatched(handle, n, x, incx, batch_count, result) + hipblasIcaminBatchedFortran = & + hipblasIcaminBatched(handle, n, x, incx, batch_count, result) return end function hipblasIcaminBatchedFortran function hipblasIzaminBatchedFortran(handle, n, x, incx, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIzaminBatchedFortran') + bind(c, name='hipblasIzaminBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzaminBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIzaminBatched(handle, n, x, incx, batch_count, result) + hipblasIzaminBatchedFortran = & + hipblasIzaminBatched(handle, n, x, incx, batch_count, result) return end function hipblasIzaminBatchedFortran ! aminStridedBatched function hipblasIsaminStridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIsaminStridedBatchedFortran') + bind(c, name='hipblasIsaminStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsaminStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2344,16 +2478,17 @@ function hipblasIsaminStridedBatchedFortran(handle, n, x, incx, stride_x, batch_ integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIsaminStridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasIsaminStridedBatchedFortran = & + hipblasIsaminStridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasIsaminStridedBatchedFortran function hipblasIdaminStridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIdaminStridedBatchedFortran') + bind(c, name='hipblasIdaminStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdaminStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2361,16 +2496,17 @@ function hipblasIdaminStridedBatchedFortran(handle, n, x, incx, stride_x, batch_ integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIdaminStridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasIdaminStridedBatchedFortran = & + hipblasIdaminStridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasIdaminStridedBatchedFortran function hipblasIcaminStridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIcaminStridedBatchedFortran') + bind(c, name='hipblasIcaminStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcaminStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2378,16 +2514,17 @@ function hipblasIcaminStridedBatchedFortran(handle, n, x, incx, stride_x, batch_ integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIcaminStridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasIcaminStridedBatchedFortran = & + hipblasIcaminStridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasIcaminStridedBatchedFortran function hipblasIzaminStridedBatchedFortran(handle, n, x, incx, stride_x, batch_count, result) & - result(res) & - bind(c, name = 'hipblasIzaminStridedBatchedFortran') + bind(c, name='hipblasIzaminStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzaminStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2395,17 +2532,18 @@ function hipblasIzaminStridedBatchedFortran(handle, n, x, incx, stride_x, batch_ integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count type(c_ptr), value :: result - integer(c_int) :: res - res = hipblasIzaminStridedBatched(handle, n, x, incx, stride_x, batch_count, result) + hipblasIzaminStridedBatchedFortran = & + hipblasIzaminStridedBatched(handle, n, x, incx, stride_x, batch_count, result) return end function hipblasIzaminStridedBatchedFortran ! rot function hipblasSrotFortran(handle, n, x, incx, y, incy, c, s) & - result(res) & - bind(c, name = 'hipblasSrotFortran') + bind(c, name='hipblasSrotFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2414,16 +2552,17 @@ function hipblasSrotFortran(handle, n, x, incx, y, incy, c, s) & integer(c_int), value :: incy type(c_ptr), value :: c type(c_ptr), value :: s - integer(c_int) :: res - res = hipblasSrot(handle, n, x, incx, y, incy, c, s) + hipblasSrotFortran = & + hipblasSrot(handle, n, x, incx, y, incy, c, s) return end function hipblasSrotFortran function hipblasDrotFortran(handle, n, x, incx, y, incy, c, s) & - result(res) & - bind(c, name = 'hipblasDrotFortran') + bind(c, name='hipblasDrotFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2432,16 +2571,17 @@ function hipblasDrotFortran(handle, n, x, incx, y, incy, c, s) & integer(c_int), value :: incy type(c_ptr), value :: c type(c_ptr), value :: s - integer(c_int) :: res - res = hipblasDrot(handle, n, x, incx, y, incy, c, s) + hipblasDrotFortran = & + hipblasDrot(handle, n, x, incx, y, incy, c, s) return end function hipblasDrotFortran function hipblasCrotFortran(handle, n, x, incx, y, incy, c, s) & - result(res) & - bind(c, name = 'hipblasCrotFortran') + bind(c, name='hipblasCrotFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2450,16 +2590,17 @@ function hipblasCrotFortran(handle, n, x, incx, y, incy, c, s) & integer(c_int), value :: incy type(c_ptr), value :: c type(c_ptr), value :: s - integer(c_int) :: res - res = hipblasCrot(handle, n, x, incx, y, incy, c, s) + hipblasCrotFortran = & + hipblasCrot(handle, n, x, incx, y, incy, c, s) return end function hipblasCrotFortran function hipblasCsrotFortran(handle, n, x, incx, y, incy, c, s) & - result(res) & - bind(c, name = 'hipblasCsrotFortran') + bind(c, name='hipblasCsrotFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsrotFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2468,16 +2609,17 @@ function hipblasCsrotFortran(handle, n, x, incx, y, incy, c, s) & integer(c_int), value :: incy type(c_ptr), value :: c type(c_ptr), value :: s - integer(c_int) :: res - res = hipblasCsrot(handle, n, x, incx, y, incy, c, s) + hipblasCsrotFortran = & + hipblasCsrot(handle, n, x, incx, y, incy, c, s) return end function hipblasCsrotFortran function hipblasZrotFortran(handle, n, x, incx, y, incy, c, s) & - result(res) & - bind(c, name = 'hipblasZrotFortran') + bind(c, name='hipblasZrotFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2486,16 +2628,17 @@ function hipblasZrotFortran(handle, n, x, incx, y, incy, c, s) & integer(c_int), value :: incy type(c_ptr), value :: c type(c_ptr), value :: s - integer(c_int) :: res - res = hipblasZrot(handle, n, x, incx, y, incy, c, s) + hipblasZrotFortran = & + hipblasZrot(handle, n, x, incx, y, incy, c, s) return end function hipblasZrotFortran function hipblasZdrotFortran(handle, n, x, incx, y, incy, c, s) & - result(res) & - bind(c, name = 'hipblasZdrotFortran') + bind(c, name='hipblasZdrotFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdrotFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2504,17 +2647,18 @@ function hipblasZdrotFortran(handle, n, x, incx, y, incy, c, s) & integer(c_int), value :: incy type(c_ptr), value :: c type(c_ptr), value :: s - integer(c_int) :: res - res = hipblasZdrot(handle, n, x, incx, y, incy, c, s) + hipblasZdrotFortran = & + hipblasZdrot(handle, n, x, incx, y, incy, c, s) return end function hipblasZdrotFortran ! rotBatched function hipblasSrotBatchedFortran(handle, n, x, incx, y, incy, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasSrotBatchedFortran') + bind(c, name='hipblasSrotBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2524,16 +2668,17 @@ function hipblasSrotBatchedFortran(handle, n, x, incx, y, incy, c, s, batch_coun type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) + hipblasSrotBatchedFortran = & + hipblasSrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) return end function hipblasSrotBatchedFortran function hipblasDrotBatchedFortran(handle, n, x, incx, y, incy, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasDrotBatchedFortran') + bind(c, name='hipblasDrotBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2543,16 +2688,17 @@ function hipblasDrotBatchedFortran(handle, n, x, incx, y, incy, c, s, batch_coun type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) + hipblasDrotBatchedFortran = & + hipblasDrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) return end function hipblasDrotBatchedFortran function hipblasCrotBatchedFortran(handle, n, x, incx, y, incy, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasCrotBatchedFortran') + bind(c, name='hipblasCrotBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2562,16 +2708,17 @@ function hipblasCrotBatchedFortran(handle, n, x, incx, y, incy, c, s, batch_coun type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) + hipblasCrotBatchedFortran = & + hipblasCrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) return end function hipblasCrotBatchedFortran function hipblasCsrotBatchedFortran(handle, n, x, incx, y, incy, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasCsrotBatchedFortran') + bind(c, name='hipblasCsrotBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsrotBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2581,16 +2728,17 @@ function hipblasCsrotBatchedFortran(handle, n, x, incx, y, incy, c, s, batch_cou type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) + hipblasCsrotBatchedFortran = & + hipblasCsrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) return end function hipblasCsrotBatchedFortran function hipblasZrotBatchedFortran(handle, n, x, incx, y, incy, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasZrotBatchedFortran') + bind(c, name='hipblasZrotBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2600,16 +2748,17 @@ function hipblasZrotBatchedFortran(handle, n, x, incx, y, incy, c, s, batch_coun type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) + hipblasZrotBatchedFortran = & + hipblasZrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) return end function hipblasZrotBatchedFortran function hipblasZdrotBatchedFortran(handle, n, x, incx, y, incy, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasZdrotBatchedFortran') + bind(c, name='hipblasZdrotBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdrotBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2619,17 +2768,18 @@ function hipblasZdrotBatchedFortran(handle, n, x, incx, y, incy, c, s, batch_cou type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZdrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) + hipblasZdrotBatchedFortran = & + hipblasZdrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) return end function hipblasZdrotBatchedFortran ! rotStridedBatched function hipblasSrotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasSrotStridedBatchedFortran') + bind(c, name='hipblasSrotStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2641,16 +2791,17 @@ function hipblasSrotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) + hipblasSrotStridedBatchedFortran = & + hipblasSrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) return end function hipblasSrotStridedBatchedFortran function hipblasDrotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasDrotStridedBatchedFortran') + bind(c, name='hipblasDrotStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2662,16 +2813,17 @@ function hipblasDrotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) + hipblasDrotStridedBatchedFortran = & + hipblasDrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) return end function hipblasDrotStridedBatchedFortran function hipblasCrotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasCrotStridedBatchedFortran') + bind(c, name='hipblasCrotStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2683,16 +2835,17 @@ function hipblasCrotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) + hipblasCrotStridedBatchedFortran = & + hipblasCrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) return end function hipblasCrotStridedBatchedFortran function hipblasCsrotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasCsrotStridedBatchedFortran') + bind(c, name='hipblasCsrotStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsrotStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2704,16 +2857,17 @@ function hipblasCsrotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) + hipblasCsrotStridedBatchedFortran = & + hipblasCsrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) return end function hipblasCsrotStridedBatchedFortran function hipblasZrotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasZrotStridedBatchedFortran') + bind(c, name='hipblasZrotStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2725,16 +2879,17 @@ function hipblasZrotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) + hipblasZrotStridedBatchedFortran = & + hipblasZrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) return end function hipblasZrotStridedBatchedFortran function hipblasZdrotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasZdrotStridedBatchedFortran') + bind(c, name='hipblasZdrotStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdrotStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2746,143 +2901,152 @@ function hipblasZdrotStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZdrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) + hipblasZdrotStridedBatchedFortran = & + hipblasZdrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) return end function hipblasZdrotStridedBatchedFortran ! rotg function hipblasSrotgFortran(handle, a, b, c, s) & - result(res) & - bind(c, name = 'hipblasSrotgFortran') + bind(c, name='hipblasSrotgFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotgFortran type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b type(c_ptr), value :: c type(c_ptr), value :: s - integer(c_int) :: res - res = hipblasSrotg(handle, a, b, c, s) + hipblasSrotgFortran = & + hipblasSrotg(handle, a, b, c, s) return end function hipblasSrotgFortran function hipblasDrotgFortran(handle, a, b, c, s) & - result(res) & - bind(c, name = 'hipblasDrotgFortran') + bind(c, name='hipblasDrotgFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotgFortran type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b type(c_ptr), value :: c type(c_ptr), value :: s - integer(c_int) :: res - res = hipblasDrotg(handle, a, b, c, s) + hipblasDrotgFortran = & + hipblasDrotg(handle, a, b, c, s) return end function hipblasDrotgFortran function hipblasCrotgFortran(handle, a, b, c, s) & - result(res) & - bind(c, name = 'hipblasCrotgFortran') + bind(c, name='hipblasCrotgFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotgFortran type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b type(c_ptr), value :: c type(c_ptr), value :: s - integer(c_int) :: res - res = hipblasCrotg(handle, a, b, c, s) + hipblasCrotgFortran = & + hipblasCrotg(handle, a, b, c, s) return end function hipblasCrotgFortran function hipblasZrotgFortran(handle, a, b, c, s) & - result(res) & - bind(c, name = 'hipblasZrotgFortran') + bind(c, name='hipblasZrotgFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotgFortran type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b type(c_ptr), value :: c type(c_ptr), value :: s - integer(c_int) :: res - res = hipblasZrotg(handle, a, b, c, s) + hipblasZrotgFortran = & + hipblasZrotg(handle, a, b, c, s) return end function hipblasZrotgFortran ! rotgBatched function hipblasSrotgBatchedFortran(handle, a, b, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasSrotgBatchedFortran') + bind(c, name='hipblasSrotgBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotgBatchedFortran type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSrotgBatched(handle, a, b, c, s, batch_count) + hipblasSrotgBatchedFortran = & + hipblasSrotgBatched(handle, a, b, c, s, batch_count) return end function hipblasSrotgBatchedFortran function hipblasDrotgBatchedFortran(handle, a, b, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasDrotgBatchedFortran') + bind(c, name='hipblasDrotgBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotgBatchedFortran type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDrotgBatched(handle, a, b, c, s, batch_count) + hipblasDrotgBatchedFortran = & + hipblasDrotgBatched(handle, a, b, c, s, batch_count) return end function hipblasDrotgBatchedFortran function hipblasCrotgBatchedFortran(handle, a, b, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasCrotgBatchedFortran') + bind(c, name='hipblasCrotgBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotgBatchedFortran type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCrotgBatched(handle, a, b, c, s, batch_count) + hipblasCrotgBatchedFortran = & + hipblasCrotgBatched(handle, a, b, c, s, batch_count) return end function hipblasCrotgBatchedFortran function hipblasZrotgBatchedFortran(handle, a, b, c, s, batch_count) & - result(res) & - bind(c, name = 'hipblasZrotgBatchedFortran') + bind(c, name='hipblasZrotgBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotgBatchedFortran type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b type(c_ptr), value :: c type(c_ptr), value :: s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZrotgBatched(handle, a, b, c, s, batch_count) + hipblasZrotgBatchedFortran = & + hipblasZrotgBatched(handle, a, b, c, s, batch_count) return end function hipblasZrotgBatchedFortran ! rotgStridedBatched function hipblasSrotgStridedBatchedFortran(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) & - result(res) & - bind(c, name = 'hipblasSrotgStridedBatchedFortran') + bind(c, name='hipblasSrotgStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotgStridedBatchedFortran type(c_ptr), value :: handle type(c_ptr), value :: a integer(c_int64_t), value :: stride_a @@ -2893,16 +3057,17 @@ function hipblasSrotgStridedBatchedFortran(handle, a, stride_a, b, stride_b, c, type(c_ptr), value :: s integer(c_int64_t), value :: stride_s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSrotgStridedBatched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) + hipblasSrotgStridedBatchedFortran = & + hipblasSrotgStridedBatched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) return end function hipblasSrotgStridedBatchedFortran function hipblasDrotgStridedBatchedFortran(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) & - result(res) & - bind(c, name = 'hipblasDrotgStridedBatchedFortran') + bind(c, name='hipblasDrotgStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotgStridedBatchedFortran type(c_ptr), value :: handle type(c_ptr), value :: a integer(c_int64_t), value :: stride_a @@ -2913,16 +3078,17 @@ function hipblasDrotgStridedBatchedFortran(handle, a, stride_a, b, stride_b, c, type(c_ptr), value :: s integer(c_int64_t), value :: stride_s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDrotgStridedBatched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) + hipblasDrotgStridedBatchedFortran = & + hipblasDrotgStridedBatched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) return end function hipblasDrotgStridedBatchedFortran function hipblasCrotgStridedBatchedFortran(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) & - result(res) & - bind(c, name = 'hipblasCrotgStridedBatchedFortran') + bind(c, name='hipblasCrotgStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotgStridedBatchedFortran type(c_ptr), value :: handle type(c_ptr), value :: a integer(c_int64_t), value :: stride_a @@ -2933,16 +3099,17 @@ function hipblasCrotgStridedBatchedFortran(handle, a, stride_a, b, stride_b, c, type(c_ptr), value :: s integer(c_int64_t), value :: stride_s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCrotgStridedBatched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) + hipblasCrotgStridedBatchedFortran = & + hipblasCrotgStridedBatched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) return end function hipblasCrotgStridedBatchedFortran function hipblasZrotgStridedBatchedFortran(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) & - result(res) & - bind(c, name = 'hipblasZrotgStridedBatchedFortran') + bind(c, name='hipblasZrotgStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotgStridedBatchedFortran type(c_ptr), value :: handle type(c_ptr), value :: a integer(c_int64_t), value :: stride_a @@ -2953,17 +3120,18 @@ function hipblasZrotgStridedBatchedFortran(handle, a, stride_a, b, stride_b, c, type(c_ptr), value :: s integer(c_int64_t), value :: stride_s integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZrotgStridedBatched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) + hipblasZrotgStridedBatchedFortran = & + hipblasZrotgStridedBatched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) return end function hipblasZrotgStridedBatchedFortran ! rotm function hipblasSrotmFortran(handle, n, x, incx, y, incy, param) & - result(res) & - bind(c, name = 'hipblasSrotmFortran') + bind(c, name='hipblasSrotmFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2971,16 +3139,17 @@ function hipblasSrotmFortran(handle, n, x, incx, y, incy, param) & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: param - integer(c_int) :: res - res = hipblasSrotm(handle, n, x, incx, y, incy, param) + hipblasSrotmFortran = & + hipblasSrotm(handle, n, x, incx, y, incy, param) return end function hipblasSrotmFortran function hipblasDrotmFortran(handle, n, x, incx, y, incy, param) & - result(res) & - bind(c, name = 'hipblasDrotmFortran') + bind(c, name='hipblasDrotmFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2988,17 +3157,18 @@ function hipblasDrotmFortran(handle, n, x, incx, y, incy, param) & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: param - integer(c_int) :: res - res = hipblasDrotm(handle, n, x, incx, y, incy, param) + hipblasDrotmFortran = & + hipblasDrotm(handle, n, x, incx, y, incy, param) return end function hipblasDrotmFortran ! rotmBatched function hipblasSrotmBatchedFortran(handle, n, x, incx, y, incy, param, batch_count) & - result(res) & - bind(c, name = 'hipblasSrotmBatchedFortran') + bind(c, name='hipblasSrotmBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -3007,16 +3177,17 @@ function hipblasSrotmBatchedFortran(handle, n, x, incx, y, incy, param, batch_co integer(c_int), value :: incy type(c_ptr), value :: param integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSrotmBatched(handle, n, x, incx, y, incy, param, batch_count) + hipblasSrotmBatchedFortran = & + hipblasSrotmBatched(handle, n, x, incx, y, incy, param, batch_count) return end function hipblasSrotmBatchedFortran function hipblasDrotmBatchedFortran(handle, n, x, incx, y, incy, param, batch_count) & - result(res) & - bind(c, name = 'hipblasDrotmBatchedFortran') + bind(c, name='hipblasDrotmBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -3025,18 +3196,19 @@ function hipblasDrotmBatchedFortran(handle, n, x, incx, y, incy, param, batch_co integer(c_int), value :: incy type(c_ptr), value :: param integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDrotmBatched(handle, n, x, incx, y, incy, param, batch_count) + hipblasDrotmBatchedFortran = & + hipblasDrotmBatched(handle, n, x, incx, y, incy, param, batch_count) return end function hipblasDrotmBatchedFortran ! rotmStridedBatched - function hipblasSrotmStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, param,& - stride_param, batch_count) & - result(res) & - bind(c, name = 'hipblasSrotmStridedBatchedFortran') + function hipblasSrotmStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, param, & + stride_param, batch_count) & + bind(c, name='hipblasSrotmStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -3048,18 +3220,19 @@ function hipblasSrotmStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy type(c_ptr), value :: param integer(c_int64_t), value :: stride_param integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSrotmStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, param,& - stride_param, batch_count) + hipblasSrotmStridedBatchedFortran = & + hipblasSrotmStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, param, & + stride_param, batch_count) return end function hipblasSrotmStridedBatchedFortran - function hipblasDrotmStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, param,& - stride_param, batch_count) & - result(res) & - bind(c, name = 'hipblasDrotmStridedBatchedFortran') + function hipblasDrotmStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy, stride_y, param, & + stride_param, batch_count) & + bind(c, name='hipblasDrotmStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -3071,51 +3244,54 @@ function hipblasDrotmStridedBatchedFortran(handle, n, x, incx, stride_x, y, incy type(c_ptr), value :: param integer(c_int64_t), value :: stride_param integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDrotmStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, param,& - stride_param, batch_count) + hipblasDrotmStridedBatchedFortran = & + hipblasDrotmStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, param, & + stride_param, batch_count) return end function hipblasDrotmStridedBatchedFortran ! rotmg function hipblasSrotmgFortran(handle, d1, d2, x1, y1, param) & - result(res) & - bind(c, name = 'hipblasSrotmgFortran') + bind(c, name='hipblasSrotmgFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmgFortran type(c_ptr), value :: handle type(c_ptr), value :: d1 type(c_ptr), value :: d2 type(c_ptr), value :: x1 type(c_ptr), value :: y1 type(c_ptr), value :: param - integer(c_int) :: res - res = hipblasSrotmg(handle, d1, d2, x1, y1, param) + hipblasSrotmgFortran = & + hipblasSrotmg(handle, d1, d2, x1, y1, param) return end function hipblasSrotmgFortran function hipblasDrotmgFortran(handle, d1, d2, x1, y1, param) & - result(res) & - bind(c, name = 'hipblasDrotmgFortran') + bind(c, name='hipblasDrotmgFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmgFortran type(c_ptr), value :: handle type(c_ptr), value :: d1 type(c_ptr), value :: d2 type(c_ptr), value :: x1 type(c_ptr), value :: y1 type(c_ptr), value :: param - integer(c_int) :: res - res = hipblasDrotmg(handle, d1, d2, x1, y1, param) + hipblasDrotmgFortran = & + hipblasDrotmg(handle, d1, d2, x1, y1, param) return end function hipblasDrotmgFortran ! rotmgBatched function hipblasSrotmgBatchedFortran(handle, d1, d2, x1, y1, param, batch_count) & - result(res) & - bind(c, name = 'hipblasSrotmgBatchedFortran') + bind(c, name='hipblasSrotmgBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmgBatchedFortran type(c_ptr), value :: handle type(c_ptr), value :: d1 type(c_ptr), value :: d2 @@ -3123,16 +3299,17 @@ function hipblasSrotmgBatchedFortran(handle, d1, d2, x1, y1, param, batch_count) type(c_ptr), value :: y1 type(c_ptr), value :: param integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSrotmgBatched(handle, d1, d2, x1, y1, param, batch_count) + hipblasSrotmgBatchedFortran = & + hipblasSrotmgBatched(handle, d1, d2, x1, y1, param, batch_count) return end function hipblasSrotmgBatchedFortran function hipblasDrotmgBatchedFortran(handle, d1, d2, x1, y1, param, batch_count) & - result(res) & - bind(c, name = 'hipblasDrotmgBatchedFortran') + bind(c, name='hipblasDrotmgBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmgBatchedFortran type(c_ptr), value :: handle type(c_ptr), value :: d1 type(c_ptr), value :: d2 @@ -3140,18 +3317,19 @@ function hipblasDrotmgBatchedFortran(handle, d1, d2, x1, y1, param, batch_count) type(c_ptr), value :: y1 type(c_ptr), value :: param integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDrotmgBatched(handle, d1, d2, x1, y1, param, batch_count) + hipblasDrotmgBatchedFortran = & + hipblasDrotmgBatched(handle, d1, d2, x1, y1, param, batch_count) return end function hipblasDrotmgBatchedFortran ! rotmgStridedBatched function hipblasSrotmgStridedBatchedFortran(handle, d1, stride_d1, d2, stride_d2, x1, stride_x1, & - y1, stride_y1, param, stride_param, batch_count) & - result(res) & - bind(c, name = 'hipblasSrotmgStridedBatchedFortran') + y1, stride_y1, param, stride_param, batch_count) & + bind(c, name='hipblasSrotmgStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmgStridedBatchedFortran type(c_ptr), value :: handle type(c_ptr), value :: d1 integer(c_int64_t), value :: stride_d1 @@ -3164,18 +3342,19 @@ function hipblasSrotmgStridedBatchedFortran(handle, d1, stride_d1, d2, stride_d2 type(c_ptr), value :: param integer(c_int64_t), value :: stride_param integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSrotmgStridedBatched(handle, d1, stride_d1, d2, stride_d2, x1, stride_x1, y1, stride_y1,& - param, stride_param, batch_count) + hipblasSrotmgStridedBatchedFortran = & + hipblasSrotmgStridedBatched(handle, d1, stride_d1, d2, stride_d2, x1, stride_x1, y1, stride_y1, & + param, stride_param, batch_count) return end function hipblasSrotmgStridedBatchedFortran function hipblasDrotmgStridedBatchedFortran(handle, d1, stride_d1, d2, stride_d2, x1, stride_x1, & - y1, stride_y1, param, stride_param, batch_count) & - result(res) & - bind(c, name = 'hipblasDrotmgStridedBatchedFortran') + y1, stride_y1, param, stride_param, batch_count) & + bind(c, name='hipblasDrotmgStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmgStridedBatchedFortran type(c_ptr), value :: handle type(c_ptr), value :: d1 integer(c_int64_t), value :: stride_d1 @@ -3188,9 +3367,9 @@ function hipblasDrotmgStridedBatchedFortran(handle, d1, stride_d1, d2, stride_d2 type(c_ptr), value :: param integer(c_int64_t), value :: stride_param integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDrotmgStridedBatched(handle, d1, stride_d1, d2, stride_d2, x1, stride_x1, y1, stride_y1,& - param, stride_param, batch_count) + hipblasDrotmgStridedBatchedFortran = & + hipblasDrotmgStridedBatched(handle, d1, stride_d1, d2, stride_d2, x1, stride_x1, y1, stride_y1, & + param, stride_param, batch_count) return end function hipblasDrotmgStridedBatchedFortran @@ -3200,11 +3379,11 @@ end function hipblasDrotmgStridedBatchedFortran ! gbmv function hipblasSgbmvFortran(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasSgbmvFortran') + bind(c, name='hipblasSgbmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3219,16 +3398,16 @@ function hipblasSgbmvFortran(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasSgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) + hipblasSgbmvFortran = & + hipblasSgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) end function hipblasSgbmvFortran function hipblasDgbmvFortran(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasDgbmvFortran') + bind(c, name='hipblasDgbmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3243,16 +3422,16 @@ function hipblasDgbmvFortran(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasDgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) + hipblasDgbmvFortran = & + hipblasDgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) end function hipblasDgbmvFortran function hipblasCgbmvFortran(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasCgbmvFortran') + bind(c, name='hipblasCgbmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3267,16 +3446,16 @@ function hipblasCgbmvFortran(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasCgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) + hipblasCgbmvFortran = & + hipblasCgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) end function hipblasCgbmvFortran function hipblasZgbmvFortran(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasZgbmvFortran') + bind(c, name='hipblasZgbmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3291,18 +3470,18 @@ function hipblasZgbmvFortran(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasZgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) + hipblasZgbmvFortran = & + hipblasZgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) end function hipblasZgbmvFortran ! gbmvBatched function hipblasSgbmvBatchedFortran(handle, trans, m, n, kl, ku, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasSgbmvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasSgbmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3318,18 +3497,18 @@ function hipblasSgbmvBatchedFortran(handle, trans, m, n, kl, ku, alpha, A, lda, type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgbmvBatched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx,& - beta, y, incy, batch_count) + hipblasSgbmvBatchedFortran = & + hipblasSgbmvBatched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, & + beta, y, incy, batch_count) end function hipblasSgbmvBatchedFortran function hipblasDgbmvBatchedFortran(handle, trans, m, n, kl, ku, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasDgbmvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasDgbmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3345,18 +3524,18 @@ function hipblasDgbmvBatchedFortran(handle, trans, m, n, kl, ku, alpha, A, lda, type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgbmvBatched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx,& - beta, y, incy, batch_count) + hipblasDgbmvBatchedFortran = & + hipblasDgbmvBatched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, & + beta, y, incy, batch_count) end function hipblasDgbmvBatchedFortran function hipblasCgbmvBatchedFortran(handle, trans, m, n, kl, ku, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasCgbmvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasCgbmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3372,18 +3551,18 @@ function hipblasCgbmvBatchedFortran(handle, trans, m, n, kl, ku, alpha, A, lda, type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgbmvBatched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx,& - beta, y, incy, batch_count) + hipblasCgbmvBatchedFortran = & + hipblasCgbmvBatched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, & + beta, y, incy, batch_count) end function hipblasCgbmvBatchedFortran function hipblasZgbmvBatchedFortran(handle, trans, m, n, kl, ku, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasZgbmvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasZgbmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3399,19 +3578,19 @@ function hipblasZgbmvBatchedFortran(handle, trans, m, n, kl, ku, alpha, A, lda, type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgbmvBatched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx,& - beta, y, incy, batch_count) + hipblasZgbmvBatchedFortran = & + hipblasZgbmvBatched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, & + beta, y, incy, batch_count) end function hipblasZgbmvBatchedFortran ! gbmvStridedBatched function hipblasSgbmvStridedBatchedFortran(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasSgbmvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasSgbmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3430,18 +3609,18 @@ function hipblasSgbmvStridedBatchedFortran(handle, trans, m, n, kl, ku, alpha, A integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgbmvStridedBatched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x,& - beta, y, incy, stride_y, batch_count) + hipblasSgbmvStridedBatchedFortran = & + hipblasSgbmvStridedBatched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x, & + beta, y, incy, stride_y, batch_count) end function hipblasSgbmvStridedBatchedFortran function hipblasDgbmvStridedBatchedFortran(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasDgbmvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasDgbmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3460,18 +3639,18 @@ function hipblasDgbmvStridedBatchedFortran(handle, trans, m, n, kl, ku, alpha, A integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgbmvStridedBatched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x,& - beta, y, incy, stride_y, batch_count) + hipblasDgbmvStridedBatchedFortran = & + hipblasDgbmvStridedBatched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x, & + beta, y, incy, stride_y, batch_count) end function hipblasDgbmvStridedBatchedFortran function hipblasCgbmvStridedBatchedFortran(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasCgbmvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasCgbmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3490,18 +3669,18 @@ function hipblasCgbmvStridedBatchedFortran(handle, trans, m, n, kl, ku, alpha, A integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgbmvStridedBatched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x,& - beta, y, incy, stride_y, batch_count) + hipblasCgbmvStridedBatchedFortran = & + hipblasCgbmvStridedBatched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x, & + beta, y, incy, stride_y, batch_count) end function hipblasCgbmvStridedBatchedFortran function hipblasZgbmvStridedBatchedFortran(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasZgbmvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasZgbmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3520,19 +3699,19 @@ function hipblasZgbmvStridedBatchedFortran(handle, trans, m, n, kl, ku, alpha, A integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgbmvStridedBatched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x,& - beta, y, incy, stride_y, batch_count) + hipblasZgbmvStridedBatchedFortran = & + hipblasZgbmvStridedBatched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x, & + beta, y, incy, stride_y, batch_count) end function hipblasZgbmvStridedBatchedFortran ! gemv function hipblasSgemvFortran(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasSgemvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasSgemvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3545,17 +3724,17 @@ function hipblasSgemvFortran(handle, trans, m, n, alpha, A, lda, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasSgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy) + hipblasSgemvFortran = & + hipblasSgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy) end function hipblasSgemvFortran function hipblasDgemvFortran(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasDgemvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasDgemvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3568,17 +3747,17 @@ function hipblasDgemvFortran(handle, trans, m, n, alpha, A, lda, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasDgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy) + hipblasDgemvFortran = & + hipblasDgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy) end function hipblasDgemvFortran function hipblasCgemvFortran(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasCgemvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasCgemvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3591,17 +3770,17 @@ function hipblasCgemvFortran(handle, trans, m, n, alpha, A, lda, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasCgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy) + hipblasCgemvFortran = & + hipblasCgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy) end function hipblasCgemvFortran function hipblasZgemvFortran(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasZgemvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasZgemvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3614,18 +3793,18 @@ function hipblasZgemvFortran(handle, trans, m, n, alpha, A, lda, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasZgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy) + hipblasZgemvFortran = & + hipblasZgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy) end function hipblasZgemvFortran ! gemvBatched function hipblasSgemvBatchedFortran(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasSgemvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasSgemvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3639,17 +3818,17 @@ function hipblasSgemvBatchedFortran(handle, trans, m, n, alpha, A, lda, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgemvBatched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count) + hipblasSgemvBatchedFortran = & + hipblasSgemvBatched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count) end function hipblasSgemvBatchedFortran function hipblasDgemvBatchedFortran(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasDgemvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasDgemvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3663,17 +3842,17 @@ function hipblasDgemvBatchedFortran(handle, trans, m, n, alpha, A, lda, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgemvBatched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count) + hipblasDgemvBatchedFortran = & + hipblasDgemvBatched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count) end function hipblasDgemvBatchedFortran function hipblasCgemvBatchedFortran(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasCgemvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasCgemvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3687,17 +3866,17 @@ function hipblasCgemvBatchedFortran(handle, trans, m, n, alpha, A, lda, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgemvBatched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count) + hipblasCgemvBatchedFortran = & + hipblasCgemvBatched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count) end function hipblasCgemvBatchedFortran function hipblasZgemvBatchedFortran(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasZgemvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasZgemvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3711,18 +3890,18 @@ function hipblasZgemvBatchedFortran(handle, trans, m, n, alpha, A, lda, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgemvBatched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count) + hipblasZgemvBatchedFortran = & + hipblasZgemvBatched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count) end function hipblasZgemvBatchedFortran ! gemvStridedBatched function hipblasSgemvStridedBatchedFortran(handle, trans, m, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasSgemvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasSgemvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3739,18 +3918,18 @@ function hipblasSgemvStridedBatchedFortran(handle, trans, m, n, alpha, A, lda, s integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgemvStridedBatched(handle, trans, m, n, alpha, A, lda, stride_A,& - x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasSgemvStridedBatchedFortran = & + hipblasSgemvStridedBatched(handle, trans, m, n, alpha, A, lda, stride_A, & + x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasSgemvStridedBatchedFortran function hipblasDgemvStridedBatchedFortran(handle, trans, m, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasDgemvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasDgemvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3767,18 +3946,18 @@ function hipblasDgemvStridedBatchedFortran(handle, trans, m, n, alpha, A, lda, s integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgemvStridedBatched(handle, trans, m, n, alpha, A, lda, stride_A,& - x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasDgemvStridedBatchedFortran = & + hipblasDgemvStridedBatched(handle, trans, m, n, alpha, A, lda, stride_A, & + x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasDgemvStridedBatchedFortran function hipblasCgemvStridedBatchedFortran(handle, trans, m, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasCgemvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasCgemvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3795,18 +3974,18 @@ function hipblasCgemvStridedBatchedFortran(handle, trans, m, n, alpha, A, lda, s integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgemvStridedBatched(handle, trans, m, n, alpha, A, lda, stride_A,& - x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasCgemvStridedBatchedFortran = & + hipblasCgemvStridedBatched(handle, trans, m, n, alpha, A, lda, stride_A, & + x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasCgemvStridedBatchedFortran function hipblasZgemvStridedBatchedFortran(handle, trans, m, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasZgemvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasZgemvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3823,19 +4002,19 @@ function hipblasZgemvStridedBatchedFortran(handle, trans, m, n, alpha, A, lda, s integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgemvStridedBatched(handle, trans, m, n, alpha, A, lda, stride_A,& - x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasZgemvStridedBatchedFortran = & + hipblasZgemvStridedBatched(handle, trans, m, n, alpha, A, lda, stride_A, & + x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasZgemvStridedBatchedFortran ! hbmv function hipblasChbmvFortran(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasChbmvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasChbmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -3848,17 +4027,17 @@ function hipblasChbmvFortran(handle, uplo, n, k, alpha, A, lda, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasChbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy) + hipblasChbmvFortran = & + hipblasChbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy) end function hipblasChbmvFortran function hipblasZhbmvFortran(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasZhbmvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasZhbmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -3871,18 +4050,18 @@ function hipblasZhbmvFortran(handle, uplo, n, k, alpha, A, lda, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasZhbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy) + hipblasZhbmvFortran = & + hipblasZhbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy) end function hipblasZhbmvFortran ! hbmvBatched function hipblasChbmvBatchedFortran(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasChbmvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasChbmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -3896,18 +4075,18 @@ function hipblasChbmvBatchedFortran(handle, uplo, n, k, alpha, A, lda, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasChbmvBatched(handle, uplo, n, k, alpha, A, lda,& - x, incx, beta, y, incy, batch_count) + hipblasChbmvBatchedFortran = & + hipblasChbmvBatched(handle, uplo, n, k, alpha, A, lda, & + x, incx, beta, y, incy, batch_count) end function hipblasChbmvBatchedFortran function hipblasZhbmvBatchedFortran(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasZhbmvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasZhbmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -3921,19 +4100,19 @@ function hipblasZhbmvBatchedFortran(handle, uplo, n, k, alpha, A, lda, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZhbmvBatched(handle, uplo, n, k, alpha, A, lda,& - x, incx, beta, y, incy, batch_count) + hipblasZhbmvBatchedFortran = & + hipblasZhbmvBatched(handle, uplo, n, k, alpha, A, lda, & + x, incx, beta, y, incy, batch_count) end function hipblasZhbmvBatchedFortran ! hbmvStridedBatched function hipblasChbmvStridedBatchedFortran(handle, uplo, n, k, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasChbmvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasChbmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -3950,18 +4129,18 @@ function hipblasChbmvStridedBatchedFortran(handle, uplo, n, k, alpha, A, lda, st integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasChbmvStridedBatched(handle, uplo, n, k, alpha, A, lda, stride_A,& - x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasChbmvStridedBatchedFortran = & + hipblasChbmvStridedBatched(handle, uplo, n, k, alpha, A, lda, stride_A, & + x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasChbmvStridedBatchedFortran function hipblasZhbmvStridedBatchedFortran(handle, uplo, n, k, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasZhbmvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasZhbmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -3978,19 +4157,19 @@ function hipblasZhbmvStridedBatchedFortran(handle, uplo, n, k, alpha, A, lda, st integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZhbmvStridedBatched(handle, uplo, n, k, alpha, A, lda, stride_A,& - x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasZhbmvStridedBatchedFortran = & + hipblasZhbmvStridedBatched(handle, uplo, n, k, alpha, A, lda, stride_A, & + x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasZhbmvStridedBatchedFortran ! hemv function hipblasChemvFortran(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasChemvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasChemvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4002,17 +4181,17 @@ function hipblasChemvFortran(handle, uplo, n, alpha, A, lda, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasChemv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy) + hipblasChemvFortran = & + hipblasChemv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy) end function hipblasChemvFortran function hipblasZhemvFortran(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasZhemvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasZhemvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4024,18 +4203,18 @@ function hipblasZhemvFortran(handle, uplo, n, alpha, A, lda, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasZhemv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy) + hipblasZhemvFortran = & + hipblasZhemv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy) end function hipblasZhemvFortran ! hemvBatched function hipblasChemvBatchedFortran(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasChemvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasChemvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4048,18 +4227,18 @@ function hipblasChemvBatchedFortran(handle, uplo, n, alpha, A, lda, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasChemvBatched(handle, uplo, n, alpha, A, lda,& - x, incx, beta, y, incy, batch_count) + hipblasChemvBatchedFortran = & + hipblasChemvBatched(handle, uplo, n, alpha, A, lda, & + x, incx, beta, y, incy, batch_count) end function hipblasChemvBatchedFortran function hipblasZhemvBatchedFortran(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasZhemvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasZhemvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4072,19 +4251,19 @@ function hipblasZhemvBatchedFortran(handle, uplo, n, alpha, A, lda, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZhemvBatched(handle, uplo, n, alpha, A, lda,& - x, incx, beta, y, incy, batch_count) + hipblasZhemvBatchedFortran = & + hipblasZhemvBatched(handle, uplo, n, alpha, A, lda, & + x, incx, beta, y, incy, batch_count) end function hipblasZhemvBatchedFortran ! hemvStridedBatched function hipblasChemvStridedBatchedFortran(handle, uplo, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasChemvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasChemvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4100,18 +4279,18 @@ function hipblasChemvStridedBatchedFortran(handle, uplo, n, alpha, A, lda, strid integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasChemvStridedBatched(handle, uplo, n, alpha, A, lda, stride_A,& - x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasChemvStridedBatchedFortran = & + hipblasChemvStridedBatched(handle, uplo, n, alpha, A, lda, stride_A, & + x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasChemvStridedBatchedFortran function hipblasZhemvStridedBatchedFortran(handle, uplo, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasZhemvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasZhemvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4127,19 +4306,19 @@ function hipblasZhemvStridedBatchedFortran(handle, uplo, n, alpha, A, lda, strid integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZhemvStridedBatched(handle, uplo, n, alpha, A, lda, stride_A,& - x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasZhemvStridedBatchedFortran = & + hipblasZhemvStridedBatched(handle, uplo, n, alpha, A, lda, stride_A, & + x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasZhemvStridedBatchedFortran ! her function hipblasCherFortran(handle, uplo, n, alpha, & - x, incx, A, lda) & - result(res) & - bind(c, name = 'hipblasCherFortran') + x, incx, A, lda) & + bind(c, name='hipblasCherFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4148,17 +4327,17 @@ function hipblasCherFortran(handle, uplo, n, alpha, & integer(c_int), value :: incx type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasCher(handle, uplo, n, alpha, x, incx, A, lda) + hipblasCherFortran = & + hipblasCher(handle, uplo, n, alpha, x, incx, A, lda) end function hipblasCherFortran function hipblasZherFortran(handle, uplo, n, alpha, & - x, incx, A, lda) & - result(res) & - bind(c, name = 'hipblasZherFortran') + x, incx, A, lda) & + bind(c, name='hipblasZherFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4167,18 +4346,18 @@ function hipblasZherFortran(handle, uplo, n, alpha, & integer(c_int), value :: incx type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasZher(handle, uplo, n, alpha, x, incx, A, lda) + hipblasZherFortran = & + hipblasZher(handle, uplo, n, alpha, x, incx, A, lda) end function hipblasZherFortran - + ! herBatched function hipblasCherBatchedFortran(handle, uplo, n, alpha, & - x, incx, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasCherBatchedFortran') + x, incx, A, lda, batch_count) & + bind(c, name='hipblasCherBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4188,17 +4367,17 @@ function hipblasCherBatchedFortran(handle, uplo, n, alpha, & type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCherBatched(handle, uplo, n, alpha, x, incx, A, lda, batch_count) + hipblasCherBatchedFortran = & + hipblasCherBatched(handle, uplo, n, alpha, x, incx, A, lda, batch_count) end function hipblasCherBatchedFortran function hipblasZherBatchedFortran(handle, uplo, n, alpha, & - x, incx, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasZherBatchedFortran') + x, incx, A, lda, batch_count) & + bind(c, name='hipblasZherBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4208,18 +4387,18 @@ function hipblasZherBatchedFortran(handle, uplo, n, alpha, & type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZherBatched(handle, uplo, n, alpha, x, incx, A, lda, batch_count) + hipblasZherBatchedFortran = & + hipblasZherBatched(handle, uplo, n, alpha, x, incx, A, lda, batch_count) end function hipblasZherBatchedFortran ! herStridedBatched function hipblasCherStridedBatchedFortran(handle, uplo, n, alpha, & - x, incx, stride_x, A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasCherStridedBatchedFortran') + x, incx, stride_x, A, lda, stride_A, batch_count) & + bind(c, name='hipblasCherStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4231,18 +4410,18 @@ function hipblasCherStridedBatchedFortran(handle, uplo, n, alpha, & integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCherStridedBatched(handle, uplo, n, alpha, x, incx, stride_x,& - A, lda, stride_A, batch_count) + hipblasCherStridedBatchedFortran = & + hipblasCherStridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & + A, lda, stride_A, batch_count) end function hipblasCherStridedBatchedFortran function hipblasZherStridedBatchedFortran(handle, uplo, n, alpha, & - x, incx, stride_x, A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasZherStridedBatchedFortran') + x, incx, stride_x, A, lda, stride_A, batch_count) & + bind(c, name='hipblasZherStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4254,19 +4433,19 @@ function hipblasZherStridedBatchedFortran(handle, uplo, n, alpha, & integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZherStridedBatched(handle, uplo, n, alpha, x, incx, stride_x,& - A, lda, stride_A, batch_count) + hipblasZherStridedBatchedFortran = & + hipblasZherStridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & + A, lda, stride_A, batch_count) end function hipblasZherStridedBatchedFortran ! her2 function hipblasCher2Fortran(handle, uplo, n, alpha, & - x, incx, y, incy, A, lda) & - result(res) & - bind(c, name = 'hipblasCher2Fortran') + x, incx, y, incy, A, lda) & + bind(c, name='hipblasCher2Fortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2Fortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4277,18 +4456,18 @@ function hipblasCher2Fortran(handle, uplo, n, alpha, & integer(c_int), value :: incy type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasCher2(handle, uplo, n, alpha, x, incx,& - y, incy, A, lda) + hipblasCher2Fortran = & + hipblasCher2(handle, uplo, n, alpha, x, incx, & + y, incy, A, lda) end function hipblasCher2Fortran function hipblasZher2Fortran(handle, uplo, n, alpha, & - x, incx, y, incy, A, lda) & - result(res) & - bind(c, name = 'hipblasZher2Fortran') + x, incx, y, incy, A, lda) & + bind(c, name='hipblasZher2Fortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2Fortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4299,19 +4478,19 @@ function hipblasZher2Fortran(handle, uplo, n, alpha, & integer(c_int), value :: incy type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasZher2(handle, uplo, n, alpha, x, incx,& - y, incy, A, lda) + hipblasZher2Fortran = & + hipblasZher2(handle, uplo, n, alpha, x, incx, & + y, incy, A, lda) end function hipblasZher2Fortran ! her2Batched function hipblasCher2BatchedFortran(handle, uplo, n, alpha, & - x, incx, y, incy, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasCher2BatchedFortran') + x, incx, y, incy, A, lda, batch_count) & + bind(c, name='hipblasCher2BatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2BatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4323,18 +4502,18 @@ function hipblasCher2BatchedFortran(handle, uplo, n, alpha, & type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCher2Batched(handle, uplo, n, alpha, x, incx,& - y, incy, A, lda, batch_count) + hipblasCher2BatchedFortran = & + hipblasCher2Batched(handle, uplo, n, alpha, x, incx, & + y, incy, A, lda, batch_count) end function hipblasCher2BatchedFortran function hipblasZher2BatchedFortran(handle, uplo, n, alpha, & - x, incx, y, incy, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasZher2BatchedFortran') + x, incx, y, incy, A, lda, batch_count) & + bind(c, name='hipblasZher2BatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2BatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4346,19 +4525,19 @@ function hipblasZher2BatchedFortran(handle, uplo, n, alpha, & type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZher2Batched(handle, uplo, n, alpha, x, incx,& - y, incy, A, lda, batch_count) + hipblasZher2BatchedFortran = & + hipblasZher2Batched(handle, uplo, n, alpha, x, incx, & + y, incy, A, lda, batch_count) end function hipblasZher2BatchedFortran ! her2StridedBatched function hipblasCher2StridedBatchedFortran(handle, uplo, n, alpha, & - x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasCher2StridedBatchedFortran') + x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasCher2StridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2StridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4373,18 +4552,18 @@ function hipblasCher2StridedBatchedFortran(handle, uplo, n, alpha, & integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCher2StridedBatched(handle, uplo, n, alpha, x, incx, stride_x,& - y, incy, stride_y, A, lda, stride_A, batch_count) + hipblasCher2StridedBatchedFortran = & + hipblasCher2StridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & + y, incy, stride_y, A, lda, stride_A, batch_count) end function hipblasCher2StridedBatchedFortran function hipblasZher2StridedBatchedFortran(handle, uplo, n, alpha, & - x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasZher2StridedBatchedFortran') + x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasZher2StridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2StridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4399,19 +4578,19 @@ function hipblasZher2StridedBatchedFortran(handle, uplo, n, alpha, & integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZher2StridedBatched(handle, uplo, n, alpha, x, incx, stride_x,& - y, incy, stride_y, A, lda, stride_A, batch_count) + hipblasZher2StridedBatchedFortran = & + hipblasZher2StridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & + y, incy, stride_y, A, lda, stride_A, batch_count) end function hipblasZher2StridedBatchedFortran ! hpmv function hipblasChpmvFortran(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasChpmvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasChpmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4422,18 +4601,18 @@ function hipblasChpmvFortran(handle, uplo, n, alpha, AP, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasChpmv(handle, uplo, n, alpha, AP,& - x, incx, beta, y, incy) + hipblasChpmvFortran = & + hipblasChpmv(handle, uplo, n, alpha, AP, & + x, incx, beta, y, incy) end function hipblasChpmvFortran function hipblasZhpmvFortran(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasZhpmvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasZhpmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4444,19 +4623,19 @@ function hipblasZhpmvFortran(handle, uplo, n, alpha, AP, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasZhpmv(handle, uplo, n, alpha, AP,& - x, incx, beta, y, incy) + hipblasZhpmvFortran = & + hipblasZhpmv(handle, uplo, n, alpha, AP, & + x, incx, beta, y, incy) end function hipblasZhpmvFortran ! hpmvBatched function hipblasChpmvBatchedFortran(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasChpmvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasChpmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4468,18 +4647,18 @@ function hipblasChpmvBatchedFortran(handle, uplo, n, alpha, AP, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasChpmvBatched(handle, uplo, n, alpha, AP,& - x, incx, beta, y, incy, batch_count) + hipblasChpmvBatchedFortran = & + hipblasChpmvBatched(handle, uplo, n, alpha, AP, & + x, incx, beta, y, incy, batch_count) end function hipblasChpmvBatchedFortran function hipblasZhpmvBatchedFortran(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasZhpmvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasZhpmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4491,19 +4670,19 @@ function hipblasZhpmvBatchedFortran(handle, uplo, n, alpha, AP, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZhpmvBatched(handle, uplo, n, alpha, AP,& - x, incx, beta, y, incy, batch_count) + hipblasZhpmvBatchedFortran = & + hipblasZhpmvBatched(handle, uplo, n, alpha, AP, & + x, incx, beta, y, incy, batch_count) end function hipblasZhpmvBatchedFortran ! hpmvStridedBatched function hipblasChpmvStridedBatchedFortran(handle, uplo, n, alpha, AP, stride_AP, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasChpmvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasChpmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4518,18 +4697,18 @@ function hipblasChpmvStridedBatchedFortran(handle, uplo, n, alpha, AP, stride_AP integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasChpmvStridedBatched(handle, uplo, n, alpha, AP, stride_AP,& - x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasChpmvStridedBatchedFortran = & + hipblasChpmvStridedBatched(handle, uplo, n, alpha, AP, stride_AP, & + x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasChpmvStridedBatchedFortran function hipblasZhpmvStridedBatchedFortran(handle, uplo, n, alpha, AP, stride_AP, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasZhpmvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasZhpmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4544,19 +4723,19 @@ function hipblasZhpmvStridedBatchedFortran(handle, uplo, n, alpha, AP, stride_AP integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZhpmvStridedBatched(handle, uplo, n, alpha, AP, stride_AP,& - x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasZhpmvStridedBatchedFortran = & + hipblasZhpmvStridedBatched(handle, uplo, n, alpha, AP, stride_AP, & + x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasZhpmvStridedBatchedFortran ! hpr function hipblasChprFortran(handle, uplo, n, alpha, & - x, incx, AP) & - result(res) & - bind(c, name = 'hipblasChprFortran') + x, incx, AP) & + bind(c, name='hipblasChprFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChprFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4564,17 +4743,17 @@ function hipblasChprFortran(handle, uplo, n, alpha, & type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: AP - integer(c_int) :: res - res = hipblasChpr(handle, uplo, n, alpha, x, incx, AP) + hipblasChprFortran = & + hipblasChpr(handle, uplo, n, alpha, x, incx, AP) end function hipblasChprFortran function hipblasZhprFortran(handle, uplo, n, alpha, & - x, incx, AP) & - result(res) & - bind(c, name = 'hipblasZhprFortran') + x, incx, AP) & + bind(c, name='hipblasZhprFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhprFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4582,18 +4761,18 @@ function hipblasZhprFortran(handle, uplo, n, alpha, & type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: AP - integer(c_int) :: res - res = hipblasZhpr(handle, uplo, n, alpha, x, incx, AP) + hipblasZhprFortran = & + hipblasZhpr(handle, uplo, n, alpha, x, incx, AP) end function hipblasZhprFortran ! hprBatched function hipblasChprBatchedFortran(handle, uplo, n, alpha, & - x, incx, AP, batch_count) & - result(res) & - bind(c, name = 'hipblasChprBatchedFortran') + x, incx, AP, batch_count) & + bind(c, name='hipblasChprBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChprBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4602,17 +4781,17 @@ function hipblasChprBatchedFortran(handle, uplo, n, alpha, & integer(c_int), value :: incx type(c_ptr), value :: AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasChprBatched(handle, uplo, n, alpha, x, incx, AP, batch_count) + hipblasChprBatchedFortran = & + hipblasChprBatched(handle, uplo, n, alpha, x, incx, AP, batch_count) end function hipblasChprBatchedFortran function hipblasZhprBatchedFortran(handle, uplo, n, alpha, & - x, incx, AP, batch_count) & - result(res) & - bind(c, name = 'hipblasZhprBatchedFortran') + x, incx, AP, batch_count) & + bind(c, name='hipblasZhprBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhprBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4621,18 +4800,18 @@ function hipblasZhprBatchedFortran(handle, uplo, n, alpha, & integer(c_int), value :: incx type(c_ptr), value :: AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZhprBatched(handle, uplo, n, alpha, x, incx, AP, batch_count) + hipblasZhprBatchedFortran = & + hipblasZhprBatched(handle, uplo, n, alpha, x, incx, AP, batch_count) end function hipblasZhprBatchedFortran ! hprStridedBatched function hipblasChprStridedBatchedFortran(handle, uplo, n, alpha, & - x, incx, stride_x, AP, stride_AP, batch_count) & - result(res) & - bind(c, name = 'hipblasChprStridedBatchedFortran') + x, incx, stride_x, AP, stride_AP, batch_count) & + bind(c, name='hipblasChprStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChprStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4643,18 +4822,18 @@ function hipblasChprStridedBatchedFortran(handle, uplo, n, alpha, & type(c_ptr), value :: AP integer(c_int64_t), value :: stride_AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasChprStridedBatched(handle, uplo, n, alpha, x, incx, stride_x,& - AP, stride_AP, batch_count) + hipblasChprStridedBatchedFortran = & + hipblasChprStridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & + AP, stride_AP, batch_count) end function hipblasChprStridedBatchedFortran function hipblasZhprStridedBatchedFortran(handle, uplo, n, alpha, & - x, incx, stride_x, AP, stride_AP, batch_count) & - result(res) & - bind(c, name = 'hipblasZhprStridedBatchedFortran') + x, incx, stride_x, AP, stride_AP, batch_count) & + bind(c, name='hipblasZhprStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhprStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4665,19 +4844,19 @@ function hipblasZhprStridedBatchedFortran(handle, uplo, n, alpha, & type(c_ptr), value :: AP integer(c_int64_t), value :: stride_AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZhprStridedBatched(handle, uplo, n, alpha, x, incx, stride_x,& - AP, stride_AP, batch_count) + hipblasZhprStridedBatchedFortran = & + hipblasZhprStridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & + AP, stride_AP, batch_count) end function hipblasZhprStridedBatchedFortran ! hpr2 function hipblasChpr2Fortran(handle, uplo, n, alpha, & - x, incx, y, incy, AP) & - result(res) & - bind(c, name = 'hipblasChpr2Fortran') + x, incx, y, incy, AP) & + bind(c, name='hipblasChpr2Fortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2Fortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4687,18 +4866,18 @@ function hipblasChpr2Fortran(handle, uplo, n, alpha, & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: AP - integer(c_int) :: res - res = hipblasChpr2(handle, uplo, n, alpha, x, incx,& - y, incy, AP) + hipblasChpr2Fortran = & + hipblasChpr2(handle, uplo, n, alpha, x, incx, & + y, incy, AP) end function hipblasChpr2Fortran function hipblasZhpr2Fortran(handle, uplo, n, alpha, & - x, incx, y, incy, AP) & - result(res) & - bind(c, name = 'hipblasZhpr2Fortran') + x, incx, y, incy, AP) & + bind(c, name='hipblasZhpr2Fortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2Fortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4708,19 +4887,19 @@ function hipblasZhpr2Fortran(handle, uplo, n, alpha, & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: AP - integer(c_int) :: res - res = hipblasZhpr2(handle, uplo, n, alpha, x, incx,& - y, incy, AP) + hipblasZhpr2Fortran = & + hipblasZhpr2(handle, uplo, n, alpha, x, incx, & + y, incy, AP) end function hipblasZhpr2Fortran ! hpr2Batched function hipblasChpr2BatchedFortran(handle, uplo, n, alpha, & - x, incx, y, incy, AP, batch_count) & - result(res) & - bind(c, name = 'hipblasChpr2BatchedFortran') + x, incx, y, incy, AP, batch_count) & + bind(c, name='hipblasChpr2BatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2BatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4731,18 +4910,18 @@ function hipblasChpr2BatchedFortran(handle, uplo, n, alpha, & integer(c_int), value :: incy type(c_ptr), value :: AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasChpr2Batched(handle, uplo, n, alpha, x, incx,& - y, incy, AP, batch_count) + hipblasChpr2BatchedFortran = & + hipblasChpr2Batched(handle, uplo, n, alpha, x, incx, & + y, incy, AP, batch_count) end function hipblasChpr2BatchedFortran function hipblasZhpr2BatchedFortran(handle, uplo, n, alpha, & - x, incx, y, incy, AP, batch_count) & - result(res) & - bind(c, name = 'hipblasZhpr2BatchedFortran') + x, incx, y, incy, AP, batch_count) & + bind(c, name='hipblasZhpr2BatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2BatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4753,19 +4932,19 @@ function hipblasZhpr2BatchedFortran(handle, uplo, n, alpha, & integer(c_int), value :: incy type(c_ptr), value :: AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZhpr2Batched(handle, uplo, n, alpha, x, incx,& - y, incy, AP, batch_count) + hipblasZhpr2BatchedFortran = & + hipblasZhpr2Batched(handle, uplo, n, alpha, x, incx, & + y, incy, AP, batch_count) end function hipblasZhpr2BatchedFortran ! hpr2StridedBatched function hipblasChpr2StridedBatchedFortran(handle, uplo, n, alpha, & - x, incx, stride_x, y, incy, stride_y, AP, stride_AP, batch_count) & - result(res) & - bind(c, name = 'hipblasChpr2StridedBatchedFortran') + x, incx, stride_x, y, incy, stride_y, AP, stride_AP, batch_count) & + bind(c, name='hipblasChpr2StridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2StridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4779,18 +4958,18 @@ function hipblasChpr2StridedBatchedFortran(handle, uplo, n, alpha, & type(c_ptr), value :: AP integer(c_int64_t), value :: stride_AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasChpr2StridedBatched(handle, uplo, n, alpha, x, incx, stride_x,& - y, incy, stride_y, AP, stride_AP, batch_count) + hipblasChpr2StridedBatchedFortran = & + hipblasChpr2StridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & + y, incy, stride_y, AP, stride_AP, batch_count) end function hipblasChpr2StridedBatchedFortran function hipblasZhpr2StridedBatchedFortran(handle, uplo, n, alpha, & - x, incx, stride_x, y, incy, stride_y, AP, stride_AP, batch_count) & - result(res) & - bind(c, name = 'hipblasZhpr2StridedBatchedFortran') + x, incx, stride_x, y, incy, stride_y, AP, stride_AP, batch_count) & + bind(c, name='hipblasZhpr2StridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2StridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4804,19 +4983,19 @@ function hipblasZhpr2StridedBatchedFortran(handle, uplo, n, alpha, & type(c_ptr), value :: AP integer(c_int64_t), value :: stride_AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZhpr2StridedBatched(handle, uplo, n, alpha, x, incx, stride_x,& - y, incy, stride_y, AP, stride_AP, batch_count) + hipblasZhpr2StridedBatchedFortran = & + hipblasZhpr2StridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & + y, incy, stride_y, AP, stride_AP, batch_count) end function hipblasZhpr2StridedBatchedFortran ! trmv function hipblasStrmvFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasStrmvFortran') + A, lda, x, incx) & + bind(c, name='hipblasStrmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4826,18 +5005,18 @@ function hipblasStrmvFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasStrmv(handle, uplo, transA, diag, m,& - A, lda, x, incx) + hipblasStrmvFortran = & + hipblasStrmv(handle, uplo, transA, diag, m, & + A, lda, x, incx) end function hipblasStrmvFortran function hipblasDtrmvFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasDtrmvFortran') + A, lda, x, incx) & + bind(c, name='hipblasDtrmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4847,18 +5026,18 @@ function hipblasDtrmvFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasDtrmv(handle, uplo, transA, diag, m,& - A, lda, x, incx) + hipblasDtrmvFortran = & + hipblasDtrmv(handle, uplo, transA, diag, m, & + A, lda, x, incx) end function hipblasDtrmvFortran function hipblasCtrmvFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasCtrmvFortran') + A, lda, x, incx) & + bind(c, name='hipblasCtrmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4868,18 +5047,18 @@ function hipblasCtrmvFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasCtrmv(handle, uplo, transA, diag, m,& - A, lda, x, incx) + hipblasCtrmvFortran = & + hipblasCtrmv(handle, uplo, transA, diag, m, & + A, lda, x, incx) end function hipblasCtrmvFortran function hipblasZtrmvFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasZtrmvFortran') + A, lda, x, incx) & + bind(c, name='hipblasZtrmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4889,19 +5068,19 @@ function hipblasZtrmvFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasZtrmv(handle, uplo, transA, diag, m,& - A, lda, x, incx) + hipblasZtrmvFortran = & + hipblasZtrmv(handle, uplo, transA, diag, m, & + A, lda, x, incx) end function hipblasZtrmvFortran ! trmvBatched function hipblasStrmvBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasStrmvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasStrmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4912,18 +5091,18 @@ function hipblasStrmvBatchedFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStrmvBatched(handle, uplo, transA, diag, m,& - A, lda, x, incx, batch_count) + hipblasStrmvBatchedFortran = & + hipblasStrmvBatched(handle, uplo, transA, diag, m, & + A, lda, x, incx, batch_count) end function hipblasStrmvBatchedFortran function hipblasDtrmvBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasDtrmvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasDtrmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4934,18 +5113,18 @@ function hipblasDtrmvBatchedFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtrmvBatched(handle, uplo, transA, diag, m,& - A, lda, x, incx, batch_count) + hipblasDtrmvBatchedFortran = & + hipblasDtrmvBatched(handle, uplo, transA, diag, m, & + A, lda, x, incx, batch_count) end function hipblasDtrmvBatchedFortran function hipblasCtrmvBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasCtrmvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasCtrmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4956,18 +5135,18 @@ function hipblasCtrmvBatchedFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtrmvBatched(handle, uplo, transA, diag, m,& - A, lda, x, incx, batch_count) + hipblasCtrmvBatchedFortran = & + hipblasCtrmvBatched(handle, uplo, transA, diag, m, & + A, lda, x, incx, batch_count) end function hipblasCtrmvBatchedFortran function hipblasZtrmvBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasZtrmvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasZtrmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4978,19 +5157,19 @@ function hipblasZtrmvBatchedFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtrmvBatched(handle, uplo, transA, diag, m,& - A, lda, x, incx, batch_count) + hipblasZtrmvBatchedFortran = & + hipblasZtrmvBatched(handle, uplo, transA, diag, m, & + A, lda, x, incx, batch_count) end function hipblasZtrmvBatchedFortran ! trmvStridedBatched function hipblasStrmvStridedBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasStrmvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasStrmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5003,18 +5182,18 @@ function hipblasStrmvStridedBatchedFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStrmvStridedBatched(handle, uplo, transA, diag, m,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasStrmvStridedBatchedFortran = & + hipblasStrmvStridedBatched(handle, uplo, transA, diag, m, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasStrmvStridedBatchedFortran function hipblasDtrmvStridedBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasDtrmvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasDtrmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5027,18 +5206,18 @@ function hipblasDtrmvStridedBatchedFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtrmvStridedBatched(handle, uplo, transA, diag, m,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasDtrmvStridedBatchedFortran = & + hipblasDtrmvStridedBatched(handle, uplo, transA, diag, m, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasDtrmvStridedBatchedFortran function hipblasCtrmvStridedBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasCtrmvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasCtrmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5051,18 +5230,18 @@ function hipblasCtrmvStridedBatchedFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtrmvStridedBatched(handle, uplo, transA, diag, m,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasCtrmvStridedBatchedFortran = & + hipblasCtrmvStridedBatched(handle, uplo, transA, diag, m, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasCtrmvStridedBatchedFortran function hipblasZtrmvStridedBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasZtrmvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasZtrmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5075,19 +5254,19 @@ function hipblasZtrmvStridedBatchedFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtrmvStridedBatched(handle, uplo, transA, diag, m,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasZtrmvStridedBatchedFortran = & + hipblasZtrmvStridedBatched(handle, uplo, transA, diag, m, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasZtrmvStridedBatchedFortran ! tpmv function hipblasStpmvFortran(handle, uplo, transA, diag, m, & - AP, x, incx) & - result(res) & - bind(c, name = 'hipblasStpmvFortran') + AP, x, incx) & + bind(c, name='hipblasStpmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5096,18 +5275,18 @@ function hipblasStpmvFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: AP type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasStpmv(handle, uplo, transA, diag, m,& - AP, x, incx) + hipblasStpmvFortran = & + hipblasStpmv(handle, uplo, transA, diag, m, & + AP, x, incx) end function hipblasStpmvFortran function hipblasDtpmvFortran(handle, uplo, transA, diag, m, & - AP, x, incx) & - result(res) & - bind(c, name = 'hipblasDtpmvFortran') + AP, x, incx) & + bind(c, name='hipblasDtpmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5116,18 +5295,18 @@ function hipblasDtpmvFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: AP type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasDtpmv(handle, uplo, transA, diag, m,& - AP, x, incx) + hipblasDtpmvFortran = & + hipblasDtpmv(handle, uplo, transA, diag, m, & + AP, x, incx) end function hipblasDtpmvFortran function hipblasCtpmvFortran(handle, uplo, transA, diag, m, & - AP, x, incx) & - result(res) & - bind(c, name = 'hipblasCtpmvFortran') + AP, x, incx) & + bind(c, name='hipblasCtpmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5136,18 +5315,18 @@ function hipblasCtpmvFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: AP type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasCtpmv(handle, uplo, transA, diag, m,& - AP, x, incx) + hipblasCtpmvFortran = & + hipblasCtpmv(handle, uplo, transA, diag, m, & + AP, x, incx) end function hipblasCtpmvFortran function hipblasZtpmvFortran(handle, uplo, transA, diag, m, & - AP, x, incx) & - result(res) & - bind(c, name = 'hipblasZtpmvFortran') + AP, x, incx) & + bind(c, name='hipblasZtpmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5156,19 +5335,19 @@ function hipblasZtpmvFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: AP type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasZtpmv(handle, uplo, transA, diag, m,& - AP, x, incx) + hipblasZtpmvFortran = & + hipblasZtpmv(handle, uplo, transA, diag, m, & + AP, x, incx) end function hipblasZtpmvFortran ! tpmvBatched function hipblasStpmvBatchedFortran(handle, uplo, transA, diag, m, & - AP, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasStpmvBatchedFortran') + AP, x, incx, batch_count) & + bind(c, name='hipblasStpmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5178,18 +5357,18 @@ function hipblasStpmvBatchedFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStpmvBatched(handle, uplo, transA, diag, m,& - AP, x, incx, batch_count) + hipblasStpmvBatchedFortran = & + hipblasStpmvBatched(handle, uplo, transA, diag, m, & + AP, x, incx, batch_count) end function hipblasStpmvBatchedFortran function hipblasDtpmvBatchedFortran(handle, uplo, transA, diag, m, & - AP, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasDtpmvBatchedFortran') + AP, x, incx, batch_count) & + bind(c, name='hipblasDtpmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5199,18 +5378,18 @@ function hipblasDtpmvBatchedFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtpmvBatched(handle, uplo, transA, diag, m,& - AP, x, incx, batch_count) + hipblasDtpmvBatchedFortran = & + hipblasDtpmvBatched(handle, uplo, transA, diag, m, & + AP, x, incx, batch_count) end function hipblasDtpmvBatchedFortran function hipblasCtpmvBatchedFortran(handle, uplo, transA, diag, m, & - AP, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasCtpmvBatchedFortran') + AP, x, incx, batch_count) & + bind(c, name='hipblasCtpmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5220,18 +5399,18 @@ function hipblasCtpmvBatchedFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtpmvBatched(handle, uplo, transA, diag, m,& - AP, x, incx, batch_count) + hipblasCtpmvBatchedFortran = & + hipblasCtpmvBatched(handle, uplo, transA, diag, m, & + AP, x, incx, batch_count) end function hipblasCtpmvBatchedFortran function hipblasZtpmvBatchedFortran(handle, uplo, transA, diag, m, & - AP, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasZtpmvBatchedFortran') + AP, x, incx, batch_count) & + bind(c, name='hipblasZtpmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5241,19 +5420,19 @@ function hipblasZtpmvBatchedFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtpmvBatched(handle, uplo, transA, diag, m,& - AP, x, incx, batch_count) + hipblasZtpmvBatchedFortran = & + hipblasZtpmvBatched(handle, uplo, transA, diag, m, & + AP, x, incx, batch_count) end function hipblasZtpmvBatchedFortran ! tpmvStridedBatched function hipblasStpmvStridedBatchedFortran(handle, uplo, transA, diag, m, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasStpmvStridedBatchedFortran') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasStpmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5265,18 +5444,18 @@ function hipblasStpmvStridedBatchedFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStpmvStridedBatched(handle, uplo, transA, diag, m,& - AP, stride_AP, x, incx, stride_x, batch_count) + hipblasStpmvStridedBatchedFortran = & + hipblasStpmvStridedBatched(handle, uplo, transA, diag, m, & + AP, stride_AP, x, incx, stride_x, batch_count) end function hipblasStpmvStridedBatchedFortran function hipblasDtpmvStridedBatchedFortran(handle, uplo, transA, diag, m, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasDtpmvStridedBatchedFortran') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasDtpmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5288,18 +5467,18 @@ function hipblasDtpmvStridedBatchedFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtpmvStridedBatched(handle, uplo, transA, diag, m,& - AP, stride_AP, x, incx, stride_x, batch_count) + hipblasDtpmvStridedBatchedFortran = & + hipblasDtpmvStridedBatched(handle, uplo, transA, diag, m, & + AP, stride_AP, x, incx, stride_x, batch_count) end function hipblasDtpmvStridedBatchedFortran function hipblasCtpmvStridedBatchedFortran(handle, uplo, transA, diag, m, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasCtpmvStridedBatchedFortran') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasCtpmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5311,18 +5490,18 @@ function hipblasCtpmvStridedBatchedFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtpmvStridedBatched(handle, uplo, transA, diag, m,& - AP, stride_AP, x, incx, stride_x, batch_count) + hipblasCtpmvStridedBatchedFortran = & + hipblasCtpmvStridedBatched(handle, uplo, transA, diag, m, & + AP, stride_AP, x, incx, stride_x, batch_count) end function hipblasCtpmvStridedBatchedFortran function hipblasZtpmvStridedBatchedFortran(handle, uplo, transA, diag, m, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasZtpmvStridedBatchedFortran') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasZtpmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5334,19 +5513,19 @@ function hipblasZtpmvStridedBatchedFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtpmvStridedBatched(handle, uplo, transA, diag, m,& - AP, stride_AP, x, incx, stride_x, batch_count) + hipblasZtpmvStridedBatchedFortran = & + hipblasZtpmvStridedBatched(handle, uplo, transA, diag, m, & + AP, stride_AP, x, incx, stride_x, batch_count) end function hipblasZtpmvStridedBatchedFortran ! tbmv function hipblasStbmvFortran(handle, uplo, transA, diag, m, k, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasStbmvFortran') + A, lda, x, incx) & + bind(c, name='hipblasStbmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5357,18 +5536,18 @@ function hipblasStbmvFortran(handle, uplo, transA, diag, m, k, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasStbmv(handle, uplo, transA, diag, m, k,& - A, lda, x, incx) + hipblasStbmvFortran = & + hipblasStbmv(handle, uplo, transA, diag, m, k, & + A, lda, x, incx) end function hipblasStbmvFortran function hipblasDtbmvFortran(handle, uplo, transA, diag, m, k, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasDtbmvFortran') + A, lda, x, incx) & + bind(c, name='hipblasDtbmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5379,18 +5558,18 @@ function hipblasDtbmvFortran(handle, uplo, transA, diag, m, k, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasDtbmv(handle, uplo, transA, diag, m, k,& - A, lda, x, incx) + hipblasDtbmvFortran = & + hipblasDtbmv(handle, uplo, transA, diag, m, k, & + A, lda, x, incx) end function hipblasDtbmvFortran function hipblasCtbmvFortran(handle, uplo, transA, diag, m, k, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasCtbmvFortran') + A, lda, x, incx) & + bind(c, name='hipblasCtbmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5401,18 +5580,18 @@ function hipblasCtbmvFortran(handle, uplo, transA, diag, m, k, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasCtbmv(handle, uplo, transA, diag, m, k,& - A, lda, x, incx) + hipblasCtbmvFortran = & + hipblasCtbmv(handle, uplo, transA, diag, m, k, & + A, lda, x, incx) end function hipblasCtbmvFortran function hipblasZtbmvFortran(handle, uplo, transA, diag, m, k, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasZtbmvFortran') + A, lda, x, incx) & + bind(c, name='hipblasZtbmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5423,19 +5602,19 @@ function hipblasZtbmvFortran(handle, uplo, transA, diag, m, k, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasZtbmv(handle, uplo, transA, diag, m, k,& - A, lda, x, incx) + hipblasZtbmvFortran = & + hipblasZtbmv(handle, uplo, transA, diag, m, k, & + A, lda, x, incx) end function hipblasZtbmvFortran ! tbmvBatched function hipblasStbmvBatchedFortran(handle, uplo, transA, diag, m, k, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasStbmvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasStbmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5447,18 +5626,18 @@ function hipblasStbmvBatchedFortran(handle, uplo, transA, diag, m, k, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStbmvBatched(handle, uplo, transA, diag, m, k,& - A, lda, x, incx, batch_count) + hipblasStbmvBatchedFortran = & + hipblasStbmvBatched(handle, uplo, transA, diag, m, k, & + A, lda, x, incx, batch_count) end function hipblasStbmvBatchedFortran function hipblasDtbmvBatchedFortran(handle, uplo, transA, diag, m, k, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasDtbmvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasDtbmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5470,18 +5649,18 @@ function hipblasDtbmvBatchedFortran(handle, uplo, transA, diag, m, k, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtbmvBatched(handle, uplo, transA, diag, m, k,& - A, lda, x, incx, batch_count) + hipblasDtbmvBatchedFortran = & + hipblasDtbmvBatched(handle, uplo, transA, diag, m, k, & + A, lda, x, incx, batch_count) end function hipblasDtbmvBatchedFortran function hipblasCtbmvBatchedFortran(handle, uplo, transA, diag, m, k, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasCtbmvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasCtbmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5493,18 +5672,18 @@ function hipblasCtbmvBatchedFortran(handle, uplo, transA, diag, m, k, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtbmvBatched(handle, uplo, transA, diag, m, k,& - A, lda, x, incx, batch_count) + hipblasCtbmvBatchedFortran = & + hipblasCtbmvBatched(handle, uplo, transA, diag, m, k, & + A, lda, x, incx, batch_count) end function hipblasCtbmvBatchedFortran function hipblasZtbmvBatchedFortran(handle, uplo, transA, diag, m, k, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasZtbmvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasZtbmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5516,19 +5695,19 @@ function hipblasZtbmvBatchedFortran(handle, uplo, transA, diag, m, k, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtbmvBatched(handle, uplo, transA, diag, m, k,& - A, lda, x, incx, batch_count) + hipblasZtbmvBatchedFortran = & + hipblasZtbmvBatched(handle, uplo, transA, diag, m, k, & + A, lda, x, incx, batch_count) end function hipblasZtbmvBatchedFortran ! tbmvStridedBatched function hipblasStbmvStridedBatchedFortran(handle, uplo, transA, diag, m, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasStbmvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasStbmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5542,18 +5721,18 @@ function hipblasStbmvStridedBatchedFortran(handle, uplo, transA, diag, m, k, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStbmvStridedBatched(handle, uplo, transA, diag, m, k,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasStbmvStridedBatchedFortran = & + hipblasStbmvStridedBatched(handle, uplo, transA, diag, m, k, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasStbmvStridedBatchedFortran function hipblasDtbmvStridedBatchedFortran(handle, uplo, transA, diag, m, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasDtbmvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasDtbmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5567,18 +5746,18 @@ function hipblasDtbmvStridedBatchedFortran(handle, uplo, transA, diag, m, k, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtbmvStridedBatched(handle, uplo, transA, diag, m, k,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasDtbmvStridedBatchedFortran = & + hipblasDtbmvStridedBatched(handle, uplo, transA, diag, m, k, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasDtbmvStridedBatchedFortran function hipblasCtbmvStridedBatchedFortran(handle, uplo, transA, diag, m, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasCtbmvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasCtbmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5592,18 +5771,18 @@ function hipblasCtbmvStridedBatchedFortran(handle, uplo, transA, diag, m, k, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtbmvStridedBatched(handle, uplo, transA, diag, m, k,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasCtbmvStridedBatchedFortran = & + hipblasCtbmvStridedBatched(handle, uplo, transA, diag, m, k, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasCtbmvStridedBatchedFortran function hipblasZtbmvStridedBatchedFortran(handle, uplo, transA, diag, m, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasZtbmvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasZtbmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5617,19 +5796,19 @@ function hipblasZtbmvStridedBatchedFortran(handle, uplo, transA, diag, m, k, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtbmvStridedBatched(handle, uplo, transA, diag, m, k,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasZtbmvStridedBatchedFortran = & + hipblasZtbmvStridedBatched(handle, uplo, transA, diag, m, k, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasZtbmvStridedBatchedFortran ! tbsv function hipblasStbsvFortran(handle, uplo, transA, diag, n, k, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasStbsvFortran') + A, lda, x, incx) & + bind(c, name='hipblasStbsvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5640,18 +5819,18 @@ function hipblasStbsvFortran(handle, uplo, transA, diag, n, k, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasStbsv(handle, uplo, transA, diag, n, k,& - A, lda, x, incx) + hipblasStbsvFortran = & + hipblasStbsv(handle, uplo, transA, diag, n, k, & + A, lda, x, incx) end function hipblasStbsvFortran function hipblasDtbsvFortran(handle, uplo, transA, diag, n, k, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasDtbsvFortran') + A, lda, x, incx) & + bind(c, name='hipblasDtbsvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5662,18 +5841,18 @@ function hipblasDtbsvFortran(handle, uplo, transA, diag, n, k, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasDtbsv(handle, uplo, transA, diag, n, k,& - A, lda, x, incx) + hipblasDtbsvFortran = & + hipblasDtbsv(handle, uplo, transA, diag, n, k, & + A, lda, x, incx) end function hipblasDtbsvFortran function hipblasCtbsvFortran(handle, uplo, transA, diag, n, k, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasCtbsvFortran') + A, lda, x, incx) & + bind(c, name='hipblasCtbsvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5684,18 +5863,18 @@ function hipblasCtbsvFortran(handle, uplo, transA, diag, n, k, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasCtbsv(handle, uplo, transA, diag, n, k,& - A, lda, x, incx) + hipblasCtbsvFortran = & + hipblasCtbsv(handle, uplo, transA, diag, n, k, & + A, lda, x, incx) end function hipblasCtbsvFortran function hipblasZtbsvFortran(handle, uplo, transA, diag, n, k, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasZtbsvFortran') + A, lda, x, incx) & + bind(c, name='hipblasZtbsvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5706,19 +5885,19 @@ function hipblasZtbsvFortran(handle, uplo, transA, diag, n, k, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasZtbsv(handle, uplo, transA, diag, n, k,& - A, lda, x, incx) + hipblasZtbsvFortran = & + hipblasZtbsv(handle, uplo, transA, diag, n, k, & + A, lda, x, incx) end function hipblasZtbsvFortran ! tbsvBatched function hipblasStbsvBatchedFortran(handle, uplo, transA, diag, n, k, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasStbsvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasStbsvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5730,18 +5909,18 @@ function hipblasStbsvBatchedFortran(handle, uplo, transA, diag, n, k, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStbsvBatched(handle, uplo, transA, diag, n, k,& - A, lda, x, incx, batch_count) + hipblasStbsvBatchedFortran = & + hipblasStbsvBatched(handle, uplo, transA, diag, n, k, & + A, lda, x, incx, batch_count) end function hipblasStbsvBatchedFortran function hipblasDtbsvBatchedFortran(handle, uplo, transA, diag, n, k, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasDtbsvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasDtbsvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5753,18 +5932,18 @@ function hipblasDtbsvBatchedFortran(handle, uplo, transA, diag, n, k, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtbsvBatched(handle, uplo, transA, diag, n, k,& - A, lda, x, incx, batch_count) + hipblasDtbsvBatchedFortran = & + hipblasDtbsvBatched(handle, uplo, transA, diag, n, k, & + A, lda, x, incx, batch_count) end function hipblasDtbsvBatchedFortran function hipblasCtbsvBatchedFortran(handle, uplo, transA, diag, n, k, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasCtbsvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasCtbsvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5776,18 +5955,18 @@ function hipblasCtbsvBatchedFortran(handle, uplo, transA, diag, n, k, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtbsvBatched(handle, uplo, transA, diag, n, k,& - A, lda, x, incx, batch_count) + hipblasCtbsvBatchedFortran = & + hipblasCtbsvBatched(handle, uplo, transA, diag, n, k, & + A, lda, x, incx, batch_count) end function hipblasCtbsvBatchedFortran function hipblasZtbsvBatchedFortran(handle, uplo, transA, diag, n, k, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasZtbsvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasZtbsvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5799,19 +5978,19 @@ function hipblasZtbsvBatchedFortran(handle, uplo, transA, diag, n, k, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtbsvBatched(handle, uplo, transA, diag, n, k,& - A, lda, x, incx, batch_count) + hipblasZtbsvBatchedFortran = & + hipblasZtbsvBatched(handle, uplo, transA, diag, n, k, & + A, lda, x, incx, batch_count) end function hipblasZtbsvBatchedFortran ! tbsvStridedBatched function hipblasStbsvStridedBatchedFortran(handle, uplo, transA, diag, n, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasStbsvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasStbsvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5825,18 +6004,18 @@ function hipblasStbsvStridedBatchedFortran(handle, uplo, transA, diag, n, k, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStbsvStridedBatched(handle, uplo, transA, diag, n, k,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasStbsvStridedBatchedFortran = & + hipblasStbsvStridedBatched(handle, uplo, transA, diag, n, k, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasStbsvStridedBatchedFortran function hipblasDtbsvStridedBatchedFortran(handle, uplo, transA, diag, n, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasDtbsvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasDtbsvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5850,18 +6029,18 @@ function hipblasDtbsvStridedBatchedFortran(handle, uplo, transA, diag, n, k, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtbsvStridedBatched(handle, uplo, transA, diag, n, k,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasDtbsvStridedBatchedFortran = & + hipblasDtbsvStridedBatched(handle, uplo, transA, diag, n, k, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasDtbsvStridedBatchedFortran function hipblasCtbsvStridedBatchedFortran(handle, uplo, transA, diag, n, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasCtbsvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasCtbsvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5875,18 +6054,18 @@ function hipblasCtbsvStridedBatchedFortran(handle, uplo, transA, diag, n, k, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtbsvStridedBatched(handle, uplo, transA, diag, n, k,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasCtbsvStridedBatchedFortran = & + hipblasCtbsvStridedBatched(handle, uplo, transA, diag, n, k, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasCtbsvStridedBatchedFortran function hipblasZtbsvStridedBatchedFortran(handle, uplo, transA, diag, n, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasZtbsvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasZtbsvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5900,19 +6079,19 @@ function hipblasZtbsvStridedBatchedFortran(handle, uplo, transA, diag, n, k, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtbsvStridedBatched(handle, uplo, transA, diag, n, k,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasZtbsvStridedBatchedFortran = & + hipblasZtbsvStridedBatched(handle, uplo, transA, diag, n, k, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasZtbsvStridedBatchedFortran ! tpsv function hipblasStpsvFortran(handle, uplo, transA, diag, n, & - AP, x, incx) & - result(res) & - bind(c, name = 'hipblasStpsvFortran') + AP, x, incx) & + bind(c, name='hipblasStpsvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5921,18 +6100,18 @@ function hipblasStpsvFortran(handle, uplo, transA, diag, n, & type(c_ptr), value :: AP type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasStpsv(handle, uplo, transA, diag, n,& - AP, x, incx) + hipblasStpsvFortran = & + hipblasStpsv(handle, uplo, transA, diag, n, & + AP, x, incx) end function hipblasStpsvFortran function hipblasDtpsvFortran(handle, uplo, transA, diag, n, & - AP, x, incx) & - result(res) & - bind(c, name = 'hipblasDtpsvFortran') + AP, x, incx) & + bind(c, name='hipblasDtpsvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5941,18 +6120,18 @@ function hipblasDtpsvFortran(handle, uplo, transA, diag, n, & type(c_ptr), value :: AP type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasDtpsv(handle, uplo, transA, diag, n,& - AP, x, incx) + hipblasDtpsvFortran = & + hipblasDtpsv(handle, uplo, transA, diag, n, & + AP, x, incx) end function hipblasDtpsvFortran function hipblasCtpsvFortran(handle, uplo, transA, diag, n, & - AP, x, incx) & - result(res) & - bind(c, name = 'hipblasCtpsvFortran') + AP, x, incx) & + bind(c, name='hipblasCtpsvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5961,18 +6140,18 @@ function hipblasCtpsvFortran(handle, uplo, transA, diag, n, & type(c_ptr), value :: AP type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasCtpsv(handle, uplo, transA, diag, n,& - AP, x, incx) + hipblasCtpsvFortran = & + hipblasCtpsv(handle, uplo, transA, diag, n, & + AP, x, incx) end function hipblasCtpsvFortran function hipblasZtpsvFortran(handle, uplo, transA, diag, n, & - AP, x, incx) & - result(res) & - bind(c, name = 'hipblasZtpsvFortran') + AP, x, incx) & + bind(c, name='hipblasZtpsvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5981,19 +6160,19 @@ function hipblasZtpsvFortran(handle, uplo, transA, diag, n, & type(c_ptr), value :: AP type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasZtpsv(handle, uplo, transA, diag, n,& - AP, x, incx) + hipblasZtpsvFortran = & + hipblasZtpsv(handle, uplo, transA, diag, n, & + AP, x, incx) end function hipblasZtpsvFortran ! tpsvBatched function hipblasStpsvBatchedFortran(handle, uplo, transA, diag, n, & - AP, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasStpsvBatchedFortran') + AP, x, incx, batch_count) & + bind(c, name='hipblasStpsvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6003,18 +6182,18 @@ function hipblasStpsvBatchedFortran(handle, uplo, transA, diag, n, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStpsvBatched(handle, uplo, transA, diag, n,& - AP, x, incx, batch_count) + hipblasStpsvBatchedFortran = & + hipblasStpsvBatched(handle, uplo, transA, diag, n, & + AP, x, incx, batch_count) end function hipblasStpsvBatchedFortran function hipblasDtpsvBatchedFortran(handle, uplo, transA, diag, n, & - AP, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasDtpsvBatchedFortran') + AP, x, incx, batch_count) & + bind(c, name='hipblasDtpsvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6024,18 +6203,18 @@ function hipblasDtpsvBatchedFortran(handle, uplo, transA, diag, n, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtpsvBatched(handle, uplo, transA, diag, n,& - AP, x, incx, batch_count) + hipblasDtpsvBatchedFortran = & + hipblasDtpsvBatched(handle, uplo, transA, diag, n, & + AP, x, incx, batch_count) end function hipblasDtpsvBatchedFortran function hipblasCtpsvBatchedFortran(handle, uplo, transA, diag, n, & - AP, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasCtpsvBatchedFortran') + AP, x, incx, batch_count) & + bind(c, name='hipblasCtpsvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6045,18 +6224,18 @@ function hipblasCtpsvBatchedFortran(handle, uplo, transA, diag, n, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtpsvBatched(handle, uplo, transA, diag, n,& - AP, x, incx, batch_count) + hipblasCtpsvBatchedFortran = & + hipblasCtpsvBatched(handle, uplo, transA, diag, n, & + AP, x, incx, batch_count) end function hipblasCtpsvBatchedFortran function hipblasZtpsvBatchedFortran(handle, uplo, transA, diag, n, & - AP, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasZtpsvBatchedFortran') + AP, x, incx, batch_count) & + bind(c, name='hipblasZtpsvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6066,19 +6245,19 @@ function hipblasZtpsvBatchedFortran(handle, uplo, transA, diag, n, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtpsvBatched(handle, uplo, transA, diag, n,& - AP, x, incx, batch_count) + hipblasZtpsvBatchedFortran = & + hipblasZtpsvBatched(handle, uplo, transA, diag, n, & + AP, x, incx, batch_count) end function hipblasZtpsvBatchedFortran ! tpsvStridedBatched function hipblasStpsvStridedBatchedFortran(handle, uplo, transA, diag, n, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasStpsvStridedBatchedFortran') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasStpsvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6090,18 +6269,18 @@ function hipblasStpsvStridedBatchedFortran(handle, uplo, transA, diag, n, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStpsvStridedBatched(handle, uplo, transA, diag, n,& - AP, stride_AP, x, incx, stride_x, batch_count) + hipblasStpsvStridedBatchedFortran = & + hipblasStpsvStridedBatched(handle, uplo, transA, diag, n, & + AP, stride_AP, x, incx, stride_x, batch_count) end function hipblasStpsvStridedBatchedFortran function hipblasDtpsvStridedBatchedFortran(handle, uplo, transA, diag, n, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasDtpsvStridedBatchedFortran') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasDtpsvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6113,18 +6292,18 @@ function hipblasDtpsvStridedBatchedFortran(handle, uplo, transA, diag, n, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtpsvStridedBatched(handle, uplo, transA, diag, n,& - AP, stride_AP, x, incx, stride_x, batch_count) + hipblasDtpsvStridedBatchedFortran = & + hipblasDtpsvStridedBatched(handle, uplo, transA, diag, n, & + AP, stride_AP, x, incx, stride_x, batch_count) end function hipblasDtpsvStridedBatchedFortran function hipblasCtpsvStridedBatchedFortran(handle, uplo, transA, diag, n, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasCtpsvStridedBatchedFortran') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasCtpsvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6136,18 +6315,18 @@ function hipblasCtpsvStridedBatchedFortran(handle, uplo, transA, diag, n, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtpsvStridedBatched(handle, uplo, transA, diag, n,& - AP, stride_AP, x, incx, stride_x, batch_count) + hipblasCtpsvStridedBatchedFortran = & + hipblasCtpsvStridedBatched(handle, uplo, transA, diag, n, & + AP, stride_AP, x, incx, stride_x, batch_count) end function hipblasCtpsvStridedBatchedFortran function hipblasZtpsvStridedBatchedFortran(handle, uplo, transA, diag, n, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasZtpsvStridedBatchedFortran') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasZtpsvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6159,19 +6338,19 @@ function hipblasZtpsvStridedBatchedFortran(handle, uplo, transA, diag, n, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtpsvStridedBatched(handle, uplo, transA, diag, n,& - AP, stride_AP, x, incx, stride_x, batch_count) + hipblasZtpsvStridedBatchedFortran = & + hipblasZtpsvStridedBatched(handle, uplo, transA, diag, n, & + AP, stride_AP, x, incx, stride_x, batch_count) end function hipblasZtpsvStridedBatchedFortran ! symv function hipblasSsymvFortran(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasSsymvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasSsymvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6183,18 +6362,18 @@ function hipblasSsymvFortran(handle, uplo, n, alpha, A, lda, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasSsymv(handle, uplo, n, alpha,& - A, lda, x, incx, beta, y, incy) + hipblasSsymvFortran = & + hipblasSsymv(handle, uplo, n, alpha, & + A, lda, x, incx, beta, y, incy) end function hipblasSsymvFortran function hipblasDsymvFortran(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasDsymvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasDsymvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6206,18 +6385,18 @@ function hipblasDsymvFortran(handle, uplo, n, alpha, A, lda, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasDsymv(handle, uplo, n, alpha,& - A, lda, x, incx, beta, y, incy) + hipblasDsymvFortran = & + hipblasDsymv(handle, uplo, n, alpha, & + A, lda, x, incx, beta, y, incy) end function hipblasDsymvFortran function hipblasCsymvFortran(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasCsymvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasCsymvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6229,18 +6408,18 @@ function hipblasCsymvFortran(handle, uplo, n, alpha, A, lda, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasCsymv(handle, uplo, n, alpha,& - A, lda, x, incx, beta, y, incy) + hipblasCsymvFortran = & + hipblasCsymv(handle, uplo, n, alpha, & + A, lda, x, incx, beta, y, incy) end function hipblasCsymvFortran function hipblasZsymvFortran(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasZsymvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasZsymvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6252,19 +6431,19 @@ function hipblasZsymvFortran(handle, uplo, n, alpha, A, lda, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasZsymv(handle, uplo, n, alpha,& - A, lda, x, incx, beta, y, incy) + hipblasZsymvFortran = & + hipblasZsymv(handle, uplo, n, alpha, & + A, lda, x, incx, beta, y, incy) end function hipblasZsymvFortran ! symvBatched function hipblasSsymvBatchedFortran(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasSsymvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasSsymvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6277,18 +6456,18 @@ function hipblasSsymvBatchedFortran(handle, uplo, n, alpha, A, lda, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsymvBatched(handle, uplo, n, alpha,& - A, lda, x, incx, beta, y, incy, batch_count) + hipblasSsymvBatchedFortran = & + hipblasSsymvBatched(handle, uplo, n, alpha, & + A, lda, x, incx, beta, y, incy, batch_count) end function hipblasSsymvBatchedFortran function hipblasDsymvBatchedFortran(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasDsymvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasDsymvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6301,18 +6480,18 @@ function hipblasDsymvBatchedFortran(handle, uplo, n, alpha, A, lda, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsymvBatched(handle, uplo, n, alpha,& - A, lda, x, incx, beta, y, incy, batch_count) + hipblasDsymvBatchedFortran = & + hipblasDsymvBatched(handle, uplo, n, alpha, & + A, lda, x, incx, beta, y, incy, batch_count) end function hipblasDsymvBatchedFortran function hipblasCsymvBatchedFortran(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasCsymvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasCsymvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6325,18 +6504,18 @@ function hipblasCsymvBatchedFortran(handle, uplo, n, alpha, A, lda, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsymvBatched(handle, uplo, n, alpha,& - A, lda, x, incx, beta, y, incy, batch_count) + hipblasCsymvBatchedFortran = & + hipblasCsymvBatched(handle, uplo, n, alpha, & + A, lda, x, incx, beta, y, incy, batch_count) end function hipblasCsymvBatchedFortran function hipblasZsymvBatchedFortran(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasZsymvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasZsymvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6349,19 +6528,19 @@ function hipblasZsymvBatchedFortran(handle, uplo, n, alpha, A, lda, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsymvBatched(handle, uplo, n, alpha,& - A, lda, x, incx, beta, y, incy, batch_count) + hipblasZsymvBatchedFortran = & + hipblasZsymvBatched(handle, uplo, n, alpha, & + A, lda, x, incx, beta, y, incy, batch_count) end function hipblasZsymvBatchedFortran ! symvStridedBatched function hipblasSsymvStridedBatchedFortran(handle, uplo, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasSsymvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasSsymvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6377,18 +6556,18 @@ function hipblasSsymvStridedBatchedFortran(handle, uplo, n, alpha, A, lda, strid integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsymvStridedBatched(handle, uplo, n, alpha,& - A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasSsymvStridedBatchedFortran = & + hipblasSsymvStridedBatched(handle, uplo, n, alpha, & + A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasSsymvStridedBatchedFortran function hipblasDsymvStridedBatchedFortran(handle, uplo, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasDsymvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasDsymvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6404,18 +6583,18 @@ function hipblasDsymvStridedBatchedFortran(handle, uplo, n, alpha, A, lda, strid integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsymvStridedBatched(handle, uplo, n, alpha,& - A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasDsymvStridedBatchedFortran = & + hipblasDsymvStridedBatched(handle, uplo, n, alpha, & + A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasDsymvStridedBatchedFortran function hipblasCsymvStridedBatchedFortran(handle, uplo, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasCsymvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasCsymvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6431,18 +6610,18 @@ function hipblasCsymvStridedBatchedFortran(handle, uplo, n, alpha, A, lda, strid integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsymvStridedBatched(handle, uplo, n, alpha,& - A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasCsymvStridedBatchedFortran = & + hipblasCsymvStridedBatched(handle, uplo, n, alpha, & + A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasCsymvStridedBatchedFortran function hipblasZsymvStridedBatchedFortran(handle, uplo, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasZsymvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasZsymvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6458,19 +6637,19 @@ function hipblasZsymvStridedBatchedFortran(handle, uplo, n, alpha, A, lda, strid integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsymvStridedBatched(handle, uplo, n, alpha,& - A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasZsymvStridedBatchedFortran = & + hipblasZsymvStridedBatched(handle, uplo, n, alpha, & + A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasZsymvStridedBatchedFortran ! spmv function hipblasSspmvFortran(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasSspmvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasSspmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6481,18 +6660,18 @@ function hipblasSspmvFortran(handle, uplo, n, alpha, AP, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasSspmv(handle, uplo, n, alpha,& - AP, x, incx, beta, y, incy) + hipblasSspmvFortran = & + hipblasSspmv(handle, uplo, n, alpha, & + AP, x, incx, beta, y, incy) end function hipblasSspmvFortran function hipblasDspmvFortran(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasDspmvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasDspmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6503,19 +6682,19 @@ function hipblasDspmvFortran(handle, uplo, n, alpha, AP, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasDspmv(handle, uplo, n, alpha,& - AP, x, incx, beta, y, incy) + hipblasDspmvFortran = & + hipblasDspmv(handle, uplo, n, alpha, & + AP, x, incx, beta, y, incy) end function hipblasDspmvFortran ! spmvBatched function hipblasSspmvBatchedFortran(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasSspmvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasSspmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6527,18 +6706,18 @@ function hipblasSspmvBatchedFortran(handle, uplo, n, alpha, AP, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSspmvBatched(handle, uplo, n, alpha,& - AP, x, incx, beta, y, incy, batch_count) + hipblasSspmvBatchedFortran = & + hipblasSspmvBatched(handle, uplo, n, alpha, & + AP, x, incx, beta, y, incy, batch_count) end function hipblasSspmvBatchedFortran function hipblasDspmvBatchedFortran(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasDspmvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasDspmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6550,19 +6729,19 @@ function hipblasDspmvBatchedFortran(handle, uplo, n, alpha, AP, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDspmvBatched(handle, uplo, n, alpha,& - AP, x, incx, beta, y, incy, batch_count) + hipblasDspmvBatchedFortran = & + hipblasDspmvBatched(handle, uplo, n, alpha, & + AP, x, incx, beta, y, incy, batch_count) end function hipblasDspmvBatchedFortran ! spmvStridedBatched function hipblasSspmvStridedBatchedFortran(handle, uplo, n, alpha, AP, stride_AP, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasSspmvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasSspmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6577,18 +6756,18 @@ function hipblasSspmvStridedBatchedFortran(handle, uplo, n, alpha, AP, stride_AP integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSspmvStridedBatched(handle, uplo, n, alpha,& - AP, stride_AP, x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasSspmvStridedBatchedFortran = & + hipblasSspmvStridedBatched(handle, uplo, n, alpha, & + AP, stride_AP, x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasSspmvStridedBatchedFortran function hipblasDspmvStridedBatchedFortran(handle, uplo, n, alpha, AP, stride_AP, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasDspmvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasDspmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6603,19 +6782,19 @@ function hipblasDspmvStridedBatchedFortran(handle, uplo, n, alpha, AP, stride_AP integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDspmvStridedBatched(handle, uplo, n, alpha,& - AP, stride_AP, x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasDspmvStridedBatchedFortran = & + hipblasDspmvStridedBatched(handle, uplo, n, alpha, & + AP, stride_AP, x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasDspmvStridedBatchedFortran ! sbmv function hipblasSsbmvFortran(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasSsbmvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasSsbmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6628,18 +6807,18 @@ function hipblasSsbmvFortran(handle, uplo, n, k, alpha, A, lda, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasSsbmv(handle, uplo, n, k, alpha,& - A, lda, x, incx, beta, y, incy) + hipblasSsbmvFortran = & + hipblasSsbmv(handle, uplo, n, k, alpha, & + A, lda, x, incx, beta, y, incy) end function hipblasSsbmvFortran function hipblasDsbmvFortran(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy) & - result(res) & - bind(c, name = 'hipblasDsbmvFortran') + x, incx, beta, y, incy) & + bind(c, name='hipblasDsbmvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6652,19 +6831,19 @@ function hipblasDsbmvFortran(handle, uplo, n, k, alpha, A, lda, & type(c_ptr), value :: beta type(c_ptr), value :: y integer(c_int), value :: incy - integer(c_int) :: res - res = hipblasDsbmv(handle, uplo, n, k, alpha,& - A, lda, x, incx, beta, y, incy) + hipblasDsbmvFortran = & + hipblasDsbmv(handle, uplo, n, k, alpha, & + A, lda, x, incx, beta, y, incy) end function hipblasDsbmvFortran ! sbmvBatched function hipblasSsbmvBatchedFortran(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasSsbmvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasSsbmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6678,18 +6857,18 @@ function hipblasSsbmvBatchedFortran(handle, uplo, n, k, alpha, A, lda, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsbmvBatched(handle, uplo, n, k, alpha,& - A, lda, x, incx, beta, y, incy, batch_count) + hipblasSsbmvBatchedFortran = & + hipblasSsbmvBatched(handle, uplo, n, k, alpha, & + A, lda, x, incx, beta, y, incy, batch_count) end function hipblasSsbmvBatchedFortran function hipblasDsbmvBatchedFortran(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(res) & - bind(c, name = 'hipblasDsbmvBatchedFortran') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasDsbmvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6703,19 +6882,19 @@ function hipblasDsbmvBatchedFortran(handle, uplo, n, k, alpha, A, lda, & type(c_ptr), value :: y integer(c_int), value :: incy integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsbmvBatched(handle, uplo, n, k, alpha,& - A, lda, x, incx, beta, y, incy, batch_count) + hipblasDsbmvBatchedFortran = & + hipblasDsbmvBatched(handle, uplo, n, k, alpha, & + A, lda, x, incx, beta, y, incy, batch_count) end function hipblasDsbmvBatchedFortran ! sbmvStridedBatched function hipblasSsbmvStridedBatchedFortran(handle, uplo, n, k, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasSsbmvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasSsbmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6732,18 +6911,18 @@ function hipblasSsbmvStridedBatchedFortran(handle, uplo, n, k, alpha, A, lda, st integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsbmvStridedBatched(handle, uplo, n, k, alpha,& - A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasSsbmvStridedBatchedFortran = & + hipblasSsbmvStridedBatched(handle, uplo, n, k, alpha, & + A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasSsbmvStridedBatchedFortran function hipblasDsbmvStridedBatchedFortran(handle, uplo, n, k, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(res) & - bind(c, name = 'hipblasDsbmvStridedBatchedFortran') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasDsbmvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6760,18 +6939,19 @@ function hipblasDsbmvStridedBatchedFortran(handle, uplo, n, k, alpha, A, lda, st integer(c_int), value :: incy integer(c_int64_t), value :: stride_y integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsbmvStridedBatched(handle, uplo, n, k, alpha,& - A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count) + hipblasDsbmvStridedBatchedFortran = & + hipblasDsbmvStridedBatched(handle, uplo, n, k, alpha, & + A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count) end function hipblasDsbmvStridedBatchedFortran ! ger function hipblasSgerFortran(handle, m, n, alpha, x, incx, & - y, incy, A, lda) & - result(res) & - bind(c, name = 'hipblasSgerFortran') + y, incy, A, lda) & + bind(c, name='hipblasSgerFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgerFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6782,17 +6962,18 @@ function hipblasSgerFortran(handle, m, n, alpha, x, incx, & integer(c_int), value :: incy type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasSger(handle, m, n, alpha,& - x, incx, y, incy, A, lda) + hipblasSgerFortran = & + hipblasSger(handle, m, n, alpha, & + x, incx, y, incy, A, lda) end function hipblasSgerFortran function hipblasDgerFortran(handle, m, n, alpha, x, incx, & - y, incy, A, lda) & - result(res) & - bind(c, name = 'hipblasDgerFortran') + y, incy, A, lda) & + bind(c, name='hipblasDgerFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgerFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6803,17 +6984,18 @@ function hipblasDgerFortran(handle, m, n, alpha, x, incx, & integer(c_int), value :: incy type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasDger(handle, m, n, alpha,& - x, incx, y, incy, A, lda) + hipblasDgerFortran = & + hipblasDger(handle, m, n, alpha, & + x, incx, y, incy, A, lda) end function hipblasDgerFortran function hipblasCgeruFortran(handle, m, n, alpha, x, incx, & - y, incy, A, lda) & - result(res) & - bind(c, name = 'hipblasCgeruFortran') + y, incy, A, lda) & + bind(c, name='hipblasCgeruFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeruFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6824,17 +7006,18 @@ function hipblasCgeruFortran(handle, m, n, alpha, x, incx, & integer(c_int), value :: incy type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasCgeru(handle, m, n, alpha,& - x, incx, y, incy, A, lda) + hipblasCgeruFortran = & + hipblasCgeru(handle, m, n, alpha, & + x, incx, y, incy, A, lda) end function hipblasCgeruFortran function hipblasCgercFortran(handle, m, n, alpha, x, incx, & - y, incy, A, lda) & - result(res) & - bind(c, name = 'hipblasCgercFortran') + y, incy, A, lda) & + bind(c, name='hipblasCgercFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgercFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6845,17 +7028,18 @@ function hipblasCgercFortran(handle, m, n, alpha, x, incx, & integer(c_int), value :: incy type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasCgerc(handle, m, n, alpha,& - x, incx, y, incy, A, lda) + hipblasCgercFortran = & + hipblasCgerc(handle, m, n, alpha, & + x, incx, y, incy, A, lda) end function hipblasCgercFortran function hipblasZgeruFortran(handle, m, n, alpha, x, incx, & - y, incy, A, lda) & - result(res) & - bind(c, name = 'hipblasZgeruFortran') + y, incy, A, lda) & + bind(c, name='hipblasZgeruFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeruFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6866,17 +7050,18 @@ function hipblasZgeruFortran(handle, m, n, alpha, x, incx, & integer(c_int), value :: incy type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasZgeru(handle, m, n, alpha,& - x, incx, y, incy, A, lda) + hipblasZgeruFortran = & + hipblasZgeru(handle, m, n, alpha, & + x, incx, y, incy, A, lda) end function hipblasZgeruFortran function hipblasZgercFortran(handle, m, n, alpha, x, incx, & - y, incy, A, lda) & - result(res) & - bind(c, name = 'hipblasZgercFortran') + y, incy, A, lda) & + bind(c, name='hipblasZgercFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgercFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6887,18 +7072,19 @@ function hipblasZgercFortran(handle, m, n, alpha, x, incx, & integer(c_int), value :: incy type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasZgerc(handle, m, n, alpha,& - x, incx, y, incy, A, lda) + hipblasZgercFortran = & + hipblasZgerc(handle, m, n, alpha, & + x, incx, y, incy, A, lda) end function hipblasZgercFortran ! gerBatched function hipblasSgerBatchedFortran(handle, m, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasSgerBatchedFortran') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasSgerBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgerBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6910,17 +7096,18 @@ function hipblasSgerBatchedFortran(handle, m, n, alpha, x, incx, & type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgerBatched(handle, m, n, alpha,& - x, incx, y, incy, A, lda, batch_count) + hipblasSgerBatchedFortran = & + hipblasSgerBatched(handle, m, n, alpha, & + x, incx, y, incy, A, lda, batch_count) end function hipblasSgerBatchedFortran function hipblasDgerBatchedFortran(handle, m, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasDgerBatchedFortran') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasDgerBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgerBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6932,17 +7119,18 @@ function hipblasDgerBatchedFortran(handle, m, n, alpha, x, incx, & type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgerBatched(handle, m, n, alpha,& - x, incx, y, incy, A, lda, batch_count) + hipblasDgerBatchedFortran = & + hipblasDgerBatched(handle, m, n, alpha, & + x, incx, y, incy, A, lda, batch_count) end function hipblasDgerBatchedFortran function hipblasCgeruBatchedFortran(handle, m, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasCgeruBatchedFortran') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasCgeruBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeruBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6954,17 +7142,18 @@ function hipblasCgeruBatchedFortran(handle, m, n, alpha, x, incx, & type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgeruBatched(handle, m, n, alpha,& - x, incx, y, incy, A, lda, batch_count) + hipblasCgeruBatchedFortran = & + hipblasCgeruBatched(handle, m, n, alpha, & + x, incx, y, incy, A, lda, batch_count) end function hipblasCgeruBatchedFortran function hipblasCgercBatchedFortran(handle, m, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasCgercBatchedFortran') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasCgercBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgercBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6976,17 +7165,18 @@ function hipblasCgercBatchedFortran(handle, m, n, alpha, x, incx, & type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgercBatched(handle, m, n, alpha,& - x, incx, y, incy, A, lda, batch_count) + hipblasCgercBatchedFortran = & + hipblasCgercBatched(handle, m, n, alpha, & + x, incx, y, incy, A, lda, batch_count) end function hipblasCgercBatchedFortran function hipblasZgeruBatchedFortran(handle, m, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasZgeruBatchedFortran') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasZgeruBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeruBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6998,17 +7188,18 @@ function hipblasZgeruBatchedFortran(handle, m, n, alpha, x, incx, & type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgeruBatched(handle, m, n, alpha,& - x, incx, y, incy, A, lda, batch_count) + hipblasZgeruBatchedFortran = & + hipblasZgeruBatched(handle, m, n, alpha, & + x, incx, y, incy, A, lda, batch_count) end function hipblasZgeruBatchedFortran function hipblasZgercBatchedFortran(handle, m, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasZgercBatchedFortran') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasZgercBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgercBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7020,18 +7211,19 @@ function hipblasZgercBatchedFortran(handle, m, n, alpha, x, incx, & type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgercBatched(handle, m, n, alpha,& - x, incx, y, incy, A, lda, batch_count) + hipblasZgercBatchedFortran = & + hipblasZgercBatched(handle, m, n, alpha, & + x, incx, y, incy, A, lda, batch_count) end function hipblasZgercBatchedFortran ! gerStridedBatched function hipblasSgerStridedBatchedFortran(handle, m, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasSgerStridedBatchedFortran') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasSgerStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgerStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7046,17 +7238,18 @@ function hipblasSgerStridedBatchedFortran(handle, m, n, alpha, x, incx, stride_x integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgerStridedBatched(handle, m, n, alpha,& - x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) + hipblasSgerStridedBatchedFortran = & + hipblasSgerStridedBatched(handle, m, n, alpha, & + x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) end function hipblasSgerStridedBatchedFortran function hipblasDgerStridedBatchedFortran(handle, m, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasDgerStridedBatchedFortran') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasDgerStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgerStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7071,17 +7264,18 @@ function hipblasDgerStridedBatchedFortran(handle, m, n, alpha, x, incx, stride_x integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgerStridedBatched(handle, m, n, alpha,& - x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) + hipblasDgerStridedBatchedFortran = & + hipblasDgerStridedBatched(handle, m, n, alpha, & + x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) end function hipblasDgerStridedBatchedFortran function hipblasCgeruStridedBatchedFortran(handle, m, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasCgeruStridedBatchedFortran') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasCgeruStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeruStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7096,17 +7290,18 @@ function hipblasCgeruStridedBatchedFortran(handle, m, n, alpha, x, incx, stride_ integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgeruStridedBatched(handle, m, n, alpha,& - x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) + hipblasCgeruStridedBatchedFortran = & + hipblasCgeruStridedBatched(handle, m, n, alpha, & + x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) end function hipblasCgeruStridedBatchedFortran function hipblasCgercStridedBatchedFortran(handle, m, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasCgercStridedBatchedFortran') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasCgercStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgercStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7121,17 +7316,18 @@ function hipblasCgercStridedBatchedFortran(handle, m, n, alpha, x, incx, stride_ integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgercStridedBatched(handle, m, n, alpha,& - x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) + hipblasCgercStridedBatchedFortran = & + hipblasCgercStridedBatched(handle, m, n, alpha, & + x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) end function hipblasCgercStridedBatchedFortran function hipblasZgeruStridedBatchedFortran(handle, m, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasZgeruStridedBatchedFortran') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasZgeruStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeruStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7146,17 +7342,18 @@ function hipblasZgeruStridedBatchedFortran(handle, m, n, alpha, x, incx, stride_ integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgeruStridedBatched(handle, m, n, alpha,& - x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) + hipblasZgeruStridedBatchedFortran = & + hipblasZgeruStridedBatched(handle, m, n, alpha, & + x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) end function hipblasZgeruStridedBatchedFortran function hipblasZgercStridedBatchedFortran(handle, m, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasZgercStridedBatchedFortran') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasZgercStridedBatchedFortran') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgercStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7171,18 +7368,18 @@ function hipblasZgercStridedBatchedFortran(handle, m, n, alpha, x, incx, stride_ integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgercStridedBatched(handle, m, n, alpha,& - x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) + hipblasZgercStridedBatchedFortran = & + hipblasZgercStridedBatched(handle, m, n, alpha, & + x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) end function hipblasZgercStridedBatchedFortran ! spr function hipblasSsprFortran(handle, uplo, n, alpha, x, incx, AP) & - result(res) & - bind(c, name = 'hipblasSsprFortran') + bind(c, name='hipblasSsprFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsprFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7190,17 +7387,17 @@ function hipblasSsprFortran(handle, uplo, n, alpha, x, incx, AP) & type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: AP - integer(c_int) :: res - res = hipblasSspr(handle, uplo, n, alpha,& - x, incx, AP) + hipblasSsprFortran = & + hipblasSspr(handle, uplo, n, alpha, & + x, incx, AP) end function hipblasSsprFortran function hipblasDsprFortran(handle, uplo, n, alpha, x, incx, AP) & - result(res) & - bind(c, name = 'hipblasDsprFortran') + bind(c, name='hipblasDsprFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsprFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7208,17 +7405,17 @@ function hipblasDsprFortran(handle, uplo, n, alpha, x, incx, AP) & type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: AP - integer(c_int) :: res - res = hipblasDspr(handle, uplo, n, alpha,& - x, incx, AP) + hipblasDsprFortran = & + hipblasDspr(handle, uplo, n, alpha, & + x, incx, AP) end function hipblasDsprFortran function hipblasCsprFortran(handle, uplo, n, alpha, x, incx, AP) & - result(res) & - bind(c, name = 'hipblasCsprFortran') + bind(c, name='hipblasCsprFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsprFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7226,17 +7423,17 @@ function hipblasCsprFortran(handle, uplo, n, alpha, x, incx, AP) & type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: AP - integer(c_int) :: res - res = hipblasCspr(handle, uplo, n, alpha,& - x, incx, AP) + hipblasCsprFortran = & + hipblasCspr(handle, uplo, n, alpha, & + x, incx, AP) end function hipblasCsprFortran function hipblasZsprFortran(handle, uplo, n, alpha, x, incx, AP) & - result(res) & - bind(c, name = 'hipblasZsprFortran') + bind(c, name='hipblasZsprFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsprFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7244,18 +7441,18 @@ function hipblasZsprFortran(handle, uplo, n, alpha, x, incx, AP) & type(c_ptr), value :: x integer(c_int), value :: incx type(c_ptr), value :: AP - integer(c_int) :: res - res = hipblasZspr(handle, uplo, n, alpha,& - x, incx, AP) + hipblasZsprFortran = & + hipblasZspr(handle, uplo, n, alpha, & + x, incx, AP) end function hipblasZsprFortran ! sprBatched function hipblasSsprBatchedFortran(handle, uplo, n, alpha, x, incx, AP, batch_count) & - result(res) & - bind(c, name = 'hipblasSsprBatchedFortran') + bind(c, name='hipblasSsprBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsprBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7264,17 +7461,17 @@ function hipblasSsprBatchedFortran(handle, uplo, n, alpha, x, incx, AP, batch_co integer(c_int), value :: incx type(c_ptr), value :: AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsprBatched(handle, uplo, n, alpha,& - x, incx, AP, batch_count) + hipblasSsprBatchedFortran = & + hipblasSsprBatched(handle, uplo, n, alpha, & + x, incx, AP, batch_count) end function hipblasSsprBatchedFortran function hipblasDsprBatchedFortran(handle, uplo, n, alpha, x, incx, AP, batch_count) & - result(res) & - bind(c, name = 'hipblasDsprBatchedFortran') + bind(c, name='hipblasDsprBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsprBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7283,17 +7480,17 @@ function hipblasDsprBatchedFortran(handle, uplo, n, alpha, x, incx, AP, batch_co integer(c_int), value :: incx type(c_ptr), value :: AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsprBatched(handle, uplo, n, alpha,& - x, incx, AP, batch_count) + hipblasDsprBatchedFortran = & + hipblasDsprBatched(handle, uplo, n, alpha, & + x, incx, AP, batch_count) end function hipblasDsprBatchedFortran function hipblasCsprBatchedFortran(handle, uplo, n, alpha, x, incx, AP, batch_count) & - result(res) & - bind(c, name = 'hipblasCsprBatchedFortran') + bind(c, name='hipblasCsprBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsprBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7302,17 +7499,17 @@ function hipblasCsprBatchedFortran(handle, uplo, n, alpha, x, incx, AP, batch_co integer(c_int), value :: incx type(c_ptr), value :: AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsprBatched(handle, uplo, n, alpha,& - x, incx, AP, batch_count) + hipblasCsprBatchedFortran = & + hipblasCsprBatched(handle, uplo, n, alpha, & + x, incx, AP, batch_count) end function hipblasCsprBatchedFortran function hipblasZsprBatchedFortran(handle, uplo, n, alpha, x, incx, AP, batch_count) & - result(res) & - bind(c, name = 'hipblasZsprBatchedFortran') + bind(c, name='hipblasZsprBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsprBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7321,19 +7518,19 @@ function hipblasZsprBatchedFortran(handle, uplo, n, alpha, x, incx, AP, batch_co integer(c_int), value :: incx type(c_ptr), value :: AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsprBatched(handle, uplo, n, alpha,& - x, incx, AP, batch_count) + hipblasZsprBatchedFortran = & + hipblasZsprBatched(handle, uplo, n, alpha, & + x, incx, AP, batch_count) end function hipblasZsprBatchedFortran ! sprStridedBatched function hipblasSsprStridedBatchedFortran(handle, uplo, n, alpha, x, incx, stride_x, & - AP, stride_AP, batch_count) & - result(res) & - bind(c, name = 'hipblasSsprStridedBatchedFortran') + AP, stride_AP, batch_count) & + bind(c, name='hipblasSsprStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsprStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7344,18 +7541,18 @@ function hipblasSsprStridedBatchedFortran(handle, uplo, n, alpha, x, incx, strid type(c_ptr), value :: AP integer(c_int64_t), value :: stride_AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsprStridedBatched(handle, uplo, n, alpha,& - x, incx, stride_x, AP, stride_AP, batch_count) + hipblasSsprStridedBatchedFortran = & + hipblasSsprStridedBatched(handle, uplo, n, alpha, & + x, incx, stride_x, AP, stride_AP, batch_count) end function hipblasSsprStridedBatchedFortran function hipblasDsprStridedBatchedFortran(handle, uplo, n, alpha, x, incx, stride_x, & - AP, stride_AP, batch_count) & - result(res) & - bind(c, name = 'hipblasDsprStridedBatchedFortran') + AP, stride_AP, batch_count) & + bind(c, name='hipblasDsprStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsprStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7366,18 +7563,18 @@ function hipblasDsprStridedBatchedFortran(handle, uplo, n, alpha, x, incx, strid type(c_ptr), value :: AP integer(c_int64_t), value :: stride_AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsprStridedBatched(handle, uplo, n, alpha,& - x, incx, stride_x, AP, stride_AP, batch_count) + hipblasDsprStridedBatchedFortran = & + hipblasDsprStridedBatched(handle, uplo, n, alpha, & + x, incx, stride_x, AP, stride_AP, batch_count) end function hipblasDsprStridedBatchedFortran function hipblasCsprStridedBatchedFortran(handle, uplo, n, alpha, x, incx, stride_x, & - AP, stride_AP, batch_count) & - result(res) & - bind(c, name = 'hipblasCsprStridedBatchedFortran') + AP, stride_AP, batch_count) & + bind(c, name='hipblasCsprStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsprStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7388,18 +7585,18 @@ function hipblasCsprStridedBatchedFortran(handle, uplo, n, alpha, x, incx, strid type(c_ptr), value :: AP integer(c_int64_t), value :: stride_AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsprStridedBatched(handle, uplo, n, alpha,& - x, incx, stride_x, AP, stride_AP, batch_count) + hipblasCsprStridedBatchedFortran = & + hipblasCsprStridedBatched(handle, uplo, n, alpha, & + x, incx, stride_x, AP, stride_AP, batch_count) end function hipblasCsprStridedBatchedFortran function hipblasZsprStridedBatchedFortran(handle, uplo, n, alpha, x, incx, stride_x, & - AP, stride_AP, batch_count) & - result(res) & - bind(c, name = 'hipblasZsprStridedBatchedFortran') + AP, stride_AP, batch_count) & + bind(c, name='hipblasZsprStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsprStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7410,19 +7607,19 @@ function hipblasZsprStridedBatchedFortran(handle, uplo, n, alpha, x, incx, strid type(c_ptr), value :: AP integer(c_int64_t), value :: stride_AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsprStridedBatched(handle, uplo, n, alpha,& - x, incx, stride_x, AP, stride_AP, batch_count) + hipblasZsprStridedBatchedFortran = & + hipblasZsprStridedBatched(handle, uplo, n, alpha, & + x, incx, stride_x, AP, stride_AP, batch_count) end function hipblasZsprStridedBatchedFortran ! spr2 function hipblasSspr2Fortran(handle, uplo, n, alpha, x, incx, & - y, incy, AP) & - result(res) & - bind(c, name = 'hipblasSspr2Fortran') + y, incy, AP) & + bind(c, name='hipblasSspr2Fortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2Fortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7432,18 +7629,18 @@ function hipblasSspr2Fortran(handle, uplo, n, alpha, x, incx, & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: AP - integer(c_int) :: res - res = hipblasSspr2(handle, uplo, n, alpha,& - x, incx, y, incy, AP) + hipblasSspr2Fortran = & + hipblasSspr2(handle, uplo, n, alpha, & + x, incx, y, incy, AP) end function hipblasSspr2Fortran function hipblasDspr2Fortran(handle, uplo, n, alpha, x, incx, & - y, incy, AP) & - result(res) & - bind(c, name = 'hipblasDspr2Fortran') + y, incy, AP) & + bind(c, name='hipblasDspr2Fortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2Fortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7453,19 +7650,19 @@ function hipblasDspr2Fortran(handle, uplo, n, alpha, x, incx, & type(c_ptr), value :: y integer(c_int), value :: incy type(c_ptr), value :: AP - integer(c_int) :: res - res = hipblasDspr2(handle, uplo, n, alpha,& - x, incx, y, incy, AP) + hipblasDspr2Fortran = & + hipblasDspr2(handle, uplo, n, alpha, & + x, incx, y, incy, AP) end function hipblasDspr2Fortran ! spr2Batched function hipblasSspr2BatchedFortran(handle, uplo, n, alpha, x, incx, & - y, incy, AP, batch_count) & - result(res) & - bind(c, name = 'hipblasSspr2BatchedFortran') + y, incy, AP, batch_count) & + bind(c, name='hipblasSspr2BatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2BatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7476,18 +7673,18 @@ function hipblasSspr2BatchedFortran(handle, uplo, n, alpha, x, incx, & integer(c_int), value :: incy type(c_ptr), value :: AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSspr2Batched(handle, uplo, n, alpha,& - x, incx, y, incy, AP, batch_count) + hipblasSspr2BatchedFortran = & + hipblasSspr2Batched(handle, uplo, n, alpha, & + x, incx, y, incy, AP, batch_count) end function hipblasSspr2BatchedFortran function hipblasDspr2BatchedFortran(handle, uplo, n, alpha, x, incx, & - y, incy, AP, batch_count) & - result(res) & - bind(c, name = 'hipblasDspr2BatchedFortran') + y, incy, AP, batch_count) & + bind(c, name='hipblasDspr2BatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2BatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7498,19 +7695,19 @@ function hipblasDspr2BatchedFortran(handle, uplo, n, alpha, x, incx, & integer(c_int), value :: incy type(c_ptr), value :: AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDspr2Batched(handle, uplo, n, alpha,& - x, incx, y, incy, AP, batch_count) + hipblasDspr2BatchedFortran = & + hipblasDspr2Batched(handle, uplo, n, alpha, & + x, incx, y, incy, AP, batch_count) end function hipblasDspr2BatchedFortran ! spr2StridedBatched function hipblasSspr2StridedBatchedFortran(handle, uplo, n, alpha, x, incx, stride_x, & - y, incy, stride_y, AP, stride_AP, batch_count) & - result(res) & - bind(c, name = 'hipblasSspr2StridedBatchedFortran') + y, incy, stride_y, AP, stride_AP, batch_count) & + bind(c, name='hipblasSspr2StridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2StridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7524,18 +7721,18 @@ function hipblasSspr2StridedBatchedFortran(handle, uplo, n, alpha, x, incx, stri type(c_ptr), value :: AP integer(c_int64_t), value :: stride_AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSspr2StridedBatched(handle, uplo, n, alpha,& - x, incx, stride_x, y, incy, stride_y, AP, stride_AP, batch_count) + hipblasSspr2StridedBatchedFortran = & + hipblasSspr2StridedBatched(handle, uplo, n, alpha, & + x, incx, stride_x, y, incy, stride_y, AP, stride_AP, batch_count) end function hipblasSspr2StridedBatchedFortran function hipblasDspr2StridedBatchedFortran(handle, uplo, n, alpha, x, incx, stride_x, & - y, incy, stride_y, AP, stride_AP, batch_count) & - result(res) & - bind(c, name = 'hipblasDspr2StridedBatchedFortran') + y, incy, stride_y, AP, stride_AP, batch_count) & + bind(c, name='hipblasDspr2StridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2StridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7549,18 +7746,18 @@ function hipblasDspr2StridedBatchedFortran(handle, uplo, n, alpha, x, incx, stri type(c_ptr), value :: AP integer(c_int64_t), value :: stride_AP integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDspr2StridedBatched(handle, uplo, n, alpha,& - x, incx, stride_x, y, incy, stride_y, AP, stride_AP, batch_count) + hipblasDspr2StridedBatchedFortran = & + hipblasDspr2StridedBatched(handle, uplo, n, alpha, & + x, incx, stride_x, y, incy, stride_y, AP, stride_AP, batch_count) end function hipblasDspr2StridedBatchedFortran ! syr function hipblasSsyrFortran(handle, uplo, n, alpha, x, incx, A, lda) & - result(res) & - bind(c, name = 'hipblasSsyrFortran') + bind(c, name='hipblasSsyrFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7569,17 +7766,17 @@ function hipblasSsyrFortran(handle, uplo, n, alpha, x, incx, A, lda) & integer(c_int), value :: incx type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasSsyr(handle, uplo, n, alpha,& - x, incx, A, lda) + hipblasSsyrFortran = & + hipblasSsyr(handle, uplo, n, alpha, & + x, incx, A, lda) end function hipblasSsyrFortran function hipblasDsyrFortran(handle, uplo, n, alpha, x, incx, A, lda) & - result(res) & - bind(c, name = 'hipblasDsyrFortran') + bind(c, name='hipblasDsyrFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7588,17 +7785,17 @@ function hipblasDsyrFortran(handle, uplo, n, alpha, x, incx, A, lda) & integer(c_int), value :: incx type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasDsyr(handle, uplo, n, alpha,& - x, incx, A, lda) + hipblasDsyrFortran = & + hipblasDsyr(handle, uplo, n, alpha, & + x, incx, A, lda) end function hipblasDsyrFortran function hipblasCsyrFortran(handle, uplo, n, alpha, x, incx, A, lda) & - result(res) & - bind(c, name = 'hipblasCsyrFortran') + bind(c, name='hipblasCsyrFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7607,17 +7804,17 @@ function hipblasCsyrFortran(handle, uplo, n, alpha, x, incx, A, lda) & integer(c_int), value :: incx type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasCsyr(handle, uplo, n, alpha,& - x, incx, A, lda) + hipblasCsyrFortran = & + hipblasCsyr(handle, uplo, n, alpha, & + x, incx, A, lda) end function hipblasCsyrFortran function hipblasZsyrFortran(handle, uplo, n, alpha, x, incx, A, lda) & - result(res) & - bind(c, name = 'hipblasZsyrFortran') + bind(c, name='hipblasZsyrFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7626,18 +7823,18 @@ function hipblasZsyrFortran(handle, uplo, n, alpha, x, incx, A, lda) & integer(c_int), value :: incx type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasZsyr(handle, uplo, n, alpha,& - x, incx, A, lda) + hipblasZsyrFortran = & + hipblasZsyr(handle, uplo, n, alpha, & + x, incx, A, lda) end function hipblasZsyrFortran ! syrBatched function hipblasSsyrBatchedFortran(handle, uplo, n, alpha, x, incx, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasSsyrBatchedFortran') + bind(c, name='hipblasSsyrBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7647,17 +7844,17 @@ function hipblasSsyrBatchedFortran(handle, uplo, n, alpha, x, incx, A, lda, batc type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsyrBatched(handle, uplo, n, alpha,& - x, incx, A, lda, batch_count) + hipblasSsyrBatchedFortran = & + hipblasSsyrBatched(handle, uplo, n, alpha, & + x, incx, A, lda, batch_count) end function hipblasSsyrBatchedFortran function hipblasDsyrBatchedFortran(handle, uplo, n, alpha, x, incx, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasDsyrBatchedFortran') + bind(c, name='hipblasDsyrBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7667,17 +7864,17 @@ function hipblasDsyrBatchedFortran(handle, uplo, n, alpha, x, incx, A, lda, batc type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsyrBatched(handle, uplo, n, alpha,& - x, incx, A, lda, batch_count) + hipblasDsyrBatchedFortran = & + hipblasDsyrBatched(handle, uplo, n, alpha, & + x, incx, A, lda, batch_count) end function hipblasDsyrBatchedFortran function hipblasCsyrBatchedFortran(handle, uplo, n, alpha, x, incx, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasCsyrBatchedFortran') + bind(c, name='hipblasCsyrBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7687,17 +7884,17 @@ function hipblasCsyrBatchedFortran(handle, uplo, n, alpha, x, incx, A, lda, batc type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsyrBatched(handle, uplo, n, alpha,& - x, incx, A, lda, batch_count) + hipblasCsyrBatchedFortran = & + hipblasCsyrBatched(handle, uplo, n, alpha, & + x, incx, A, lda, batch_count) end function hipblasCsyrBatchedFortran function hipblasZsyrBatchedFortran(handle, uplo, n, alpha, x, incx, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasZsyrBatchedFortran') + bind(c, name='hipblasZsyrBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7707,19 +7904,19 @@ function hipblasZsyrBatchedFortran(handle, uplo, n, alpha, x, incx, A, lda, batc type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsyrBatched(handle, uplo, n, alpha,& - x, incx, A, lda, batch_count) + hipblasZsyrBatchedFortran = & + hipblasZsyrBatched(handle, uplo, n, alpha, & + x, incx, A, lda, batch_count) end function hipblasZsyrBatchedFortran ! syrStridedBatched function hipblasSsyrStridedBatchedFortran(handle, uplo, n, alpha, x, incx, stride_x, & - A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasSsyrStridedBatchedFortran') + A, lda, stride_A, batch_count) & + bind(c, name='hipblasSsyrStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7731,18 +7928,18 @@ function hipblasSsyrStridedBatchedFortran(handle, uplo, n, alpha, x, incx, strid integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsyrStridedBatched(handle, uplo, n, alpha,& - x, incx, stride_x, A, lda, stride_A, batch_count) + hipblasSsyrStridedBatchedFortran = & + hipblasSsyrStridedBatched(handle, uplo, n, alpha, & + x, incx, stride_x, A, lda, stride_A, batch_count) end function hipblasSsyrStridedBatchedFortran function hipblasDsyrStridedBatchedFortran(handle, uplo, n, alpha, x, incx, stride_x, & - A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasDsyrStridedBatchedFortran') + A, lda, stride_A, batch_count) & + bind(c, name='hipblasDsyrStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7754,18 +7951,18 @@ function hipblasDsyrStridedBatchedFortran(handle, uplo, n, alpha, x, incx, strid integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsyrStridedBatched(handle, uplo, n, alpha,& - x, incx, stride_x, A, lda, stride_A, batch_count) + hipblasDsyrStridedBatchedFortran = & + hipblasDsyrStridedBatched(handle, uplo, n, alpha, & + x, incx, stride_x, A, lda, stride_A, batch_count) end function hipblasDsyrStridedBatchedFortran function hipblasCsyrStridedBatchedFortran(handle, uplo, n, alpha, x, incx, stride_x, & - A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasCsyrStridedBatchedFortran') + A, lda, stride_A, batch_count) & + bind(c, name='hipblasCsyrStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7777,18 +7974,18 @@ function hipblasCsyrStridedBatchedFortran(handle, uplo, n, alpha, x, incx, strid integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsyrStridedBatched(handle, uplo, n, alpha,& - x, incx, stride_x, A, lda, stride_A, batch_count) + hipblasCsyrStridedBatchedFortran = & + hipblasCsyrStridedBatched(handle, uplo, n, alpha, & + x, incx, stride_x, A, lda, stride_A, batch_count) end function hipblasCsyrStridedBatchedFortran function hipblasZsyrStridedBatchedFortran(handle, uplo, n, alpha, x, incx, stride_x, & - A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasZsyrStridedBatchedFortran') + A, lda, stride_A, batch_count) & + bind(c, name='hipblasZsyrStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7800,19 +7997,19 @@ function hipblasZsyrStridedBatchedFortran(handle, uplo, n, alpha, x, incx, strid integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsyrStridedBatched(handle, uplo, n, alpha,& - x, incx, stride_x, A, lda, stride_A, batch_count) + hipblasZsyrStridedBatchedFortran = & + hipblasZsyrStridedBatched(handle, uplo, n, alpha, & + x, incx, stride_x, A, lda, stride_A, batch_count) end function hipblasZsyrStridedBatchedFortran ! syr2 function hipblasSsyr2Fortran(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda) & - result(res) & - bind(c, name = 'hipblasSsyr2Fortran') + y, incy, A, lda) & + bind(c, name='hipblasSsyr2Fortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2Fortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7823,18 +8020,18 @@ function hipblasSsyr2Fortran(handle, uplo, n, alpha, x, incx, & integer(c_int), value :: incy type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasSsyr2(handle, uplo, n, alpha,& - x, incx, y, incy, A, lda) + hipblasSsyr2Fortran = & + hipblasSsyr2(handle, uplo, n, alpha, & + x, incx, y, incy, A, lda) end function hipblasSsyr2Fortran function hipblasDsyr2Fortran(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda) & - result(res) & - bind(c, name = 'hipblasDsyr2Fortran') + y, incy, A, lda) & + bind(c, name='hipblasDsyr2Fortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2Fortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7845,18 +8042,18 @@ function hipblasDsyr2Fortran(handle, uplo, n, alpha, x, incx, & integer(c_int), value :: incy type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasDsyr2(handle, uplo, n, alpha,& - x, incx, y, incy, A, lda) + hipblasDsyr2Fortran = & + hipblasDsyr2(handle, uplo, n, alpha, & + x, incx, y, incy, A, lda) end function hipblasDsyr2Fortran function hipblasCsyr2Fortran(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda) & - result(res) & - bind(c, name = 'hipblasCsyr2Fortran') + y, incy, A, lda) & + bind(c, name='hipblasCsyr2Fortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2Fortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7867,18 +8064,18 @@ function hipblasCsyr2Fortran(handle, uplo, n, alpha, x, incx, & integer(c_int), value :: incy type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasCsyr2(handle, uplo, n, alpha,& - x, incx, y, incy, A, lda) + hipblasCsyr2Fortran = & + hipblasCsyr2(handle, uplo, n, alpha, & + x, incx, y, incy, A, lda) end function hipblasCsyr2Fortran function hipblasZsyr2Fortran(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda) & - result(res) & - bind(c, name = 'hipblasZsyr2Fortran') + y, incy, A, lda) & + bind(c, name='hipblasZsyr2Fortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2Fortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7889,19 +8086,19 @@ function hipblasZsyr2Fortran(handle, uplo, n, alpha, x, incx, & integer(c_int), value :: incy type(c_ptr), value :: A integer(c_int), value :: lda - integer(c_int) :: res - res = hipblasZsyr2(handle, uplo, n, alpha,& - x, incx, y, incy, A, lda) + hipblasZsyr2Fortran = & + hipblasZsyr2(handle, uplo, n, alpha, & + x, incx, y, incy, A, lda) end function hipblasZsyr2Fortran ! syr2Batched function hipblasSsyr2BatchedFortran(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasSsyr2BatchedFortran') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasSsyr2BatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2BatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7913,18 +8110,18 @@ function hipblasSsyr2BatchedFortran(handle, uplo, n, alpha, x, incx, & type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsyr2Batched(handle, uplo, n, alpha,& - x, incx, y, incy, A, lda, batch_count) + hipblasSsyr2BatchedFortran = & + hipblasSsyr2Batched(handle, uplo, n, alpha, & + x, incx, y, incy, A, lda, batch_count) end function hipblasSsyr2BatchedFortran function hipblasDsyr2BatchedFortran(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasDsyr2BatchedFortran') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasDsyr2BatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2BatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7936,18 +8133,18 @@ function hipblasDsyr2BatchedFortran(handle, uplo, n, alpha, x, incx, & type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsyr2Batched(handle, uplo, n, alpha,& - x, incx, y, incy, A, lda, batch_count) + hipblasDsyr2BatchedFortran = & + hipblasDsyr2Batched(handle, uplo, n, alpha, & + x, incx, y, incy, A, lda, batch_count) end function hipblasDsyr2BatchedFortran function hipblasCsyr2BatchedFortran(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasCsyr2BatchedFortran') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasCsyr2BatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2BatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7959,18 +8156,18 @@ function hipblasCsyr2BatchedFortran(handle, uplo, n, alpha, x, incx, & type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsyr2Batched(handle, uplo, n, alpha,& - x, incx, y, incy, A, lda, batch_count) + hipblasCsyr2BatchedFortran = & + hipblasCsyr2Batched(handle, uplo, n, alpha, & + x, incx, y, incy, A, lda, batch_count) end function hipblasCsyr2BatchedFortran function hipblasZsyr2BatchedFortran(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(res) & - bind(c, name = 'hipblasZsyr2BatchedFortran') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasZsyr2BatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2BatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7982,19 +8179,19 @@ function hipblasZsyr2BatchedFortran(handle, uplo, n, alpha, x, incx, & type(c_ptr), value :: A integer(c_int), value :: lda integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsyr2Batched(handle, uplo, n, alpha,& - x, incx, y, incy, A, lda, batch_count) + hipblasZsyr2BatchedFortran = & + hipblasZsyr2Batched(handle, uplo, n, alpha, & + x, incx, y, incy, A, lda, batch_count) end function hipblasZsyr2BatchedFortran ! syr2StridedBatched function hipblasSsyr2StridedBatchedFortran(handle, uplo, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasSsyr2StridedBatchedFortran') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasSsyr2StridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2StridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -8009,18 +8206,18 @@ function hipblasSsyr2StridedBatchedFortran(handle, uplo, n, alpha, x, incx, stri integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsyr2StridedBatched(handle, uplo, n, alpha,& - x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) + hipblasSsyr2StridedBatchedFortran = & + hipblasSsyr2StridedBatched(handle, uplo, n, alpha, & + x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) end function hipblasSsyr2StridedBatchedFortran function hipblasDsyr2StridedBatchedFortran(handle, uplo, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasDsyr2StridedBatchedFortran') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasDsyr2StridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2StridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -8035,18 +8232,18 @@ function hipblasDsyr2StridedBatchedFortran(handle, uplo, n, alpha, x, incx, stri integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsyr2StridedBatched(handle, uplo, n, alpha,& - x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) + hipblasDsyr2StridedBatchedFortran = & + hipblasDsyr2StridedBatched(handle, uplo, n, alpha, & + x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) end function hipblasDsyr2StridedBatchedFortran function hipblasCsyr2StridedBatchedFortran(handle, uplo, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasCsyr2StridedBatchedFortran') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasCsyr2StridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2StridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -8061,18 +8258,18 @@ function hipblasCsyr2StridedBatchedFortran(handle, uplo, n, alpha, x, incx, stri integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsyr2StridedBatched(handle, uplo, n, alpha,& - x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) + hipblasCsyr2StridedBatchedFortran = & + hipblasCsyr2StridedBatched(handle, uplo, n, alpha, & + x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) end function hipblasCsyr2StridedBatchedFortran function hipblasZsyr2StridedBatchedFortran(handle, uplo, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(res) & - bind(c, name = 'hipblasZsyr2StridedBatchedFortran') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasZsyr2StridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2StridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -8087,19 +8284,19 @@ function hipblasZsyr2StridedBatchedFortran(handle, uplo, n, alpha, x, incx, stri integer(c_int), value :: lda integer(c_int64_t), value :: stride_A integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsyr2StridedBatched(handle, uplo, n, alpha,& - x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) + hipblasZsyr2StridedBatchedFortran = & + hipblasZsyr2StridedBatched(handle, uplo, n, alpha, & + x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) end function hipblasZsyr2StridedBatchedFortran ! trsv function hipblasStrsvFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasStrsvFortran') + A, lda, x, incx) & + bind(c, name='hipblasStrsvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8109,18 +8306,18 @@ function hipblasStrsvFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasStrsv(handle, uplo, transA, diag, m,& - A, lda, x, incx) + hipblasStrsvFortran = & + hipblasStrsv(handle, uplo, transA, diag, m, & + A, lda, x, incx) end function hipblasStrsvFortran function hipblasDtrsvFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasDtrsvFortran') + A, lda, x, incx) & + bind(c, name='hipblasDtrsvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8130,18 +8327,18 @@ function hipblasDtrsvFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasDtrsv(handle, uplo, transA, diag, m,& - A, lda, x, incx) + hipblasDtrsvFortran = & + hipblasDtrsv(handle, uplo, transA, diag, m, & + A, lda, x, incx) end function hipblasDtrsvFortran function hipblasCtrsvFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasCtrsvFortran') + A, lda, x, incx) & + bind(c, name='hipblasCtrsvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8151,18 +8348,18 @@ function hipblasCtrsvFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasCtrsv(handle, uplo, transA, diag, m,& - A, lda, x, incx) + hipblasCtrsvFortran = & + hipblasCtrsv(handle, uplo, transA, diag, m, & + A, lda, x, incx) end function hipblasCtrsvFortran function hipblasZtrsvFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(res) & - bind(c, name = 'hipblasZtrsvFortran') + A, lda, x, incx) & + bind(c, name='hipblasZtrsvFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsvFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8172,19 +8369,19 @@ function hipblasZtrsvFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: lda type(c_ptr), value :: x integer(c_int), value :: incx - integer(c_int) :: res - res = hipblasZtrsv(handle, uplo, transA, diag, m,& - A, lda, x, incx) + hipblasZtrsvFortran = & + hipblasZtrsv(handle, uplo, transA, diag, m, & + A, lda, x, incx) end function hipblasZtrsvFortran ! trsvBatched function hipblasStrsvBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasStrsvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasStrsvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8195,18 +8392,18 @@ function hipblasStrsvBatchedFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStrsvBatched(handle, uplo, transA, diag, m,& - A, lda, x, incx, batch_count) + hipblasStrsvBatchedFortran = & + hipblasStrsvBatched(handle, uplo, transA, diag, m, & + A, lda, x, incx, batch_count) end function hipblasStrsvBatchedFortran function hipblasDtrsvBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasDtrsvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasDtrsvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8217,18 +8414,18 @@ function hipblasDtrsvBatchedFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtrsvBatched(handle, uplo, transA, diag, m,& - A, lda, x, incx, batch_count) + hipblasDtrsvBatchedFortran = & + hipblasDtrsvBatched(handle, uplo, transA, diag, m, & + A, lda, x, incx, batch_count) end function hipblasDtrsvBatchedFortran function hipblasCtrsvBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasCtrsvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasCtrsvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8239,18 +8436,18 @@ function hipblasCtrsvBatchedFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtrsvBatched(handle, uplo, transA, diag, m,& - A, lda, x, incx, batch_count) + hipblasCtrsvBatchedFortran = & + hipblasCtrsvBatched(handle, uplo, transA, diag, m, & + A, lda, x, incx, batch_count) end function hipblasCtrsvBatchedFortran function hipblasZtrsvBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(res) & - bind(c, name = 'hipblasZtrsvBatchedFortran') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasZtrsvBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsvBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8261,19 +8458,19 @@ function hipblasZtrsvBatchedFortran(handle, uplo, transA, diag, m, & type(c_ptr), value :: x integer(c_int), value :: incx integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtrsvBatched(handle, uplo, transA, diag, m,& - A, lda, x, incx, batch_count) + hipblasZtrsvBatchedFortran = & + hipblasZtrsvBatched(handle, uplo, transA, diag, m, & + A, lda, x, incx, batch_count) end function hipblasZtrsvBatchedFortran ! trsvStridedBatched function hipblasStrsvStridedBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasStrsvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasStrsvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8286,18 +8483,18 @@ function hipblasStrsvStridedBatchedFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStrsvStridedBatched(handle, uplo, transA, diag, m,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasStrsvStridedBatchedFortran = & + hipblasStrsvStridedBatched(handle, uplo, transA, diag, m, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasStrsvStridedBatchedFortran function hipblasDtrsvStridedBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasDtrsvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasDtrsvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8310,18 +8507,18 @@ function hipblasDtrsvStridedBatchedFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtrsvStridedBatched(handle, uplo, transA, diag, m,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasDtrsvStridedBatchedFortran = & + hipblasDtrsvStridedBatched(handle, uplo, transA, diag, m, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasDtrsvStridedBatchedFortran function hipblasCtrsvStridedBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasCtrsvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasCtrsvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8334,18 +8531,18 @@ function hipblasCtrsvStridedBatchedFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtrsvStridedBatched(handle, uplo, transA, diag, m,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasCtrsvStridedBatchedFortran = & + hipblasCtrsvStridedBatched(handle, uplo, transA, diag, m, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasCtrsvStridedBatchedFortran function hipblasZtrsvStridedBatchedFortran(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(res) & - bind(c, name = 'hipblasZtrsvStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasZtrsvStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsvStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8358,9 +8555,9 @@ function hipblasZtrsvStridedBatchedFortran(handle, uplo, transA, diag, m, & integer(c_int), value :: incx integer(c_int64_t), value :: stride_x integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtrsvStridedBatched(handle, uplo, transA, diag, m,& - A, lda, stride_A, x, incx, stride_x, batch_count) + hipblasZtrsvStridedBatchedFortran = & + hipblasZtrsvStridedBatched(handle, uplo, transA, diag, m, & + A, lda, stride_A, x, incx, stride_x, batch_count) end function hipblasZtrsvStridedBatchedFortran !--------! @@ -8369,12 +8566,12 @@ end function hipblasZtrsvStridedBatchedFortran ! hemm function hipblasChemmFortran(handle, side, uplo, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasChemmFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasChemmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8388,18 +8585,18 @@ function hipblasChemmFortran(handle, side, uplo, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasChemm(handle, side, uplo, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasChemmFortran = & + hipblasChemm(handle, side, uplo, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasChemmFortran function hipblasZhemmFortran(handle, side, uplo, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasZhemmFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasZhemmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8413,19 +8610,19 @@ function hipblasZhemmFortran(handle, side, uplo, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasZhemm(handle, side, uplo, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasZhemmFortran = & + hipblasZhemm(handle, side, uplo, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasZhemmFortran ! hemmBatched function hipblasChemmBatchedFortran(handle, side, uplo, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasChemmBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasChemmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8440,18 +8637,18 @@ function hipblasChemmBatchedFortran(handle, side, uplo, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasChemmBatched(handle, side, uplo, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasChemmBatchedFortran = & + hipblasChemmBatched(handle, side, uplo, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasChemmBatchedFortran function hipblasZhemmBatchedFortran(handle, side, uplo, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasZhemmBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasZhemmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8466,19 +8663,19 @@ function hipblasZhemmBatchedFortran(handle, side, uplo, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZhemmBatched(handle, side, uplo, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasZhemmBatchedFortran = & + hipblasZhemmBatched(handle, side, uplo, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasZhemmBatchedFortran ! hemmStridedBatched function hipblasChemmStridedBatchedFortran(handle, side, uplo, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasChemmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasChemmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8496,18 +8693,18 @@ function hipblasChemmStridedBatchedFortran(handle, side, uplo, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasChemmStridedBatched(handle, side, uplo, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasChemmStridedBatchedFortran = & + hipblasChemmStridedBatched(handle, side, uplo, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasChemmStridedBatchedFortran function hipblasZhemmStridedBatchedFortran(handle, side, uplo, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasZhemmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZhemmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8525,19 +8722,19 @@ function hipblasZhemmStridedBatchedFortran(handle, side, uplo, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZhemmStridedBatched(handle, side, uplo, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasZhemmStridedBatchedFortran = & + hipblasZhemmStridedBatched(handle, side, uplo, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasZhemmStridedBatchedFortran ! herk function hipblasCherkFortran(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasCherkFortran') + A, lda, beta, C, ldc) & + bind(c, name='hipblasCherkFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8549,18 +8746,18 @@ function hipblasCherkFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasCherk(handle, uplo, transA, n, k, alpha,& - A, lda, beta, C, ldc) + hipblasCherkFortran = & + hipblasCherk(handle, uplo, transA, n, k, alpha, & + A, lda, beta, C, ldc) end function hipblasCherkFortran function hipblasZherkFortran(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasZherkFortran') + A, lda, beta, C, ldc) & + bind(c, name='hipblasZherkFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8572,19 +8769,19 @@ function hipblasZherkFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasZherk(handle, uplo, transA, n, k, alpha,& - A, lda, beta, C, ldc) + hipblasZherkFortran = & + hipblasZherk(handle, uplo, transA, n, k, alpha, & + A, lda, beta, C, ldc) end function hipblasZherkFortran ! herkBatched function hipblasCherkBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasCherkBatchedFortran') + A, lda, beta, C, ldc, batch_count) & + bind(c, name='hipblasCherkBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8597,18 +8794,18 @@ function hipblasCherkBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCherkBatched(handle, uplo, transA, n, k, alpha,& - A, lda, beta, C, ldc, batch_count) + hipblasCherkBatchedFortran = & + hipblasCherkBatched(handle, uplo, transA, n, k, alpha, & + A, lda, beta, C, ldc, batch_count) end function hipblasCherkBatchedFortran function hipblasZherkBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasZherkBatchedFortran') + A, lda, beta, C, ldc, batch_count) & + bind(c, name='hipblasZherkBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8621,19 +8818,19 @@ function hipblasZherkBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZherkBatched(handle, uplo, transA, n, k, alpha,& - A, lda, beta, C, ldc, batch_count) + hipblasZherkBatchedFortran = & + hipblasZherkBatched(handle, uplo, transA, n, k, alpha, & + A, lda, beta, C, ldc, batch_count) end function hipblasZherkBatchedFortran ! herkStridedBatched function hipblasCherkStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasCherkStridedBatchedFortran') + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCherkStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8648,18 +8845,18 @@ function hipblasCherkStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCherkStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) + hipblasCherkStridedBatchedFortran = & + hipblasCherkStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) end function hipblasCherkStridedBatchedFortran function hipblasZherkStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasZherkStridedBatchedFortran') + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZherkStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8674,19 +8871,19 @@ function hipblasZherkStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZherkStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) + hipblasZherkStridedBatchedFortran = & + hipblasZherkStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) end function hipblasZherkStridedBatchedFortran ! her2k function hipblasCher2kFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasCher2kFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasCher2kFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2kFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8700,18 +8897,18 @@ function hipblasCher2kFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasCher2k(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasCher2kFortran = & + hipblasCher2k(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasCher2kFortran function hipblasZher2kFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasZher2kFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasZher2kFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2kFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8725,19 +8922,19 @@ function hipblasZher2kFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasZher2k(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasZher2kFortran = & + hipblasZher2k(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasZher2kFortran ! her2kBatched function hipblasCher2kBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasCher2kBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasCher2kBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2kBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8752,18 +8949,18 @@ function hipblasCher2kBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCher2kBatched(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasCher2kBatchedFortran = & + hipblasCher2kBatched(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasCher2kBatchedFortran function hipblasZher2kBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasZher2kBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasZher2kBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2kBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8778,19 +8975,19 @@ function hipblasZher2kBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZher2kBatched(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasZher2kBatchedFortran = & + hipblasZher2kBatched(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasZher2kBatchedFortran ! her2kStridedBatched function hipblasCher2kStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasCher2kStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCher2kStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2kStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8808,18 +9005,18 @@ function hipblasCher2kStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCher2kStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasCher2kStridedBatchedFortran = & + hipblasCher2kStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasCher2kStridedBatchedFortran function hipblasZher2kStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasZher2kStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZher2kStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2kStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8837,19 +9034,19 @@ function hipblasZher2kStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZher2kStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasZher2kStridedBatchedFortran = & + hipblasZher2kStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasZher2kStridedBatchedFortran ! herkx function hipblasCherkxFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasCherkxFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasCherkxFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkxFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8863,18 +9060,18 @@ function hipblasCherkxFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasCherkx(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasCherkxFortran = & + hipblasCherkx(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasCherkxFortran function hipblasZherkxFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasZherkxFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasZherkxFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkxFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8888,19 +9085,19 @@ function hipblasZherkxFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasZherkx(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasZherkxFortran = & + hipblasZherkx(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasZherkxFortran ! herkxBatched function hipblasCherkxBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasCherkxBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasCherkxBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkxBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8915,18 +9112,18 @@ function hipblasCherkxBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCherkxBatched(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasCherkxBatchedFortran = & + hipblasCherkxBatched(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasCherkxBatchedFortran function hipblasZherkxBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasZherkxBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasZherkxBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkxBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8941,19 +9138,19 @@ function hipblasZherkxBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZherkxBatched(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasZherkxBatchedFortran = & + hipblasZherkxBatched(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasZherkxBatchedFortran ! herkxStridedBatched function hipblasCherkxStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasCherkxStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCherkxStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkxStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8971,18 +9168,18 @@ function hipblasCherkxStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCherkxStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasCherkxStridedBatchedFortran = & + hipblasCherkxStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasCherkxStridedBatchedFortran function hipblasZherkxStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasZherkxStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZherkxStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkxStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9000,19 +9197,19 @@ function hipblasZherkxStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZherkxStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasZherkxStridedBatchedFortran = & + hipblasZherkxStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasZherkxStridedBatchedFortran ! symm function hipblasSsymmFortran(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasSsymmFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasSsymmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9026,18 +9223,18 @@ function hipblasSsymmFortran(handle, side, uplo, m, n, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasSsymm(handle, side, uplo, m, n, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasSsymmFortran = & + hipblasSsymm(handle, side, uplo, m, n, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasSsymmFortran function hipblasDsymmFortran(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasDsymmFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasDsymmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9051,18 +9248,18 @@ function hipblasDsymmFortran(handle, side, uplo, m, n, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasDsymm(handle, side, uplo, m, n, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasDsymmFortran = & + hipblasDsymm(handle, side, uplo, m, n, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasDsymmFortran function hipblasCsymmFortran(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasCsymmFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasCsymmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9076,18 +9273,18 @@ function hipblasCsymmFortran(handle, side, uplo, m, n, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasCsymm(handle, side, uplo, m, n, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasCsymmFortran = & + hipblasCsymm(handle, side, uplo, m, n, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasCsymmFortran function hipblasZsymmFortran(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasZsymmFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasZsymmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9101,19 +9298,19 @@ function hipblasZsymmFortran(handle, side, uplo, m, n, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasZsymm(handle, side, uplo, m, n, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasZsymmFortran = & + hipblasZsymm(handle, side, uplo, m, n, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasZsymmFortran ! symmBatched function hipblasSsymmBatchedFortran(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasSsymmBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasSsymmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9128,18 +9325,18 @@ function hipblasSsymmBatchedFortran(handle, side, uplo, m, n, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsymmBatched(handle, side, uplo, m, n, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasSsymmBatchedFortran = & + hipblasSsymmBatched(handle, side, uplo, m, n, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasSsymmBatchedFortran function hipblasDsymmBatchedFortran(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasDsymmBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasDsymmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9154,18 +9351,18 @@ function hipblasDsymmBatchedFortran(handle, side, uplo, m, n, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsymmBatched(handle, side, uplo, m, n, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasDsymmBatchedFortran = & + hipblasDsymmBatched(handle, side, uplo, m, n, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasDsymmBatchedFortran function hipblasCsymmBatchedFortran(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasCsymmBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasCsymmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9180,18 +9377,18 @@ function hipblasCsymmBatchedFortran(handle, side, uplo, m, n, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsymmBatched(handle, side, uplo, m, n, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasCsymmBatchedFortran = & + hipblasCsymmBatched(handle, side, uplo, m, n, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasCsymmBatchedFortran function hipblasZsymmBatchedFortran(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasZsymmBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasZsymmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9206,19 +9403,19 @@ function hipblasZsymmBatchedFortran(handle, side, uplo, m, n, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsymmBatched(handle, side, uplo, m, n, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasZsymmBatchedFortran = & + hipblasZsymmBatched(handle, side, uplo, m, n, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasZsymmBatchedFortran ! symmStridedBatched function hipblasSsymmStridedBatchedFortran(handle, side, uplo, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasSsymmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasSsymmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9236,18 +9433,18 @@ function hipblasSsymmStridedBatchedFortran(handle, side, uplo, m, n, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsymmStridedBatched(handle, side, uplo, m, n, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasSsymmStridedBatchedFortran = & + hipblasSsymmStridedBatched(handle, side, uplo, m, n, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasSsymmStridedBatchedFortran function hipblasDsymmStridedBatchedFortran(handle, side, uplo, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasDsymmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasDsymmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9265,18 +9462,18 @@ function hipblasDsymmStridedBatchedFortran(handle, side, uplo, m, n, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsymmStridedBatched(handle, side, uplo, m, n, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasDsymmStridedBatchedFortran = & + hipblasDsymmStridedBatched(handle, side, uplo, m, n, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasDsymmStridedBatchedFortran function hipblasCsymmStridedBatchedFortran(handle, side, uplo, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasCsymmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCsymmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9294,18 +9491,18 @@ function hipblasCsymmStridedBatchedFortran(handle, side, uplo, m, n, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsymmStridedBatched(handle, side, uplo, m, n, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasCsymmStridedBatchedFortran = & + hipblasCsymmStridedBatched(handle, side, uplo, m, n, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasCsymmStridedBatchedFortran function hipblasZsymmStridedBatchedFortran(handle, side, uplo, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasZsymmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZsymmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9323,19 +9520,19 @@ function hipblasZsymmStridedBatchedFortran(handle, side, uplo, m, n, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsymmStridedBatched(handle, side, uplo, m, n, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasZsymmStridedBatchedFortran = & + hipblasZsymmStridedBatched(handle, side, uplo, m, n, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasZsymmStridedBatchedFortran ! syrk function hipblasSsyrkFortran(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasSsyrkFortran') + A, lda, beta, C, ldc) & + bind(c, name='hipblasSsyrkFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9347,18 +9544,18 @@ function hipblasSsyrkFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasSsyrk(handle, uplo, transA, n, k, alpha,& - A, lda, beta, C, ldc) + hipblasSsyrkFortran = & + hipblasSsyrk(handle, uplo, transA, n, k, alpha, & + A, lda, beta, C, ldc) end function hipblasSsyrkFortran function hipblasDsyrkFortran(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasDsyrkFortran') + A, lda, beta, C, ldc) & + bind(c, name='hipblasDsyrkFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9370,18 +9567,18 @@ function hipblasDsyrkFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasDsyrk(handle, uplo, transA, n, k, alpha,& - A, lda, beta, C, ldc) + hipblasDsyrkFortran = & + hipblasDsyrk(handle, uplo, transA, n, k, alpha, & + A, lda, beta, C, ldc) end function hipblasDsyrkFortran function hipblasCsyrkFortran(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasCsyrkFortran') + A, lda, beta, C, ldc) & + bind(c, name='hipblasCsyrkFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9393,18 +9590,18 @@ function hipblasCsyrkFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasCsyrk(handle, uplo, transA, n, k, alpha,& - A, lda, beta, C, ldc) + hipblasCsyrkFortran = & + hipblasCsyrk(handle, uplo, transA, n, k, alpha, & + A, lda, beta, C, ldc) end function hipblasCsyrkFortran function hipblasZsyrkFortran(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasZsyrkFortran') + A, lda, beta, C, ldc) & + bind(c, name='hipblasZsyrkFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9416,19 +9613,19 @@ function hipblasZsyrkFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasZsyrk(handle, uplo, transA, n, k, alpha,& - A, lda, beta, C, ldc) + hipblasZsyrkFortran = & + hipblasZsyrk(handle, uplo, transA, n, k, alpha, & + A, lda, beta, C, ldc) end function hipblasZsyrkFortran ! syrkBatched function hipblasSsyrkBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasSsyrkBatchedFortran') + A, lda, beta, C, ldc, batch_count) & + bind(c, name='hipblasSsyrkBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9441,18 +9638,18 @@ function hipblasSsyrkBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsyrkBatched(handle, uplo, transA, n, k, alpha,& - A, lda, beta, C, ldc, batch_count) + hipblasSsyrkBatchedFortran = & + hipblasSsyrkBatched(handle, uplo, transA, n, k, alpha, & + A, lda, beta, C, ldc, batch_count) end function hipblasSsyrkBatchedFortran function hipblasDsyrkBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasDsyrkBatchedFortran') + A, lda, beta, C, ldc, batch_count) & + bind(c, name='hipblasDsyrkBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9465,18 +9662,18 @@ function hipblasDsyrkBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsyrkBatched(handle, uplo, transA, n, k, alpha,& - A, lda, beta, C, ldc, batch_count) + hipblasDsyrkBatchedFortran = & + hipblasDsyrkBatched(handle, uplo, transA, n, k, alpha, & + A, lda, beta, C, ldc, batch_count) end function hipblasDsyrkBatchedFortran function hipblasCsyrkBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasCsyrkBatchedFortran') + A, lda, beta, C, ldc, batch_count) & + bind(c, name='hipblasCsyrkBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9489,18 +9686,18 @@ function hipblasCsyrkBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsyrkBatched(handle, uplo, transA, n, k, alpha,& - A, lda, beta, C, ldc, batch_count) + hipblasCsyrkBatchedFortran = & + hipblasCsyrkBatched(handle, uplo, transA, n, k, alpha, & + A, lda, beta, C, ldc, batch_count) end function hipblasCsyrkBatchedFortran function hipblasZsyrkBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasZsyrkBatchedFortran') + A, lda, beta, C, ldc, batch_count) & + bind(c, name='hipblasZsyrkBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9513,19 +9710,19 @@ function hipblasZsyrkBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsyrkBatched(handle, uplo, transA, n, k, alpha,& - A, lda, beta, C, ldc, batch_count) + hipblasZsyrkBatchedFortran = & + hipblasZsyrkBatched(handle, uplo, transA, n, k, alpha, & + A, lda, beta, C, ldc, batch_count) end function hipblasZsyrkBatchedFortran ! syrkStridedBatched function hipblasSsyrkStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasSsyrkStridedBatchedFortran') + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasSsyrkStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9540,18 +9737,18 @@ function hipblasSsyrkStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsyrkStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) + hipblasSsyrkStridedBatchedFortran = & + hipblasSsyrkStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) end function hipblasSsyrkStridedBatchedFortran function hipblasDsyrkStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasDsyrkStridedBatchedFortran') + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasDsyrkStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9566,18 +9763,18 @@ function hipblasDsyrkStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsyrkStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) + hipblasDsyrkStridedBatchedFortran = & + hipblasDsyrkStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) end function hipblasDsyrkStridedBatchedFortran function hipblasCsyrkStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasCsyrkStridedBatchedFortran') + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCsyrkStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9592,18 +9789,18 @@ function hipblasCsyrkStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsyrkStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) + hipblasCsyrkStridedBatchedFortran = & + hipblasCsyrkStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) end function hipblasCsyrkStridedBatchedFortran function hipblasZsyrkStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasZsyrkStridedBatchedFortran') + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZsyrkStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9618,19 +9815,19 @@ function hipblasZsyrkStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsyrkStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) + hipblasZsyrkStridedBatchedFortran = & + hipblasZsyrkStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) end function hipblasZsyrkStridedBatchedFortran ! syr2k function hipblasSsyr2kFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasSsyr2kFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasSsyr2kFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2kFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9644,18 +9841,18 @@ function hipblasSsyr2kFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasSsyr2k(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasSsyr2kFortran = & + hipblasSsyr2k(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasSsyr2kFortran function hipblasDsyr2kFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasDsyr2kFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasDsyr2kFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2kFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9669,18 +9866,18 @@ function hipblasDsyr2kFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasDsyr2k(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasDsyr2kFortran = & + hipblasDsyr2k(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasDsyr2kFortran function hipblasCsyr2kFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasCsyr2kFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasCsyr2kFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2kFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9694,18 +9891,18 @@ function hipblasCsyr2kFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasCsyr2k(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasCsyr2kFortran = & + hipblasCsyr2k(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasCsyr2kFortran function hipblasZsyr2kFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasZsyr2kFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasZsyr2kFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2kFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9719,19 +9916,19 @@ function hipblasZsyr2kFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasZsyr2k(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasZsyr2kFortran = & + hipblasZsyr2k(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasZsyr2kFortran ! syr2kBatched function hipblasSsyr2kBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasSsyr2kBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasSsyr2kBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2kBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9746,18 +9943,18 @@ function hipblasSsyr2kBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsyr2kBatched(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasSsyr2kBatchedFortran = & + hipblasSsyr2kBatched(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasSsyr2kBatchedFortran function hipblasDsyr2kBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasDsyr2kBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasDsyr2kBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2kBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9772,18 +9969,18 @@ function hipblasDsyr2kBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsyr2kBatched(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasDsyr2kBatchedFortran = & + hipblasDsyr2kBatched(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasDsyr2kBatchedFortran function hipblasCsyr2kBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasCsyr2kBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasCsyr2kBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2kBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9798,18 +9995,18 @@ function hipblasCsyr2kBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsyr2kBatched(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasCsyr2kBatchedFortran = & + hipblasCsyr2kBatched(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasCsyr2kBatchedFortran function hipblasZsyr2kBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasZsyr2kBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasZsyr2kBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2kBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9824,19 +10021,19 @@ function hipblasZsyr2kBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsyr2kBatched(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasZsyr2kBatchedFortran = & + hipblasZsyr2kBatched(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasZsyr2kBatchedFortran ! syr2kStridedBatched function hipblasSsyr2kStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasSsyr2kStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasSsyr2kStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2kStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9854,18 +10051,18 @@ function hipblasSsyr2kStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsyr2kStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasSsyr2kStridedBatchedFortran = & + hipblasSsyr2kStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasSsyr2kStridedBatchedFortran function hipblasDsyr2kStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasDsyr2kStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasDsyr2kStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2kStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9883,18 +10080,18 @@ function hipblasDsyr2kStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsyr2kStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasDsyr2kStridedBatchedFortran = & + hipblasDsyr2kStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasDsyr2kStridedBatchedFortran function hipblasCsyr2kStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasCsyr2kStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCsyr2kStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2kStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9912,18 +10109,18 @@ function hipblasCsyr2kStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsyr2kStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasCsyr2kStridedBatchedFortran = & + hipblasCsyr2kStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasCsyr2kStridedBatchedFortran function hipblasZsyr2kStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasZsyr2kStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZsyr2kStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2kStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9941,19 +10138,19 @@ function hipblasZsyr2kStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsyr2kStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasZsyr2kStridedBatchedFortran = & + hipblasZsyr2kStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasZsyr2kStridedBatchedFortran ! syrkx function hipblasSsyrkxFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasSsyrkxFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasSsyrkxFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkxFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9967,18 +10164,18 @@ function hipblasSsyrkxFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasSsyrkx(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasSsyrkxFortran = & + hipblasSsyrkx(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasSsyrkxFortran function hipblasDsyrkxFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasDsyrkxFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasDsyrkxFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkxFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9992,18 +10189,18 @@ function hipblasDsyrkxFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasDsyrkx(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasDsyrkxFortran = & + hipblasDsyrkx(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasDsyrkxFortran function hipblasCsyrkxFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasCsyrkxFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasCsyrkxFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkxFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -10017,18 +10214,18 @@ function hipblasCsyrkxFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasCsyrkx(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasCsyrkxFortran = & + hipblasCsyrkx(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasCsyrkxFortran function hipblasZsyrkxFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasZsyrkxFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasZsyrkxFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkxFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -10042,19 +10239,19 @@ function hipblasZsyrkxFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasZsyrkx(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasZsyrkxFortran = & + hipblasZsyrkx(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasZsyrkxFortran ! syrkxBatched function hipblasSsyrkxBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasSsyrkxBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasSsyrkxBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkxBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -10069,18 +10266,18 @@ function hipblasSsyrkxBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsyrkxBatched(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasSsyrkxBatchedFortran = & + hipblasSsyrkxBatched(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasSsyrkxBatchedFortran function hipblasDsyrkxBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasDsyrkxBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasDsyrkxBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkxBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -10095,18 +10292,18 @@ function hipblasDsyrkxBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsyrkxBatched(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasDsyrkxBatchedFortran = & + hipblasDsyrkxBatched(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasDsyrkxBatchedFortran function hipblasCsyrkxBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasCsyrkxBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasCsyrkxBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkxBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -10121,18 +10318,18 @@ function hipblasCsyrkxBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsyrkxBatched(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasCsyrkxBatchedFortran = & + hipblasCsyrkxBatched(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasCsyrkxBatchedFortran function hipblasZsyrkxBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasZsyrkxBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasZsyrkxBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkxBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -10147,19 +10344,19 @@ function hipblasZsyrkxBatchedFortran(handle, uplo, transA, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsyrkxBatched(handle, uplo, transA, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasZsyrkxBatchedFortran = & + hipblasZsyrkxBatched(handle, uplo, transA, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasZsyrkxBatchedFortran ! syrkxStridedBatched function hipblasSsyrkxStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasSsyrkxStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasSsyrkxStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkxStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -10177,18 +10374,18 @@ function hipblasSsyrkxStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSsyrkxStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasSsyrkxStridedBatchedFortran = & + hipblasSsyrkxStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasSsyrkxStridedBatchedFortran function hipblasDsyrkxStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasDsyrkxStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasDsyrkxStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkxStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -10206,18 +10403,18 @@ function hipblasDsyrkxStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDsyrkxStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasDsyrkxStridedBatchedFortran = & + hipblasDsyrkxStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasDsyrkxStridedBatchedFortran function hipblasCsyrkxStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasCsyrkxStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCsyrkxStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkxStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -10235,18 +10432,18 @@ function hipblasCsyrkxStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCsyrkxStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasCsyrkxStridedBatchedFortran = & + hipblasCsyrkxStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasCsyrkxStridedBatchedFortran function hipblasZsyrkxStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasZsyrkxStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZsyrkxStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkxStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -10264,19 +10461,19 @@ function hipblasZsyrkxStridedBatchedFortran(handle, uplo, transA, n, k, alpha, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZsyrkxStridedBatched(handle, uplo, transA, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasZsyrkxStridedBatchedFortran = & + hipblasZsyrkxStridedBatched(handle, uplo, transA, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasZsyrkxStridedBatchedFortran ! trmm function hipblasStrmmFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(res) & - bind(c, name = 'hipblasStrmmFortran') + A, lda, B, ldb) & + bind(c, name='hipblasStrmmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10289,18 +10486,18 @@ function hipblasStrmmFortran(handle, side, uplo, transA, diag, m, n, alpha, & integer(c_int), value :: lda type(c_ptr), value :: B integer(c_int), value :: ldb - integer(c_int) :: res - res = hipblasStrmm(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb) + hipblasStrmmFortran = & + hipblasStrmm(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb) end function hipblasStrmmFortran function hipblasDtrmmFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(res) & - bind(c, name = 'hipblasDtrmmFortran') + A, lda, B, ldb) & + bind(c, name='hipblasDtrmmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10313,18 +10510,18 @@ function hipblasDtrmmFortran(handle, side, uplo, transA, diag, m, n, alpha, & integer(c_int), value :: lda type(c_ptr), value :: B integer(c_int), value :: ldb - integer(c_int) :: res - res = hipblasDtrmm(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb) + hipblasDtrmmFortran = & + hipblasDtrmm(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb) end function hipblasDtrmmFortran function hipblasCtrmmFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(res) & - bind(c, name = 'hipblasCtrmmFortran') + A, lda, B, ldb) & + bind(c, name='hipblasCtrmmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10337,18 +10534,18 @@ function hipblasCtrmmFortran(handle, side, uplo, transA, diag, m, n, alpha, & integer(c_int), value :: lda type(c_ptr), value :: B integer(c_int), value :: ldb - integer(c_int) :: res - res = hipblasCtrmm(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb) + hipblasCtrmmFortran = & + hipblasCtrmm(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb) end function hipblasCtrmmFortran function hipblasZtrmmFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(res) & - bind(c, name = 'hipblasZtrmmFortran') + A, lda, B, ldb) & + bind(c, name='hipblasZtrmmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10361,19 +10558,19 @@ function hipblasZtrmmFortran(handle, side, uplo, transA, diag, m, n, alpha, & integer(c_int), value :: lda type(c_ptr), value :: B integer(c_int), value :: ldb - integer(c_int) :: res - res = hipblasZtrmm(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb) + hipblasZtrmmFortran = & + hipblasZtrmm(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb) end function hipblasZtrmmFortran ! trmmBatched function hipblasStrmmBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(res) & - bind(c, name = 'hipblasStrmmBatchedFortran') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasStrmmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10387,18 +10584,18 @@ function hipblasStrmmBatchedFortran(handle, side, uplo, transA, diag, m, n, alph type(c_ptr), value :: B integer(c_int), value :: ldb integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStrmmBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb, batch_count) + hipblasStrmmBatchedFortran = & + hipblasStrmmBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb, batch_count) end function hipblasStrmmBatchedFortran function hipblasDtrmmBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(res) & - bind(c, name = 'hipblasDtrmmBatchedFortran') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasDtrmmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10412,18 +10609,18 @@ function hipblasDtrmmBatchedFortran(handle, side, uplo, transA, diag, m, n, alph type(c_ptr), value :: B integer(c_int), value :: ldb integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtrmmBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb, batch_count) + hipblasDtrmmBatchedFortran = & + hipblasDtrmmBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb, batch_count) end function hipblasDtrmmBatchedFortran function hipblasCtrmmBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(res) & - bind(c, name = 'hipblasCtrmmBatchedFortran') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasCtrmmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10437,18 +10634,18 @@ function hipblasCtrmmBatchedFortran(handle, side, uplo, transA, diag, m, n, alph type(c_ptr), value :: B integer(c_int), value :: ldb integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtrmmBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb, batch_count) + hipblasCtrmmBatchedFortran = & + hipblasCtrmmBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb, batch_count) end function hipblasCtrmmBatchedFortran function hipblasZtrmmBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(res) & - bind(c, name = 'hipblasZtrmmBatchedFortran') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasZtrmmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10462,19 +10659,19 @@ function hipblasZtrmmBatchedFortran(handle, side, uplo, transA, diag, m, n, alph type(c_ptr), value :: B integer(c_int), value :: ldb integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtrmmBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb, batch_count) + hipblasZtrmmBatchedFortran = & + hipblasZtrmmBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb, batch_count) end function hipblasZtrmmBatchedFortran ! trmmStridedBatched function hipblasStrmmStridedBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(res) & - bind(c, name = 'hipblasStrmmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasStrmmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10490,18 +10687,18 @@ function hipblasStrmmStridedBatchedFortran(handle, side, uplo, transA, diag, m, integer(c_int), value :: ldb integer(c_int64_t), value :: stride_B integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStrmmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, stride_A, B, ldb, stride_B, batch_count) + hipblasStrmmStridedBatchedFortran = & + hipblasStrmmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, stride_A, B, ldb, stride_B, batch_count) end function hipblasStrmmStridedBatchedFortran function hipblasDtrmmStridedBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(res) & - bind(c, name = 'hipblasDtrmmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasDtrmmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10517,18 +10714,18 @@ function hipblasDtrmmStridedBatchedFortran(handle, side, uplo, transA, diag, m, integer(c_int), value :: ldb integer(c_int64_t), value :: stride_B integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtrmmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, stride_A, B, ldb, stride_B, batch_count) + hipblasDtrmmStridedBatchedFortran = & + hipblasDtrmmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, stride_A, B, ldb, stride_B, batch_count) end function hipblasDtrmmStridedBatchedFortran function hipblasCtrmmStridedBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(res) & - bind(c, name = 'hipblasCtrmmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasCtrmmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10544,18 +10741,18 @@ function hipblasCtrmmStridedBatchedFortran(handle, side, uplo, transA, diag, m, integer(c_int), value :: ldb integer(c_int64_t), value :: stride_B integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtrmmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, stride_A, B, ldb, stride_B, batch_count) + hipblasCtrmmStridedBatchedFortran = & + hipblasCtrmmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, stride_A, B, ldb, stride_B, batch_count) end function hipblasCtrmmStridedBatchedFortran function hipblasZtrmmStridedBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(res) & - bind(c, name = 'hipblasZtrmmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasZtrmmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10571,19 +10768,19 @@ function hipblasZtrmmStridedBatchedFortran(handle, side, uplo, transA, diag, m, integer(c_int), value :: ldb integer(c_int64_t), value :: stride_B integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtrmmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, stride_A, B, ldb, stride_B, batch_count) + hipblasZtrmmStridedBatchedFortran = & + hipblasZtrmmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, stride_A, B, ldb, stride_B, batch_count) end function hipblasZtrmmStridedBatchedFortran ! trtri function hipblasStrtriFortran(handle, uplo, diag, n, & - A, lda, invA, ldinvA) & - result(res) & - bind(c, name = 'hipblasStrtriFortran') + A, lda, invA, ldinvA) & + bind(c, name='hipblasStrtriFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtriFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10592,18 +10789,18 @@ function hipblasStrtriFortran(handle, uplo, diag, n, & integer(c_int), value :: lda type(c_ptr), value :: invA integer(c_int), value :: ldinvA - integer(c_int) :: res - res = hipblasStrtri(handle, uplo, diag, n,& - A, lda, invA, ldinvA) + hipblasStrtriFortran = & + hipblasStrtri(handle, uplo, diag, n, & + A, lda, invA, ldinvA) end function hipblasStrtriFortran function hipblasDtrtriFortran(handle, uplo, diag, n, & - A, lda, invA, ldinvA) & - result(res) & - bind(c, name = 'hipblasDtrtriFortran') + A, lda, invA, ldinvA) & + bind(c, name='hipblasDtrtriFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtriFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10612,18 +10809,18 @@ function hipblasDtrtriFortran(handle, uplo, diag, n, & integer(c_int), value :: lda type(c_ptr), value :: invA integer(c_int), value :: ldinvA - integer(c_int) :: res - res = hipblasDtrtri(handle, uplo, diag, n,& - A, lda, invA, ldinvA) + hipblasDtrtriFortran = & + hipblasDtrtri(handle, uplo, diag, n, & + A, lda, invA, ldinvA) end function hipblasDtrtriFortran function hipblasCtrtriFortran(handle, uplo, diag, n, & - A, lda, invA, ldinvA) & - result(res) & - bind(c, name = 'hipblasCtrtriFortran') + A, lda, invA, ldinvA) & + bind(c, name='hipblasCtrtriFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtriFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10632,18 +10829,18 @@ function hipblasCtrtriFortran(handle, uplo, diag, n, & integer(c_int), value :: lda type(c_ptr), value :: invA integer(c_int), value :: ldinvA - integer(c_int) :: res - res = hipblasCtrtri(handle, uplo, diag, n,& - A, lda, invA, ldinvA) + hipblasCtrtriFortran = & + hipblasCtrtri(handle, uplo, diag, n, & + A, lda, invA, ldinvA) end function hipblasCtrtriFortran function hipblasZtrtriFortran(handle, uplo, diag, n, & - A, lda, invA, ldinvA) & - result(res) & - bind(c, name = 'hipblasZtrtriFortran') + A, lda, invA, ldinvA) & + bind(c, name='hipblasZtrtriFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtriFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10652,19 +10849,19 @@ function hipblasZtrtriFortran(handle, uplo, diag, n, & integer(c_int), value :: lda type(c_ptr), value :: invA integer(c_int), value :: ldinvA - integer(c_int) :: res - res = hipblasZtrtri(handle, uplo, diag, n,& - A, lda, invA, ldinvA) + hipblasZtrtriFortran = & + hipblasZtrtri(handle, uplo, diag, n, & + A, lda, invA, ldinvA) end function hipblasZtrtriFortran ! trtriBatched function hipblasStrtriBatchedFortran(handle, uplo, diag, n, & - A, lda, invA, ldinvA, batch_count) & - result(res) & - bind(c, name = 'hipblasStrtriBatchedFortran') + A, lda, invA, ldinvA, batch_count) & + bind(c, name='hipblasStrtriBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtriBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10674,18 +10871,18 @@ function hipblasStrtriBatchedFortran(handle, uplo, diag, n, & type(c_ptr), value :: invA integer(c_int), value :: ldinvA integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStrtriBatched(handle, uplo, diag, n,& - A, lda, invA, ldinvA, batch_count) + hipblasStrtriBatchedFortran = & + hipblasStrtriBatched(handle, uplo, diag, n, & + A, lda, invA, ldinvA, batch_count) end function hipblasStrtriBatchedFortran function hipblasDtrtriBatchedFortran(handle, uplo, diag, n, & - A, lda, invA, ldinvA, batch_count) & - result(res) & - bind(c, name = 'hipblasDtrtriBatchedFortran') + A, lda, invA, ldinvA, batch_count) & + bind(c, name='hipblasDtrtriBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtriBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10695,18 +10892,18 @@ function hipblasDtrtriBatchedFortran(handle, uplo, diag, n, & type(c_ptr), value :: invA integer(c_int), value :: ldinvA integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtrtriBatched(handle, uplo, diag, n,& - A, lda, invA, ldinvA, batch_count) + hipblasDtrtriBatchedFortran = & + hipblasDtrtriBatched(handle, uplo, diag, n, & + A, lda, invA, ldinvA, batch_count) end function hipblasDtrtriBatchedFortran function hipblasCtrtriBatchedFortran(handle, uplo, diag, n, & - A, lda, invA, ldinvA, batch_count) & - result(res) & - bind(c, name = 'hipblasCtrtriBatchedFortran') + A, lda, invA, ldinvA, batch_count) & + bind(c, name='hipblasCtrtriBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtriBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10716,18 +10913,18 @@ function hipblasCtrtriBatchedFortran(handle, uplo, diag, n, & type(c_ptr), value :: invA integer(c_int), value :: ldinvA integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtrtriBatched(handle, uplo, diag, n,& - A, lda, invA, ldinvA, batch_count) + hipblasCtrtriBatchedFortran = & + hipblasCtrtriBatched(handle, uplo, diag, n, & + A, lda, invA, ldinvA, batch_count) end function hipblasCtrtriBatchedFortran function hipblasZtrtriBatchedFortran(handle, uplo, diag, n, & - A, lda, invA, ldinvA, batch_count) & - result(res) & - bind(c, name = 'hipblasZtrtriBatchedFortran') + A, lda, invA, ldinvA, batch_count) & + bind(c, name='hipblasZtrtriBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtriBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10737,19 +10934,19 @@ function hipblasZtrtriBatchedFortran(handle, uplo, diag, n, & type(c_ptr), value :: invA integer(c_int), value :: ldinvA integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtrtriBatched(handle, uplo, diag, n,& - A, lda, invA, ldinvA, batch_count) + hipblasZtrtriBatchedFortran = & + hipblasZtrtriBatched(handle, uplo, diag, n, & + A, lda, invA, ldinvA, batch_count) end function hipblasZtrtriBatchedFortran ! trtriStridedBatched function hipblasStrtriStridedBatchedFortran(handle, uplo, diag, n, & - A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & - result(res) & - bind(c, name = 'hipblasStrtriStridedBatchedFortran') + A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & + bind(c, name='hipblasStrtriStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtriStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10761,18 +10958,18 @@ function hipblasStrtriStridedBatchedFortran(handle, uplo, diag, n, & integer(c_int), value :: ldinvA integer(c_int64_t), value :: stride_invA integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStrtriStridedBatched(handle, uplo, diag, n,& - A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) + hipblasStrtriStridedBatchedFortran = & + hipblasStrtriStridedBatched(handle, uplo, diag, n, & + A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) end function hipblasStrtriStridedBatchedFortran function hipblasDtrtriStridedBatchedFortran(handle, uplo, diag, n, & - A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & - result(res) & - bind(c, name = 'hipblasDtrtriStridedBatchedFortran') + A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & + bind(c, name='hipblasDtrtriStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtriStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10784,18 +10981,18 @@ function hipblasDtrtriStridedBatchedFortran(handle, uplo, diag, n, & integer(c_int), value :: ldinvA integer(c_int64_t), value :: stride_invA integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtrtriStridedBatched(handle, uplo, diag, n,& - A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) + hipblasDtrtriStridedBatchedFortran = & + hipblasDtrtriStridedBatched(handle, uplo, diag, n, & + A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) end function hipblasDtrtriStridedBatchedFortran function hipblasCtrtriStridedBatchedFortran(handle, uplo, diag, n, & - A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & - result(res) & - bind(c, name = 'hipblasCtrtriStridedBatchedFortran') + A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & + bind(c, name='hipblasCtrtriStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtriStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10807,18 +11004,18 @@ function hipblasCtrtriStridedBatchedFortran(handle, uplo, diag, n, & integer(c_int), value :: ldinvA integer(c_int64_t), value :: stride_invA integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtrtriStridedBatched(handle, uplo, diag, n,& - A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) + hipblasCtrtriStridedBatchedFortran = & + hipblasCtrtriStridedBatched(handle, uplo, diag, n, & + A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) end function hipblasCtrtriStridedBatchedFortran function hipblasZtrtriStridedBatchedFortran(handle, uplo, diag, n, & - A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & - result(res) & - bind(c, name = 'hipblasZtrtriStridedBatchedFortran') + A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & + bind(c, name='hipblasZtrtriStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtriStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10830,19 +11027,19 @@ function hipblasZtrtriStridedBatchedFortran(handle, uplo, diag, n, & integer(c_int), value :: ldinvA integer(c_int64_t), value :: stride_invA integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtrtriStridedBatched(handle, uplo, diag, n,& - A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) + hipblasZtrtriStridedBatchedFortran = & + hipblasZtrtriStridedBatched(handle, uplo, diag, n, & + A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) end function hipblasZtrtriStridedBatchedFortran ! trsm function hipblasStrsmFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(res) & - bind(c, name = 'hipblasStrsmFortran') + A, lda, B, ldb) & + bind(c, name='hipblasStrsmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10855,18 +11052,18 @@ function hipblasStrsmFortran(handle, side, uplo, transA, diag, m, n, alpha, & integer(c_int), value :: lda type(c_ptr), value :: B integer(c_int), value :: ldb - integer(c_int) :: res - res = hipblasStrsm(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb) + hipblasStrsmFortran = & + hipblasStrsm(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb) end function hipblasStrsmFortran function hipblasDtrsmFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(res) & - bind(c, name = 'hipblasDtrsmFortran') + A, lda, B, ldb) & + bind(c, name='hipblasDtrsmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10879,18 +11076,18 @@ function hipblasDtrsmFortran(handle, side, uplo, transA, diag, m, n, alpha, & integer(c_int), value :: lda type(c_ptr), value :: B integer(c_int), value :: ldb - integer(c_int) :: res - res = hipblasDtrsm(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb) + hipblasDtrsmFortran = & + hipblasDtrsm(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb) end function hipblasDtrsmFortran function hipblasCtrsmFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(res) & - bind(c, name = 'hipblasCtrsmFortran') + A, lda, B, ldb) & + bind(c, name='hipblasCtrsmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10903,18 +11100,18 @@ function hipblasCtrsmFortran(handle, side, uplo, transA, diag, m, n, alpha, & integer(c_int), value :: lda type(c_ptr), value :: B integer(c_int), value :: ldb - integer(c_int) :: res - res = hipblasCtrsm(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb) + hipblasCtrsmFortran = & + hipblasCtrsm(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb) end function hipblasCtrsmFortran function hipblasZtrsmFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(res) & - bind(c, name = 'hipblasZtrsmFortran') + A, lda, B, ldb) & + bind(c, name='hipblasZtrsmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10927,19 +11124,19 @@ function hipblasZtrsmFortran(handle, side, uplo, transA, diag, m, n, alpha, & integer(c_int), value :: lda type(c_ptr), value :: B integer(c_int), value :: ldb - integer(c_int) :: res - res = hipblasZtrsm(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb) + hipblasZtrsmFortran = & + hipblasZtrsm(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb) end function hipblasZtrsmFortran ! trsmBatched function hipblasStrsmBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(res) & - bind(c, name = 'hipblasStrsmBatchedFortran') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasStrsmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10953,18 +11150,18 @@ function hipblasStrsmBatchedFortran(handle, side, uplo, transA, diag, m, n, alph type(c_ptr), value :: B integer(c_int), value :: ldb integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStrsmBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb, batch_count) + hipblasStrsmBatchedFortran = & + hipblasStrsmBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb, batch_count) end function hipblasStrsmBatchedFortran function hipblasDtrsmBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(res) & - bind(c, name = 'hipblasDtrsmBatchedFortran') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasDtrsmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10978,18 +11175,18 @@ function hipblasDtrsmBatchedFortran(handle, side, uplo, transA, diag, m, n, alph type(c_ptr), value :: B integer(c_int), value :: ldb integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtrsmBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb, batch_count) + hipblasDtrsmBatchedFortran = & + hipblasDtrsmBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb, batch_count) end function hipblasDtrsmBatchedFortran function hipblasCtrsmBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(res) & - bind(c, name = 'hipblasCtrsmBatchedFortran') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasCtrsmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -11003,18 +11200,18 @@ function hipblasCtrsmBatchedFortran(handle, side, uplo, transA, diag, m, n, alph type(c_ptr), value :: B integer(c_int), value :: ldb integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtrsmBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb, batch_count) + hipblasCtrsmBatchedFortran = & + hipblasCtrsmBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb, batch_count) end function hipblasCtrsmBatchedFortran function hipblasZtrsmBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(res) & - bind(c, name = 'hipblasZtrsmBatchedFortran') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasZtrsmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -11028,19 +11225,19 @@ function hipblasZtrsmBatchedFortran(handle, side, uplo, transA, diag, m, n, alph type(c_ptr), value :: B integer(c_int), value :: ldb integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtrsmBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb, batch_count) + hipblasZtrsmBatchedFortran = & + hipblasZtrsmBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb, batch_count) end function hipblasZtrsmBatchedFortran ! trsmStridedBatched function hipblasStrsmStridedBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(res) & - bind(c, name = 'hipblasStrsmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasStrsmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -11056,18 +11253,18 @@ function hipblasStrsmStridedBatchedFortran(handle, side, uplo, transA, diag, m, integer(c_int), value :: ldb integer(c_int64_t), value :: stride_B integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasStrsmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, stride_A, B, ldb, stride_B, batch_count) + hipblasStrsmStridedBatchedFortran = & + hipblasStrsmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, stride_A, B, ldb, stride_B, batch_count) end function hipblasStrsmStridedBatchedFortran function hipblasDtrsmStridedBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(res) & - bind(c, name = 'hipblasDtrsmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasDtrsmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -11083,18 +11280,18 @@ function hipblasDtrsmStridedBatchedFortran(handle, side, uplo, transA, diag, m, integer(c_int), value :: ldb integer(c_int64_t), value :: stride_B integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDtrsmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, stride_A, B, ldb, stride_B, batch_count) + hipblasDtrsmStridedBatchedFortran = & + hipblasDtrsmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, stride_A, B, ldb, stride_B, batch_count) end function hipblasDtrsmStridedBatchedFortran function hipblasCtrsmStridedBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(res) & - bind(c, name = 'hipblasCtrsmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasCtrsmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -11110,18 +11307,18 @@ function hipblasCtrsmStridedBatchedFortran(handle, side, uplo, transA, diag, m, integer(c_int), value :: ldb integer(c_int64_t), value :: stride_B integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCtrsmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, stride_A, B, ldb, stride_B, batch_count) + hipblasCtrsmStridedBatchedFortran = & + hipblasCtrsmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, stride_A, B, ldb, stride_B, batch_count) end function hipblasCtrsmStridedBatchedFortran function hipblasZtrsmStridedBatchedFortran(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(res) & - bind(c, name = 'hipblasZtrsmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasZtrsmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -11137,19 +11334,19 @@ function hipblasZtrsmStridedBatchedFortran(handle, side, uplo, transA, diag, m, integer(c_int), value :: ldb integer(c_int64_t), value :: stride_B integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZtrsmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, stride_A, B, ldb, stride_B, batch_count) + hipblasZtrsmStridedBatchedFortran = & + hipblasZtrsmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, stride_A, B, ldb, stride_B, batch_count) end function hipblasZtrsmStridedBatchedFortran ! gemm function hipblasHgemmFortran(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasHgemmFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasHgemmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHgemmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11164,18 +11361,18 @@ function hipblasHgemmFortran(handle, transA, transB, m, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasHgemm(handle, transA, transB, m, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasHgemmFortran = & + hipblasHgemm(handle, transA, transB, m, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasHgemmFortran function hipblasSgemmFortran(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasSgemmFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasSgemmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11190,18 +11387,18 @@ function hipblasSgemmFortran(handle, transA, transB, m, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasSgemm(handle, transA, transB, m, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasSgemmFortran = & + hipblasSgemm(handle, transA, transB, m, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasSgemmFortran function hipblasDgemmFortran(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasDgemmFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasDgemmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11216,18 +11413,18 @@ function hipblasDgemmFortran(handle, transA, transB, m, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasDgemm(handle, transA, transB, m, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasDgemmFortran = & + hipblasDgemm(handle, transA, transB, m, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasDgemmFortran function hipblasCgemmFortran(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasCgemmFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasCgemmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11242,18 +11439,18 @@ function hipblasCgemmFortran(handle, transA, transB, m, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasCgemm(handle, transA, transB, m, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasCgemmFortran = & + hipblasCgemm(handle, transA, transB, m, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasCgemmFortran function hipblasZgemmFortran(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(res) & - bind(c, name = 'hipblasZgemmFortran') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasZgemmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11268,19 +11465,19 @@ function hipblasZgemmFortran(handle, transA, transB, m, n, k, alpha, & type(c_ptr), value :: beta type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasZgemm(handle, transA, transB, m, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc) + hipblasZgemmFortran = & + hipblasZgemm(handle, transA, transB, m, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc) end function hipblasZgemmFortran ! gemmBatched function hipblasHgemmBatchedFortran(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasHgemmBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasHgemmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHgemmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11296,18 +11493,18 @@ function hipblasHgemmBatchedFortran(handle, transA, transB, m, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasHgemmBatched(handle, transA, transB, m, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasHgemmBatchedFortran = & + hipblasHgemmBatched(handle, transA, transB, m, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasHgemmBatchedFortran function hipblasSgemmBatchedFortran(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasSgemmBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasSgemmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11323,18 +11520,18 @@ function hipblasSgemmBatchedFortran(handle, transA, transB, m, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgemmBatched(handle, transA, transB, m, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasSgemmBatchedFortran = & + hipblasSgemmBatched(handle, transA, transB, m, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasSgemmBatchedFortran function hipblasDgemmBatchedFortran(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasDgemmBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasDgemmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11350,18 +11547,18 @@ function hipblasDgemmBatchedFortran(handle, transA, transB, m, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgemmBatched(handle, transA, transB, m, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasDgemmBatchedFortran = & + hipblasDgemmBatched(handle, transA, transB, m, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasDgemmBatchedFortran function hipblasCgemmBatchedFortran(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasCgemmBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasCgemmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11377,18 +11574,18 @@ function hipblasCgemmBatchedFortran(handle, transA, transB, m, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgemmBatched(handle, transA, transB, m, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasCgemmBatchedFortran = & + hipblasCgemmBatched(handle, transA, transB, m, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasCgemmBatchedFortran function hipblasZgemmBatchedFortran(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasZgemmBatchedFortran') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasZgemmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11404,19 +11601,19 @@ function hipblasZgemmBatchedFortran(handle, transA, transB, m, n, k, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgemmBatched(handle, transA, transB, m, n, k, alpha,& - A, lda, B, ldb, beta, C, ldc, batch_count) + hipblasZgemmBatchedFortran = & + hipblasZgemmBatched(handle, transA, transB, m, n, k, alpha, & + A, lda, B, ldb, beta, C, ldc, batch_count) end function hipblasZgemmBatchedFortran ! gemmStridedBatched function hipblasHgemmStridedBatchedFortran(handle, transA, transB, m, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasHgemmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasHgemmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHgemmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11435,18 +11632,18 @@ function hipblasHgemmStridedBatchedFortran(handle, transA, transB, m, n, k, alph integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasHgemmStridedBatched(handle, transA, transB, m, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasHgemmStridedBatchedFortran = & + hipblasHgemmStridedBatched(handle, transA, transB, m, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasHgemmStridedBatchedFortran function hipblasSgemmStridedBatchedFortran(handle, transA, transB, m, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasSgemmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasSgemmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11465,18 +11662,18 @@ function hipblasSgemmStridedBatchedFortran(handle, transA, transB, m, n, k, alph integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgemmStridedBatched(handle, transA, transB, m, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasSgemmStridedBatchedFortran = & + hipblasSgemmStridedBatched(handle, transA, transB, m, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasSgemmStridedBatchedFortran function hipblasDgemmStridedBatchedFortran(handle, transA, transB, m, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasDgemmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasDgemmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11495,18 +11692,18 @@ function hipblasDgemmStridedBatchedFortran(handle, transA, transB, m, n, k, alph integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgemmStridedBatched(handle, transA, transB, m, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasDgemmStridedBatchedFortran = & + hipblasDgemmStridedBatched(handle, transA, transB, m, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasDgemmStridedBatchedFortran function hipblasCgemmStridedBatchedFortran(handle, transA, transB, m, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasCgemmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCgemmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11525,18 +11722,18 @@ function hipblasCgemmStridedBatchedFortran(handle, transA, transB, m, n, k, alph integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgemmStridedBatched(handle, transA, transB, m, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasCgemmStridedBatchedFortran = & + hipblasCgemmStridedBatched(handle, transA, transB, m, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasCgemmStridedBatchedFortran function hipblasZgemmStridedBatchedFortran(handle, transA, transB, m, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasZgemmStridedBatchedFortran') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZgemmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11555,19 +11752,19 @@ function hipblasZgemmStridedBatchedFortran(handle, transA, transB, m, n, k, alph integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgemmStridedBatched(handle, transA, transB, m, n, k, alpha,& - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) + hipblasZgemmStridedBatchedFortran = & + hipblasZgemmStridedBatched(handle, transA, transB, m, n, k, alpha, & + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) end function hipblasZgemmStridedBatchedFortran ! dgmm function hipblasSdgmmFortran(handle, side, m, n, & - A, lda, x, incx, C, ldc) & - result(res) & - bind(c, name = 'hipblasSdgmmFortran') + A, lda, x, incx, C, ldc) & + bind(c, name='hipblasSdgmmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11578,18 +11775,18 @@ function hipblasSdgmmFortran(handle, side, m, n, & integer(c_int), value :: incx type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasSdgmm(handle, side, m, n,& - A, lda, x, incx, C, ldc) + hipblasSdgmmFortran = & + hipblasSdgmm(handle, side, m, n, & + A, lda, x, incx, C, ldc) end function hipblasSdgmmFortran function hipblasDdgmmFortran(handle, side, m, n, & - A, lda, x, incx, C, ldc) & - result(res) & - bind(c, name = 'hipblasDdgmmFortran') + A, lda, x, incx, C, ldc) & + bind(c, name='hipblasDdgmmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11600,18 +11797,18 @@ function hipblasDdgmmFortran(handle, side, m, n, & integer(c_int), value :: incx type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasDdgmm(handle, side, m, n,& - A, lda, x, incx, C, ldc) + hipblasDdgmmFortran = & + hipblasDdgmm(handle, side, m, n, & + A, lda, x, incx, C, ldc) end function hipblasDdgmmFortran function hipblasCdgmmFortran(handle, side, m, n, & - A, lda, x, incx, C, ldc) & - result(res) & - bind(c, name = 'hipblasCdgmmFortran') + A, lda, x, incx, C, ldc) & + bind(c, name='hipblasCdgmmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11622,18 +11819,18 @@ function hipblasCdgmmFortran(handle, side, m, n, & integer(c_int), value :: incx type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasCdgmm(handle, side, m, n,& - A, lda, x, incx, C, ldc) + hipblasCdgmmFortran = & + hipblasCdgmm(handle, side, m, n, & + A, lda, x, incx, C, ldc) end function hipblasCdgmmFortran function hipblasZdgmmFortran(handle, side, m, n, & - A, lda, x, incx, C, ldc) & - result(res) & - bind(c, name = 'hipblasZdgmmFortran') + A, lda, x, incx, C, ldc) & + bind(c, name='hipblasZdgmmFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmmFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11644,19 +11841,19 @@ function hipblasZdgmmFortran(handle, side, m, n, & integer(c_int), value :: incx type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasZdgmm(handle, side, m, n,& - A, lda, x, incx, C, ldc) + hipblasZdgmmFortran = & + hipblasZdgmm(handle, side, m, n, & + A, lda, x, incx, C, ldc) end function hipblasZdgmmFortran ! dgmmBatched function hipblasSdgmmBatchedFortran(handle, side, m, n, & - A, lda, x, incx, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasSdgmmBatchedFortran') + A, lda, x, incx, C, ldc, batch_count) & + bind(c, name='hipblasSdgmmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11668,18 +11865,18 @@ function hipblasSdgmmBatchedFortran(handle, side, m, n, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSdgmmBatched(handle, side, m, n,& - A, lda, x, incx, C, ldc, batch_count) + hipblasSdgmmBatchedFortran = & + hipblasSdgmmBatched(handle, side, m, n, & + A, lda, x, incx, C, ldc, batch_count) end function hipblasSdgmmBatchedFortran function hipblasDdgmmBatchedFortran(handle, side, m, n, & - A, lda, x, incx, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasDdgmmBatchedFortran') + A, lda, x, incx, C, ldc, batch_count) & + bind(c, name='hipblasDdgmmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11691,18 +11888,18 @@ function hipblasDdgmmBatchedFortran(handle, side, m, n, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDdgmmBatched(handle, side, m, n,& - A, lda, x, incx, C, ldc, batch_count) + hipblasDdgmmBatchedFortran = & + hipblasDdgmmBatched(handle, side, m, n, & + A, lda, x, incx, C, ldc, batch_count) end function hipblasDdgmmBatchedFortran function hipblasCdgmmBatchedFortran(handle, side, m, n, & - A, lda, x, incx, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasCdgmmBatchedFortran') + A, lda, x, incx, C, ldc, batch_count) & + bind(c, name='hipblasCdgmmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11714,18 +11911,18 @@ function hipblasCdgmmBatchedFortran(handle, side, m, n, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCdgmmBatched(handle, side, m, n,& - A, lda, x, incx, C, ldc, batch_count) + hipblasCdgmmBatchedFortran = & + hipblasCdgmmBatched(handle, side, m, n, & + A, lda, x, incx, C, ldc, batch_count) end function hipblasCdgmmBatchedFortran function hipblasZdgmmBatchedFortran(handle, side, m, n, & - A, lda, x, incx, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasZdgmmBatchedFortran') + A, lda, x, incx, C, ldc, batch_count) & + bind(c, name='hipblasZdgmmBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmmBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11737,19 +11934,19 @@ function hipblasZdgmmBatchedFortran(handle, side, m, n, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZdgmmBatched(handle, side, m, n,& - A, lda, x, incx, C, ldc, batch_count) + hipblasZdgmmBatchedFortran = & + hipblasZdgmmBatched(handle, side, m, n, & + A, lda, x, incx, C, ldc, batch_count) end function hipblasZdgmmBatchedFortran ! dgmmStridedBatched function hipblasSdgmmStridedBatchedFortran(handle, side, m, n, & - A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasSdgmmStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasSdgmmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11764,18 +11961,18 @@ function hipblasSdgmmStridedBatchedFortran(handle, side, m, n, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSdgmmStridedBatched(handle, side, m, n,& - A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) + hipblasSdgmmStridedBatchedFortran = & + hipblasSdgmmStridedBatched(handle, side, m, n, & + A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) end function hipblasSdgmmStridedBatchedFortran function hipblasDdgmmStridedBatchedFortran(handle, side, m, n, & - A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasDdgmmStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasDdgmmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11790,18 +11987,18 @@ function hipblasDdgmmStridedBatchedFortran(handle, side, m, n, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDdgmmStridedBatched(handle, side, m, n,& - A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) + hipblasDdgmmStridedBatchedFortran = & + hipblasDdgmmStridedBatched(handle, side, m, n, & + A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) end function hipblasDdgmmStridedBatchedFortran function hipblasCdgmmStridedBatchedFortran(handle, side, m, n, & - A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasCdgmmStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCdgmmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11816,18 +12013,18 @@ function hipblasCdgmmStridedBatchedFortran(handle, side, m, n, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCdgmmStridedBatched(handle, side, m, n,& - A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) + hipblasCdgmmStridedBatchedFortran = & + hipblasCdgmmStridedBatched(handle, side, m, n, & + A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) end function hipblasCdgmmStridedBatchedFortran function hipblasZdgmmStridedBatchedFortran(handle, side, m, n, & - A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasZdgmmStridedBatchedFortran') + A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZdgmmStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmmStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11842,19 +12039,19 @@ function hipblasZdgmmStridedBatchedFortran(handle, side, m, n, & integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZdgmmStridedBatched(handle, side, m, n,& - A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) + hipblasZdgmmStridedBatchedFortran = & + hipblasZdgmmStridedBatched(handle, side, m, n, & + A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) end function hipblasZdgmmStridedBatchedFortran ! geam function hipblasSgeamFortran(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc) & - result(res) & - bind(c, name = 'hipblasSgeamFortran') + A, lda, beta, B, ldb, C, ldc) & + bind(c, name='hipblasSgeamFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeamFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11868,18 +12065,18 @@ function hipblasSgeamFortran(handle, transA, transB, m, n, alpha, & integer(c_int), value :: ldb type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasSgeam(handle, transA, transB, m, n, alpha,& - A, lda, beta, B, ldb, C, ldc) + hipblasSgeamFortran = & + hipblasSgeam(handle, transA, transB, m, n, alpha, & + A, lda, beta, B, ldb, C, ldc) end function hipblasSgeamFortran function hipblasDgeamFortran(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc) & - result(res) & - bind(c, name = 'hipblasDgeamFortran') + A, lda, beta, B, ldb, C, ldc) & + bind(c, name='hipblasDgeamFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeamFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11893,18 +12090,18 @@ function hipblasDgeamFortran(handle, transA, transB, m, n, alpha, & integer(c_int), value :: ldb type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasDgeam(handle, transA, transB, m, n, alpha,& - A, lda, beta, B, ldb, C, ldc) + hipblasDgeamFortran = & + hipblasDgeam(handle, transA, transB, m, n, alpha, & + A, lda, beta, B, ldb, C, ldc) end function hipblasDgeamFortran function hipblasCgeamFortran(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc) & - result(res) & - bind(c, name = 'hipblasCgeamFortran') + A, lda, beta, B, ldb, C, ldc) & + bind(c, name='hipblasCgeamFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeamFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11918,18 +12115,18 @@ function hipblasCgeamFortran(handle, transA, transB, m, n, alpha, & integer(c_int), value :: ldb type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasCgeam(handle, transA, transB, m, n, alpha,& - A, lda, beta, B, ldb, C, ldc) + hipblasCgeamFortran = & + hipblasCgeam(handle, transA, transB, m, n, alpha, & + A, lda, beta, B, ldb, C, ldc) end function hipblasCgeamFortran function hipblasZgeamFortran(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc) & - result(res) & - bind(c, name = 'hipblasZgeamFortran') + A, lda, beta, B, ldb, C, ldc) & + bind(c, name='hipblasZgeamFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeamFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11943,19 +12140,19 @@ function hipblasZgeamFortran(handle, transA, transB, m, n, alpha, & integer(c_int), value :: ldb type(c_ptr), value :: C integer(c_int), value :: ldc - integer(c_int) :: res - res = hipblasZgeam(handle, transA, transB, m, n, alpha,& - A, lda, beta, B, ldb, C, ldc) + hipblasZgeamFortran = & + hipblasZgeam(handle, transA, transB, m, n, alpha, & + A, lda, beta, B, ldb, C, ldc) end function hipblasZgeamFortran ! geamBatched function hipblasSgeamBatchedFortran(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasSgeamBatchedFortran') + A, lda, beta, B, ldb, C, ldc, batch_count) & + bind(c, name='hipblasSgeamBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeamBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11970,18 +12167,18 @@ function hipblasSgeamBatchedFortran(handle, transA, transB, m, n, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgeamBatched(handle, transA, transB, m, n, alpha,& - A, lda, beta, B, ldb, C, ldc, batch_count) + hipblasSgeamBatchedFortran = & + hipblasSgeamBatched(handle, transA, transB, m, n, alpha, & + A, lda, beta, B, ldb, C, ldc, batch_count) end function hipblasSgeamBatchedFortran function hipblasDgeamBatchedFortran(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasDgeamBatchedFortran') + A, lda, beta, B, ldb, C, ldc, batch_count) & + bind(c, name='hipblasDgeamBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeamBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11996,18 +12193,18 @@ function hipblasDgeamBatchedFortran(handle, transA, transB, m, n, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgeamBatched(handle, transA, transB, m, n, alpha,& - A, lda, beta, B, ldb, C, ldc, batch_count) + hipblasDgeamBatchedFortran = & + hipblasDgeamBatched(handle, transA, transB, m, n, alpha, & + A, lda, beta, B, ldb, C, ldc, batch_count) end function hipblasDgeamBatchedFortran function hipblasCgeamBatchedFortran(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasCgeamBatchedFortran') + A, lda, beta, B, ldb, C, ldc, batch_count) & + bind(c, name='hipblasCgeamBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeamBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -12022,18 +12219,18 @@ function hipblasCgeamBatchedFortran(handle, transA, transB, m, n, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgeamBatched(handle, transA, transB, m, n, alpha,& - A, lda, beta, B, ldb, C, ldc, batch_count) + hipblasCgeamBatchedFortran = & + hipblasCgeamBatched(handle, transA, transB, m, n, alpha, & + A, lda, beta, B, ldb, C, ldc, batch_count) end function hipblasCgeamBatchedFortran function hipblasZgeamBatchedFortran(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc, batch_count) & - result(res) & - bind(c, name = 'hipblasZgeamBatchedFortran') + A, lda, beta, B, ldb, C, ldc, batch_count) & + bind(c, name='hipblasZgeamBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeamBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -12048,19 +12245,19 @@ function hipblasZgeamBatchedFortran(handle, transA, transB, m, n, alpha, & type(c_ptr), value :: C integer(c_int), value :: ldc integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgeamBatched(handle, transA, transB, m, n, alpha,& - A, lda, beta, B, ldb, C, ldc, batch_count) + hipblasZgeamBatchedFortran = & + hipblasZgeamBatched(handle, transA, transB, m, n, alpha, & + A, lda, beta, B, ldb, C, ldc, batch_count) end function hipblasZgeamBatchedFortran ! geamStridedBatched function hipblasSgeamStridedBatchedFortran(handle, transA, transB, m, n, alpha, & - A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasSgeamStridedBatchedFortran') + A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasSgeamStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeamStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -12078,18 +12275,18 @@ function hipblasSgeamStridedBatchedFortran(handle, transA, transB, m, n, alpha, integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgeamStridedBatched(handle, transA, transB, m, n, alpha,& - A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) + hipblasSgeamStridedBatchedFortran = & + hipblasSgeamStridedBatched(handle, transA, transB, m, n, alpha, & + A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) end function hipblasSgeamStridedBatchedFortran function hipblasDgeamStridedBatchedFortran(handle, transA, transB, m, n, alpha, & - A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasDgeamStridedBatchedFortran') + A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasDgeamStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeamStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -12107,18 +12304,18 @@ function hipblasDgeamStridedBatchedFortran(handle, transA, transB, m, n, alpha, integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgeamStridedBatched(handle, transA, transB, m, n, alpha,& - A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) + hipblasDgeamStridedBatchedFortran = & + hipblasDgeamStridedBatched(handle, transA, transB, m, n, alpha, & + A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) end function hipblasDgeamStridedBatchedFortran function hipblasCgeamStridedBatchedFortran(handle, transA, transB, m, n, alpha, & - A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasCgeamStridedBatchedFortran') + A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCgeamStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeamStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -12136,18 +12333,18 @@ function hipblasCgeamStridedBatchedFortran(handle, transA, transB, m, n, alpha, integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgeamStridedBatched(handle, transA, transB, m, n, alpha,& - A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) + hipblasCgeamStridedBatchedFortran = & + hipblasCgeamStridedBatched(handle, transA, transB, m, n, alpha, & + A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) end function hipblasCgeamStridedBatchedFortran function hipblasZgeamStridedBatchedFortran(handle, transA, transB, m, n, alpha, & - A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & - result(res) & - bind(c, name = 'hipblasZgeamStridedBatchedFortran') + A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZgeamStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeamStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -12165,9 +12362,9 @@ function hipblasZgeamStridedBatchedFortran(handle, transA, transB, m, n, alpha, integer(c_int), value :: ldc integer(c_int64_t), value :: stride_C integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgeamStridedBatched(handle, transA, transB, m, n, alpha,& - A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) + hipblasZgeamStridedBatchedFortran = & + hipblasZgeamStridedBatched(handle, transA, transB, m, n, alpha, & + A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) end function hipblasZgeamStridedBatchedFortran !-----------------! @@ -12176,13 +12373,13 @@ end function hipblasZgeamStridedBatchedFortran ! gemmEx function hipblasGemmExFortran(handle, transA, transB, m, n, k, alpha, a, a_type, lda, & - b, b_type, ldb, beta, c, c_type, ldc,& - compute_type, algo, solution_index, flags) & - result(res) & - bind(c, name = 'hipblasGemmExFortran') + b, b_type, ldb, beta, c, c_type, ldc, & + compute_type, algo, solution_index, flags) & + bind(c, name='hipblasGemmExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGemmExFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -12206,20 +12403,20 @@ function hipblasGemmExFortran(handle, transA, transB, m, n, k, alpha, a, a_type, ! No unsigned types in fortran. If larger values are needed ! we will need a workaround. integer(c_int32_t), value :: flags - integer(c_int) :: res - res = hipblasGemmEx(handle, transA, transB, m, n, k, alpha,& - a, a_type, lda, b, b_type, ldb, beta, c, c_type, ldc,& - compute_type, algo, solution_index, flags) + hipblasGemmExFortran = & + hipblasGemmEx(handle, transA, transB, m, n, k, alpha, & + a, a_type, lda, b, b_type, ldb, beta, c, c_type, ldc, & + compute_type, algo, solution_index, flags) end function hipblasGemmExFortran function hipblasGemmBatchedExFortran(handle, transA, transB, m, n, k, alpha, a, a_type, lda, & - b, b_type, ldb, beta, c, c_type, ldc,& - batch_count, compute_type, algo, solution_index, flags) & - result(res) & - bind(c, name = 'hipblasGemmBatchedExFortran') + b, b_type, ldb, beta, c, c_type, ldc, & + batch_count, compute_type, algo, solution_index, flags) & + bind(c, name='hipblasGemmBatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGemmBatchedExFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -12244,20 +12441,20 @@ function hipblasGemmBatchedExFortran(handle, transA, transB, m, n, k, alpha, a, ! No unsigned types in fortran. If larger values are needed ! we will need a workaround. integer(c_int32_t), value :: flags - integer(c_int) :: res - res = hipblasGemmBatchedEx(handle, transA, transB, m, n, k, alpha,& - a, a_type, lda, b, b_type, ldb, beta, c, c_type, ldc,& - batch_count, compute_type, algo, solution_index, flags) + hipblasGemmBatchedExFortran = & + hipblasGemmBatchedEx(handle, transA, transB, m, n, k, alpha, & + a, a_type, lda, b, b_type, ldb, beta, c, c_type, ldc, & + batch_count, compute_type, algo, solution_index, flags) end function hipblasGemmBatchedExFortran function hipblasGemmStridedBatchedExFortran(handle, transA, transB, m, n, k, alpha, a, a_type, lda, stride_a, & - b, b_type, ldb, stride_b, beta, c, c_type, ldc, stride_c,& - batch_count, compute_type, algo, solution_index, flags) & - result(res) & - bind(c, name = 'hipblasGemmStridedBatchedExFortran') + b, b_type, ldb, stride_b, beta, c, c_type, ldc, stride_c, & + batch_count, compute_type, algo, solution_index, flags) & + bind(c, name='hipblasGemmStridedBatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGemmStridedBatchedExFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -12285,20 +12482,20 @@ function hipblasGemmStridedBatchedExFortran(handle, transA, transB, m, n, k, alp ! No unsigned types in fortran. If larger values are needed ! we will need a workaround. integer(c_int32_t), value :: flags - integer(c_int) :: res - res = hipblasGemmStridedBatchedEx(handle, transA, transB, m, n, k, alpha,& - a, a_type, lda, stride_a, b, b_type, ldb, stride_b, beta, c, c_type, ldc, stride_c,& - batch_count, compute_type, algo, solution_index, flags) + hipblasGemmStridedBatchedExFortran = & + hipblasGemmStridedBatchedEx(handle, transA, transB, m, n, k, alpha, & + a, a_type, lda, stride_a, b, b_type, ldb, stride_b, beta, c, c_type, ldc, stride_c, & + batch_count, compute_type, algo, solution_index, flags) end function hipblasGemmStridedBatchedExFortran ! trsmEx function hipblasTrsmExFortran(handle, side, uplo, transA, diag, m, n, alpha, A, lda, & - B, ldb, invA, invA_size, compute_type) & - result(res) & - bind(c, name = 'hipblasTrsmExFortran') + B, ldb, invA, invA_size, compute_type) & + bind(c, name='hipblasTrsmExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasTrsmExFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)), value :: uplo @@ -12314,18 +12511,18 @@ function hipblasTrsmExFortran(handle, side, uplo, transA, diag, m, n, alpha, A, type(c_ptr), value :: invA integer(c_int), value :: invA_size integer(kind(HIPBLAS_R_16F)), value :: compute_type - integer(c_int) :: res - res = hipblasTrsmEx(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb, invA, invA_size, compute_type) + hipblasTrsmExFortran = & + hipblasTrsmEx(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb, invA, invA_size, compute_type) end function hipblasTrsmExFortran function hipblasTrsmBatchedExFortran(handle, side, uplo, transA, diag, m, n, alpha, A, lda, & - B, ldb, batch_count, invA, invA_size, compute_type) & - result(res) & - bind(c, name = 'hipblasTrsmBatchedExFortran') + B, ldb, batch_count, invA, invA_size, compute_type) & + bind(c, name='hipblasTrsmBatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasTrsmBatchedExFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)), value :: uplo @@ -12342,18 +12539,18 @@ function hipblasTrsmBatchedExFortran(handle, side, uplo, transA, diag, m, n, alp type(c_ptr), value :: invA integer(c_int), value :: invA_size integer(kind(HIPBLAS_R_16F)), value :: compute_type - integer(c_int) :: res - res = hipblasTrsmBatchedEx(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, B, ldb, batch_count, invA, invA_size, compute_type) + hipblasTrsmBatchedExFortran = & + hipblasTrsmBatchedEx(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, B, ldb, batch_count, invA, invA_size, compute_type) end function hipblasTrsmBatchedExFortran function hipblasTrsmStridedBatchedExFortran(handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, & - B, ldb, stride_B, batch_count, invA, invA_size, stride_invA, compute_type) & - result(res) & - bind(c, name = 'hipblasTrsmStridedBatchedExFortran') + B, ldb, stride_B, batch_count, invA, invA_size, stride_invA, compute_type) & + bind(c, name='hipblasTrsmStridedBatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasTrsmStridedBatchedExFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)), value :: uplo @@ -12373,18 +12570,18 @@ function hipblasTrsmStridedBatchedExFortran(handle, side, uplo, transA, diag, m, integer(c_int), value :: invA_size integer(c_int64_t), value :: stride_invA integer(kind(HIPBLAS_R_16F)), value :: compute_type - integer(c_int) :: res - res = hipblasTrsmStridedBatchedEx(handle, side, uplo, transA, diag, m, n, alpha,& - A, lda, stride_A, B, ldb, stride_B, batch_count, invA, invA_size, stride_invA, compute_type) + hipblasTrsmStridedBatchedExFortran = & + hipblasTrsmStridedBatchedEx(handle, side, uplo, transA, diag, m, n, alpha, & + A, lda, stride_A, B, ldb, stride_B, batch_count, invA, invA_size, stride_invA, compute_type) end function hipblasTrsmStridedBatchedExFortran ! AxpyEx function hipblasAxpyExFortran(handle, n, alpha, alphaType, x, xType, incx, y, yType, incy, executionType) & - result(res) & - bind(c, name = 'hipblasAxpyExFortran') + bind(c, name='hipblasAxpyExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasAxpyExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -12396,17 +12593,17 @@ function hipblasAxpyExFortran(handle, n, alpha, alphaType, x, xType, incx, y, yT integer(kind(HIPBLAS_R_16F)), value :: yType integer(c_int), value :: incy integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasAxpyEx(handle, n, alpha, alphaType, x, xType, incx, y, yType, incy, executionType) + hipblasAxpyExFortran = & + hipblasAxpyEx(handle, n, alpha, alphaType, x, xType, incx, y, yType, incy, executionType) return end function hipblasAxpyExFortran function hipblasAxpyBatchedExFortran(handle, n, alpha, alphaType, x, xType, incx, y, yType, incy, batch_count, executionType) & - result(res) & - bind(c, name = 'hipblasAxpyBatchedExFortran') + bind(c, name='hipblasAxpyBatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasAxpyBatchedExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -12419,18 +12616,18 @@ function hipblasAxpyBatchedExFortran(handle, n, alpha, alphaType, x, xType, incx integer(c_int), value :: incy integer(c_int), value :: batch_count integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasAxpyBatchedEx(handle, n, alpha, alphaType, x, xType, incx, y, yType, incy, batch_count, executionType) + hipblasAxpyBatchedExFortran = & + hipblasAxpyBatchedEx(handle, n, alpha, alphaType, x, xType, incx, y, yType, incy, batch_count, executionType) return end function hipblasAxpyBatchedExFortran function hipblasAxpyStridedBatchedExFortran(handle, n, alpha, alphaType, x, xType, incx, stridex, & - y, yType, incy, stridey, batch_count, executionType) & - result(res) & - bind(c, name = 'hipblasAxpyStridedBatchedExFortran') + y, yType, incy, stridey, batch_count, executionType) & + bind(c, name='hipblasAxpyStridedBatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasAxpyStridedBatchedExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -12445,20 +12642,20 @@ function hipblasAxpyStridedBatchedExFortran(handle, n, alpha, alphaType, x, xTyp integer(c_int64_t), value :: stridey integer(c_int), value :: batch_count integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasAxpyStridedBatchedEx(handle, n, alpha, alphaType, x, xType, incx, stridex, & - y, yType, incy, stridey, batch_count, executionType) + hipblasAxpyStridedBatchedExFortran = & + hipblasAxpyStridedBatchedEx(handle, n, alpha, alphaType, x, xType, incx, stridex, & + y, yType, incy, stridey, batch_count, executionType) return end function hipblasAxpyStridedBatchedExFortran ! DotEx function hipblasDotExFortran(handle, n, x, xType, incx, y, yType, incy, result, & - resultType, executionType) & - result(res) & - bind(c, name = 'hipblasDotExFortran') + resultType, executionType) & + bind(c, name='hipblasDotExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12470,18 +12667,18 @@ function hipblasDotExFortran(handle, n, x, xType, incx, y, yType, incy, result, type(c_ptr), value :: result integer(kind(HIPBLAS_R_16F)), value :: resultType integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasDotEx(handle, n, x, xType, incx, y, yType, incy, result, resultType, executionType) + hipblasDotExFortran = & + hipblasDotEx(handle, n, x, xType, incx, y, yType, incy, result, resultType, executionType) return end function hipblasDotExFortran function hipblasDotcExFortran(handle, n, x, xType, incx, y, yType, incy, result, & - resultType, executionType) & - result(res) & - bind(c, name = 'hipblasDotcExFortran') + resultType, executionType) & + bind(c, name='hipblasDotcExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotcExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12493,18 +12690,18 @@ function hipblasDotcExFortran(handle, n, x, xType, incx, y, yType, incy, result, type(c_ptr), value :: result integer(kind(HIPBLAS_R_16F)), value :: resultType integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasDotcEx(handle, n, x, xType, incx, y, yType, incy, result, resultType, executionType) + hipblasDotcExFortran = & + hipblasDotcEx(handle, n, x, xType, incx, y, yType, incy, result, resultType, executionType) return end function hipblasDotcExFortran function hipblasDotBatchedExFortran(handle, n, x, xType, incx, y, yType, incy, batch_count, result, & - resultType, executionType) & - result(res) & - bind(c, name = 'hipblasDotBatchedExFortran') + resultType, executionType) & + bind(c, name='hipblasDotBatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotBatchedExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12517,18 +12714,18 @@ function hipblasDotBatchedExFortran(handle, n, x, xType, incx, y, yType, incy, b type(c_ptr), value :: result integer(kind(HIPBLAS_R_16F)), value :: resultType integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasDotBatchedEx(handle, n, x, xType, incx, y, yType, incy, batch_count, result, resultType, executionType) + hipblasDotBatchedExFortran = & + hipblasDotBatchedEx(handle, n, x, xType, incx, y, yType, incy, batch_count, result, resultType, executionType) return end function hipblasDotBatchedExFortran function hipblasDotcBatchedExFortran(handle, n, x, xType, incx, y, yType, incy, batch_count, result, & - resultType, executionType) & - result(res) & - bind(c, name = 'hipblasDotcBatchedExFortran') + resultType, executionType) & + bind(c, name='hipblasDotcBatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotcBatchedExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12541,18 +12738,18 @@ function hipblasDotcBatchedExFortran(handle, n, x, xType, incx, y, yType, incy, type(c_ptr), value :: result integer(kind(HIPBLAS_R_16F)), value :: resultType integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasDotcBatchedEx(handle, n, x, xType, incx, y, yType, incy, batch_count, result, resultType, executionType) + hipblasDotcBatchedExFortran = & + hipblasDotcBatchedEx(handle, n, x, xType, incx, y, yType, incy, batch_count, result, resultType, executionType) return end function hipblasDotcBatchedExFortran function hipblasDotStridedBatchedExFortran(handle, n, x, xType, incx, stridex, & - y, yType, incy, stridey,batch_count, result, resultType, executionType) & - result(res) & - bind(c, name = 'hipblasDotStridedBatchedExFortran') + y, yType, incy, stridey, batch_count, result, resultType, executionType) & + bind(c, name='hipblasDotStridedBatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotStridedBatchedExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12567,19 +12764,19 @@ function hipblasDotStridedBatchedExFortran(handle, n, x, xType, incx, stridex, & type(c_ptr), value :: result integer(kind(HIPBLAS_R_16F)), value :: resultType integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasDotStridedBatchedEx(handle, n, x, xType, incx, stridex, & - y, yType, incy, stridey, batch_count, result, resultType, executionType) + hipblasDotStridedBatchedExFortran = & + hipblasDotStridedBatchedEx(handle, n, x, xType, incx, stridex, & + y, yType, incy, stridey, batch_count, result, resultType, executionType) return end function hipblasDotStridedBatchedExFortran function hipblasDotcStridedBatchedExFortran(handle, n, x, xType, incx, stridex, & - y, yType, incy, stridey,batch_count, result, resultType, executionType) & - result(res) & - bind(c, name = 'hipblasDotcStridedBatchedExFortran') + y, yType, incy, stridey, batch_count, result, resultType, executionType) & + bind(c, name='hipblasDotcStridedBatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotcStridedBatchedExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12594,19 +12791,19 @@ function hipblasDotcStridedBatchedExFortran(handle, n, x, xType, incx, stridex, type(c_ptr), value :: result integer(kind(HIPBLAS_R_16F)), value :: resultType integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasDotcStridedBatchedEx(handle, n, x, xType, incx, stridex, & - y, yType, incy, stridey, batch_count, result, resultType, executionType) + hipblasDotcStridedBatchedExFortran = & + hipblasDotcStridedBatchedEx(handle, n, x, xType, incx, stridex, & + y, yType, incy, stridey, batch_count, result, resultType, executionType) return end function hipblasDotcStridedBatchedExFortran ! Nrm2Ex function hipblasNrm2ExFortran(handle, n, x, xType, incx, result, resultType, executionType) & - result(res) & - bind(c, name = 'hipblasNrm2ExFortran') + bind(c, name='hipblasNrm2ExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasNrm2ExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12615,17 +12812,17 @@ function hipblasNrm2ExFortran(handle, n, x, xType, incx, result, resultType, exe type(c_ptr), value :: result integer(kind(HIPBLAS_R_16F)), value :: resultType integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasNrm2Ex(handle, n, x, xType, incx, result, resultType, executionType) + hipblasNrm2ExFortran = & + hipblasNrm2Ex(handle, n, x, xType, incx, result, resultType, executionType) return end function hipblasNrm2ExFortran function hipblasNrm2BatchedExFortran(handle, n, x, xType, incx, batch_count, result, resultType, executionType) & - result(res) & - bind(c, name = 'hipblasNrm2BatchedExFortran') + bind(c, name='hipblasNrm2BatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasNrm2BatchedExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12635,18 +12832,18 @@ function hipblasNrm2BatchedExFortran(handle, n, x, xType, incx, batch_count, res type(c_ptr), value :: result integer(kind(HIPBLAS_R_16F)), value :: resultType integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasNrm2BatchedEx(handle, n, x, xType, incx, batch_count, result, resultType, executionType) + hipblasNrm2BatchedExFortran = & + hipblasNrm2BatchedEx(handle, n, x, xType, incx, batch_count, result, resultType, executionType) return end function hipblasNrm2BatchedExFortran function hipblasNrm2StridedBatchedExFortran(handle, n, x, xType, incx, stridex, & - batch_count, result, resultType, executionType) & - result(res) & - bind(c, name = 'hipblasNrm2StridedBatchedExFortran') + batch_count, result, resultType, executionType) & + bind(c, name='hipblasNrm2StridedBatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasNrm2StridedBatchedExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12657,20 +12854,20 @@ function hipblasNrm2StridedBatchedExFortran(handle, n, x, xType, incx, stridex, type(c_ptr), value :: result integer(kind(HIPBLAS_R_16F)), value :: resultType integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasNrm2StridedBatchedEx(handle, n, x, xType, incx, stridex, & - batch_count, result, resultType, executionType) + hipblasNrm2StridedBatchedExFortran = & + hipblasNrm2StridedBatchedEx(handle, n, x, xType, incx, stridex, & + batch_count, result, resultType, executionType) return end function hipblasNrm2StridedBatchedExFortran ! RotEx function hipblasRotExFortran(handle, n, x, xType, incx, y, yType, incy, c, s, & - csType, executionType) & - result(res) & - bind(c, name = 'hipblasRotExFortran') + csType, executionType) & + bind(c, name='hipblasRotExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasRotExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12683,18 +12880,18 @@ function hipblasRotExFortran(handle, n, x, xType, incx, y, yType, incy, c, s, & type(c_ptr), value :: s integer(kind(HIPBLAS_R_16F)), value :: csType integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasRotEx(handle, n, x, xType, incx, y, yType, incy, c, s, csType, executionType) + hipblasRotExFortran = & + hipblasRotEx(handle, n, x, xType, incx, y, yType, incy, c, s, csType, executionType) return end function hipblasRotExFortran function hipblasRotBatchedExFortran(handle, n, x, xType, incx, y, yType, incy, c, s, & - csType, batch_count, executionType) & - result(res) & - bind(c, name = 'hipblasRotBatchedExFortran') + csType, batch_count, executionType) & + bind(c, name='hipblasRotBatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasRotBatchedExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12708,18 +12905,18 @@ function hipblasRotBatchedExFortran(handle, n, x, xType, incx, y, yType, incy, c integer(kind(HIPBLAS_R_16F)), value :: csType integer(c_int), value :: batch_count integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasRotBatchedEx(handle, n, x, xType, incx, y, yType, incy, c, s, csType, batch_count, executionType) + hipblasRotBatchedExFortran = & + hipblasRotBatchedEx(handle, n, x, xType, incx, y, yType, incy, c, s, csType, batch_count, executionType) return end function hipblasRotBatchedExFortran function hipblasRotStridedBatchedExFortran(handle, n, x, xType, incx, stridex, & - y, yType, incy, stridey, c, s, csType, batch_count, executionType) & - result(res) & - bind(c, name = 'hipblasRotStridedBatchedExFortran') + y, yType, incy, stridey, c, s, csType, batch_count, executionType) & + bind(c, name='hipblasRotStridedBatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasRotStridedBatchedExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12735,19 +12932,19 @@ function hipblasRotStridedBatchedExFortran(handle, n, x, xType, incx, stridex, & integer(kind(HIPBLAS_R_16F)), value :: csType integer(c_int), value :: batch_count integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasRotStridedBatchedEx(handle, n, x, xType, incx, stridex, & - y, yType, incy, stridey, c, s, csType, batch_count, executionType) + hipblasRotStridedBatchedExFortran = & + hipblasRotStridedBatchedEx(handle, n, x, xType, incx, stridex, & + y, yType, incy, stridey, c, s, csType, batch_count, executionType) return end function hipblasRotStridedBatchedExFortran ! ScalEx function hipblasScalExFortran(handle, n, alpha, alphaType, x, xType, incx, executionType) & - result(res) & - bind(c, name = 'hipblasScalExFortran') + bind(c, name='hipblasScalExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScalExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -12756,17 +12953,17 @@ function hipblasScalExFortran(handle, n, alpha, alphaType, x, xType, incx, execu integer(kind(HIPBLAS_R_16F)), value :: xType integer(c_int), value :: incx integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasScalEx(handle, n, alpha, alphaType, x, xType, incx, executionType) + hipblasScalExFortran = & + hipblasScalEx(handle, n, alpha, alphaType, x, xType, incx, executionType) return end function hipblasScalExFortran function hipblasScalBatchedExFortran(handle, n, alpha, alphaType, x, xType, incx, batch_count, executionType) & - result(res) & - bind(c, name = 'hipblasScalBatchedExFortran') + bind(c, name='hipblasScalBatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScalBatchedExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -12776,18 +12973,18 @@ function hipblasScalBatchedExFortran(handle, n, alpha, alphaType, x, xType, incx integer(c_int), value :: incx integer(c_int), value :: batch_count integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasScalBatchedEx(handle, n, alpha, alphaType, x, xType, incx, batch_count, executionType) + hipblasScalBatchedExFortran = & + hipblasScalBatchedEx(handle, n, alpha, alphaType, x, xType, incx, batch_count, executionType) return end function hipblasScalBatchedExFortran function hipblasScalStridedBatchedExFortran(handle, n, alpha, alphaType, x, xType, incx, stridex, & - batch_count, executionType) & - result(res) & - bind(c, name = 'hipblasScalStridedBatchedExFortran') + batch_count, executionType) & + bind(c, name='hipblasScalStridedBatchedExFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScalStridedBatchedExFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -12798,19 +12995,19 @@ function hipblasScalStridedBatchedExFortran(handle, n, alpha, alphaType, x, xTyp integer(c_int64_t), value :: stridex integer(c_int), value :: batch_count integer(kind(HIPBLAS_R_16F)), value :: executionType - integer(c_int) :: res - res = hipblasScalStridedBatchedEx(handle, n, alpha, alphaType, x, xType, incx, stridex, & - batch_count, executionType) + hipblasScalStridedBatchedExFortran = & + hipblasScalStridedBatchedEx(handle, n, alpha, alphaType, x, xType, incx, stridex, & + batch_count, executionType) return end function hipblasScalStridedBatchedExFortran ! ! CsyrkEx ! function hipblasCsyrkExFortran(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C, Ctype, ldc) & -! result(res) & -! bind(c, name = 'hipblasCsyrkExFortran') +! bind(c, name = 'hipblasCsyrkExFortran') ! use iso_c_binding ! use hipblas_enums ! implicit none +! integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkExFortran ! type(c_ptr), value :: handle ! integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo ! integer(kind(HIPBLAS_OP_N)), value :: trans @@ -12824,32 +13021,31 @@ end function hipblasScalStridedBatchedExFortran ! type(c_ptr), value :: C ! integer(kind(HIPBLAS_R_16F)), value :: Ctype ! integer(c_int), value :: ldc -! integer(c_int) :: res -! res = hipblasCsyrkEx(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C, Ctype, ldc) +! ! hipblasCsyrkExFortran = & +! hipblasCsyrkEx(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C, Ctype, ldc) ! end function hipblasCsyrkExFortran - ! ! CherkEx ! function hipblasCherkExFortran(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C, Ctype, ldc) & -! result(res) & ! bind(c, name = 'hipblasCherkExFortran') -! use iso_c_binding -! use hipblas_enums -! implicit none -! type(c_ptr), value :: handle -! integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo -! integer(kind(HIPBLAS_OP_N)), value :: trans -! integer(c_int), value :: n -! integer(c_int), value :: k -! type(c_ptr), value :: alpha -! type(c_ptr), value :: A -! integer(kind(HIPBLAS_R_16F)), value :: Atype -! integer(c_int), value :: lda -! type(c_ptr), value :: beta -! type(c_ptr), value :: C -! integer(kind(HIPBLAS_R_16F)), value :: Ctype -! integer(c_int), value :: ldc -! integer(c_int) :: res -! res = hipblasCherkEx(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C, Ctype, ldc) -! end function hipblasCherkExFortran +! use iso_c_binding +! use hipblas_enums +! implicit none +! integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkExFortran +! type(c_ptr), value :: handle +! integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo +! integer(kind(HIPBLAS_OP_N)), value :: trans +! integer(c_int), value :: n +! integer(c_int), value :: k +! type(c_ptr), value :: alpha +! type(c_ptr), value :: A +! integer(kind(HIPBLAS_R_16F)), value :: Atype +! integer(c_int), value :: lda +! type(c_ptr), value :: beta +! type(c_ptr), value :: C +! integer(kind(HIPBLAS_R_16F)), value :: Ctype +! integer(c_int), value :: ldc +! ! hipblasCherkExFortran = & +! hipblasCherkEx(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C, Ctype, ldc) +! end function hipblasCherkExFortran end module hipblas_interface diff --git a/clients/include/hipblas_fortran_solver.f90 b/clients/include/hipblas_fortran_solver.f90 index 1eea0e625..8fb37d105 100644 --- a/clients/include/hipblas_fortran_solver.f90 +++ b/clients/include/hipblas_fortran_solver.f90 @@ -25,7 +25,7 @@ module hipblas_interface use iso_c_binding use hipblas - contains +contains !--------! ! Solver ! @@ -33,76 +33,76 @@ module hipblas_interface ! getrf function hipblasSgetrfFortran(handle, n, A, lda, ipiv, info) & - result(res) & - bind(c, name = 'hipblasSgetrfFortran') + bind(c, name='hipblasSgetrfFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrfFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A integer(c_int), value :: lda type(c_ptr), value :: ipiv type(c_ptr), value :: info - integer(c_int) :: res - res = hipblasSgetrf(handle, n, A, lda, ipiv, info) + hipblasSgetrfFortran = & + hipblasSgetrf(handle, n, A, lda, ipiv, info) end function hipblasSgetrfFortran function hipblasDgetrfFortran(handle, n, A, lda, ipiv, info) & - result(res) & - bind(c, name = 'hipblasDgetrfFortran') + bind(c, name='hipblasDgetrfFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrfFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A integer(c_int), value :: lda type(c_ptr), value :: ipiv type(c_ptr), value :: info - integer(c_int) :: res - res = hipblasDgetrf(handle, n, A, lda, ipiv, info) + hipblasDgetrfFortran = & + hipblasDgetrf(handle, n, A, lda, ipiv, info) end function hipblasDgetrfFortran function hipblasCgetrfFortran(handle, n, A, lda, ipiv, info) & - result(res) & - bind(c, name = 'hipblasCgetrfFortran') + bind(c, name='hipblasCgetrfFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrfFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A integer(c_int), value :: lda type(c_ptr), value :: ipiv type(c_ptr), value :: info - integer(c_int) :: res - res = hipblasCgetrf(handle, n, A, lda, ipiv, info) + hipblasCgetrfFortran = & + hipblasCgetrf(handle, n, A, lda, ipiv, info) end function hipblasCgetrfFortran function hipblasZgetrfFortran(handle, n, A, lda, ipiv, info) & - result(res) & - bind(c, name = 'hipblasZgetrfFortran') + bind(c, name='hipblasZgetrfFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrfFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A integer(c_int), value :: lda type(c_ptr), value :: ipiv type(c_ptr), value :: info - integer(c_int) :: res - res = hipblasZgetrf(handle, n, A, lda, ipiv, info) + hipblasZgetrfFortran = & + hipblasZgetrf(handle, n, A, lda, ipiv, info) end function hipblasZgetrfFortran ! getrf_batched function hipblasSgetrfBatchedFortran(handle, n, A, lda, ipiv, info, batch_count) & - result(res) & - bind(c, name = 'hipblasSgetrfBatchedFortran') + bind(c, name='hipblasSgetrfBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrfBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -110,16 +110,16 @@ function hipblasSgetrfBatchedFortran(handle, n, A, lda, ipiv, info, batch_count) type(c_ptr), value :: ipiv type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgetrfBatched(handle, n, A, lda, ipiv, info, batch_count) + hipblasSgetrfBatchedFortran = & + hipblasSgetrfBatched(handle, n, A, lda, ipiv, info, batch_count) end function hipblasSgetrfBatchedFortran function hipblasDgetrfBatchedFortran(handle, n, A, lda, ipiv, info, batch_count) & - result(res) & - bind(c, name = 'hipblasDgetrfBatchedFortran') + bind(c, name='hipblasDgetrfBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrfBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -127,16 +127,16 @@ function hipblasDgetrfBatchedFortran(handle, n, A, lda, ipiv, info, batch_count) type(c_ptr), value :: ipiv type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgetrfBatched(handle, n, A, lda, ipiv, info, batch_count) + hipblasDgetrfBatchedFortran = & + hipblasDgetrfBatched(handle, n, A, lda, ipiv, info, batch_count) end function hipblasDgetrfBatchedFortran function hipblasCgetrfBatchedFortran(handle, n, A, lda, ipiv, info, batch_count) & - result(res) & - bind(c, name = 'hipblasCgetrfBatchedFortran') + bind(c, name='hipblasCgetrfBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrfBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -144,16 +144,16 @@ function hipblasCgetrfBatchedFortran(handle, n, A, lda, ipiv, info, batch_count) type(c_ptr), value :: ipiv type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgetrfBatched(handle, n, A, lda, ipiv, info, batch_count) + hipblasCgetrfBatchedFortran = & + hipblasCgetrfBatched(handle, n, A, lda, ipiv, info, batch_count) end function hipblasCgetrfBatchedFortran function hipblasZgetrfBatchedFortran(handle, n, A, lda, ipiv, info, batch_count) & - result(res) & - bind(c, name = 'hipblasZgetrfBatchedFortran') + bind(c, name='hipblasZgetrfBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrfBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -161,18 +161,18 @@ function hipblasZgetrfBatchedFortran(handle, n, A, lda, ipiv, info, batch_count) type(c_ptr), value :: ipiv type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgetrfBatched(handle, n, A, lda, ipiv, info, batch_count) + hipblasZgetrfBatchedFortran = & + hipblasZgetrfBatched(handle, n, A, lda, ipiv, info, batch_count) end function hipblasZgetrfBatchedFortran ! getrf_strided_batched - function hipblasSgetrfStridedBatchedFortran(handle, n, A, lda, stride_A,& - ipiv, stride_P, info, batch_count) & - result(res) & - bind(c, name = 'hipblasSgetrfStridedBatchedFortran') + function hipblasSgetrfStridedBatchedFortran(handle, n, A, lda, stride_A, & + ipiv, stride_P, info, batch_count) & + bind(c, name='hipblasSgetrfStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrfStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -182,18 +182,18 @@ function hipblasSgetrfStridedBatchedFortran(handle, n, A, lda, stride_A,& integer(c_int), value :: stride_P type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgetrfStridedBatched(handle, n, A, lda, stride_A,& - ipiv, stride_P, info, batch_count) + hipblasSgetrfStridedBatchedFortran = & + hipblasSgetrfStridedBatched(handle, n, A, lda, stride_A, & + ipiv, stride_P, info, batch_count) end function hipblasSgetrfStridedBatchedFortran - function hipblasDgetrfStridedBatchedFortran(handle, n, A, lda, stride_A,& - ipiv, stride_P, info, batch_count) & - result(res) & - bind(c, name = 'hipblasDgetrfStridedBatchedFortran') + function hipblasDgetrfStridedBatchedFortran(handle, n, A, lda, stride_A, & + ipiv, stride_P, info, batch_count) & + bind(c, name='hipblasDgetrfStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrfStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -203,18 +203,18 @@ function hipblasDgetrfStridedBatchedFortran(handle, n, A, lda, stride_A,& integer(c_int), value :: stride_P type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgetrfStridedBatched(handle, n, A, lda, stride_A,& - ipiv, stride_P, info, batch_count) + hipblasDgetrfStridedBatchedFortran = & + hipblasDgetrfStridedBatched(handle, n, A, lda, stride_A, & + ipiv, stride_P, info, batch_count) end function hipblasDgetrfStridedBatchedFortran - function hipblasCgetrfStridedBatchedFortran(handle, n, A, lda, stride_A,& - ipiv, stride_P, info, batch_count) & - result(res) & - bind(c, name = 'hipblasCgetrfStridedBatchedFortran') + function hipblasCgetrfStridedBatchedFortran(handle, n, A, lda, stride_A, & + ipiv, stride_P, info, batch_count) & + bind(c, name='hipblasCgetrfStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrfStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -224,18 +224,18 @@ function hipblasCgetrfStridedBatchedFortran(handle, n, A, lda, stride_A,& integer(c_int), value :: stride_P type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgetrfStridedBatched(handle, n, A, lda, stride_A,& - ipiv, stride_P, info, batch_count) + hipblasCgetrfStridedBatchedFortran = & + hipblasCgetrfStridedBatched(handle, n, A, lda, stride_A, & + ipiv, stride_P, info, batch_count) end function hipblasCgetrfStridedBatchedFortran - function hipblasZgetrfStridedBatchedFortran(handle, n, A, lda, stride_A,& - ipiv, stride_P, info, batch_count) & - result(res) & - bind(c, name = 'hipblasZgetrfStridedBatchedFortran') + function hipblasZgetrfStridedBatchedFortran(handle, n, A, lda, stride_A, & + ipiv, stride_P, info, batch_count) & + bind(c, name='hipblasZgetrfStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrfStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -245,19 +245,19 @@ function hipblasZgetrfStridedBatchedFortran(handle, n, A, lda, stride_A,& integer(c_int), value :: stride_P type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgetrfStridedBatched(handle, n, A, lda, stride_A,& - ipiv, stride_P, info, batch_count) + hipblasZgetrfStridedBatchedFortran = & + hipblasZgetrfStridedBatched(handle, n, A, lda, stride_A, & + ipiv, stride_P, info, batch_count) end function hipblasZgetrfStridedBatchedFortran ! getrs - function hipblasSgetrsFortran(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info) & - result(res) & - bind(c, name = 'hipblasSgetrsFortran') + function hipblasSgetrsFortran(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info) & + bind(c, name='hipblasSgetrsFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrsFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -268,18 +268,18 @@ function hipblasSgetrsFortran(handle, trans, n, nrhs, A, lda, ipiv,& type(c_ptr), value :: B integer(c_int), value :: ldb type(c_ptr), value :: info - integer(c_int) :: res - res = hipblasSgetrs(handle, trans, n, nrhs, A, lda,& - ipiv, B, ldb, info) + hipblasSgetrsFortran = & + hipblasSgetrs(handle, trans, n, nrhs, A, lda, & + ipiv, B, ldb, info) end function hipblasSgetrsFortran - function hipblasDgetrsFortran(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info) & - result(res) & - bind(c, name = 'hipblasDgetrsFortran') + function hipblasDgetrsFortran(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info) & + bind(c, name='hipblasDgetrsFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrsFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -290,18 +290,18 @@ function hipblasDgetrsFortran(handle, trans, n, nrhs, A, lda, ipiv,& type(c_ptr), value :: B integer(c_int), value :: ldb type(c_ptr), value :: info - integer(c_int) :: res - res = hipblasDgetrs(handle, trans, n, nrhs, A, lda,& - ipiv, B, ldb, info) + hipblasDgetrsFortran = & + hipblasDgetrs(handle, trans, n, nrhs, A, lda, & + ipiv, B, ldb, info) end function hipblasDgetrsFortran - function hipblasCgetrsFortran(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info) & - result(res) & - bind(c, name = 'hipblasCgetrsFortran') + function hipblasCgetrsFortran(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info) & + bind(c, name='hipblasCgetrsFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrsFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -312,18 +312,18 @@ function hipblasCgetrsFortran(handle, trans, n, nrhs, A, lda, ipiv,& type(c_ptr), value :: B integer(c_int), value :: ldb type(c_ptr), value :: info - integer(c_int) :: res - res = hipblasCgetrs(handle, trans, n, nrhs, A, lda,& - ipiv, B, ldb, info) + hipblasCgetrsFortran = & + hipblasCgetrs(handle, trans, n, nrhs, A, lda, & + ipiv, B, ldb, info) end function hipblasCgetrsFortran - function hipblasZgetrsFortran(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info) & - result(res) & - bind(c, name = 'hipblasZgetrsFortran') + function hipblasZgetrsFortran(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info) & + bind(c, name='hipblasZgetrsFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrsFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -334,19 +334,19 @@ function hipblasZgetrsFortran(handle, trans, n, nrhs, A, lda, ipiv,& type(c_ptr), value :: B integer(c_int), value :: ldb type(c_ptr), value :: info - integer(c_int) :: res - res = hipblasZgetrs(handle, trans, n, nrhs, A, lda,& - ipiv, B, ldb, info) + hipblasZgetrsFortran = & + hipblasZgetrs(handle, trans, n, nrhs, A, lda, & + ipiv, B, ldb, info) end function hipblasZgetrsFortran ! getrs_batched - function hipblasSgetrsBatchedFortran(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info, batch_count) & - result(res) & - bind(c, name = 'hipblasSgetrsBatchedFortran') + function hipblasSgetrsBatchedFortran(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info, batch_count) & + bind(c, name='hipblasSgetrsBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrsBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -358,18 +358,18 @@ function hipblasSgetrsBatchedFortran(handle, trans, n, nrhs, A, lda, ipiv,& integer(c_int), value :: ldb type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgetrsBatched(handle, trans, n, nrhs, A, lda,& - ipiv, B, ldb, info, batch_count) + hipblasSgetrsBatchedFortran = & + hipblasSgetrsBatched(handle, trans, n, nrhs, A, lda, & + ipiv, B, ldb, info, batch_count) end function hipblasSgetrsBatchedFortran - function hipblasDgetrsBatchedFortran(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info, batch_count) & - result(res) & - bind(c, name = 'hipblasDgetrsBatchedFortran') + function hipblasDgetrsBatchedFortran(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info, batch_count) & + bind(c, name='hipblasDgetrsBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrsBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -381,18 +381,18 @@ function hipblasDgetrsBatchedFortran(handle, trans, n, nrhs, A, lda, ipiv,& integer(c_int), value :: ldb type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgetrsBatched(handle, trans, n, nrhs, A, lda,& - ipiv, B, ldb, info, batch_count) + hipblasDgetrsBatchedFortran = & + hipblasDgetrsBatched(handle, trans, n, nrhs, A, lda, & + ipiv, B, ldb, info, batch_count) end function hipblasDgetrsBatchedFortran - function hipblasCgetrsBatchedFortran(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info, batch_count) & - result(res) & - bind(c, name = 'hipblasCgetrsBatchedFortran') + function hipblasCgetrsBatchedFortran(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info, batch_count) & + bind(c, name='hipblasCgetrsBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrsBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -404,18 +404,18 @@ function hipblasCgetrsBatchedFortran(handle, trans, n, nrhs, A, lda, ipiv,& integer(c_int), value :: ldb type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgetrsBatched(handle, trans, n, nrhs, A, lda,& - ipiv, B, ldb, info, batch_count) + hipblasCgetrsBatchedFortran = & + hipblasCgetrsBatched(handle, trans, n, nrhs, A, lda, & + ipiv, B, ldb, info, batch_count) end function hipblasCgetrsBatchedFortran - function hipblasZgetrsBatchedFortran(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info, batch_count) & - result(res) & - bind(c, name = 'hipblasZgetrsBatchedFortran') + function hipblasZgetrsBatchedFortran(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info, batch_count) & + bind(c, name='hipblasZgetrsBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrsBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -427,19 +427,19 @@ function hipblasZgetrsBatchedFortran(handle, trans, n, nrhs, A, lda, ipiv,& integer(c_int), value :: ldb type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgetrsBatched(handle, trans, n, nrhs, A, lda,& - ipiv, B, ldb, info, batch_count) + hipblasZgetrsBatchedFortran = & + hipblasZgetrsBatched(handle, trans, n, nrhs, A, lda, & + ipiv, B, ldb, info, batch_count) end function hipblasZgetrsBatchedFortran ! getrs_strided_batched - function hipblasSgetrsStridedBatchedFortran(handle, trans, n, nrhs, A, lda, stride_A, ipiv,& - stride_P, B, ldb, stride_B, info, batch_count) & - result(res) & - bind(c, name = 'hipblasSgetrsStridedBatchedFortran') + function hipblasSgetrsStridedBatchedFortran(handle, trans, n, nrhs, A, lda, stride_A, ipiv, & + stride_P, B, ldb, stride_B, info, batch_count) & + bind(c, name='hipblasSgetrsStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrsStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -454,18 +454,18 @@ function hipblasSgetrsStridedBatchedFortran(handle, trans, n, nrhs, A, lda, stri integer(c_int), value :: stride_B type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A,& - ipiv, stride_P, B, ldb, stride_B, info, batch_count) + hipblasSgetrsStridedBatchedFortran = & + hipblasSgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A, & + ipiv, stride_P, B, ldb, stride_B, info, batch_count) end function hipblasSgetrsStridedBatchedFortran - function hipblasDgetrsStridedBatchedFortran(handle, trans, n, nrhs, A, lda, stride_A, ipiv,& - stride_P, B, ldb, stride_B, info, batch_count) & - result(res) & - bind(c, name = 'hipblasDgetrsStridedBatchedFortran') + function hipblasDgetrsStridedBatchedFortran(handle, trans, n, nrhs, A, lda, stride_A, ipiv, & + stride_P, B, ldb, stride_B, info, batch_count) & + bind(c, name='hipblasDgetrsStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrsStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -480,18 +480,18 @@ function hipblasDgetrsStridedBatchedFortran(handle, trans, n, nrhs, A, lda, stri integer(c_int), value :: stride_B type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A,& - ipiv, stride_P, B, ldb, stride_B, info, batch_count) + hipblasDgetrsStridedBatchedFortran = & + hipblasDgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A, & + ipiv, stride_P, B, ldb, stride_B, info, batch_count) end function hipblasDgetrsStridedBatchedFortran - function hipblasCgetrsStridedBatchedFortran(handle, trans, n, nrhs, A, lda, stride_A, ipiv,& - stride_P, B, ldb, stride_B, info, batch_count) & - result(res) & - bind(c, name = 'hipblasCgetrsStridedBatchedFortran') + function hipblasCgetrsStridedBatchedFortran(handle, trans, n, nrhs, A, lda, stride_A, ipiv, & + stride_P, B, ldb, stride_B, info, batch_count) & + bind(c, name='hipblasCgetrsStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrsStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -506,18 +506,18 @@ function hipblasCgetrsStridedBatchedFortran(handle, trans, n, nrhs, A, lda, stri integer(c_int), value :: stride_B type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A,& - ipiv, stride_P, B, ldb, stride_B, info, batch_count) + hipblasCgetrsStridedBatchedFortran = & + hipblasCgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A, & + ipiv, stride_P, B, ldb, stride_B, info, batch_count) end function hipblasCgetrsStridedBatchedFortran - function hipblasZgetrsStridedBatchedFortran(handle, trans, n, nrhs, A, lda, stride_A, ipiv,& - stride_P, B, ldb, stride_B, info, batch_count) & - result(res) & - bind(c, name = 'hipblasZgetrsStridedBatchedFortran') + function hipblasZgetrsStridedBatchedFortran(handle, trans, n, nrhs, A, lda, stride_A, ipiv, & + stride_P, B, ldb, stride_B, info, batch_count) & + bind(c, name='hipblasZgetrsStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrsStridedBatchedFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -532,18 +532,18 @@ function hipblasZgetrsStridedBatchedFortran(handle, trans, n, nrhs, A, lda, stri integer(c_int), value :: stride_B type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A,& - ipiv, stride_P, B, ldb, stride_B, info, batch_count) + hipblasZgetrsStridedBatchedFortran = & + hipblasZgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A, & + ipiv, stride_P, B, ldb, stride_B, info, batch_count) end function hipblasZgetrsStridedBatchedFortran ! getri_batched function hipblasSgetriBatchedFortran(handle, n, A, lda, ipiv, C, ldc, info, batch_count) & - result(res) & - bind(c, name = 'hipblasSgetriBatchedFortran') + bind(c, name='hipblasSgetriBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetriBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -553,16 +553,16 @@ function hipblasSgetriBatchedFortran(handle, n, A, lda, ipiv, C, ldc, info, batc integer(c_int), value :: ldc type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgetriBatched(handle, n, A, lda, ipiv, C, ldc, info, batch_count) + hipblasSgetriBatchedFortran = & + hipblasSgetriBatched(handle, n, A, lda, ipiv, C, ldc, info, batch_count) end function hipblasSgetriBatchedFortran function hipblasDgetriBatchedFortran(handle, n, A, lda, ipiv, C, ldc, info, batch_count) & - result(res) & - bind(c, name = 'hipblasDgetriBatchedFortran') + bind(c, name='hipblasDgetriBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetriBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -572,16 +572,16 @@ function hipblasDgetriBatchedFortran(handle, n, A, lda, ipiv, C, ldc, info, batc integer(c_int), value :: ldc type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgetriBatched(handle, n, A, lda, ipiv, C, ldc, info, batch_count) + hipblasDgetriBatchedFortran = & + hipblasDgetriBatched(handle, n, A, lda, ipiv, C, ldc, info, batch_count) end function hipblasDgetriBatchedFortran function hipblasCgetriBatchedFortran(handle, n, A, lda, ipiv, C, ldc, info, batch_count) & - result(res) & - bind(c, name = 'hipblasCgetriBatchedFortran') + bind(c, name='hipblasCgetriBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetriBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -591,16 +591,16 @@ function hipblasCgetriBatchedFortran(handle, n, A, lda, ipiv, C, ldc, info, batc integer(c_int), value :: ldc type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgetriBatched(handle, n, A, lda, ipiv, C, ldc, info, batch_count) + hipblasCgetriBatchedFortran = & + hipblasCgetriBatched(handle, n, A, lda, ipiv, C, ldc, info, batch_count) end function hipblasCgetriBatchedFortran function hipblasZgetriBatchedFortran(handle, n, A, lda, ipiv, C, ldc, info, batch_count) & - result(res) & - bind(c, name = 'hipblasZgetriBatchedFortran') + bind(c, name='hipblasZgetriBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetriBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -610,17 +610,17 @@ function hipblasZgetriBatchedFortran(handle, n, A, lda, ipiv, C, ldc, info, batc integer(c_int), value :: ldc type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgetriBatched(handle, n, A, lda, ipiv, C, ldc, info, batch_count) + hipblasZgetriBatchedFortran = & + hipblasZgetriBatched(handle, n, A, lda, ipiv, C, ldc, info, batch_count) end function hipblasZgetriBatchedFortran ! geqrf function hipblasSgeqrfFortran(handle, m, n, A, lda, tau, info) & - result(res) & - bind(c, name = 'hipblasSgeqrfFortran') + bind(c, name='hipblasSgeqrfFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeqrfFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -628,16 +628,16 @@ function hipblasSgeqrfFortran(handle, m, n, A, lda, tau, info) & integer(c_int), value :: lda type(c_ptr), value :: tau type(c_ptr), value :: info - integer(c_int) :: res - res = hipblasSgeqrf(handle, m, n, A, lda, tau, info) + hipblasSgeqrfFortran = & + hipblasSgeqrf(handle, m, n, A, lda, tau, info) end function hipblasSgeqrfFortran function hipblasDgeqrfFortran(handle, m, n, A, lda, tau, info) & - result(res) & - bind(c, name = 'hipblasDgeqrfFortran') + bind(c, name='hipblasDgeqrfFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeqrfFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -645,16 +645,16 @@ function hipblasDgeqrfFortran(handle, m, n, A, lda, tau, info) & integer(c_int), value :: lda type(c_ptr), value :: tau type(c_ptr), value :: info - integer(c_int) :: res - res = hipblasDgeqrf(handle, m, n, A, lda, tau, info) + hipblasDgeqrfFortran = & + hipblasDgeqrf(handle, m, n, A, lda, tau, info) end function hipblasDgeqrfFortran function hipblasCgeqrfFortran(handle, m, n, A, lda, tau, info) & - result(res) & - bind(c, name = 'hipblasCgeqrfFortran') + bind(c, name='hipblasCgeqrfFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeqrfFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -662,16 +662,16 @@ function hipblasCgeqrfFortran(handle, m, n, A, lda, tau, info) & integer(c_int), value :: lda type(c_ptr), value :: tau type(c_ptr), value :: info - integer(c_int) :: res - res = hipblasCgeqrf(handle, m, n, A, lda, tau, info) + hipblasCgeqrfFortran = & + hipblasCgeqrf(handle, m, n, A, lda, tau, info) end function hipblasCgeqrfFortran function hipblasZgeqrfFortran(handle, m, n, A, lda, tau, info) & - result(res) & - bind(c, name = 'hipblasZgeqrfFortran') + bind(c, name='hipblasZgeqrfFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeqrfFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -679,17 +679,17 @@ function hipblasZgeqrfFortran(handle, m, n, A, lda, tau, info) & integer(c_int), value :: lda type(c_ptr), value :: tau type(c_ptr), value :: info - integer(c_int) :: res - res = hipblasZgeqrf(handle, m, n, A, lda, tau, info) + hipblasZgeqrfFortran = & + hipblasZgeqrf(handle, m, n, A, lda, tau, info) end function hipblasZgeqrfFortran ! geqrf_batched function hipblasSgeqrfBatchedFortran(handle, m, n, A, lda, tau, info, batch_count) & - result(res) & - bind(c, name = 'hipblasSgeqrfBatchedFortran') + bind(c, name='hipblasSgeqrfBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeqrfBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -698,16 +698,16 @@ function hipblasSgeqrfBatchedFortran(handle, m, n, A, lda, tau, info, batch_coun type(c_ptr), value :: tau type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgeqrfBatched(handle, m, n, A, lda, tau, info, batch_count) + hipblasSgeqrfBatchedFortran = & + hipblasSgeqrfBatched(handle, m, n, A, lda, tau, info, batch_count) end function hipblasSgeqrfBatchedFortran function hipblasDgeqrfBatchedFortran(handle, m, n, A, lda, tau, info, batch_count) & - result(res) & - bind(c, name = 'hipblasDgeqrfBatchedFortran') + bind(c, name='hipblasDgeqrfBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeqrfBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -716,16 +716,16 @@ function hipblasDgeqrfBatchedFortran(handle, m, n, A, lda, tau, info, batch_coun type(c_ptr), value :: tau type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgeqrfBatched(handle, m, n, A, lda, tau, info, batch_count) + hipblasDgeqrfBatchedFortran = & + hipblasDgeqrfBatched(handle, m, n, A, lda, tau, info, batch_count) end function hipblasDgeqrfBatchedFortran function hipblasCgeqrfBatchedFortran(handle, m, n, A, lda, tau, info, batch_count) & - result(res) & - bind(c, name = 'hipblasCgeqrfBatchedFortran') + bind(c, name='hipblasCgeqrfBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeqrfBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -734,16 +734,16 @@ function hipblasCgeqrfBatchedFortran(handle, m, n, A, lda, tau, info, batch_coun type(c_ptr), value :: tau type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgeqrfBatched(handle, m, n, A, lda, tau, info, batch_count) + hipblasCgeqrfBatchedFortran = & + hipblasCgeqrfBatched(handle, m, n, A, lda, tau, info, batch_count) end function hipblasCgeqrfBatchedFortran function hipblasZgeqrfBatchedFortran(handle, m, n, A, lda, tau, info, batch_count) & - result(res) & - bind(c, name = 'hipblasZgeqrfBatchedFortran') + bind(c, name='hipblasZgeqrfBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeqrfBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -752,18 +752,18 @@ function hipblasZgeqrfBatchedFortran(handle, m, n, A, lda, tau, info, batch_coun type(c_ptr), value :: tau type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgeqrfBatched(handle, m, n, A, lda, tau, info, batch_count) + hipblasZgeqrfBatchedFortran = & + hipblasZgeqrfBatched(handle, m, n, A, lda, tau, info, batch_count) end function hipblasZgeqrfBatchedFortran ! geqrf_strided_batched - function hipblasSgeqrfStridedBatchedFortran(handle, m, n, A, lda, stride_A,& - tau, stride_T, info, batch_count) & - result(res) & - bind(c, name = 'hipblasSgeqrfStridedBatchedFortran') + function hipblasSgeqrfStridedBatchedFortran(handle, m, n, A, lda, stride_A, & + tau, stride_T, info, batch_count) & + bind(c, name='hipblasSgeqrfStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeqrfStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -774,40 +774,38 @@ function hipblasSgeqrfStridedBatchedFortran(handle, m, n, A, lda, stride_A,& integer(c_int), value :: stride_T type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasSgeqrfStridedBatched(handle, m, n, A, lda, stride_A,& - tau, stride_T, info, batch_count) + hipblasSgeqrfStridedBatchedFortran = & + hipblasSgeqrfStridedBatched(handle, m, n, A, lda, stride_A, & + tau, stride_T, info, batch_count) end function hipblasSgeqrfStridedBatchedFortran -function hipblasDgeqrfStridedBatchedFortran(handle, m, n, A, lda, stride_A,& - tau, stride_T, info, batch_count) & - result(res) & - bind(c, name = 'hipblasDgeqrfStridedBatchedFortran') - use iso_c_binding - use hipblas_enums - implicit none - type(c_ptr), value :: handle - integer(c_int), value :: m - integer(c_int), value :: n - type(c_ptr), value :: A - integer(c_int), value :: lda - integer(c_int), value :: stride_A - type(c_ptr), value :: tau - integer(c_int), value :: stride_T - type(c_ptr), value :: info - integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasDgeqrfStridedBatched(handle, m, n, A, lda, stride_A,& - tau, stride_T, info, batch_count) -end function hipblasDgeqrfStridedBatchedFortran - - function hipblasCgeqrfStridedBatchedFortran(handle, m, n, A, lda, stride_A,& - tau, stride_T, info, batch_count) & - result(res) & - bind(c, name = 'hipblasCgeqrfStridedBatchedFortran') + function hipblasDgeqrfStridedBatchedFortran(handle, m, n, A, lda, stride_A, & + tau, stride_T, info, batch_count) & + bind(c, name='hipblasDgeqrfStridedBatchedFortran') + use iso_c_binding + use hipblas_enums + implicit none + type(c_ptr), value :: handle + integer(c_int), value :: m + integer(c_int), value :: n + type(c_ptr), value :: A + integer(c_int), value :: lda + integer(c_int), value :: stride_A + type(c_ptr), value :: tau + integer(c_int), value :: stride_T + type(c_ptr), value :: info + integer(c_int), value :: batch_count + res = hipblasDgeqrfStridedBatched(handle, m, n, A, lda, stride_A, & + tau, stride_T, info, batch_count) + end function hipblasDgeqrfStridedBatchedFortran + + function hipblasCgeqrfStridedBatchedFortran(handle, m, n, A, lda, stride_A, & + tau, stride_T, info, batch_count) & + bind(c, name='hipblasCgeqrfStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeqrfStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -818,18 +816,18 @@ function hipblasCgeqrfStridedBatchedFortran(handle, m, n, A, lda, stride_A,& integer(c_int), value :: stride_T type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasCgeqrfStridedBatched(handle, m, n, A, lda, stride_A,& - tau, stride_T, info, batch_count) + hipblasCgeqrfStridedBatchedFortran = & + hipblasCgeqrfStridedBatched(handle, m, n, A, lda, stride_A, & + tau, stride_T, info, batch_count) end function hipblasCgeqrfStridedBatchedFortran - function hipblasZgeqrfStridedBatchedFortran(handle, m, n, A, lda, stride_A,& - tau, stride_T, info, batch_count) & - result(res) & - bind(c, name = 'hipblasZgeqrfStridedBatchedFortran') + function hipblasZgeqrfStridedBatchedFortran(handle, m, n, A, lda, stride_A, & + tau, stride_T, info, batch_count) & + bind(c, name='hipblasZgeqrfStridedBatchedFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeqrfStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -840,18 +838,18 @@ function hipblasZgeqrfStridedBatchedFortran(handle, m, n, A, lda, stride_A,& integer(c_int), value :: stride_T type(c_ptr), value :: info integer(c_int), value :: batch_count - integer(c_int) :: res - res = hipblasZgeqrfStridedBatched(handle, m, n, A, lda, stride_A,& - tau, stride_T, info, batch_count) + hipblasZgeqrfStridedBatchedFortran = & + hipblasZgeqrfStridedBatched(handle, m, n, A, lda, stride_A, & + tau, stride_T, info, batch_count) end function hipblasZgeqrfStridedBatchedFortran ! gels function hipblasSgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) & - result(res) & - bind(c, name = 'hipblasSgelsFortran') + bind(c, name='hipblasSgelsFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgelsFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -863,16 +861,16 @@ function hipblasSgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, de integer(c_int), value :: ldb type(c_ptr), value :: info type(c_ptr), value :: deviceInfo - integer(c_int) :: res - res = hipblasSgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) + hipblasSgelsFortran = & + hipblasSgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) end function hipblasSgelsFortran function hipblasDgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) & - result(res) & - bind(c, name = 'hipblasDgelsFortran') + bind(c, name='hipblasDgelsFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgelsFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -884,16 +882,16 @@ function hipblasDgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, de integer(c_int), value :: ldb type(c_ptr), value :: info type(c_ptr), value :: deviceInfo - integer(c_int) :: res - res = hipblasDgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) + hipblasDgelsFortran = & + hipblasDgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) end function hipblasDgelsFortran function hipblasCgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) & - result(res) & - bind(c, name = 'hipblasCgelsFortran') + bind(c, name='hipblasCgelsFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgelsFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -905,16 +903,16 @@ function hipblasCgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, de integer(c_int), value :: ldb type(c_ptr), value :: info type(c_ptr), value :: deviceInfo - integer(c_int) :: res - res = hipblasCgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) + hipblasCgelsFortran = & + hipblasCgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) end function hipblasCgelsFortran function hipblasZgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) & - result(res) & - bind(c, name = 'hipblasZgelsFortran') + bind(c, name='hipblasZgelsFortran') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgelsFortran type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -926,8 +924,8 @@ function hipblasZgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, de integer(c_int), value :: ldb type(c_ptr), value :: info type(c_ptr), value :: deviceInfo - integer(c_int) :: res - res = hipblasZgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) + hipblasZgelsFortran = & + hipblasZgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) end function hipblasZgelsFortran -end module hipblas_interface \ No newline at end of file +end module hipblas_interface diff --git a/library/src/hipblas_module.f90 b/library/src/hipblas_module.f90 index ae523718d..94fdd2d18 100644 --- a/library/src/hipblas_module.f90 +++ b/library/src/hipblas_module.f90 @@ -36,33 +36,33 @@ module hipblas_enums enum, bind(c) enumerator :: HIPBLAS_FILL_MODE_UPPER = 121 enumerator :: HIPBLAS_FILL_MODE_LOWER = 122 - enumerator :: HIPBLAS_FILL_MODE_FULL = 123 + enumerator :: HIPBLAS_FILL_MODE_FULL = 123 end enum enum, bind(c) enumerator :: HIPBLAS_DIAG_NON_UNIT = 131 - enumerator :: HIPBLAS_DIAG_UNIT = 132 + enumerator :: HIPBLAS_DIAG_UNIT = 132 end enum enum, bind(c) - enumerator :: HIPBLAS_SIDE_LEFT = 141 + enumerator :: HIPBLAS_SIDE_LEFT = 141 enumerator :: HIPBLAS_SIDE_RIGHT = 142 - enumerator :: HIPBLAS_SIDE_BOTH = 143 + enumerator :: HIPBLAS_SIDE_BOTH = 143 end enum enum, bind(c) - enumerator :: HIPBLAS_STATUS_SUCCESS = 0 - enumerator :: HIPBLAS_STATUS_NOT_INITIALIZED = 1 - enumerator :: HIPBLAS_STATUS_ALLOC_FAILED = 2 - enumerator :: HIPBLAS_STATUS_INVALID_VALUE = 3 - enumerator :: HIPBLAS_STATUS_MAPPING_ERROR = 4 - enumerator :: HIPBLAS_STATUS_EXECUTION_FAILED = 5 - enumerator :: HIPBLAS_STATUS_INTERNAL_ERROR = 6 - enumerator :: HIPBLAS_STATUS_NOT_SUPPORTED = 7 - enumerator :: HIPBLAS_STATUS_ARCH_MISMATCH = 8 + enumerator :: HIPBLAS_STATUS_SUCCESS = 0 + enumerator :: HIPBLAS_STATUS_NOT_INITIALIZED = 1 + enumerator :: HIPBLAS_STATUS_ALLOC_FAILED = 2 + enumerator :: HIPBLAS_STATUS_INVALID_VALUE = 3 + enumerator :: HIPBLAS_STATUS_MAPPING_ERROR = 4 + enumerator :: HIPBLAS_STATUS_EXECUTION_FAILED = 5 + enumerator :: HIPBLAS_STATUS_INTERNAL_ERROR = 6 + enumerator :: HIPBLAS_STATUS_NOT_SUPPORTED = 7 + enumerator :: HIPBLAS_STATUS_ARCH_MISMATCH = 8 enumerator :: HIPBLAS_STATUS_HANDLE_IS_NULLPTR = 9 - enumerator :: HIPBLAS_STATUS_INVALID_ENUM = 10 - enumerator :: HIPBLAS_STATUS_UNKNOWN = 11 + enumerator :: HIPBLAS_STATUS_INVALID_ENUM = 10 + enumerator :: HIPBLAS_STATUS_UNKNOWN = 11 end enum enum, bind(c) @@ -72,12 +72,12 @@ module hipblas_enums enumerator :: HIPBLAS_C_16F = 153 enumerator :: HIPBLAS_C_32F = 154 enumerator :: HIPBLAS_C_64F = 155 - enumerator :: HIPBLAS_R_8I = 160 - enumerator :: HIPBLAS_R_8U = 161 + enumerator :: HIPBLAS_R_8I = 160 + enumerator :: HIPBLAS_R_8U = 161 enumerator :: HIPBLAS_R_32I = 162 enumerator :: HIPBLAS_R_32U = 163 - enumerator :: HIPBLAS_C_8I = 164 - enumerator :: HIPBLAS_C_8U = 165 + enumerator :: HIPBLAS_C_8I = 164 + enumerator :: HIPBLAS_C_8U = 165 enumerator :: HIPBLAS_C_32I = 166 enumerator :: HIPBLAS_C_32U = 167 enumerator :: HIPBLAS_R_16B = 168 @@ -108,30 +108,33 @@ module hipblas !--------! interface function hipblasCreate(handle) & - result(c_int) & - bind(c, name = 'hipblasCreate') + bind(c, name='hipblasCreate') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCreate type(c_ptr), value :: handle end function hipblasCreate end interface interface function hipblasDestroy(handle) & - result(c_int) & - bind(c, name = 'hipblasDestroy') + bind(c, name='hipblasDestroy') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDestroy type(c_ptr), value :: handle end function hipblasDestroy end interface interface function hipblasSetStream(handle, streamId) & - result(c_int) & - bind(c, name = 'hipblasSetStream') + bind(c, name='hipblasSetStream') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetStream type(c_ptr), value :: handle type(c_ptr), value :: streamId end function hipblasSetStream @@ -139,10 +142,11 @@ end function hipblasSetStream interface function hipblasGetStream(handle, streamId) & - result(c_int) & - bind(c, name = 'hipblasGetStream') + bind(c, name='hipblasGetStream') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetStream type(c_ptr), value :: handle type(c_ptr), value :: streamId end function hipblasGetStream @@ -150,10 +154,11 @@ end function hipblasGetStream interface function hipblasSetPointerMode(handle, mode) & - result(c_int) & - bind(c, name = 'hipblasSetPointerMode') + bind(c, name='hipblasSetPointerMode') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetPointerMode type(c_ptr), value :: handle type(c_ptr), value :: mode end function hipblasSetPointerMode @@ -161,10 +166,11 @@ end function hipblasSetPointerMode interface function hipblasGetPointerMode(handle, mode) & - result(c_int) & - bind(c, name = 'hipblasGetPointerMode') + bind(c, name='hipblasGetPointerMode') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetPointerMode type(c_ptr), value :: handle type(c_ptr), value :: mode end function hipblasGetPointerMode @@ -172,10 +178,11 @@ end function hipblasGetPointerMode interface function hipblasSetVector(n, elemSize, x, incx, y, incy) & - result(c_int) & - bind(c, name = 'hipblasSetVector') + bind(c, name='hipblasSetVector') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetVector integer(c_int), value :: n integer(c_int), value :: elemSize type(c_ptr), value :: x @@ -187,10 +194,11 @@ end function hipblasSetVector interface function hipblasGetVector(n, elemSize, x, incx, y, incy) & - result(c_int) & - bind(c, name = 'hipblasGetVector') + bind(c, name='hipblasGetVector') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetVector integer(c_int), value :: n integer(c_int), value :: elemSize type(c_ptr), value :: x @@ -202,10 +210,11 @@ end function hipblasGetVector interface function hipblasSetMatrix(rows, cols, elemSize, A, lda, B, ldb) & - result(c_int) & - bind(c, name = 'hipblasSetMatrix') + bind(c, name='hipblasSetMatrix') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetMatrix integer(c_int), value :: rows integer(c_int), value :: cols integer(c_int), value :: elemSize @@ -218,10 +227,11 @@ end function hipblasSetMatrix interface function hipblasGetMatrix(rows, cols, elemSize, A, lda, B, ldb) & - result(c_int) & - bind(c, name = 'hipblasGetMatrix') + bind(c, name='hipblasGetMatrix') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetMatrix integer(c_int), value :: rows integer(c_int), value :: cols integer(c_int), value :: elemSize @@ -234,10 +244,11 @@ end function hipblasGetMatrix interface function hipblasSetVectorAsync(n, elemSize, x, incx, y, incy, stream) & - result(c_int) & - bind(c, name = 'hipblasSetVectorAsync') + bind(c, name='hipblasSetVectorAsync') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetVectorAsync integer(c_int), value :: n integer(c_int), value :: elemSize type(c_ptr), value :: x @@ -250,10 +261,11 @@ end function hipblasSetVectorAsync interface function hipblasGetVectorAsync(n, elemSize, x, incx, y, incy, stream) & - result(c_int) & - bind(c, name = 'hipblasGetVectorAsync') + bind(c, name='hipblasGetVectorAsync') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetVectorAsync integer(c_int), value :: n integer(c_int), value :: elemSize type(c_ptr), value :: x @@ -266,10 +278,11 @@ end function hipblasGetVectorAsync interface function hipblasSetMatrixAsync(rows, cols, elemSize, A, lda, B, ldb, stream) & - result(c_int) & - bind(c, name = 'hipblasSetMatrixAsync') + bind(c, name='hipblasSetMatrixAsync') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetMatrixAsync integer(c_int), value :: rows integer(c_int), value :: cols integer(c_int), value :: elemSize @@ -283,10 +296,11 @@ end function hipblasSetMatrixAsync interface function hipblasGetMatrixAsync(rows, cols, elemSize, A, lda, B, ldb, stream) & - result(c_int) & - bind(c, name = 'hipblasGetMatrixAsync') + bind(c, name='hipblasGetMatrixAsync') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetMatrixAsync integer(c_int), value :: rows integer(c_int), value :: cols integer(c_int), value :: elemSize @@ -301,11 +315,11 @@ end function hipblasGetMatrixAsync ! atomics mode interface function hipblasSetAtomicsMode(handle, atomics_mode) & - result(c_int) & - bind(c, name = 'hipblasSetAtomicsMode') + bind(c, name='hipblasSetAtomicsMode') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetAtomicsMode type(c_ptr), value :: handle integer(kind(HIPBLAS_ATOMICS_ALLOWED)), value :: atomics_mode end function hipblasSetAtomicsMode @@ -313,11 +327,11 @@ end function hipblasSetAtomicsMode interface function hipblasGetAtomicsMode(handle, atomics_mode) & - result(c_int) & - bind(c, name = 'hipblasGetAtomicsMode') + bind(c, name='hipblasGetAtomicsMode') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetAtomicsMode type(c_ptr), value :: handle type(c_ptr), value :: atomics_mode end function hipblasGetAtomicsMode @@ -330,10 +344,11 @@ end function hipblasGetAtomicsMode ! scal interface function hipblasSscal(handle, n, alpha, x, incx) & - result(c_int) & - bind(c, name = 'hipblasSscal') + bind(c, name='hipblasSscal') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscal type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -344,10 +359,11 @@ end function hipblasSscal interface function hipblasDscal(handle, n, alpha, x, incx) & - result(c_int) & - bind(c, name = 'hipblasDscal') + bind(c, name='hipblasDscal') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscal type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -358,10 +374,11 @@ end function hipblasDscal interface function hipblasCscal(handle, n, alpha, x, incx) & - result(c_int) & - bind(c, name = 'hipblasCscal') + bind(c, name='hipblasCscal') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscal type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -372,10 +389,11 @@ end function hipblasCscal interface function hipblasZscal(handle, n, alpha, x, incx) & - result(c_int) & - bind(c, name = 'hipblasZscal') + bind(c, name='hipblasZscal') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscal type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -386,10 +404,11 @@ end function hipblasZscal interface function hipblasCsscal(handle, n, alpha, x, incx) & - result(c_int) & - bind(c, name = 'hipblasCsscal') + bind(c, name='hipblasCsscal') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscal type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -400,10 +419,11 @@ end function hipblasCsscal interface function hipblasZdscal(handle, n, alpha, x, incx) & - result(c_int) & - bind(c, name = 'hipblasZdscal') + bind(c, name='hipblasZdscal') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscal type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -415,10 +435,11 @@ end function hipblasZdscal ! scalBatched interface function hipblasSscalBatched(handle, n, alpha, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSscalBatched') + bind(c, name='hipblasSscalBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscalBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -430,10 +451,11 @@ end function hipblasSscalBatched interface function hipblasDscalBatched(handle, n, alpha, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDscalBatched') + bind(c, name='hipblasDscalBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscalBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -445,10 +467,11 @@ end function hipblasDscalBatched interface function hipblasCscalBatched(handle, n, alpha, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCscalBatched') + bind(c, name='hipblasCscalBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscalBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -460,10 +483,11 @@ end function hipblasCscalBatched interface function hipblasZscalBatched(handle, n, alpha, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZscalBatched') + bind(c, name='hipblasZscalBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscalBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -475,10 +499,11 @@ end function hipblasZscalBatched interface function hipblasCsscalBatched(handle, n, alpha, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsscalBatched') + bind(c, name='hipblasCsscalBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscalBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -490,10 +515,11 @@ end function hipblasCsscalBatched interface function hipblasZdscalBatched(handle, n, alpha, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZdscalBatched') + bind(c, name='hipblasZdscalBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscalBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -506,10 +532,11 @@ end function hipblasZdscalBatched ! scalStridedBatched interface function hipblasSscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSscalStridedBatched') + bind(c, name='hipblasSscalStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscalStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -522,10 +549,11 @@ end function hipblasSscalStridedBatched interface function hipblasDscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDscalStridedBatched') + bind(c, name='hipblasDscalStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscalStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -538,10 +566,11 @@ end function hipblasDscalStridedBatched interface function hipblasCscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCscalStridedBatched') + bind(c, name='hipblasCscalStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscalStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -554,10 +583,11 @@ end function hipblasCscalStridedBatched interface function hipblasZscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZscalStridedBatched') + bind(c, name='hipblasZscalStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscalStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -570,10 +600,11 @@ end function hipblasZscalStridedBatched interface function hipblasCsscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsscalStridedBatched') + bind(c, name='hipblasCsscalStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscalStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -586,10 +617,11 @@ end function hipblasCsscalStridedBatched interface function hipblasZdscalStridedBatched(handle, n, alpha, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZdscalStridedBatched') + bind(c, name='hipblasZdscalStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscalStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -603,10 +635,11 @@ end function hipblasZdscalStridedBatched ! copy interface function hipblasScopy(handle, n, x, incx, y, incy) & - result(c_int) & - bind(c, name = 'hipblasScopy') + bind(c, name='hipblasScopy') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScopy type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -618,10 +651,11 @@ end function hipblasScopy interface function hipblasDcopy(handle, n, x, incx, y, incy) & - result(c_int) & - bind(c, name = 'hipblasDcopy') + bind(c, name='hipblasDcopy') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDcopy type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -633,10 +667,11 @@ end function hipblasDcopy interface function hipblasCcopy(handle, n, x, incx, y, incy) & - result(c_int) & - bind(c, name = 'hipblasCcopy') + bind(c, name='hipblasCcopy') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCcopy type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -648,10 +683,11 @@ end function hipblasCcopy interface function hipblasZcopy(handle, n, x, incx, y, incy) & - result(c_int) & - bind(c, name = 'hipblasZcopy') + bind(c, name='hipblasZcopy') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZcopy type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -664,10 +700,11 @@ end function hipblasZcopy ! copyBatched interface function hipblasScopyBatched(handle, n, x, incx, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasScopyBatched') + bind(c, name='hipblasScopyBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScopyBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -680,10 +717,11 @@ end function hipblasScopyBatched interface function hipblasDcopyBatched(handle, n, x, incx, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDcopyBatched') + bind(c, name='hipblasDcopyBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDcopyBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -696,10 +734,11 @@ end function hipblasDcopyBatched interface function hipblasCcopyBatched(handle, n, x, incx, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCcopyBatched') + bind(c, name='hipblasCcopyBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCcopyBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -712,10 +751,11 @@ end function hipblasCcopyBatched interface function hipblasZcopyBatched(handle, n, x, incx, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZcopyBatched') + bind(c, name='hipblasZcopyBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZcopyBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -729,10 +769,11 @@ end function hipblasZcopyBatched ! copyStridedBatched interface function hipblasScopyStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasScopyStridedBatched') + bind(c, name='hipblasScopyStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScopyStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -747,10 +788,11 @@ end function hipblasScopyStridedBatched interface function hipblasDcopyStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDcopyStridedBatched') + bind(c, name='hipblasDcopyStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDcopyStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -765,10 +807,11 @@ end function hipblasDcopyStridedBatched interface function hipblasCcopyStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCcopyStridedBatched') + bind(c, name='hipblasCcopyStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCcopyStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -783,10 +826,11 @@ end function hipblasCcopyStridedBatched interface function hipblasZcopyStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZcopyStridedBatched') + bind(c, name='hipblasZcopyStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZcopyStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -802,10 +846,11 @@ end function hipblasZcopyStridedBatched ! dot interface function hipblasSdot(handle, n, x, incx, y, incy, result) & - result(c_int) & - bind(c, name = 'hipblasSdot') + bind(c, name='hipblasSdot') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdot type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -818,10 +863,11 @@ end function hipblasSdot interface function hipblasDdot(handle, n, x, incx, y, incy, result) & - result(c_int) & - bind(c, name = 'hipblasDdot') + bind(c, name='hipblasDdot') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdot type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -834,10 +880,11 @@ end function hipblasDdot interface function hipblasHdot(handle, n, x, incx, y, incy, result) & - result(c_int) & - bind(c, name = 'hipblasHdot') + bind(c, name='hipblasHdot') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHdot type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -850,10 +897,11 @@ end function hipblasHdot interface function hipblasBfdot(handle, n, x, incx, y, incy, result) & - result(c_int) & - bind(c, name = 'hipblasBfdot') + bind(c, name='hipblasBfdot') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasBfdot type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -866,10 +914,11 @@ end function hipblasBfdot interface function hipblasCdotu(handle, n, x, incx, y, incy, result) & - result(c_int) & - bind(c, name = 'hipblasCdotu') + bind(c, name='hipblasCdotu') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotu type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -882,10 +931,11 @@ end function hipblasCdotu interface function hipblasCdotc(handle, n, x, incx, y, incy, result) & - result(c_int) & - bind(c, name = 'hipblasCdotc') + bind(c, name='hipblasCdotc') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotc type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -898,10 +948,11 @@ end function hipblasCdotc interface function hipblasZdotu(handle, n, x, incx, y, incy, result) & - result(c_int) & - bind(c, name = 'hipblasZdotu') + bind(c, name='hipblasZdotu') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotu type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -914,10 +965,11 @@ end function hipblasZdotu interface function hipblasZdotc(handle, n, x, incx, y, incy, result) & - result(c_int) & - bind(c, name = 'hipblasZdotc') + bind(c, name='hipblasZdotc') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotc type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -931,10 +983,11 @@ end function hipblasZdotc ! dotBatched interface function hipblasSdotBatched(handle, n, x, incx, y, incy, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasSdotBatched') + bind(c, name='hipblasSdotBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdotBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -948,10 +1001,11 @@ end function hipblasSdotBatched interface function hipblasDdotBatched(handle, n, x, incx, y, incy, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasDdotBatched') + bind(c, name='hipblasDdotBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdotBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -965,10 +1019,11 @@ end function hipblasDdotBatched interface function hipblasHdotBatched(handle, n, x, incx, y, incy, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasHdotBatched') + bind(c, name='hipblasHdotBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHdotBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -982,10 +1037,11 @@ end function hipblasHdotBatched interface function hipblasBfdotBatched(handle, n, x, incx, y, incy, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasBfdotBatched') + bind(c, name='hipblasBfdotBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasBfdotBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -999,10 +1055,11 @@ end function hipblasBfdotBatched interface function hipblasCdotuBatched(handle, n, x, incx, y, incy, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasCdotuBatched') + bind(c, name='hipblasCdotuBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotuBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1016,10 +1073,11 @@ end function hipblasCdotuBatched interface function hipblasCdotcBatched(handle, n, x, incx, y, incy, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasCdotcBatched') + bind(c, name='hipblasCdotcBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotcBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1033,10 +1091,11 @@ end function hipblasCdotcBatched interface function hipblasZdotuBatched(handle, n, x, incx, y, incy, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasZdotuBatched') + bind(c, name='hipblasZdotuBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotuBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1050,10 +1109,11 @@ end function hipblasZdotuBatched interface function hipblasZdotcBatched(handle, n, x, incx, y, incy, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasZdotcBatched') + bind(c, name='hipblasZdotcBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotcBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1068,10 +1128,11 @@ end function hipblasZdotcBatched ! dotStridedBatched interface function hipblasSdotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasSdotStridedBatched') + bind(c, name='hipblasSdotStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdotStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1087,10 +1148,11 @@ end function hipblasSdotStridedBatched interface function hipblasDdotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasDdotStridedBatched') + bind(c, name='hipblasDdotStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdotStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1106,10 +1168,11 @@ end function hipblasDdotStridedBatched interface function hipblasHdotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasHdotStridedBatched') + bind(c, name='hipblasHdotStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHdotStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1125,10 +1188,11 @@ end function hipblasHdotStridedBatched interface function hipblasBfdotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasBfdotStridedBatched') + bind(c, name='hipblasBfdotStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasBfdotStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1144,10 +1208,11 @@ end function hipblasBfdotStridedBatched interface function hipblasCdotuStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasCdotuStridedBatched') + bind(c, name='hipblasCdotuStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotuStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1163,10 +1228,11 @@ end function hipblasCdotuStridedBatched interface function hipblasCdotcStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasCdotcStridedBatched') + bind(c, name='hipblasCdotcStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotcStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1182,10 +1248,11 @@ end function hipblasCdotcStridedBatched interface function hipblasZdotuStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasZdotuStridedBatched') + bind(c, name='hipblasZdotuStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotuStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1201,10 +1268,11 @@ end function hipblasZdotuStridedBatched interface function hipblasZdotcStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasZdotcStridedBatched') + bind(c, name='hipblasZdotcStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotcStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1221,10 +1289,11 @@ end function hipblasZdotcStridedBatched ! swap interface function hipblasSswap(handle, n, x, incx, y, incy) & - result(c_int) & - bind(c, name = 'hipblasSswap') + bind(c, name='hipblasSswap') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSswap type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1236,10 +1305,11 @@ end function hipblasSswap interface function hipblasDswap(handle, n, x, incx, y, incy) & - result(c_int) & - bind(c, name = 'hipblasDswap') + bind(c, name='hipblasDswap') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDswap type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1251,10 +1321,11 @@ end function hipblasDswap interface function hipblasCswap(handle, n, x, incx, y, incy) & - result(c_int) & - bind(c, name = 'hipblasCswap') + bind(c, name='hipblasCswap') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCswap type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1266,10 +1337,11 @@ end function hipblasCswap interface function hipblasZswap(handle, n, x, incx, y, incy) & - result(c_int) & - bind(c, name = 'hipblasZswap') + bind(c, name='hipblasZswap') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZswap type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1282,10 +1354,11 @@ end function hipblasZswap ! swapBatched interface function hipblasSswapBatched(handle, n, x, incx, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSswapBatched') + bind(c, name='hipblasSswapBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSswapBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1298,10 +1371,11 @@ end function hipblasSswapBatched interface function hipblasDswapBatched(handle, n, x, incx, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDswapBatched') + bind(c, name='hipblasDswapBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDswapBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1314,10 +1388,11 @@ end function hipblasDswapBatched interface function hipblasCswapBatched(handle, n, x, incx, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCswapBatched') + bind(c, name='hipblasCswapBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCswapBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1330,10 +1405,11 @@ end function hipblasCswapBatched interface function hipblasZswapBatched(handle, n, x, incx, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZswapBatched') + bind(c, name='hipblasZswapBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZswapBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1347,10 +1423,11 @@ end function hipblasZswapBatched ! swapStridedBatched interface function hipblasSswapStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSswapStridedBatched') + bind(c, name='hipblasSswapStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSswapStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1365,10 +1442,11 @@ end function hipblasSswapStridedBatched interface function hipblasDswapStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDswapStridedBatched') + bind(c, name='hipblasDswapStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDswapStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1383,10 +1461,11 @@ end function hipblasDswapStridedBatched interface function hipblasCswapStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCswapStridedBatched') + bind(c, name='hipblasCswapStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCswapStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1401,10 +1480,11 @@ end function hipblasCswapStridedBatched interface function hipblasZswapStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZswapStridedBatched') + bind(c, name='hipblasZswapStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZswapStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1420,10 +1500,11 @@ end function hipblasZswapStridedBatched ! axpy interface function hipblasHaxpy(handle, n, alpha, x, incx, y, incy) & - result(c_int) & - bind(c, name = 'hipblasHaxpy') + bind(c, name='hipblasHaxpy') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHaxpy type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1436,10 +1517,11 @@ end function hipblasHaxpy interface function hipblasSaxpy(handle, n, alpha, x, incx, y, incy) & - result(c_int) & - bind(c, name = 'hipblasSaxpy') + bind(c, name='hipblasSaxpy') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpy type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1452,10 +1534,11 @@ end function hipblasSaxpy interface function hipblasDaxpy(handle, n, alpha, x, incx, y, incy) & - result(c_int) & - bind(c, name = 'hipblasDaxpy') + bind(c, name='hipblasDaxpy') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpy type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1468,10 +1551,11 @@ end function hipblasDaxpy interface function hipblasCaxpy(handle, n, alpha, x, incx, y, incy) & - result(c_int) & - bind(c, name = 'hipblasCaxpy') + bind(c, name='hipblasCaxpy') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpy type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1484,10 +1568,11 @@ end function hipblasCaxpy interface function hipblasZaxpy(handle, n, alpha, x, incx, y, incy) & - result(c_int) & - bind(c, name = 'hipblasZaxpy') + bind(c, name='hipblasZaxpy') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpy type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1501,10 +1586,11 @@ end function hipblasZaxpy ! axpyBatched interface function hipblasHaxpyBatched(handle, n, alpha, x, incx, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasHaxpyBatched') + bind(c, name='hipblasHaxpyBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHaxpyBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1518,10 +1604,11 @@ end function hipblasHaxpyBatched interface function hipblasSaxpyBatched(handle, n, alpha, x, incx, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSaxpyBatched') + bind(c, name='hipblasSaxpyBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpyBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1535,10 +1622,11 @@ end function hipblasSaxpyBatched interface function hipblasDaxpyBatched(handle, n, alpha, x, incx, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDaxpyBatched') + bind(c, name='hipblasDaxpyBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpyBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1552,10 +1640,11 @@ end function hipblasDaxpyBatched interface function hipblasCaxpyBatched(handle, n, alpha, x, incx, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCaxpyBatched') + bind(c, name='hipblasCaxpyBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpyBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1569,10 +1658,11 @@ end function hipblasCaxpyBatched interface function hipblasZaxpyBatched(handle, n, alpha, x, incx, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZaxpyBatched') + bind(c, name='hipblasZaxpyBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpyBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1587,10 +1677,11 @@ end function hipblasZaxpyBatched ! axpyStridedBatched interface function hipblasHaxpyStridedBatched(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasHaxpyStridedBatched') + bind(c, name='hipblasHaxpyStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHaxpyStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1606,10 +1697,11 @@ end function hipblasHaxpyStridedBatched interface function hipblasSaxpyStridedBatched(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSaxpyStridedBatched') + bind(c, name='hipblasSaxpyStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpyStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1625,10 +1717,11 @@ end function hipblasSaxpyStridedBatched interface function hipblasDaxpyStridedBatched(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDaxpyStridedBatched') + bind(c, name='hipblasDaxpyStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpyStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1644,10 +1737,11 @@ end function hipblasDaxpyStridedBatched interface function hipblasCaxpyStridedBatched(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCaxpyStridedBatched') + bind(c, name='hipblasCaxpyStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpyStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1663,10 +1757,11 @@ end function hipblasCaxpyStridedBatched interface function hipblasZaxpyStridedBatched(handle, n, alpha, x, incx, stride_x, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZaxpyStridedBatched') + bind(c, name='hipblasZaxpyStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpyStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -1683,10 +1778,11 @@ end function hipblasZaxpyStridedBatched ! asum interface function hipblasSasum(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasSasum') + bind(c, name='hipblasSasum') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSasum type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1697,10 +1793,11 @@ end function hipblasSasum interface function hipblasDasum(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasDasum') + bind(c, name='hipblasDasum') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDasum type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1711,10 +1808,11 @@ end function hipblasDasum interface function hipblasScasum(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasScasum') + bind(c, name='hipblasScasum') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScasum type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1725,10 +1823,11 @@ end function hipblasScasum interface function hipblasDzasum(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasDzasum') + bind(c, name='hipblasDzasum') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDzasum type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1740,10 +1839,11 @@ end function hipblasDzasum ! asumBatched interface function hipblasSasumBatched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasSasumBatched') + bind(c, name='hipblasSasumBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSasumBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1755,10 +1855,11 @@ end function hipblasSasumBatched interface function hipblasDasumBatched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasDasumBatched') + bind(c, name='hipblasDasumBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDasumBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1770,10 +1871,11 @@ end function hipblasDasumBatched interface function hipblasScasumBatched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasScasumBatched') + bind(c, name='hipblasScasumBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScasumBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1785,10 +1887,11 @@ end function hipblasScasumBatched interface function hipblasDzasumBatched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasDzasumBatched') + bind(c, name='hipblasDzasumBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDzasumBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1801,10 +1904,11 @@ end function hipblasDzasumBatched ! asumStridedBatched interface function hipblasSasumStridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasSasumStridedBatched') + bind(c, name='hipblasSasumStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSasumStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1817,10 +1921,11 @@ end function hipblasSasumStridedBatched interface function hipblasDasumStridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasDasumStridedBatched') + bind(c, name='hipblasDasumStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDasumStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1833,10 +1938,11 @@ end function hipblasDasumStridedBatched interface function hipblasScasumStridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasScasumStridedBatched') + bind(c, name='hipblasScasumStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScasumStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1849,10 +1955,11 @@ end function hipblasScasumStridedBatched interface function hipblasDzasumStridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasDzasumStridedBatched') + bind(c, name='hipblasDzasumStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDzasumStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1866,10 +1973,11 @@ end function hipblasDzasumStridedBatched ! nrm2 interface function hipblasSnrm2(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasSnrm2') + bind(c, name='hipblasSnrm2') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSnrm2 type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1880,10 +1988,11 @@ end function hipblasSnrm2 interface function hipblasDnrm2(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasDnrm2') + bind(c, name='hipblasDnrm2') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDnrm2 type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1894,10 +2003,11 @@ end function hipblasDnrm2 interface function hipblasScnrm2(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasScnrm2') + bind(c, name='hipblasScnrm2') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScnrm2 type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1908,10 +2018,11 @@ end function hipblasScnrm2 interface function hipblasDznrm2(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasDznrm2') + bind(c, name='hipblasDznrm2') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDznrm2 type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1923,10 +2034,11 @@ end function hipblasDznrm2 ! nrm2Batched interface function hipblasSnrm2Batched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasSnrm2Batched') + bind(c, name='hipblasSnrm2Batched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSnrm2Batched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1938,10 +2050,11 @@ end function hipblasSnrm2Batched interface function hipblasDnrm2Batched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasDnrm2Batched') + bind(c, name='hipblasDnrm2Batched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDnrm2Batched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1953,10 +2066,11 @@ end function hipblasDnrm2Batched interface function hipblasScnrm2Batched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasScnrm2Batched') + bind(c, name='hipblasScnrm2Batched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScnrm2Batched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1968,10 +2082,11 @@ end function hipblasScnrm2Batched interface function hipblasDznrm2Batched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasDznrm2Batched') + bind(c, name='hipblasDznrm2Batched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDznrm2Batched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -1984,10 +2099,11 @@ end function hipblasDznrm2Batched ! nrm2StridedBatched interface function hipblasSnrm2StridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasSnrm2StridedBatched') + bind(c, name='hipblasSnrm2StridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSnrm2StridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2000,10 +2116,11 @@ end function hipblasSnrm2StridedBatched interface function hipblasDnrm2StridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasDnrm2StridedBatched') + bind(c, name='hipblasDnrm2StridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDnrm2StridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2016,10 +2133,11 @@ end function hipblasDnrm2StridedBatched interface function hipblasScnrm2StridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasScnrm2StridedBatched') + bind(c, name='hipblasScnrm2StridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScnrm2StridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2032,10 +2150,11 @@ end function hipblasScnrm2StridedBatched interface function hipblasDznrm2StridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasDznrm2StridedBatched') + bind(c, name='hipblasDznrm2StridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDznrm2StridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2049,10 +2168,11 @@ end function hipblasDznrm2StridedBatched ! amax interface function hipblasIsamax(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasIsamax') + bind(c, name='hipblasIsamax') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamax type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2063,10 +2183,11 @@ end function hipblasIsamax interface function hipblasIdamax(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasIdamax') + bind(c, name='hipblasIdamax') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamax type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2077,10 +2198,11 @@ end function hipblasIdamax interface function hipblasIcamax(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasIcamax') + bind(c, name='hipblasIcamax') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamax type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2091,10 +2213,11 @@ end function hipblasIcamax interface function hipblasIzamax(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasIzamax') + bind(c, name='hipblasIzamax') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamax type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2106,10 +2229,11 @@ end function hipblasIzamax ! amaxBatched interface function hipblasIsamaxBatched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIsamaxBatched') + bind(c, name='hipblasIsamaxBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamaxBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2121,10 +2245,11 @@ end function hipblasIsamaxBatched interface function hipblasIdamaxBatched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIdamaxBatched') + bind(c, name='hipblasIdamaxBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamaxBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2136,10 +2261,11 @@ end function hipblasIdamaxBatched interface function hipblasIcamaxBatched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIcamaxBatched') + bind(c, name='hipblasIcamaxBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamaxBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2151,10 +2277,11 @@ end function hipblasIcamaxBatched interface function hipblasIzamaxBatched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIzamaxBatched') + bind(c, name='hipblasIzamaxBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamaxBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2167,10 +2294,11 @@ end function hipblasIzamaxBatched ! amaxStridedBatched interface function hipblasIsamaxStridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIsamaxStridedBatched') + bind(c, name='hipblasIsamaxStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamaxStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2183,10 +2311,11 @@ end function hipblasIsamaxStridedBatched interface function hipblasIdamaxStridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIdamaxStridedBatched') + bind(c, name='hipblasIdamaxStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamaxStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2199,10 +2328,11 @@ end function hipblasIdamaxStridedBatched interface function hipblasIcamaxStridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIcamaxStridedBatched') + bind(c, name='hipblasIcamaxStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamaxStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2215,10 +2345,11 @@ end function hipblasIcamaxStridedBatched interface function hipblasIzamaxStridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIzamaxStridedBatched') + bind(c, name='hipblasIzamaxStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamaxStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2232,10 +2363,11 @@ end function hipblasIzamaxStridedBatched ! amin interface function hipblasIsamin(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasIsamin') + bind(c, name='hipblasIsamin') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamin type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2246,10 +2378,11 @@ end function hipblasIsamin interface function hipblasIdamin(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasIdamin') + bind(c, name='hipblasIdamin') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamin type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2260,10 +2393,11 @@ end function hipblasIdamin interface function hipblasIcamin(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasIcamin') + bind(c, name='hipblasIcamin') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamin type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2274,10 +2408,11 @@ end function hipblasIcamin interface function hipblasIzamin(handle, n, x, incx, result) & - result(c_int) & - bind(c, name = 'hipblasIzamin') + bind(c, name='hipblasIzamin') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamin type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2289,10 +2424,11 @@ end function hipblasIzamin ! aminBatched interface function hipblasIsaminBatched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIsaminBatched') + bind(c, name='hipblasIsaminBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsaminBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2304,10 +2440,11 @@ end function hipblasIsaminBatched interface function hipblasIdaminBatched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIdaminBatched') + bind(c, name='hipblasIdaminBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdaminBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2319,10 +2456,11 @@ end function hipblasIdaminBatched interface function hipblasIcaminBatched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIcaminBatched') + bind(c, name='hipblasIcaminBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcaminBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2334,10 +2472,11 @@ end function hipblasIcaminBatched interface function hipblasIzaminBatched(handle, n, x, incx, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIzaminBatched') + bind(c, name='hipblasIzaminBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzaminBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2350,10 +2489,11 @@ end function hipblasIzaminBatched ! aminStridedBatched interface function hipblasIsaminStridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIsaminStridedBatched') + bind(c, name='hipblasIsaminStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsaminStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2366,10 +2506,11 @@ end function hipblasIsaminStridedBatched interface function hipblasIdaminStridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIdaminStridedBatched') + bind(c, name='hipblasIdaminStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdaminStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2382,10 +2523,11 @@ end function hipblasIdaminStridedBatched interface function hipblasIcaminStridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIcaminStridedBatched') + bind(c, name='hipblasIcaminStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcaminStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2398,10 +2540,11 @@ end function hipblasIcaminStridedBatched interface function hipblasIzaminStridedBatched(handle, n, x, incx, stride_x, batch_count, result) & - result(c_int) & - bind(c, name = 'hipblasIzaminStridedBatched') + bind(c, name='hipblasIzaminStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzaminStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2415,10 +2558,11 @@ end function hipblasIzaminStridedBatched ! rot interface function hipblasSrot(handle, n, x, incx, y, incy, c, s) & - result(c_int) & - bind(c, name = 'hipblasSrot') + bind(c, name='hipblasSrot') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrot type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2432,10 +2576,11 @@ end function hipblasSrot interface function hipblasDrot(handle, n, x, incx, y, incy, c, s) & - result(c_int) & - bind(c, name = 'hipblasDrot') + bind(c, name='hipblasDrot') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrot type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2449,10 +2594,11 @@ end function hipblasDrot interface function hipblasCrot(handle, n, x, incx, y, incy, c, s) & - result(c_int) & - bind(c, name = 'hipblasCrot') + bind(c, name='hipblasCrot') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrot type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2466,10 +2612,11 @@ end function hipblasCrot interface function hipblasCsrot(handle, n, x, incx, y, incy, c, s) & - result(c_int) & - bind(c, name = 'hipblasCsrot') + bind(c, name='hipblasCsrot') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsrot type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2483,10 +2630,11 @@ end function hipblasCsrot interface function hipblasZrot(handle, n, x, incx, y, incy, c, s) & - result(c_int) & - bind(c, name = 'hipblasZrot') + bind(c, name='hipblasZrot') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrot type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2500,10 +2648,11 @@ end function hipblasZrot interface function hipblasZdrot(handle, n, x, incx, y, incy, c, s) & - result(c_int) & - bind(c, name = 'hipblasZdrot') + bind(c, name='hipblasZdrot') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdrot type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2518,10 +2667,11 @@ end function hipblasZdrot ! rotBatched interface function hipblasSrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSrotBatched') + bind(c, name='hipblasSrotBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2536,10 +2686,11 @@ end function hipblasSrotBatched interface function hipblasDrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDrotBatched') + bind(c, name='hipblasDrotBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2554,10 +2705,11 @@ end function hipblasDrotBatched interface function hipblasCrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCrotBatched') + bind(c, name='hipblasCrotBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2572,10 +2724,11 @@ end function hipblasCrotBatched interface function hipblasCsrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsrotBatched') + bind(c, name='hipblasCsrotBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsrotBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2590,10 +2743,11 @@ end function hipblasCsrotBatched interface function hipblasZrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZrotBatched') + bind(c, name='hipblasZrotBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2608,10 +2762,11 @@ end function hipblasZrotBatched interface function hipblasZdrotBatched(handle, n, x, incx, y, incy, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZdrotBatched') + bind(c, name='hipblasZdrotBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdrotBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2627,10 +2782,11 @@ end function hipblasZdrotBatched ! rotStridedBatched interface function hipblasSrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSrotStridedBatched') + bind(c, name='hipblasSrotStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2647,10 +2803,11 @@ end function hipblasSrotStridedBatched interface function hipblasDrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDrotStridedBatched') + bind(c, name='hipblasDrotStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2667,10 +2824,11 @@ end function hipblasDrotStridedBatched interface function hipblasCrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCrotStridedBatched') + bind(c, name='hipblasCrotStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2687,10 +2845,11 @@ end function hipblasCrotStridedBatched interface function hipblasCsrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsrotStridedBatched') + bind(c, name='hipblasCsrotStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsrotStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2707,10 +2866,11 @@ end function hipblasCsrotStridedBatched interface function hipblasZrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZrotStridedBatched') + bind(c, name='hipblasZrotStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2727,10 +2887,11 @@ end function hipblasZrotStridedBatched interface function hipblasZdrotStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZdrotStridedBatched') + bind(c, name='hipblasZdrotStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdrotStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2748,10 +2909,11 @@ end function hipblasZdrotStridedBatched ! rotg interface function hipblasSrotg(handle, a, b, c, s) & - result(c_int) & - bind(c, name = 'hipblasSrotg') + bind(c, name='hipblasSrotg') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotg type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b @@ -2762,10 +2924,11 @@ end function hipblasSrotg interface function hipblasDrotg(handle, a, b, c, s) & - result(c_int) & - bind(c, name = 'hipblasDrotg') + bind(c, name='hipblasDrotg') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotg type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b @@ -2776,10 +2939,11 @@ end function hipblasDrotg interface function hipblasCrotg(handle, a, b, c, s) & - result(c_int) & - bind(c, name = 'hipblasCrotg') + bind(c, name='hipblasCrotg') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotg type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b @@ -2790,10 +2954,11 @@ end function hipblasCrotg interface function hipblasZrotg(handle, a, b, c, s) & - result(c_int) & - bind(c, name = 'hipblasZrotg') + bind(c, name='hipblasZrotg') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotg type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b @@ -2805,10 +2970,11 @@ end function hipblasZrotg ! rotgBatched interface function hipblasSrotgBatched(handle, a, b, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSrotgBatched') + bind(c, name='hipblasSrotgBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotgBatched type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b @@ -2820,10 +2986,11 @@ end function hipblasSrotgBatched interface function hipblasDrotgBatched(handle, a, b, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDrotgBatched') + bind(c, name='hipblasDrotgBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotgBatched type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b @@ -2835,10 +3002,11 @@ end function hipblasDrotgBatched interface function hipblasCrotgBatched(handle, a, b, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCrotgBatched') + bind(c, name='hipblasCrotgBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotgBatched type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b @@ -2850,10 +3018,11 @@ end function hipblasCrotgBatched interface function hipblasZrotgBatched(handle, a, b, c, s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZrotgBatched') + bind(c, name='hipblasZrotgBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotgBatched type(c_ptr), value :: handle type(c_ptr), value :: a type(c_ptr), value :: b @@ -2866,10 +3035,11 @@ end function hipblasZrotgBatched ! rotgStridedBatched interface function hipblasSrotgStridedBatched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSrotgStridedBatched') + bind(c, name='hipblasSrotgStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotgStridedBatched type(c_ptr), value :: handle type(c_ptr), value :: a integer(c_int64_t), value :: stride_a @@ -2885,10 +3055,11 @@ end function hipblasSrotgStridedBatched interface function hipblasDrotgStridedBatched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDrotgStridedBatched') + bind(c, name='hipblasDrotgStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotgStridedBatched type(c_ptr), value :: handle type(c_ptr), value :: a integer(c_int64_t), value :: stride_a @@ -2904,10 +3075,11 @@ end function hipblasDrotgStridedBatched interface function hipblasCrotgStridedBatched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCrotgStridedBatched') + bind(c, name='hipblasCrotgStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotgStridedBatched type(c_ptr), value :: handle type(c_ptr), value :: a integer(c_int64_t), value :: stride_a @@ -2923,10 +3095,11 @@ end function hipblasCrotgStridedBatched interface function hipblasZrotgStridedBatched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZrotgStridedBatched') + bind(c, name='hipblasZrotgStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotgStridedBatched type(c_ptr), value :: handle type(c_ptr), value :: a integer(c_int64_t), value :: stride_a @@ -2943,10 +3116,11 @@ end function hipblasZrotgStridedBatched ! rotm interface function hipblasSrotm(handle, n, x, incx, y, incy, param) & - result(c_int) & - bind(c, name = 'hipblasSrotm') + bind(c, name='hipblasSrotm') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotm type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2959,10 +3133,11 @@ end function hipblasSrotm interface function hipblasDrotm(handle, n, x, incx, y, incy, param) & - result(c_int) & - bind(c, name = 'hipblasDrotm') + bind(c, name='hipblasDrotm') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotm type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2976,10 +3151,11 @@ end function hipblasDrotm ! rotmBatched interface function hipblasSrotmBatched(handle, n, x, incx, y, incy, param, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSrotmBatched') + bind(c, name='hipblasSrotmBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -2993,10 +3169,11 @@ end function hipblasSrotmBatched interface function hipblasDrotmBatched(handle, n, x, incx, y, incy, param, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDrotmBatched') + bind(c, name='hipblasDrotmBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -3011,10 +3188,11 @@ end function hipblasDrotmBatched ! rotmStridedBatched interface function hipblasSrotmStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, param, stride_param, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSrotmStridedBatched') + bind(c, name='hipblasSrotmStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -3031,10 +3209,11 @@ end function hipblasSrotmStridedBatched interface function hipblasDrotmStridedBatched(handle, n, x, incx, stride_x, y, incy, stride_y, param, stride_param, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDrotmStridedBatched') + bind(c, name='hipblasDrotmStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -3052,10 +3231,11 @@ end function hipblasDrotmStridedBatched ! rotmg interface function hipblasSrotmg(handle, d1, d2, x1, y1, param) & - result(c_int) & - bind(c, name = 'hipblasSrotmg') + bind(c, name='hipblasSrotmg') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmg type(c_ptr), value :: handle type(c_ptr), value :: d1 type(c_ptr), value :: d2 @@ -3067,10 +3247,11 @@ end function hipblasSrotmg interface function hipblasDrotmg(handle, d1, d2, x1, y1, param) & - result(c_int) & - bind(c, name = 'hipblasDrotmg') + bind(c, name='hipblasDrotmg') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmg type(c_ptr), value :: handle type(c_ptr), value :: d1 type(c_ptr), value :: d2 @@ -3083,10 +3264,11 @@ end function hipblasDrotmg ! rotmgBatched interface function hipblasSrotmgBatched(handle, d1, d2, x1, y1, param, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSrotmgBatched') + bind(c, name='hipblasSrotmgBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmgBatched type(c_ptr), value :: handle type(c_ptr), value :: d1 type(c_ptr), value :: d2 @@ -3099,10 +3281,11 @@ end function hipblasSrotmgBatched interface function hipblasDrotmgBatched(handle, d1, d2, x1, y1, param, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDrotmgBatched') + bind(c, name='hipblasDrotmgBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmgBatched type(c_ptr), value :: handle type(c_ptr), value :: d1 type(c_ptr), value :: d2 @@ -3116,11 +3299,12 @@ end function hipblasDrotmgBatched ! rotmgStridedBatched interface function hipblasSrotmgStridedBatched(handle, d1, stride_d1, d2, stride_d2, x1, stride_x1, & - y1, stride_y1, param, stride_param, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSrotmgStridedBatched') + y1, stride_y1, param, stride_param, batch_count) & + bind(c, name='hipblasSrotmgStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmgStridedBatched type(c_ptr), value :: handle type(c_ptr), value :: d1 integer(c_int64_t), value :: stride_d1 @@ -3138,11 +3322,12 @@ end function hipblasSrotmgStridedBatched interface function hipblasDrotmgStridedBatched(handle, d1, stride_d1, d2, stride_d2, x1, stride_x1, & - y1, stride_y1, param, stride_param, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDrotmgStridedBatched') + y1, stride_y1, param, stride_param, batch_count) & + bind(c, name='hipblasDrotmgStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmgStridedBatched type(c_ptr), value :: handle type(c_ptr), value :: d1 integer(c_int64_t), value :: stride_d1 @@ -3165,11 +3350,11 @@ end function hipblasDrotmgStridedBatched ! gbmv interface function hipblasSgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasSgbmv') + bind(c, name='hipblasSgbmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmv type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3189,11 +3374,11 @@ end function hipblasSgbmv interface function hipblasDgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasDgbmv') + bind(c, name='hipblasDgbmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmv type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3213,11 +3398,11 @@ end function hipblasDgbmv interface function hipblasCgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasCgbmv') + bind(c, name='hipblasCgbmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmv type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3237,11 +3422,11 @@ end function hipblasCgbmv interface function hipblasZgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasZgbmv') + bind(c, name='hipblasZgbmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmv type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3262,12 +3447,12 @@ end function hipblasZgbmv ! gbmvBatched interface function hipblasSgbmvBatched(handle, trans, m, n, kl, ku, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgbmvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasSgbmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3288,12 +3473,12 @@ end function hipblasSgbmvBatched interface function hipblasDgbmvBatched(handle, trans, m, n, kl, ku, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgbmvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasDgbmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3314,12 +3499,12 @@ end function hipblasDgbmvBatched interface function hipblasCgbmvBatched(handle, trans, m, n, kl, ku, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgbmvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasCgbmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3340,12 +3525,12 @@ end function hipblasCgbmvBatched interface function hipblasZgbmvBatched(handle, trans, m, n, kl, ku, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgbmvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasZgbmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3367,12 +3552,12 @@ end function hipblasZgbmvBatched ! gbmvStridedBatched interface function hipblasSgbmvStridedBatched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgbmvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasSgbmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3396,12 +3581,12 @@ end function hipblasSgbmvStridedBatched interface function hipblasDgbmvStridedBatched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgbmvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasDgbmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3425,12 +3610,12 @@ end function hipblasDgbmvStridedBatched interface function hipblasCgbmvStridedBatched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgbmvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasCgbmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3454,12 +3639,12 @@ end function hipblasCgbmvStridedBatched interface function hipblasZgbmvStridedBatched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgbmvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasZgbmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3484,12 +3669,12 @@ end function hipblasZgbmvStridedBatched ! gemv interface function hipblasSgemv(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasSgemv') + x, incx, beta, y, incy) & + bind(c, name='hipblasSgemv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemv type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3507,12 +3692,12 @@ end function hipblasSgemv interface function hipblasDgemv(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasDgemv') + x, incx, beta, y, incy) & + bind(c, name='hipblasDgemv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemv type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3530,12 +3715,12 @@ end function hipblasDgemv interface function hipblasCgemv(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasCgemv') + x, incx, beta, y, incy) & + bind(c, name='hipblasCgemv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemv type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3553,12 +3738,12 @@ end function hipblasCgemv interface function hipblasZgemv(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasZgemv') + x, incx, beta, y, incy) & + bind(c, name='hipblasZgemv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemv type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3577,12 +3762,12 @@ end function hipblasZgemv ! gemvBatched interface function hipblasSgemvBatched(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgemvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasSgemvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3601,12 +3786,12 @@ end function hipblasSgemvBatched interface function hipblasDgemvBatched(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgemvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasDgemvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3625,12 +3810,12 @@ end function hipblasDgemvBatched interface function hipblasCgemvBatched(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgemvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasCgemvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3649,12 +3834,12 @@ end function hipblasCgemvBatched interface function hipblasZgemvBatched(handle, trans, m, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgemvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasZgemvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3674,12 +3859,12 @@ end function hipblasZgemvBatched ! gemvStridedBatched interface function hipblasSgemvStridedBatched(handle, trans, m, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgemvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasSgemvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3701,12 +3886,12 @@ end function hipblasSgemvStridedBatched interface function hipblasDgemvStridedBatched(handle, trans, m, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgemvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasDgemvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3728,12 +3913,12 @@ end function hipblasDgemvStridedBatched interface function hipblasCgemvStridedBatched(handle, trans, m, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgemvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasCgemvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3755,12 +3940,12 @@ end function hipblasCgemvStridedBatched interface function hipblasZgemvStridedBatched(handle, trans, m, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgemvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasZgemvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -3783,12 +3968,12 @@ end function hipblasZgemvStridedBatched ! hbmv interface function hipblasChbmv(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasChbmv') + x, incx, beta, y, incy) & + bind(c, name='hipblasChbmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -3806,12 +3991,12 @@ end function hipblasChbmv interface function hipblasZhbmv(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasZhbmv') + x, incx, beta, y, incy) & + bind(c, name='hipblasZhbmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -3830,12 +4015,12 @@ end function hipblasZhbmv ! hbmvBatched interface function hipblasChbmvBatched(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasChbmvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasChbmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -3854,12 +4039,12 @@ end function hipblasChbmvBatched interface function hipblasZhbmvBatched(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZhbmvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasZhbmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -3879,12 +4064,12 @@ end function hipblasZhbmvBatched ! hbmvStridedBatched interface function hipblasChbmvStridedBatched(handle, uplo, n, k, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasChbmvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasChbmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -3906,12 +4091,12 @@ end function hipblasChbmvStridedBatched interface function hipblasZhbmvStridedBatched(handle, uplo, n, k, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZhbmvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasZhbmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -3934,12 +4119,12 @@ end function hipblasZhbmvStridedBatched ! hemv interface function hipblasChemv(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasChemv') + x, incx, beta, y, incy) & + bind(c, name='hipblasChemv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -3956,12 +4141,12 @@ end function hipblasChemv interface function hipblasZhemv(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasZhemv') + x, incx, beta, y, incy) & + bind(c, name='hipblasZhemv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -3979,12 +4164,12 @@ end function hipblasZhemv ! hemvBatched interface function hipblasChemvBatched(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasChemvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasChemvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4002,12 +4187,12 @@ end function hipblasChemvBatched interface function hipblasZhemvBatched(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZhemvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasZhemvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4026,12 +4211,12 @@ end function hipblasZhemvBatched ! hemvStridedBatched interface function hipblasChemvStridedBatched(handle, uplo, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasChemvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasChemvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4052,12 +4237,12 @@ end function hipblasChemvStridedBatched interface function hipblasZhemvStridedBatched(handle, uplo, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZhemvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasZhemvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4079,12 +4264,12 @@ end function hipblasZhemvStridedBatched ! her interface function hipblasCher(handle, uplo, n, alpha, & - x, incx, A, lda) & - result(c_int) & - bind(c, name = 'hipblasCher') + x, incx, A, lda) & + bind(c, name='hipblasCher') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4098,12 +4283,12 @@ end function hipblasCher interface function hipblasZher(handle, uplo, n, alpha, & - x, incx, A, lda) & - result(c_int) & - bind(c, name = 'hipblasZher') + x, incx, A, lda) & + bind(c, name='hipblasZher') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4118,12 +4303,12 @@ end function hipblasZher ! herBatched interface function hipblasCherBatched(handle, uplo, n, alpha, & - x, incx, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCherBatched') + x, incx, A, lda, batch_count) & + bind(c, name='hipblasCherBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4138,12 +4323,12 @@ end function hipblasCherBatched interface function hipblasZherBatched(handle, uplo, n, alpha, & - x, incx, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZherBatched') + x, incx, A, lda, batch_count) & + bind(c, name='hipblasZherBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4159,12 +4344,12 @@ end function hipblasZherBatched ! herStridedBatched interface function hipblasCherStridedBatched(handle, uplo, n, alpha, & - x, incx, stride_x, A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCherStridedBatched') + x, incx, stride_x, A, lda, stride_A, batch_count) & + bind(c, name='hipblasCherStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4181,12 +4366,12 @@ end function hipblasCherStridedBatched interface function hipblasZherStridedBatched(handle, uplo, n, alpha, & - x, incx, stride_x, A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZherStridedBatched') + x, incx, stride_x, A, lda, stride_A, batch_count) & + bind(c, name='hipblasZherStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4204,12 +4389,12 @@ end function hipblasZherStridedBatched ! her2 interface function hipblasCher2(handle, uplo, n, alpha, & - x, incx, y, incy, A, lda) & - result(c_int) & - bind(c, name = 'hipblasCher2') + x, incx, y, incy, A, lda) & + bind(c, name='hipblasCher2') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2 type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4225,12 +4410,12 @@ end function hipblasCher2 interface function hipblasZher2(handle, uplo, n, alpha, & - x, incx, y, incy, A, lda) & - result(c_int) & - bind(c, name = 'hipblasZher2') + x, incx, y, incy, A, lda) & + bind(c, name='hipblasZher2') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2 type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4247,12 +4432,12 @@ end function hipblasZher2 ! her2Batched interface function hipblasCher2Batched(handle, uplo, n, alpha, & - x, incx, y, incy, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCher2Batched') + x, incx, y, incy, A, lda, batch_count) & + bind(c, name='hipblasCher2Batched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2Batched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4269,12 +4454,12 @@ end function hipblasCher2Batched interface function hipblasZher2Batched(handle, uplo, n, alpha, & - x, incx, y, incy, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZher2Batched') + x, incx, y, incy, A, lda, batch_count) & + bind(c, name='hipblasZher2Batched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2Batched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4292,12 +4477,12 @@ end function hipblasZher2Batched ! her2StridedBatched interface function hipblasCher2StridedBatched(handle, uplo, n, alpha, & - x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCher2StridedBatched') + x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasCher2StridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2StridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4317,12 +4502,12 @@ end function hipblasCher2StridedBatched interface function hipblasZher2StridedBatched(handle, uplo, n, alpha, & - x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZher2StridedBatched') + x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasZher2StridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2StridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4343,12 +4528,12 @@ end function hipblasZher2StridedBatched ! hpmv interface function hipblasChpmv(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasChpmv') + x, incx, beta, y, incy) & + bind(c, name='hipblasChpmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4364,12 +4549,12 @@ end function hipblasChpmv interface function hipblasZhpmv(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasZhpmv') + x, incx, beta, y, incy) & + bind(c, name='hipblasZhpmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4386,12 +4571,12 @@ end function hipblasZhpmv ! hpmvBatched interface function hipblasChpmvBatched(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasChpmvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasChpmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4408,12 +4593,12 @@ end function hipblasChpmvBatched interface function hipblasZhpmvBatched(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZhpmvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasZhpmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4431,12 +4616,12 @@ end function hipblasZhpmvBatched ! hpmvStridedBatched interface function hipblasChpmvStridedBatched(handle, uplo, n, alpha, AP, stride_AP, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasChpmvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasChpmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4456,12 +4641,12 @@ end function hipblasChpmvStridedBatched interface function hipblasZhpmvStridedBatched(handle, uplo, n, alpha, AP, stride_AP, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZhpmvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasZhpmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4482,12 +4667,12 @@ end function hipblasZhpmvStridedBatched ! hpr interface function hipblasChpr(handle, uplo, n, alpha, & - x, incx, AP) & - result(c_int) & - bind(c, name = 'hipblasChpr') + x, incx, AP) & + bind(c, name='hipblasChpr') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4500,12 +4685,12 @@ end function hipblasChpr interface function hipblasZhpr(handle, uplo, n, alpha, & - x, incx, AP) & - result(c_int) & - bind(c, name = 'hipblasZhpr') + x, incx, AP) & + bind(c, name='hipblasZhpr') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4519,12 +4704,12 @@ end function hipblasZhpr ! hprBatched interface function hipblasChprBatched(handle, uplo, n, alpha, & - x, incx, AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasChprBatched') + x, incx, AP, batch_count) & + bind(c, name='hipblasChprBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChprBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4538,12 +4723,12 @@ end function hipblasChprBatched interface function hipblasZhprBatched(handle, uplo, n, alpha, & - x, incx, AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZhprBatched') + x, incx, AP, batch_count) & + bind(c, name='hipblasZhprBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhprBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4558,12 +4743,12 @@ end function hipblasZhprBatched ! hprStridedBatched interface function hipblasChprStridedBatched(handle, uplo, n, alpha, & - x, incx, stride_x, AP, stride_AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasChprStridedBatched') + x, incx, stride_x, AP, stride_AP, batch_count) & + bind(c, name='hipblasChprStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChprStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4579,12 +4764,12 @@ end function hipblasChprStridedBatched interface function hipblasZhprStridedBatched(handle, uplo, n, alpha, & - x, incx, stride_x, AP, stride_AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZhprStridedBatched') + x, incx, stride_x, AP, stride_AP, batch_count) & + bind(c, name='hipblasZhprStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhprStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4601,12 +4786,12 @@ end function hipblasZhprStridedBatched ! hpr2 interface function hipblasChpr2(handle, uplo, n, alpha, & - x, incx, y, incy, AP) & - result(c_int) & - bind(c, name = 'hipblasChpr2') + x, incx, y, incy, AP) & + bind(c, name='hipblasChpr2') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2 type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4621,12 +4806,12 @@ end function hipblasChpr2 interface function hipblasZhpr2(handle, uplo, n, alpha, & - x, incx, y, incy, AP) & - result(c_int) & - bind(c, name = 'hipblasZhpr2') + x, incx, y, incy, AP) & + bind(c, name='hipblasZhpr2') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2 type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4642,12 +4827,12 @@ end function hipblasZhpr2 ! hpr2Batched interface function hipblasChpr2Batched(handle, uplo, n, alpha, & - x, incx, y, incy, AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasChpr2Batched') + x, incx, y, incy, AP, batch_count) & + bind(c, name='hipblasChpr2Batched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2Batched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4663,12 +4848,12 @@ end function hipblasChpr2Batched interface function hipblasZhpr2Batched(handle, uplo, n, alpha, & - x, incx, y, incy, AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZhpr2Batched') + x, incx, y, incy, AP, batch_count) & + bind(c, name='hipblasZhpr2Batched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2Batched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4685,12 +4870,12 @@ end function hipblasZhpr2Batched ! hpr2StridedBatched interface function hipblasChpr2StridedBatched(handle, uplo, n, alpha, & - x, incx, stride_x, y, incy, stride_y, AP, stride_AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasChpr2StridedBatched') + x, incx, stride_x, y, incy, stride_y, AP, stride_AP, batch_count) & + bind(c, name='hipblasChpr2StridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2StridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4709,12 +4894,12 @@ end function hipblasChpr2StridedBatched interface function hipblasZhpr2StridedBatched(handle, uplo, n, alpha, & - x, incx, stride_x, y, incy, stride_y, AP, stride_AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZhpr2StridedBatched') + x, incx, stride_x, y, incy, stride_y, AP, stride_AP, batch_count) & + bind(c, name='hipblasZhpr2StridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2StridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -4734,12 +4919,12 @@ end function hipblasZhpr2StridedBatched ! trmv interface function hipblasStrmv(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasStrmv') + A, lda, x, incx) & + bind(c, name='hipblasStrmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4754,12 +4939,12 @@ end function hipblasStrmv interface function hipblasDtrmv(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasDtrmv') + A, lda, x, incx) & + bind(c, name='hipblasDtrmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4774,12 +4959,12 @@ end function hipblasDtrmv interface function hipblasCtrmv(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasCtrmv') + A, lda, x, incx) & + bind(c, name='hipblasCtrmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4794,12 +4979,12 @@ end function hipblasCtrmv interface function hipblasZtrmv(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasZtrmv') + A, lda, x, incx) & + bind(c, name='hipblasZtrmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4815,12 +5000,12 @@ end function hipblasZtrmv ! trmvBatched interface function hipblasStrmvBatched(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStrmvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasStrmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4836,12 +5021,12 @@ end function hipblasStrmvBatched interface function hipblasDtrmvBatched(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtrmvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasDtrmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4857,12 +5042,12 @@ end function hipblasDtrmvBatched interface function hipblasCtrmvBatched(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtrmvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasCtrmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4878,12 +5063,12 @@ end function hipblasCtrmvBatched interface function hipblasZtrmvBatched(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtrmvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasZtrmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4900,12 +5085,12 @@ end function hipblasZtrmvBatched ! trmvStridedBatched interface function hipblasStrmvStridedBatched(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStrmvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasStrmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4923,12 +5108,12 @@ end function hipblasStrmvStridedBatched interface function hipblasDtrmvStridedBatched(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtrmvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasDtrmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4946,12 +5131,12 @@ end function hipblasDtrmvStridedBatched interface function hipblasCtrmvStridedBatched(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtrmvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasCtrmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4969,12 +5154,12 @@ end function hipblasCtrmvStridedBatched interface function hipblasZtrmvStridedBatched(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtrmvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasZtrmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -4993,12 +5178,12 @@ end function hipblasZtrmvStridedBatched ! tpmv interface function hipblasStpmv(handle, uplo, transA, diag, m, & - AP, x, incx) & - result(c_int) & - bind(c, name = 'hipblasStpmv') + AP, x, incx) & + bind(c, name='hipblasStpmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5012,12 +5197,12 @@ end function hipblasStpmv interface function hipblasDtpmv(handle, uplo, transA, diag, m, & - AP, x, incx) & - result(c_int) & - bind(c, name = 'hipblasDtpmv') + AP, x, incx) & + bind(c, name='hipblasDtpmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5031,12 +5216,12 @@ end function hipblasDtpmv interface function hipblasCtpmv(handle, uplo, transA, diag, m, & - AP, x, incx) & - result(c_int) & - bind(c, name = 'hipblasCtpmv') + AP, x, incx) & + bind(c, name='hipblasCtpmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5050,12 +5235,12 @@ end function hipblasCtpmv interface function hipblasZtpmv(handle, uplo, transA, diag, m, & - AP, x, incx) & - result(c_int) & - bind(c, name = 'hipblasZtpmv') + AP, x, incx) & + bind(c, name='hipblasZtpmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5070,12 +5255,12 @@ end function hipblasZtpmv ! tpmvBatched interface function hipblasStpmvBatched(handle, uplo, transA, diag, m, & - AP, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStpmvBatched') + AP, x, incx, batch_count) & + bind(c, name='hipblasStpmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5090,12 +5275,12 @@ end function hipblasStpmvBatched interface function hipblasDtpmvBatched(handle, uplo, transA, diag, m, & - AP, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtpmvBatched') + AP, x, incx, batch_count) & + bind(c, name='hipblasDtpmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5110,12 +5295,12 @@ end function hipblasDtpmvBatched interface function hipblasCtpmvBatched(handle, uplo, transA, diag, m, & - AP, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtpmvBatched') + AP, x, incx, batch_count) & + bind(c, name='hipblasCtpmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5130,12 +5315,12 @@ end function hipblasCtpmvBatched interface function hipblasZtpmvBatched(handle, uplo, transA, diag, m, & - AP, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtpmvBatched') + AP, x, incx, batch_count) & + bind(c, name='hipblasZtpmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5151,12 +5336,12 @@ end function hipblasZtpmvBatched ! tpmvStridedBatched interface function hipblasStpmvStridedBatched(handle, uplo, transA, diag, m, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStpmvStridedBatched') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasStpmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5173,12 +5358,12 @@ end function hipblasStpmvStridedBatched interface function hipblasDtpmvStridedBatched(handle, uplo, transA, diag, m, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtpmvStridedBatched') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasDtpmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5195,12 +5380,12 @@ end function hipblasDtpmvStridedBatched interface function hipblasCtpmvStridedBatched(handle, uplo, transA, diag, m, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtpmvStridedBatched') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasCtpmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5217,12 +5402,12 @@ end function hipblasCtpmvStridedBatched interface function hipblasZtpmvStridedBatched(handle, uplo, transA, diag, m, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtpmvStridedBatched') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasZtpmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5240,12 +5425,12 @@ end function hipblasZtpmvStridedBatched ! tbmv interface function hipblasStbmv(handle, uplo, transA, diag, m, k, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasStbmv') + A, lda, x, incx) & + bind(c, name='hipblasStbmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5261,12 +5446,12 @@ end function hipblasStbmv interface function hipblasDtbmv(handle, uplo, transA, diag, m, k, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasDtbmv') + A, lda, x, incx) & + bind(c, name='hipblasDtbmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5282,12 +5467,12 @@ end function hipblasDtbmv interface function hipblasCtbmv(handle, uplo, transA, diag, m, k, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasCtbmv') + A, lda, x, incx) & + bind(c, name='hipblasCtbmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5303,12 +5488,12 @@ end function hipblasCtbmv interface function hipblasZtbmv(handle, uplo, transA, diag, m, k, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasZtbmv') + A, lda, x, incx) & + bind(c, name='hipblasZtbmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5325,12 +5510,12 @@ end function hipblasZtbmv ! tbmvBatched interface function hipblasStbmvBatched(handle, uplo, transA, diag, m, k, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStbmvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasStbmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5347,12 +5532,12 @@ end function hipblasStbmvBatched interface function hipblasDtbmvBatched(handle, uplo, transA, diag, m, k, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtbmvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasDtbmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5369,12 +5554,12 @@ end function hipblasDtbmvBatched interface function hipblasCtbmvBatched(handle, uplo, transA, diag, m, k, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtbmvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasCtbmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5391,12 +5576,12 @@ end function hipblasCtbmvBatched interface function hipblasZtbmvBatched(handle, uplo, transA, diag, m, k, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtbmvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasZtbmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5414,12 +5599,12 @@ end function hipblasZtbmvBatched ! tbmvStridedBatched interface function hipblasStbmvStridedBatched(handle, uplo, transA, diag, m, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStbmvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasStbmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5438,12 +5623,12 @@ end function hipblasStbmvStridedBatched interface function hipblasDtbmvStridedBatched(handle, uplo, transA, diag, m, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtbmvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasDtbmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5462,12 +5647,12 @@ end function hipblasDtbmvStridedBatched interface function hipblasCtbmvStridedBatched(handle, uplo, transA, diag, m, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtbmvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasCtbmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5486,12 +5671,12 @@ end function hipblasCtbmvStridedBatched interface function hipblasZtbmvStridedBatched(handle, uplo, transA, diag, m, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtbmvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasZtbmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5511,12 +5696,12 @@ end function hipblasZtbmvStridedBatched ! tbsv interface function hipblasStbsv(handle, uplo, transA, diag, n, k, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasStbsv') + A, lda, x, incx) & + bind(c, name='hipblasStbsv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5532,12 +5717,12 @@ end function hipblasStbsv interface function hipblasDtbsv(handle, uplo, transA, diag, n, k, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasDtbsv') + A, lda, x, incx) & + bind(c, name='hipblasDtbsv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5553,12 +5738,12 @@ end function hipblasDtbsv interface function hipblasCtbsv(handle, uplo, transA, diag, n, k, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasCtbsv') + A, lda, x, incx) & + bind(c, name='hipblasCtbsv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5574,12 +5759,12 @@ end function hipblasCtbsv interface function hipblasZtbsv(handle, uplo, transA, diag, n, k, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasZtbsv') + A, lda, x, incx) & + bind(c, name='hipblasZtbsv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5596,12 +5781,12 @@ end function hipblasZtbsv ! tbsvBatched interface function hipblasStbsvBatched(handle, uplo, transA, diag, n, k, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStbsvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasStbsvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5618,12 +5803,12 @@ end function hipblasStbsvBatched interface function hipblasDtbsvBatched(handle, uplo, transA, diag, n, k, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtbsvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasDtbsvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5640,12 +5825,12 @@ end function hipblasDtbsvBatched interface function hipblasCtbsvBatched(handle, uplo, transA, diag, n, k, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtbsvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasCtbsvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5662,12 +5847,12 @@ end function hipblasCtbsvBatched interface function hipblasZtbsvBatched(handle, uplo, transA, diag, n, k, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtbsvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasZtbsvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5685,12 +5870,12 @@ end function hipblasZtbsvBatched ! tbsvStridedBatched interface function hipblasStbsvStridedBatched(handle, uplo, transA, diag, n, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStbsvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasStbsvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5709,12 +5894,12 @@ end function hipblasStbsvStridedBatched interface function hipblasDtbsvStridedBatched(handle, uplo, transA, diag, n, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtbsvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasDtbsvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5733,12 +5918,12 @@ end function hipblasDtbsvStridedBatched interface function hipblasCtbsvStridedBatched(handle, uplo, transA, diag, n, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtbsvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasCtbsvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5757,12 +5942,12 @@ end function hipblasCtbsvStridedBatched interface function hipblasZtbsvStridedBatched(handle, uplo, transA, diag, n, k, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtbsvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasZtbsvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5782,12 +5967,12 @@ end function hipblasZtbsvStridedBatched ! trsv interface function hipblasStrsv(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasStrsv') + A, lda, x, incx) & + bind(c, name='hipblasStrsv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5802,12 +5987,12 @@ end function hipblasStrsv interface function hipblasDtrsv(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasDtrsv') + A, lda, x, incx) & + bind(c, name='hipblasDtrsv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5822,12 +6007,12 @@ end function hipblasDtrsv interface function hipblasCtrsv(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasCtrsv') + A, lda, x, incx) & + bind(c, name='hipblasCtrsv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5842,12 +6027,12 @@ end function hipblasCtrsv interface function hipblasZtrsv(handle, uplo, transA, diag, m, & - A, lda, x, incx) & - result(c_int) & - bind(c, name = 'hipblasZtrsv') + A, lda, x, incx) & + bind(c, name='hipblasZtrsv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5863,12 +6048,12 @@ end function hipblasZtrsv ! trsvBatched interface function hipblasStrsvBatched(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStrsvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasStrsvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5884,12 +6069,12 @@ end function hipblasStrsvBatched interface function hipblasDtrsvBatched(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtrsvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasDtrsvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5905,12 +6090,12 @@ end function hipblasDtrsvBatched interface function hipblasCtrsvBatched(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtrsvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasCtrsvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5926,12 +6111,12 @@ end function hipblasCtrsvBatched interface function hipblasZtrsvBatched(handle, uplo, transA, diag, m, & - A, lda, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtrsvBatched') + A, lda, x, incx, batch_count) & + bind(c, name='hipblasZtrsvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5948,12 +6133,12 @@ end function hipblasZtrsvBatched ! trsvStridedBatched interface function hipblasStrsvStridedBatched(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStrsvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasStrsvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5971,12 +6156,12 @@ end function hipblasStrsvStridedBatched interface function hipblasDtrsvStridedBatched(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtrsvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasDtrsvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -5994,12 +6179,12 @@ end function hipblasDtrsvStridedBatched interface function hipblasCtrsvStridedBatched(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtrsvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasCtrsvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6017,12 +6202,12 @@ end function hipblasCtrsvStridedBatched interface function hipblasZtrsvStridedBatched(handle, uplo, transA, diag, m, & - A, lda, stride_A, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtrsvStridedBatched') + A, lda, stride_A, x, incx, stride_x, batch_count) & + bind(c, name='hipblasZtrsvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6041,12 +6226,12 @@ end function hipblasZtrsvStridedBatched ! tpsv interface function hipblasStpsv(handle, uplo, transA, diag, n, & - AP, x, incx) & - result(c_int) & - bind(c, name = 'hipblasStpsv') + AP, x, incx) & + bind(c, name='hipblasStpsv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6060,12 +6245,12 @@ end function hipblasStpsv interface function hipblasDtpsv(handle, uplo, transA, diag, n, & - AP, x, incx) & - result(c_int) & - bind(c, name = 'hipblasDtpsv') + AP, x, incx) & + bind(c, name='hipblasDtpsv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6079,12 +6264,12 @@ end function hipblasDtpsv interface function hipblasCtpsv(handle, uplo, transA, diag, n, & - AP, x, incx) & - result(c_int) & - bind(c, name = 'hipblasCtpsv') + AP, x, incx) & + bind(c, name='hipblasCtpsv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6098,12 +6283,12 @@ end function hipblasCtpsv interface function hipblasZtpsv(handle, uplo, transA, diag, n, & - AP, x, incx) & - result(c_int) & - bind(c, name = 'hipblasZtpsv') + AP, x, incx) & + bind(c, name='hipblasZtpsv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6118,12 +6303,12 @@ end function hipblasZtpsv ! tpsvBatched interface function hipblasStpsvBatched(handle, uplo, transA, diag, n, & - AP, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStpsvBatched') + AP, x, incx, batch_count) & + bind(c, name='hipblasStpsvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6138,12 +6323,12 @@ end function hipblasStpsvBatched interface function hipblasDtpsvBatched(handle, uplo, transA, diag, n, & - AP, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtpsvBatched') + AP, x, incx, batch_count) & + bind(c, name='hipblasDtpsvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6158,12 +6343,12 @@ end function hipblasDtpsvBatched interface function hipblasCtpsvBatched(handle, uplo, transA, diag, n, & - AP, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtpsvBatched') + AP, x, incx, batch_count) & + bind(c, name='hipblasCtpsvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6178,12 +6363,12 @@ end function hipblasCtpsvBatched interface function hipblasZtpsvBatched(handle, uplo, transA, diag, n, & - AP, x, incx, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtpsvBatched') + AP, x, incx, batch_count) & + bind(c, name='hipblasZtpsvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6199,12 +6384,12 @@ end function hipblasZtpsvBatched ! tpsvStridedBatched interface function hipblasStpsvStridedBatched(handle, uplo, transA, diag, n, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStpsvStridedBatched') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasStpsvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6221,12 +6406,12 @@ end function hipblasStpsvStridedBatched interface function hipblasDtpsvStridedBatched(handle, uplo, transA, diag, n, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtpsvStridedBatched') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasDtpsvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6243,12 +6428,12 @@ end function hipblasDtpsvStridedBatched interface function hipblasCtpsvStridedBatched(handle, uplo, transA, diag, n, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtpsvStridedBatched') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasCtpsvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6265,12 +6450,12 @@ end function hipblasCtpsvStridedBatched interface function hipblasZtpsvStridedBatched(handle, uplo, transA, diag, n, & - AP, stride_AP, x, incx, stride_x, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtpsvStridedBatched') + AP, stride_AP, x, incx, stride_x, batch_count) & + bind(c, name='hipblasZtpsvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -6288,12 +6473,12 @@ end function hipblasZtpsvStridedBatched ! symv interface function hipblasSsymv(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasSsymv') + x, incx, beta, y, incy) & + bind(c, name='hipblasSsymv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6310,12 +6495,12 @@ end function hipblasSsymv interface function hipblasDsymv(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasDsymv') + x, incx, beta, y, incy) & + bind(c, name='hipblasDsymv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6332,12 +6517,12 @@ end function hipblasDsymv interface function hipblasCsymv(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasCsymv') + x, incx, beta, y, incy) & + bind(c, name='hipblasCsymv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6354,12 +6539,12 @@ end function hipblasCsymv interface function hipblasZsymv(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasZsymv') + x, incx, beta, y, incy) & + bind(c, name='hipblasZsymv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6377,12 +6562,12 @@ end function hipblasZsymv ! symvBatched interface function hipblasSsymvBatched(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsymvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasSsymvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6400,12 +6585,12 @@ end function hipblasSsymvBatched interface function hipblasDsymvBatched(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsymvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasDsymvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6423,12 +6608,12 @@ end function hipblasDsymvBatched interface function hipblasCsymvBatched(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsymvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasCsymvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6446,12 +6631,12 @@ end function hipblasCsymvBatched interface function hipblasZsymvBatched(handle, uplo, n, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsymvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasZsymvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6470,12 +6655,12 @@ end function hipblasZsymvBatched ! symvStridedBatched interface function hipblasSsymvStridedBatched(handle, uplo, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsymvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasSsymvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6496,12 +6681,12 @@ end function hipblasSsymvStridedBatched interface function hipblasDsymvStridedBatched(handle, uplo, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsymvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasDsymvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6522,12 +6707,12 @@ end function hipblasDsymvStridedBatched interface function hipblasCsymvStridedBatched(handle, uplo, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsymvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasCsymvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6548,12 +6733,12 @@ end function hipblasCsymvStridedBatched interface function hipblasZsymvStridedBatched(handle, uplo, n, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsymvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasZsymvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6575,12 +6760,12 @@ end function hipblasZsymvStridedBatched ! spmv interface function hipblasSspmv(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasSspmv') + x, incx, beta, y, incy) & + bind(c, name='hipblasSspmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6596,12 +6781,12 @@ end function hipblasSspmv interface function hipblasDspmv(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasDspmv') + x, incx, beta, y, incy) & + bind(c, name='hipblasDspmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6618,12 +6803,12 @@ end function hipblasDspmv ! spmvBatched interface function hipblasSspmvBatched(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSspmvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasSspmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6640,12 +6825,12 @@ end function hipblasSspmvBatched interface function hipblasDspmvBatched(handle, uplo, n, alpha, AP, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDspmvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasDspmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6663,12 +6848,12 @@ end function hipblasDspmvBatched ! spmvStridedBatched interface function hipblasSspmvStridedBatched(handle, uplo, n, alpha, AP, stride_AP, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSspmvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasSspmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6688,12 +6873,12 @@ end function hipblasSspmvStridedBatched interface function hipblasDspmvStridedBatched(handle, uplo, n, alpha, AP, stride_AP, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDspmvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasDspmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6714,12 +6899,12 @@ end function hipblasDspmvStridedBatched ! sbmv interface function hipblasSsbmv(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasSsbmv') + x, incx, beta, y, incy) & + bind(c, name='hipblasSsbmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6737,12 +6922,12 @@ end function hipblasSsbmv interface function hipblasDsbmv(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy) & - result(c_int) & - bind(c, name = 'hipblasDsbmv') + x, incx, beta, y, incy) & + bind(c, name='hipblasDsbmv') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmv type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6761,12 +6946,12 @@ end function hipblasDsbmv ! sbmvBatched interface function hipblasSsbmvBatched(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsbmvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasSsbmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6785,12 +6970,12 @@ end function hipblasSsbmvBatched interface function hipblasDsbmvBatched(handle, uplo, n, k, alpha, A, lda, & - x, incx, beta, y, incy, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsbmvBatched') + x, incx, beta, y, incy, batch_count) & + bind(c, name='hipblasDsbmvBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmvBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6810,12 +6995,12 @@ end function hipblasDsbmvBatched ! sbmvStridedBatched interface function hipblasSsbmvStridedBatched(handle, uplo, n, k, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsbmvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasSsbmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6837,12 +7022,12 @@ end function hipblasSsbmvStridedBatched interface function hipblasDsbmvStridedBatched(handle, uplo, n, k, alpha, A, lda, stride_A, & - x, incx, stride_x, beta, y, incy, stride_y, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsbmvStridedBatched') + x, incx, stride_x, beta, y, incy, stride_y, batch_count) & + bind(c, name='hipblasDsbmvStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmvStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -6865,11 +7050,12 @@ end function hipblasDsbmvStridedBatched ! ger interface function hipblasSger(handle, m, n, alpha, x, incx, & - y, incy, A, lda) & - result(c_int) & - bind(c, name = 'hipblasSger') + y, incy, A, lda) & + bind(c, name='hipblasSger') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSger type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6885,11 +7071,12 @@ end function hipblasSger interface function hipblasDger(handle, m, n, alpha, x, incx, & - y, incy, A, lda) & - result(c_int) & - bind(c, name = 'hipblasDger') + y, incy, A, lda) & + bind(c, name='hipblasDger') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDger type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6905,11 +7092,12 @@ end function hipblasDger interface function hipblasCgeru(handle, m, n, alpha, x, incx, & - y, incy, A, lda) & - result(c_int) & - bind(c, name = 'hipblasCgeru') + y, incy, A, lda) & + bind(c, name='hipblasCgeru') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeru type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6925,11 +7113,12 @@ end function hipblasCgeru interface function hipblasCgerc(handle, m, n, alpha, x, incx, & - y, incy, A, lda) & - result(c_int) & - bind(c, name = 'hipblasCgerc') + y, incy, A, lda) & + bind(c, name='hipblasCgerc') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgerc type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6945,11 +7134,12 @@ end function hipblasCgerc interface function hipblasZgeru(handle, m, n, alpha, x, incx, & - y, incy, A, lda) & - result(c_int) & - bind(c, name = 'hipblasZgeru') + y, incy, A, lda) & + bind(c, name='hipblasZgeru') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeru type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6965,11 +7155,12 @@ end function hipblasZgeru interface function hipblasZgerc(handle, m, n, alpha, x, incx, & - y, incy, A, lda) & - result(c_int) & - bind(c, name = 'hipblasZgerc') + y, incy, A, lda) & + bind(c, name='hipblasZgerc') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgerc type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -6986,11 +7177,12 @@ end function hipblasZgerc ! gerBatched interface function hipblasSgerBatched(handle, m, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgerBatched') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasSgerBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgerBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7007,11 +7199,12 @@ end function hipblasSgerBatched interface function hipblasDgerBatched(handle, m, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgerBatched') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasDgerBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgerBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7028,11 +7221,12 @@ end function hipblasDgerBatched interface function hipblasCgeruBatched(handle, m, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgeruBatched') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasCgeruBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeruBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7049,11 +7243,12 @@ end function hipblasCgeruBatched interface function hipblasCgercBatched(handle, m, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgercBatched') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasCgercBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgercBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7070,11 +7265,12 @@ end function hipblasCgercBatched interface function hipblasZgeruBatched(handle, m, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgeruBatched') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasZgeruBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeruBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7091,11 +7287,12 @@ end function hipblasZgeruBatched interface function hipblasZgercBatched(handle, m, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgercBatched') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasZgercBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgercBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7113,11 +7310,12 @@ end function hipblasZgercBatched ! gerStridedBatched interface function hipblasSgerStridedBatched(handle, m, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgerStridedBatched') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasSgerStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgerStridedBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7137,11 +7335,12 @@ end function hipblasSgerStridedBatched interface function hipblasDgerStridedBatched(handle, m, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgerStridedBatched') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasDgerStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgerStridedBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7161,11 +7360,12 @@ end function hipblasDgerStridedBatched interface function hipblasCgeruStridedBatched(handle, m, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgeruStridedBatched') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasCgeruStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeruStridedBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7185,11 +7385,12 @@ end function hipblasCgeruStridedBatched interface function hipblasCgercStridedBatched(handle, m, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgercStridedBatched') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasCgercStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgercStridedBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7209,11 +7410,12 @@ end function hipblasCgercStridedBatched interface function hipblasZgeruStridedBatched(handle, m, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgeruStridedBatched') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasZgeruStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeruStridedBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7233,11 +7435,12 @@ end function hipblasZgeruStridedBatched interface function hipblasZgercStridedBatched(handle, m, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgercStridedBatched') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasZgercStridedBatched') use iso_c_binding + use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgercStridedBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -7258,11 +7461,11 @@ end function hipblasZgercStridedBatched ! spr interface function hipblasSspr(handle, uplo, n, alpha, x, incx, AP) & - result(c_int) & - bind(c, name = 'hipblasSspr') + bind(c, name='hipblasSspr') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7275,11 +7478,11 @@ end function hipblasSspr interface function hipblasDspr(handle, uplo, n, alpha, x, incx, AP) & - result(c_int) & - bind(c, name = 'hipblasDspr') + bind(c, name='hipblasDspr') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7292,11 +7495,11 @@ end function hipblasDspr interface function hipblasCspr(handle, uplo, n, alpha, x, incx, AP) & - result(c_int) & - bind(c, name = 'hipblasCspr') + bind(c, name='hipblasCspr') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCspr type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7309,11 +7512,11 @@ end function hipblasCspr interface function hipblasZspr(handle, uplo, n, alpha, x, incx, AP) & - result(c_int) & - bind(c, name = 'hipblasZspr') + bind(c, name='hipblasZspr') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZspr type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7327,11 +7530,11 @@ end function hipblasZspr ! sprBatched interface function hipblasSsprBatched(handle, uplo, n, alpha, x, incx, AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsprBatched') + bind(c, name='hipblasSsprBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsprBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7345,11 +7548,11 @@ end function hipblasSsprBatched interface function hipblasDsprBatched(handle, uplo, n, alpha, x, incx, AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsprBatched') + bind(c, name='hipblasDsprBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsprBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7363,11 +7566,11 @@ end function hipblasDsprBatched interface function hipblasCsprBatched(handle, uplo, n, alpha, x, incx, AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsprBatched') + bind(c, name='hipblasCsprBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsprBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7381,11 +7584,11 @@ end function hipblasCsprBatched interface function hipblasZsprBatched(handle, uplo, n, alpha, x, incx, AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsprBatched') + bind(c, name='hipblasZsprBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsprBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7400,12 +7603,12 @@ end function hipblasZsprBatched ! sprStridedBatched interface function hipblasSsprStridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & - AP, stride_AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsprStridedBatched') + AP, stride_AP, batch_count) & + bind(c, name='hipblasSsprStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsprStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7421,12 +7624,12 @@ end function hipblasSsprStridedBatched interface function hipblasDsprStridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & - AP, stride_AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsprStridedBatched') + AP, stride_AP, batch_count) & + bind(c, name='hipblasDsprStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsprStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7442,12 +7645,12 @@ end function hipblasDsprStridedBatched interface function hipblasCsprStridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & - AP, stride_AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsprStridedBatched') + AP, stride_AP, batch_count) & + bind(c, name='hipblasCsprStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsprStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7463,12 +7666,12 @@ end function hipblasCsprStridedBatched interface function hipblasZsprStridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & - AP, stride_AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsprStridedBatched') + AP, stride_AP, batch_count) & + bind(c, name='hipblasZsprStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsprStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7485,12 +7688,12 @@ end function hipblasZsprStridedBatched ! spr2 interface function hipblasSspr2(handle, uplo, n, alpha, x, incx, & - y, incy, AP) & - result(c_int) & - bind(c, name = 'hipblasSspr2') + y, incy, AP) & + bind(c, name='hipblasSspr2') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2 type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7505,12 +7708,12 @@ end function hipblasSspr2 interface function hipblasDspr2(handle, uplo, n, alpha, x, incx, & - y, incy, AP) & - result(c_int) & - bind(c, name = 'hipblasDspr2') + y, incy, AP) & + bind(c, name='hipblasDspr2') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2 type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7526,12 +7729,12 @@ end function hipblasDspr2 ! spr2Batched interface function hipblasSspr2Batched(handle, uplo, n, alpha, x, incx, & - y, incy, AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSspr2Batched') + y, incy, AP, batch_count) & + bind(c, name='hipblasSspr2Batched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2Batched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7547,12 +7750,12 @@ end function hipblasSspr2Batched interface function hipblasDspr2Batched(handle, uplo, n, alpha, x, incx, & - y, incy, AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDspr2Batched') + y, incy, AP, batch_count) & + bind(c, name='hipblasDspr2Batched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2Batched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7569,12 +7772,12 @@ end function hipblasDspr2Batched ! spr2StridedBatched interface function hipblasSspr2StridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & - y, incy, stride_y, AP, stride_AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSspr2StridedBatched') + y, incy, stride_y, AP, stride_AP, batch_count) & + bind(c, name='hipblasSspr2StridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2StridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7593,12 +7796,12 @@ end function hipblasSspr2StridedBatched interface function hipblasDspr2StridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & - y, incy, stride_y, AP, stride_AP, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDspr2StridedBatched') + y, incy, stride_y, AP, stride_AP, batch_count) & + bind(c, name='hipblasDspr2StridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2StridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7618,11 +7821,11 @@ end function hipblasDspr2StridedBatched ! syr interface function hipblasSsyr(handle, uplo, n, alpha, x, incx, A, lda) & - result(c_int) & - bind(c, name = 'hipblasSsyr') + bind(c, name='hipblasSsyr') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7636,11 +7839,11 @@ end function hipblasSsyr interface function hipblasDsyr(handle, uplo, n, alpha, x, incx, A, lda) & - result(c_int) & - bind(c, name = 'hipblasDsyr') + bind(c, name='hipblasDsyr') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7654,11 +7857,11 @@ end function hipblasDsyr interface function hipblasCsyr(handle, uplo, n, alpha, x, incx, A, lda) & - result(c_int) & - bind(c, name = 'hipblasCsyr') + bind(c, name='hipblasCsyr') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7672,11 +7875,11 @@ end function hipblasCsyr interface function hipblasZsyr(handle, uplo, n, alpha, x, incx, A, lda) & - result(c_int) & - bind(c, name = 'hipblasZsyr') + bind(c, name='hipblasZsyr') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7691,11 +7894,11 @@ end function hipblasZsyr ! syrBatched interface function hipblasSsyrBatched(handle, uplo, n, alpha, x, incx, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsyrBatched') + bind(c, name='hipblasSsyrBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7710,11 +7913,11 @@ end function hipblasSsyrBatched interface function hipblasDsyrBatched(handle, uplo, n, alpha, x, incx, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsyrBatched') + bind(c, name='hipblasDsyrBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7729,11 +7932,11 @@ end function hipblasDsyrBatched interface function hipblasCsyrBatched(handle, uplo, n, alpha, x, incx, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsyrBatched') + bind(c, name='hipblasCsyrBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7748,11 +7951,11 @@ end function hipblasCsyrBatched interface function hipblasZsyrBatched(handle, uplo, n, alpha, x, incx, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsyrBatched') + bind(c, name='hipblasZsyrBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7768,12 +7971,12 @@ end function hipblasZsyrBatched ! syrStridedBatched interface function hipblasSsyrStridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & - A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsyrStridedBatched') + A, lda, stride_A, batch_count) & + bind(c, name='hipblasSsyrStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7790,12 +7993,12 @@ end function hipblasSsyrStridedBatched interface function hipblasDsyrStridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & - A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsyrStridedBatched') + A, lda, stride_A, batch_count) & + bind(c, name='hipblasDsyrStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7812,12 +8015,12 @@ end function hipblasDsyrStridedBatched interface function hipblasCsyrStridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & - A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsyrStridedBatched') + A, lda, stride_A, batch_count) & + bind(c, name='hipblasCsyrStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7834,12 +8037,12 @@ end function hipblasCsyrStridedBatched interface function hipblasZsyrStridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & - A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsyrStridedBatched') + A, lda, stride_A, batch_count) & + bind(c, name='hipblasZsyrStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7857,12 +8060,12 @@ end function hipblasZsyrStridedBatched ! syr2 interface function hipblasSsyr2(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda) & - result(c_int) & - bind(c, name = 'hipblasSsyr2') + y, incy, A, lda) & + bind(c, name='hipblasSsyr2') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2 type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7878,12 +8081,12 @@ end function hipblasSsyr2 interface function hipblasDsyr2(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda) & - result(c_int) & - bind(c, name = 'hipblasDsyr2') + y, incy, A, lda) & + bind(c, name='hipblasDsyr2') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2 type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7899,12 +8102,12 @@ end function hipblasDsyr2 interface function hipblasCsyr2(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda) & - result(c_int) & - bind(c, name = 'hipblasCsyr2') + y, incy, A, lda) & + bind(c, name='hipblasCsyr2') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2 type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7920,12 +8123,12 @@ end function hipblasCsyr2 interface function hipblasZsyr2(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda) & - result(c_int) & - bind(c, name = 'hipblasZsyr2') + y, incy, A, lda) & + bind(c, name='hipblasZsyr2') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2 type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7942,12 +8145,12 @@ end function hipblasZsyr2 ! syr2Batched interface function hipblasSsyr2Batched(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsyr2Batched') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasSsyr2Batched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2Batched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7964,12 +8167,12 @@ end function hipblasSsyr2Batched interface function hipblasDsyr2Batched(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsyr2Batched') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasDsyr2Batched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2Batched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -7986,12 +8189,12 @@ end function hipblasDsyr2Batched interface function hipblasCsyr2Batched(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsyr2Batched') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasCsyr2Batched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2Batched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -8008,12 +8211,12 @@ end function hipblasCsyr2Batched interface function hipblasZsyr2Batched(handle, uplo, n, alpha, x, incx, & - y, incy, A, lda, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsyr2Batched') + y, incy, A, lda, batch_count) & + bind(c, name='hipblasZsyr2Batched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2Batched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -8031,12 +8234,12 @@ end function hipblasZsyr2Batched ! syr2StridedBatched interface function hipblasSsyr2StridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsyr2StridedBatched') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasSsyr2StridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2StridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -8056,12 +8259,12 @@ end function hipblasSsyr2StridedBatched interface function hipblasDsyr2StridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsyr2StridedBatched') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasDsyr2StridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2StridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -8081,12 +8284,12 @@ end function hipblasDsyr2StridedBatched interface function hipblasCsyr2StridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsyr2StridedBatched') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasCsyr2StridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2StridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -8106,12 +8309,12 @@ end function hipblasCsyr2StridedBatched interface function hipblasZsyr2StridedBatched(handle, uplo, n, alpha, x, incx, stride_x, & - y, incy, stride_y, A, lda, stride_A, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsyr2StridedBatched') + y, incy, stride_y, A, lda, stride_A, batch_count) & + bind(c, name='hipblasZsyr2StridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2StridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(c_int), value :: n @@ -8136,12 +8339,12 @@ end function hipblasZsyr2StridedBatched ! hemm interface function hipblasChemm(handle, side, uplo, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasChemm') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasChemm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8160,12 +8363,12 @@ end function hipblasChemm interface function hipblasZhemm(handle, side, uplo, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasZhemm') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasZhemm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8185,12 +8388,12 @@ end function hipblasZhemm ! hemmBatched interface function hipblasChemmBatched(handle, side, uplo, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasChemmBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasChemmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8210,12 +8413,12 @@ end function hipblasChemmBatched interface function hipblasZhemmBatched(handle, side, uplo, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZhemmBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasZhemmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8236,12 +8439,12 @@ end function hipblasZhemmBatched ! hemmStridedBatched interface function hipblasChemmStridedBatched(handle, side, uplo, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasChemmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasChemmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8264,12 +8467,12 @@ end function hipblasChemmStridedBatched interface function hipblasZhemmStridedBatched(handle, side, uplo, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZhemmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZhemmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8293,12 +8496,12 @@ end function hipblasZhemmStridedBatched ! herk interface function hipblasCherk(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasCherk') + A, lda, beta, C, ldc) & + bind(c, name='hipblasCherk') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherk type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8315,12 +8518,12 @@ end function hipblasCherk interface function hipblasZherk(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasZherk') + A, lda, beta, C, ldc) & + bind(c, name='hipblasZherk') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherk type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8338,12 +8541,12 @@ end function hipblasZherk ! herkBatched interface function hipblasCherkBatched(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCherkBatched') + A, lda, beta, C, ldc, batch_count) & + bind(c, name='hipblasCherkBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8361,12 +8564,12 @@ end function hipblasCherkBatched interface function hipblasZherkBatched(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZherkBatched') + A, lda, beta, C, ldc, batch_count) & + bind(c, name='hipblasZherkBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8385,12 +8588,12 @@ end function hipblasZherkBatched ! herkStridedBatched interface function hipblasCherkStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCherkStridedBatched') + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCherkStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8410,12 +8613,12 @@ end function hipblasCherkStridedBatched interface function hipblasZherkStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZherkStridedBatched') + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZherkStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8436,12 +8639,12 @@ end function hipblasZherkStridedBatched ! her2k interface function hipblasCher2k(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasCher2k') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasCher2k') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2k type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8460,12 +8663,12 @@ end function hipblasCher2k interface function hipblasZher2k(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasZher2k') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasZher2k') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2k type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8485,12 +8688,12 @@ end function hipblasZher2k ! her2kBatched interface function hipblasCher2kBatched(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCher2kBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasCher2kBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2kBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8510,12 +8713,12 @@ end function hipblasCher2kBatched interface function hipblasZher2kBatched(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZher2kBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasZher2kBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2kBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8536,12 +8739,12 @@ end function hipblasZher2kBatched ! her2kStridedBatched interface function hipblasCher2kStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCher2kStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCher2kStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2kStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8564,12 +8767,12 @@ end function hipblasCher2kStridedBatched interface function hipblasZher2kStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZher2kStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZher2kStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2kStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8593,12 +8796,12 @@ end function hipblasZher2kStridedBatched ! herkx interface function hipblasCherkx(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasCherkx') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasCherkx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkx type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8617,12 +8820,12 @@ end function hipblasCherkx interface function hipblasZherkx(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasZherkx') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasZherkx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkx type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8642,12 +8845,12 @@ end function hipblasZherkx ! herkxBatched interface function hipblasCherkxBatched(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCherkxBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasCherkxBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkxBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8667,12 +8870,12 @@ end function hipblasCherkxBatched interface function hipblasZherkxBatched(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZherkxBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasZherkxBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkxBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8693,12 +8896,12 @@ end function hipblasZherkxBatched ! herkxStridedBatched interface function hipblasCherkxStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCherkxStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCherkxStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkxStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8721,12 +8924,12 @@ end function hipblasCherkxStridedBatched interface function hipblasZherkxStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZherkxStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZherkxStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkxStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -8750,12 +8953,12 @@ end function hipblasZherkxStridedBatched ! symm interface function hipblasSsymm(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasSsymm') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasSsymm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8774,12 +8977,12 @@ end function hipblasSsymm interface function hipblasDsymm(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasDsymm') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasDsymm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8798,12 +9001,12 @@ end function hipblasDsymm interface function hipblasCsymm(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasCsymm') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasCsymm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8822,12 +9025,12 @@ end function hipblasCsymm interface function hipblasZsymm(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasZsymm') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasZsymm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8847,12 +9050,12 @@ end function hipblasZsymm ! symmBatched interface function hipblasSsymmBatched(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsymmBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasSsymmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8872,12 +9075,12 @@ end function hipblasSsymmBatched interface function hipblasDsymmBatched(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsymmBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasDsymmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8897,12 +9100,12 @@ end function hipblasDsymmBatched interface function hipblasCsymmBatched(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsymmBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasCsymmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8922,12 +9125,12 @@ end function hipblasCsymmBatched interface function hipblasZsymmBatched(handle, side, uplo, m, n, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsymmBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasZsymmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8948,12 +9151,12 @@ end function hipblasZsymmBatched ! symmStridedBatched interface function hipblasSsymmStridedBatched(handle, side, uplo, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsymmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasSsymmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -8976,12 +9179,12 @@ end function hipblasSsymmStridedBatched interface function hipblasDsymmStridedBatched(handle, side, uplo, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsymmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasDsymmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9004,12 +9207,12 @@ end function hipblasDsymmStridedBatched interface function hipblasCsymmStridedBatched(handle, side, uplo, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsymmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCsymmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9032,12 +9235,12 @@ end function hipblasCsymmStridedBatched interface function hipblasZsymmStridedBatched(handle, side, uplo, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsymmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZsymmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9061,12 +9264,12 @@ end function hipblasZsymmStridedBatched ! syrk interface function hipblasSsyrk(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasSsyrk') + A, lda, beta, C, ldc) & + bind(c, name='hipblasSsyrk') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrk type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9083,12 +9286,12 @@ end function hipblasSsyrk interface function hipblasDsyrk(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasDsyrk') + A, lda, beta, C, ldc) & + bind(c, name='hipblasDsyrk') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrk type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9105,12 +9308,12 @@ end function hipblasDsyrk interface function hipblasCsyrk(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasCsyrk') + A, lda, beta, C, ldc) & + bind(c, name='hipblasCsyrk') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrk type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9127,12 +9330,12 @@ end function hipblasCsyrk interface function hipblasZsyrk(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasZsyrk') + A, lda, beta, C, ldc) & + bind(c, name='hipblasZsyrk') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrk type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9150,12 +9353,12 @@ end function hipblasZsyrk ! syrkBatched interface function hipblasSsyrkBatched(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsyrkBatched') + A, lda, beta, C, ldc, batch_count) & + bind(c, name='hipblasSsyrkBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9173,12 +9376,12 @@ end function hipblasSsyrkBatched interface function hipblasDsyrkBatched(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsyrkBatched') + A, lda, beta, C, ldc, batch_count) & + bind(c, name='hipblasDsyrkBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9196,12 +9399,12 @@ end function hipblasDsyrkBatched interface function hipblasCsyrkBatched(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsyrkBatched') + A, lda, beta, C, ldc, batch_count) & + bind(c, name='hipblasCsyrkBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9219,12 +9422,12 @@ end function hipblasCsyrkBatched interface function hipblasZsyrkBatched(handle, uplo, transA, n, k, alpha, & - A, lda, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsyrkBatched') + A, lda, beta, C, ldc, batch_count) & + bind(c, name='hipblasZsyrkBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9243,12 +9446,12 @@ end function hipblasZsyrkBatched ! syrkStridedBatched interface function hipblasSsyrkStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsyrkStridedBatched') + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasSsyrkStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9268,12 +9471,12 @@ end function hipblasSsyrkStridedBatched interface function hipblasDsyrkStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsyrkStridedBatched') + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasDsyrkStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9293,12 +9496,12 @@ end function hipblasDsyrkStridedBatched interface function hipblasCsyrkStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsyrkStridedBatched') + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCsyrkStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9318,12 +9521,12 @@ end function hipblasCsyrkStridedBatched interface function hipblasZsyrkStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsyrkStridedBatched') + A, lda, stride_A, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZsyrkStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9344,12 +9547,12 @@ end function hipblasZsyrkStridedBatched ! syr2k interface function hipblasSsyr2k(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasSsyr2k') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasSsyr2k') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2k type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9368,12 +9571,12 @@ end function hipblasSsyr2k interface function hipblasDsyr2k(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasDsyr2k') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasDsyr2k') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2k type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9392,12 +9595,12 @@ end function hipblasDsyr2k interface function hipblasCsyr2k(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasCsyr2k') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasCsyr2k') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2k type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9416,12 +9619,12 @@ end function hipblasCsyr2k interface function hipblasZsyr2k(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasZsyr2k') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasZsyr2k') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2k type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9441,12 +9644,12 @@ end function hipblasZsyr2k ! syr2kBatched interface function hipblasSsyr2kBatched(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsyr2kBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasSsyr2kBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2kBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9466,12 +9669,12 @@ end function hipblasSsyr2kBatched interface function hipblasDsyr2kBatched(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsyr2kBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasDsyr2kBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2kBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9491,12 +9694,12 @@ end function hipblasDsyr2kBatched interface function hipblasCsyr2kBatched(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsyr2kBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasCsyr2kBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2kBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9516,12 +9719,12 @@ end function hipblasCsyr2kBatched interface function hipblasZsyr2kBatched(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsyr2kBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasZsyr2kBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2kBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9542,12 +9745,12 @@ end function hipblasZsyr2kBatched ! syr2kStridedBatched interface function hipblasSsyr2kStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsyr2kStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasSsyr2kStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2kStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9570,12 +9773,12 @@ end function hipblasSsyr2kStridedBatched interface function hipblasDsyr2kStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsyr2kStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasDsyr2kStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2kStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9598,12 +9801,12 @@ end function hipblasDsyr2kStridedBatched interface function hipblasCsyr2kStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsyr2kStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCsyr2kStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2kStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9626,12 +9829,12 @@ end function hipblasCsyr2kStridedBatched interface function hipblasZsyr2kStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsyr2kStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZsyr2kStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2kStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9655,12 +9858,12 @@ end function hipblasZsyr2kStridedBatched ! syrkx interface function hipblasSsyrkx(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasSsyrkx') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasSsyrkx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkx type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9679,12 +9882,12 @@ end function hipblasSsyrkx interface function hipblasDsyrkx(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasDsyrkx') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasDsyrkx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkx type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9703,12 +9906,12 @@ end function hipblasDsyrkx interface function hipblasCsyrkx(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasCsyrkx') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasCsyrkx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkx type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9727,12 +9930,12 @@ end function hipblasCsyrkx interface function hipblasZsyrkx(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasZsyrkx') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasZsyrkx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkx type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9752,12 +9955,12 @@ end function hipblasZsyrkx ! syrkxBatched interface function hipblasSsyrkxBatched(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsyrkxBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasSsyrkxBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkxBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9777,12 +9980,12 @@ end function hipblasSsyrkxBatched interface function hipblasDsyrkxBatched(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsyrkxBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasDsyrkxBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkxBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9802,12 +10005,12 @@ end function hipblasDsyrkxBatched interface function hipblasCsyrkxBatched(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsyrkxBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasCsyrkxBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkxBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9827,12 +10030,12 @@ end function hipblasCsyrkxBatched interface function hipblasZsyrkxBatched(handle, uplo, transA, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsyrkxBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasZsyrkxBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkxBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9853,12 +10056,12 @@ end function hipblasZsyrkxBatched ! syrkxStridedBatched interface function hipblasSsyrkxStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSsyrkxStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasSsyrkxStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkxStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9881,12 +10084,12 @@ end function hipblasSsyrkxStridedBatched interface function hipblasDsyrkxStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDsyrkxStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasDsyrkxStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkxStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9909,12 +10112,12 @@ end function hipblasDsyrkxStridedBatched interface function hipblasCsyrkxStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCsyrkxStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCsyrkxStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkxStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9937,12 +10140,12 @@ end function hipblasCsyrkxStridedBatched interface function hipblasZsyrkxStridedBatched(handle, uplo, transA, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZsyrkxStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZsyrkxStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkxStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_OP_N)), value :: transA @@ -9966,12 +10169,12 @@ end function hipblasZsyrkxStridedBatched ! trmm interface function hipblasStrmm(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(c_int) & - bind(c, name = 'hipblasStrmm') + A, lda, B, ldb) & + bind(c, name='hipblasStrmm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -9989,12 +10192,12 @@ end function hipblasStrmm interface function hipblasDtrmm(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(c_int) & - bind(c, name = 'hipblasDtrmm') + A, lda, B, ldb) & + bind(c, name='hipblasDtrmm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10012,12 +10215,12 @@ end function hipblasDtrmm interface function hipblasCtrmm(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(c_int) & - bind(c, name = 'hipblasCtrmm') + A, lda, B, ldb) & + bind(c, name='hipblasCtrmm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10035,12 +10238,12 @@ end function hipblasCtrmm interface function hipblasZtrmm(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(c_int) & - bind(c, name = 'hipblasZtrmm') + A, lda, B, ldb) & + bind(c, name='hipblasZtrmm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10059,12 +10262,12 @@ end function hipblasZtrmm ! trmmBatched interface function hipblasStrmmBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStrmmBatched') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasStrmmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10083,12 +10286,12 @@ end function hipblasStrmmBatched interface function hipblasDtrmmBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtrmmBatched') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasDtrmmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10107,12 +10310,12 @@ end function hipblasDtrmmBatched interface function hipblasCtrmmBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtrmmBatched') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasCtrmmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10131,12 +10334,12 @@ end function hipblasCtrmmBatched interface function hipblasZtrmmBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtrmmBatched') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasZtrmmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10156,12 +10359,12 @@ end function hipblasZtrmmBatched ! trmmStridedBatched interface function hipblasStrmmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStrmmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasStrmmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10182,12 +10385,12 @@ end function hipblasStrmmStridedBatched interface function hipblasDtrmmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtrmmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasDtrmmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10208,12 +10411,12 @@ end function hipblasDtrmmStridedBatched interface function hipblasCtrmmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtrmmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasCtrmmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10234,12 +10437,12 @@ end function hipblasCtrmmStridedBatched interface function hipblasZtrmmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtrmmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasZtrmmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10261,12 +10464,12 @@ end function hipblasZtrmmStridedBatched ! trtri interface function hipblasStrtri(handle, uplo, diag, n, & - A, lda, invA, ldinvA) & - result(c_int) & - bind(c, name = 'hipblasStrtri') + A, lda, invA, ldinvA) & + bind(c, name='hipblasStrtri') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtri type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10280,12 +10483,12 @@ end function hipblasStrtri interface function hipblasDtrtri(handle, uplo, diag, n, & - A, lda, invA, ldinvA) & - result(c_int) & - bind(c, name = 'hipblasDtrtri') + A, lda, invA, ldinvA) & + bind(c, name='hipblasDtrtri') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtri type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10299,12 +10502,12 @@ end function hipblasDtrtri interface function hipblasCtrtri(handle, uplo, diag, n, & - A, lda, invA, ldinvA) & - result(c_int) & - bind(c, name = 'hipblasCtrtri') + A, lda, invA, ldinvA) & + bind(c, name='hipblasCtrtri') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtri type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10318,12 +10521,12 @@ end function hipblasCtrtri interface function hipblasZtrtri(handle, uplo, diag, n, & - A, lda, invA, ldinvA) & - result(c_int) & - bind(c, name = 'hipblasZtrtri') + A, lda, invA, ldinvA) & + bind(c, name='hipblasZtrtri') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtri type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10338,12 +10541,12 @@ end function hipblasZtrtri ! trtriBatched interface function hipblasStrtriBatched(handle, uplo, diag, n, & - A, lda, invA, ldinvA, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStrtriBatched') + A, lda, invA, ldinvA, batch_count) & + bind(c, name='hipblasStrtriBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtriBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10358,12 +10561,12 @@ end function hipblasStrtriBatched interface function hipblasDtrtriBatched(handle, uplo, diag, n, & - A, lda, invA, ldinvA, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtrtriBatched') + A, lda, invA, ldinvA, batch_count) & + bind(c, name='hipblasDtrtriBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtriBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10378,12 +10581,12 @@ end function hipblasDtrtriBatched interface function hipblasCtrtriBatched(handle, uplo, diag, n, & - A, lda, invA, ldinvA, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtrtriBatched') + A, lda, invA, ldinvA, batch_count) & + bind(c, name='hipblasCtrtriBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtriBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10398,12 +10601,12 @@ end function hipblasCtrtriBatched interface function hipblasZtrtriBatched(handle, uplo, diag, n, & - A, lda, invA, ldinvA, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtrtriBatched') + A, lda, invA, ldinvA, batch_count) & + bind(c, name='hipblasZtrtriBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtriBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10419,12 +10622,12 @@ end function hipblasZtrtriBatched ! trtriStridedBatched interface function hipblasStrtriStridedBatched(handle, uplo, diag, n, & - A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStrtriStridedBatched') + A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & + bind(c, name='hipblasStrtriStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtriStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10441,12 +10644,12 @@ end function hipblasStrtriStridedBatched interface function hipblasDtrtriStridedBatched(handle, uplo, diag, n, & - A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtrtriStridedBatched') + A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & + bind(c, name='hipblasDtrtriStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtriStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10463,12 +10666,12 @@ end function hipblasDtrtriStridedBatched interface function hipblasCtrtriStridedBatched(handle, uplo, diag, n, & - A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtrtriStridedBatched') + A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & + bind(c, name='hipblasCtrtriStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtriStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10485,12 +10688,12 @@ end function hipblasCtrtriStridedBatched interface function hipblasZtrtriStridedBatched(handle, uplo, diag, n, & - A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtrtriStridedBatched') + A, lda, stride_A, invA, ldinvA, stride_invA, batch_count) & + bind(c, name='hipblasZtrtriStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtriStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo integer(kind(HIPBLAS_DIAG_UNIT)), value :: diag @@ -10508,12 +10711,12 @@ end function hipblasZtrtriStridedBatched ! trsm interface function hipblasStrsm(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(c_int) & - bind(c, name = 'hipblasStrsm') + A, lda, B, ldb) & + bind(c, name='hipblasStrsm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10531,12 +10734,12 @@ end function hipblasStrsm interface function hipblasDtrsm(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(c_int) & - bind(c, name = 'hipblasDtrsm') + A, lda, B, ldb) & + bind(c, name='hipblasDtrsm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10554,12 +10757,12 @@ end function hipblasDtrsm interface function hipblasCtrsm(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(c_int) & - bind(c, name = 'hipblasCtrsm') + A, lda, B, ldb) & + bind(c, name='hipblasCtrsm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10577,12 +10780,12 @@ end function hipblasCtrsm interface function hipblasZtrsm(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb) & - result(c_int) & - bind(c, name = 'hipblasZtrsm') + A, lda, B, ldb) & + bind(c, name='hipblasZtrsm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10601,12 +10804,12 @@ end function hipblasZtrsm ! trsmBatched interface function hipblasStrsmBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStrsmBatched') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasStrsmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10625,12 +10828,12 @@ end function hipblasStrsmBatched interface function hipblasDtrsmBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtrsmBatched') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasDtrsmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10649,12 +10852,12 @@ end function hipblasDtrsmBatched interface function hipblasCtrsmBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtrsmBatched') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasCtrsmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10673,12 +10876,12 @@ end function hipblasCtrsmBatched interface function hipblasZtrsmBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, B, ldb, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtrsmBatched') + A, lda, B, ldb, batch_count) & + bind(c, name='hipblasZtrsmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10698,12 +10901,12 @@ end function hipblasZtrsmBatched ! trsmStridedBatched interface function hipblasStrsmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(c_int) & - bind(c, name = 'hipblasStrsmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasStrsmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10724,12 +10927,12 @@ end function hipblasStrsmStridedBatched interface function hipblasDtrsmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDtrsmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasDtrsmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10750,12 +10953,12 @@ end function hipblasDtrsmStridedBatched interface function hipblasCtrsmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCtrsmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasCtrsmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10776,12 +10979,12 @@ end function hipblasCtrsmStridedBatched interface function hipblasZtrsmStridedBatched(handle, side, uplo, transA, diag, m, n, alpha, & - A, lda, stride_A, B, ldb, stride_B, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZtrsmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, batch_count) & + bind(c, name='hipblasZtrsmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo @@ -10803,12 +11006,12 @@ end function hipblasZtrsmStridedBatched ! gemm interface function hipblasHgemm(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasHgemm') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasHgemm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHgemm type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -10828,12 +11031,12 @@ end function hipblasHgemm interface function hipblasSgemm(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasSgemm') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasSgemm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemm type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -10853,12 +11056,12 @@ end function hipblasSgemm interface function hipblasDgemm(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasDgemm') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasDgemm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemm type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -10878,12 +11081,12 @@ end function hipblasDgemm interface function hipblasCgemm(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasCgemm') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasCgemm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemm type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -10903,12 +11106,12 @@ end function hipblasCgemm interface function hipblasZgemm(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasZgemm') + A, lda, B, ldb, beta, C, ldc) & + bind(c, name='hipblasZgemm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemm type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -10929,12 +11132,12 @@ end function hipblasZgemm ! gemmBatched interface function hipblasHgemmBatched(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasHgemmBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasHgemmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHgemmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -10955,12 +11158,12 @@ end function hipblasHgemmBatched interface function hipblasSgemmBatched(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgemmBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasSgemmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -10981,12 +11184,12 @@ end function hipblasSgemmBatched interface function hipblasDgemmBatched(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgemmBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasDgemmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11007,12 +11210,12 @@ end function hipblasDgemmBatched interface function hipblasCgemmBatched(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgemmBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasCgemmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11033,12 +11236,12 @@ end function hipblasCgemmBatched interface function hipblasZgemmBatched(handle, transA, transB, m, n, k, alpha, & - A, lda, B, ldb, beta, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgemmBatched') + A, lda, B, ldb, beta, C, ldc, batch_count) & + bind(c, name='hipblasZgemmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11060,12 +11263,12 @@ end function hipblasZgemmBatched ! gemmStridedBatched interface function hipblasHgemmStridedBatched(handle, transA, transB, m, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasHgemmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasHgemmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHgemmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11089,12 +11292,12 @@ end function hipblasHgemmStridedBatched interface function hipblasSgemmStridedBatched(handle, transA, transB, m, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgemmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasSgemmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11118,12 +11321,12 @@ end function hipblasSgemmStridedBatched interface function hipblasDgemmStridedBatched(handle, transA, transB, m, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgemmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasDgemmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11147,12 +11350,12 @@ end function hipblasDgemmStridedBatched interface function hipblasCgemmStridedBatched(handle, transA, transB, m, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgemmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCgemmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11176,12 +11379,12 @@ end function hipblasCgemmStridedBatched interface function hipblasZgemmStridedBatched(handle, transA, transB, m, n, k, alpha, & - A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgemmStridedBatched') + A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZgemmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11206,12 +11409,12 @@ end function hipblasZgemmStridedBatched ! dgmm interface function hipblasSdgmm(handle, side, m, n, & - A, lda, x, incx, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasSdgmm') + A, lda, x, incx, C, ldc) & + bind(c, name='hipblasSdgmm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11227,12 +11430,12 @@ end function hipblasSdgmm interface function hipblasDdgmm(handle, side, m, n, & - A, lda, x, incx, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasDdgmm') + A, lda, x, incx, C, ldc) & + bind(c, name='hipblasDdgmm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11248,12 +11451,12 @@ end function hipblasDdgmm interface function hipblasCdgmm(handle, side, m, n, & - A, lda, x, incx, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasCdgmm') + A, lda, x, incx, C, ldc) & + bind(c, name='hipblasCdgmm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11269,12 +11472,12 @@ end function hipblasCdgmm interface function hipblasZdgmm(handle, side, m, n, & - A, lda, x, incx, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasZdgmm') + A, lda, x, incx, C, ldc) & + bind(c, name='hipblasZdgmm') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmm type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11291,12 +11494,12 @@ end function hipblasZdgmm ! dgmmBatched interface function hipblasSdgmmBatched(handle, side, m, n, & - A, lda, x, incx, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSdgmmBatched') + A, lda, x, incx, C, ldc, batch_count) & + bind(c, name='hipblasSdgmmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11313,12 +11516,12 @@ end function hipblasSdgmmBatched interface function hipblasDdgmmBatched(handle, side, m, n, & - A, lda, x, incx, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDdgmmBatched') + A, lda, x, incx, C, ldc, batch_count) & + bind(c, name='hipblasDdgmmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11335,12 +11538,12 @@ end function hipblasDdgmmBatched interface function hipblasCdgmmBatched(handle, side, m, n, & - A, lda, x, incx, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCdgmmBatched') + A, lda, x, incx, C, ldc, batch_count) & + bind(c, name='hipblasCdgmmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11357,12 +11560,12 @@ end function hipblasCdgmmBatched interface function hipblasZdgmmBatched(handle, side, m, n, & - A, lda, x, incx, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZdgmmBatched') + A, lda, x, incx, C, ldc, batch_count) & + bind(c, name='hipblasZdgmmBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmmBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11380,12 +11583,12 @@ end function hipblasZdgmmBatched ! dgmmStridedBatched interface function hipblasSdgmmStridedBatched(handle, side, m, n, & - A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSdgmmStridedBatched') + A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasSdgmmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11405,12 +11608,12 @@ end function hipblasSdgmmStridedBatched interface function hipblasDdgmmStridedBatched(handle, side, m, n, & - A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDdgmmStridedBatched') + A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasDdgmmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11430,12 +11633,12 @@ end function hipblasDdgmmStridedBatched interface function hipblasCdgmmStridedBatched(handle, side, m, n, & - A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCdgmmStridedBatched') + A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCdgmmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11455,12 +11658,12 @@ end function hipblasCdgmmStridedBatched interface function hipblasZdgmmStridedBatched(handle, side, m, n, & - A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZdgmmStridedBatched') + A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZdgmmStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmmStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(c_int), value :: m @@ -11481,12 +11684,12 @@ end function hipblasZdgmmStridedBatched ! geam interface function hipblasSgeam(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasSgeam') + A, lda, beta, B, ldb, C, ldc) & + bind(c, name='hipblasSgeam') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeam type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11505,12 +11708,12 @@ end function hipblasSgeam interface function hipblasDgeam(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasDgeam') + A, lda, beta, B, ldb, C, ldc) & + bind(c, name='hipblasDgeam') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeam type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11529,12 +11732,12 @@ end function hipblasDgeam interface function hipblasCgeam(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasCgeam') + A, lda, beta, B, ldb, C, ldc) & + bind(c, name='hipblasCgeam') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeam type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11553,12 +11756,12 @@ end function hipblasCgeam interface function hipblasZgeam(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc) & - result(c_int) & - bind(c, name = 'hipblasZgeam') + A, lda, beta, B, ldb, C, ldc) & + bind(c, name='hipblasZgeam') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeam type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11578,12 +11781,12 @@ end function hipblasZgeam ! geamBatched interface function hipblasSgeamBatched(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgeamBatched') + A, lda, beta, B, ldb, C, ldc, batch_count) & + bind(c, name='hipblasSgeamBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeamBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11603,12 +11806,12 @@ end function hipblasSgeamBatched interface function hipblasDgeamBatched(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgeamBatched') + A, lda, beta, B, ldb, C, ldc, batch_count) & + bind(c, name='hipblasDgeamBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeamBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11628,12 +11831,12 @@ end function hipblasDgeamBatched interface function hipblasCgeamBatched(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgeamBatched') + A, lda, beta, B, ldb, C, ldc, batch_count) & + bind(c, name='hipblasCgeamBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeamBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11653,12 +11856,12 @@ end function hipblasCgeamBatched interface function hipblasZgeamBatched(handle, transA, transB, m, n, alpha, & - A, lda, beta, B, ldb, C, ldc, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgeamBatched') + A, lda, beta, B, ldb, C, ldc, batch_count) & + bind(c, name='hipblasZgeamBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeamBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11679,12 +11882,12 @@ end function hipblasZgeamBatched ! geamStridedBatched interface function hipblasSgeamStridedBatched(handle, transA, transB, m, n, alpha, & - A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgeamStridedBatched') + A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasSgeamStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeamStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11707,12 +11910,12 @@ end function hipblasSgeamStridedBatched interface function hipblasDgeamStridedBatched(handle, transA, transB, m, n, alpha, & - A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgeamStridedBatched') + A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasDgeamStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeamStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11735,12 +11938,12 @@ end function hipblasDgeamStridedBatched interface function hipblasCgeamStridedBatched(handle, transA, transB, m, n, alpha, & - A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgeamStridedBatched') + A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasCgeamStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeamStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11763,12 +11966,12 @@ end function hipblasCgeamStridedBatched interface function hipblasZgeamStridedBatched(handle, transA, transB, m, n, alpha, & - A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgeamStridedBatched') + A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count) & + bind(c, name='hipblasZgeamStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeamStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11796,13 +11999,13 @@ end function hipblasZgeamStridedBatched ! gemmEx interface function hipblasGemmEx(handle, transA, transB, m, n, k, alpha, a, a_type, lda, & - b, b_type, ldb, beta, c, c_type, ldc,& - compute_type, algo, solution_index, flags) & - result(c_int) & - bind(c, name = 'hipblasGemmEx') + b, b_type, ldb, beta, c, c_type, ldc, & + compute_type, algo, solution_index, flags) & + bind(c, name='hipblasGemmEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGemmEx type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11831,13 +12034,13 @@ end function hipblasGemmEx interface function hipblasGemmBatchedEx(handle, transA, transB, m, n, k, alpha, a, a_type, lda, & - b, b_type, ldb, beta, c, c_type, ldc,& - batch_count, compute_type, algo, solution_index, flags) & - result(c_int) & - bind(c, name = 'hipblasGemmBatchedEx') + b, b_type, ldb, beta, c, c_type, ldc, & + batch_count, compute_type, algo, solution_index, flags) & + bind(c, name='hipblasGemmBatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGemmBatchedEx type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11867,13 +12070,13 @@ end function hipblasGemmBatchedEx interface function hipblasGemmStridedBatchedEx(handle, transA, transB, m, n, k, alpha, a, a_type, lda, stride_a, & - b, b_type, ldb, stride_b, beta, c, c_type, ldc, stride_c,& - batch_count, compute_type, algo, solution_index, flags) & - result(c_int) & - bind(c, name = 'hipblasGemmStridedBatchedEx') + b, b_type, ldb, stride_b, beta, c, c_type, ldc, stride_c, & + batch_count, compute_type, algo, solution_index, flags) & + bind(c, name='hipblasGemmStridedBatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGemmStridedBatchedEx type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: transA integer(kind(HIPBLAS_OP_N)), value :: transB @@ -11907,12 +12110,12 @@ end function hipblasGemmStridedBatchedEx ! trsmEx interface function hipblasTrsmEx(handle, side, uplo, transA, diag, m, n, alpha, A, lda, & - B, ldb, invA, invA_size, compute_type) & - result(c_int) & - bind(c, name = 'hipblasTrsmEx') + B, ldb, invA, invA_size, compute_type) & + bind(c, name='hipblasTrsmEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasTrsmEx type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)), value :: uplo @@ -11933,12 +12136,12 @@ end function hipblasTrsmEx interface function hipblasTrsmBatchedEx(handle, side, uplo, transA, diag, m, n, alpha, A, lda, & - B, ldb, batch_count, invA, invA_size, compute_type) & - result(c_int) & - bind(c, name = 'hipblasTrsmBatchedEx') + B, ldb, batch_count, invA, invA_size, compute_type) & + bind(c, name='hipblasTrsmBatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasTrsmBatchedEx type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)), value :: uplo @@ -11960,12 +12163,12 @@ end function hipblasTrsmBatchedEx interface function hipblasTrsmStridedBatchedEx(handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, & - B, ldb, stride_B, batch_count, invA, invA_size, stride_invA, compute_type) & - result(c_int) & - bind(c, name = 'hipblasTrsmStridedBatchedEx') + B, ldb, stride_B, batch_count, invA, invA_size, stride_invA, compute_type) & + bind(c, name='hipblasTrsmStridedBatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasTrsmStridedBatchedEx type(c_ptr), value :: handle integer(kind(HIPBLAS_SIDE_LEFT)), value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)), value :: uplo @@ -11991,11 +12194,11 @@ end function hipblasTrsmStridedBatchedEx ! ! syrkEx ! interface ! function hipblasCsyrkEx(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C, Ctype, ldc) & - ! result(c_int) & - ! bind(c, name = 'hipblasCsyrkEx') + ! ! bind(c, name = 'hipblasCsyrkEx') ! use iso_c_binding ! use hipblas_enums ! implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkEx ! type(c_ptr), value :: handle ! integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo ! integer(kind(HIPBLAS_OP_N)), value :: trans @@ -12015,11 +12218,11 @@ end function hipblasTrsmStridedBatchedEx ! ! herkEx ! interface ! function hipblasCherkEx(handle, uplo, trans, n, k, alpha, A, Atype, lda, beta, C, Ctype, ldc) & - ! result(c_int) & - ! bind(c, name = 'hipblasCherkEx') + ! ! bind(c, name = 'hipblasCherkEx') ! use iso_c_binding ! use hipblas_enums ! implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkEx ! type(c_ptr), value :: handle ! integer(kind(HIPBLAS_FILL_MODE_FULL)), value :: uplo ! integer(kind(HIPBLAS_OP_N)), value :: trans @@ -12039,11 +12242,11 @@ end function hipblasTrsmStridedBatchedEx ! axpyEx interface function hipblasAxpyEx(handle, n, alpha, alphaType, x, xType, incx, y, yType, incy, executionType) & - result(c_int) & - bind(c, name = 'hipblasAxpyEx') + bind(c, name='hipblasAxpyEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasAxpyEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -12060,12 +12263,12 @@ end function hipblasAxpyEx interface function hipblasAxpyBatchedEx(handle, n, alpha, alphaType, x, xType, incx, & - y, yType, incy, batch_count, executionType) & - result(c_int) & - bind(c, name = 'hipblasAxpyBatchedEx') + y, yType, incy, batch_count, executionType) & + bind(c, name='hipblasAxpyBatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasAxpyBatchedEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -12083,12 +12286,12 @@ end function hipblasAxpyBatchedEx interface function hipblasAxpyStridedBatchedEx(handle, n, alpha, alphaType, x, xType, incx, stridex, & - y, yType, incy, stridey, batch_count, executionType) & - result(c_int) & - bind(c, name = 'hipblasAxpyStridedBatchedEx') + y, yType, incy, stridey, batch_count, executionType) & + bind(c, name='hipblasAxpyStridedBatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasAxpyStridedBatchedEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -12109,11 +12312,11 @@ end function hipblasAxpyStridedBatchedEx ! dotEx interface function hipblasDotEx(handle, n, x, xType, incx, y, yType, incy, result, resultType, executionType) & - result(c_int) & - bind(c, name = 'hipblasDotEx') + bind(c, name='hipblasDotEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12130,11 +12333,11 @@ end function hipblasDotEx interface function hipblasDotcEx(handle, n, x, xType, incx, y, yType, incy, result, resultType, executionType) & - result(c_int) & - bind(c, name = 'hipblasDotcEx') + bind(c, name='hipblasDotcEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotcEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12151,12 +12354,12 @@ end function hipblasDotcEx interface function hipblasDotBatchedEx(handle, n, x, xType, incx, & - y, yType, incy, batch_count, result, resultType, executionType) & - result(c_int) & - bind(c, name = 'hipblasDotBatchedEx') + y, yType, incy, batch_count, result, resultType, executionType) & + bind(c, name='hipblasDotBatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotBatchedEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12174,12 +12377,12 @@ end function hipblasDotBatchedEx interface function hipblasDotcBatchedEx(handle, n, x, xType, incx, & - y, yType, incy, batch_count, result, resultType, executionType) & - result(c_int) & - bind(c, name = 'hipblasDotcBatchedEx') + y, yType, incy, batch_count, result, resultType, executionType) & + bind(c, name='hipblasDotcBatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotcBatchedEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12197,12 +12400,12 @@ end function hipblasDotcBatchedEx interface function hipblasDotStridedBatchedEx(handle, n, x, xType, incx, stridex, & - y, yType, incy, stridey, batch_count, result, resultType, executionType) & - result(c_int) & - bind(c, name = 'hipblasDotStridedBatchedEx') + y, yType, incy, stridey, batch_count, result, resultType, executionType) & + bind(c, name='hipblasDotStridedBatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotStridedBatchedEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12222,12 +12425,12 @@ end function hipblasDotStridedBatchedEx interface function hipblasDotcStridedBatchedEx(handle, n, x, xType, incx, stridex, & - y, yType, incy, stridey, batch_count, result, resultType, executionType) & - result(c_int) & - bind(c, name = 'hipblasDotcStridedBatchedEx') + y, yType, incy, stridey, batch_count, result, resultType, executionType) & + bind(c, name='hipblasDotcStridedBatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotcStridedBatchedEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12248,11 +12451,11 @@ end function hipblasDotcStridedBatchedEx ! nrm2Ex interface function hipblasNrm2Ex(handle, n, x, xType, incx, result, resultType, executionType) & - result(c_int) & - bind(c, name = 'hipblasNrm2Ex') + bind(c, name='hipblasNrm2Ex') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasNrm2Ex type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12266,12 +12469,12 @@ end function hipblasNrm2Ex interface function hipblasNrm2BatchedEx(handle, n, x, xType, incx, & - batch_count, result, resultType, executionType) & - result(c_int) & - bind(c, name = 'hipblasNrm2BatchedEx') + batch_count, result, resultType, executionType) & + bind(c, name='hipblasNrm2BatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasNrm2BatchedEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12286,12 +12489,12 @@ end function hipblasNrm2BatchedEx interface function hipblasNrm2StridedBatchedEx(handle, n, x, xType, incx, stridex, & - batch_count, result, resultType, executionType) & - result(c_int) & - bind(c, name = 'hipblasNrm2StridedBatchedEx') + batch_count, result, resultType, executionType) & + bind(c, name='hipblasNrm2StridedBatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasNrm2StridedBatchedEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12308,11 +12511,11 @@ end function hipblasNrm2StridedBatchedEx ! rotEx interface function hipblasRotEx(handle, n, x, xType, incx, y, yType, incy, c, s, csType, executionType) & - result(c_int) & - bind(c, name = 'hipblasRotEx') + bind(c, name='hipblasRotEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasRotEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12330,12 +12533,12 @@ end function hipblasRotEx interface function hipblasRotBatchedEx(handle, n, x, xType, incx, & - y, yType, incy, c, s, csType, batch_count, executionType) & - result(c_int) & - bind(c, name = 'hipblasRotBatchedEx') + y, yType, incy, c, s, csType, batch_count, executionType) & + bind(c, name='hipblasRotBatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasRotBatchedEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12354,12 +12557,12 @@ end function hipblasRotBatchedEx interface function hipblasRotStridedBatchedEx(handle, n, x, xType, incx, stridex, & - y, yType, incy, stridey, c, s, csType, batch_count, executionType) & - result(c_int) & - bind(c, name = 'hipblasRotStridedBatchedEx') + y, yType, incy, stridey, c, s, csType, batch_count, executionType) & + bind(c, name='hipblasRotStridedBatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasRotStridedBatchedEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: x @@ -12381,11 +12584,11 @@ end function hipblasRotStridedBatchedEx ! scalEx interface function hipblasScalEx(handle, n, alpha, alphaType, x, xType, incx, executionType) & - result(c_int) & - bind(c, name = 'hipblasScalEx') + bind(c, name='hipblasScalEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScalEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -12399,12 +12602,12 @@ end function hipblasScalEx interface function hipblasScalBatchedEx(handle, n, alpha, alphaType, x, xType, incx, & - batch_count, executionType) & - result(c_int) & - bind(c, name = 'hipblasScalBatchedEx') + batch_count, executionType) & + bind(c, name='hipblasScalBatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScalBatchedEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -12419,12 +12622,12 @@ end function hipblasScalBatchedEx interface function hipblasScalStridedBatchedEx(handle, n, alpha, alphaType, x, xType, incx, stridex, & - batch_count, executionType) & - result(c_int) & - bind(c, name = 'hipblasScalStridedBatchedEx') + batch_count, executionType) & + bind(c, name='hipblasScalStridedBatchedEx') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScalStridedBatchedEx type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: alpha @@ -12445,11 +12648,11 @@ end function hipblasScalStridedBatchedEx ! getrf interface function hipblasSgetrf(handle, n, A, lda, ipiv, info) & - result(c_int) & - bind(c, name = 'hipblasSgetrf') + bind(c, name='hipblasSgetrf') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrf type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -12461,11 +12664,11 @@ end function hipblasSgetrf interface function hipblasDgetrf(handle, n, A, lda, ipiv, info) & - result(c_int) & - bind(c, name = 'hipblasDgetrf') + bind(c, name='hipblasDgetrf') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrf type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -12477,11 +12680,11 @@ end function hipblasDgetrf interface function hipblasCgetrf(handle, n, A, lda, ipiv, info) & - result(c_int) & - bind(c, name = 'hipblasCgetrf') + bind(c, name='hipblasCgetrf') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrf type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -12493,11 +12696,11 @@ end function hipblasCgetrf interface function hipblasZgetrf(handle, n, A, lda, ipiv, info) & - result(c_int) & - bind(c, name = 'hipblasZgetrf') + bind(c, name='hipblasZgetrf') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrf type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -12510,11 +12713,11 @@ end function hipblasZgetrf ! getrf_batched interface function hipblasSgetrfBatched(handle, n, A, lda, ipiv, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgetrfBatched') + bind(c, name='hipblasSgetrfBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrfBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -12527,11 +12730,11 @@ end function hipblasSgetrfBatched interface function hipblasDgetrfBatched(handle, n, A, lda, ipiv, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgetrfBatched') + bind(c, name='hipblasDgetrfBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrfBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -12544,11 +12747,11 @@ end function hipblasDgetrfBatched interface function hipblasCgetrfBatched(handle, n, A, lda, ipiv, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgetrfBatched') + bind(c, name='hipblasCgetrfBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrfBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -12561,11 +12764,11 @@ end function hipblasCgetrfBatched interface function hipblasZgetrfBatched(handle, n, A, lda, ipiv, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgetrfBatched') + bind(c, name='hipblasZgetrfBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrfBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -12578,13 +12781,13 @@ end function hipblasZgetrfBatched ! getrf_strided_batched interface - function hipblasSgetrfStridedBatched(handle, n, A, lda, stride_A,& - ipiv, stride_P, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgetrfStridedBatched') + function hipblasSgetrfStridedBatched(handle, n, A, lda, stride_A, & + ipiv, stride_P, info, batch_count) & + bind(c, name='hipblasSgetrfStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrfStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -12598,13 +12801,13 @@ end function hipblasSgetrfStridedBatched end interface interface - function hipblasDgetrfStridedBatched(handle, n, A, lda, stride_A,& - ipiv, stride_P, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgetrfStridedBatched') + function hipblasDgetrfStridedBatched(handle, n, A, lda, stride_A, & + ipiv, stride_P, info, batch_count) & + bind(c, name='hipblasDgetrfStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrfStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -12618,13 +12821,13 @@ end function hipblasDgetrfStridedBatched end interface interface - function hipblasCgetrfStridedBatched(handle, n, A, lda, stride_A,& - ipiv, stride_P, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgetrfStridedBatched') + function hipblasCgetrfStridedBatched(handle, n, A, lda, stride_A, & + ipiv, stride_P, info, batch_count) & + bind(c, name='hipblasCgetrfStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrfStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -12638,13 +12841,13 @@ end function hipblasCgetrfStridedBatched end interface interface - function hipblasZgetrfStridedBatched(handle, n, A, lda, stride_A,& - ipiv, stride_P, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgetrfStridedBatched') + function hipblasZgetrfStridedBatched(handle, n, A, lda, stride_A, & + ipiv, stride_P, info, batch_count) & + bind(c, name='hipblasZgetrfStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrfStridedBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -12659,13 +12862,13 @@ end function hipblasZgetrfStridedBatched ! getrs interface - function hipblasSgetrs(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info) & - result(c_int) & - bind(c, name = 'hipblasSgetrs') + function hipblasSgetrs(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info) & + bind(c, name='hipblasSgetrs') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrs type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -12680,13 +12883,13 @@ end function hipblasSgetrs end interface interface - function hipblasDgetrs(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info) & - result(c_int) & - bind(c, name = 'hipblasDgetrs') + function hipblasDgetrs(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info) & + bind(c, name='hipblasDgetrs') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrs type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -12701,13 +12904,13 @@ end function hipblasDgetrs end interface interface - function hipblasCgetrs(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info) & - result(c_int) & - bind(c, name = 'hipblasCgetrs') + function hipblasCgetrs(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info) & + bind(c, name='hipblasCgetrs') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrs type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -12722,13 +12925,13 @@ end function hipblasCgetrs end interface interface - function hipblasZgetrs(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info) & - result(c_int) & - bind(c, name = 'hipblasZgetrs') + function hipblasZgetrs(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info) & + bind(c, name='hipblasZgetrs') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrs type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -12744,13 +12947,13 @@ end function hipblasZgetrs ! getrs_batched interface - function hipblasSgetrsBatched(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgetrsBatched') + function hipblasSgetrsBatched(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info, batch_count) & + bind(c, name='hipblasSgetrsBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrsBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -12766,13 +12969,13 @@ end function hipblasSgetrsBatched end interface interface - function hipblasDgetrsBatched(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgetrsBatched') + function hipblasDgetrsBatched(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info, batch_count) & + bind(c, name='hipblasDgetrsBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrsBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -12788,13 +12991,13 @@ end function hipblasDgetrsBatched end interface interface - function hipblasCgetrsBatched(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgetrsBatched') + function hipblasCgetrsBatched(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info, batch_count) & + bind(c, name='hipblasCgetrsBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrsBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -12810,13 +13013,13 @@ end function hipblasCgetrsBatched end interface interface - function hipblasZgetrsBatched(handle, trans, n, nrhs, A, lda, ipiv,& - B, ldb, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgetrsBatched') + function hipblasZgetrsBatched(handle, trans, n, nrhs, A, lda, ipiv, & + B, ldb, info, batch_count) & + bind(c, name='hipblasZgetrsBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrsBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -12833,13 +13036,13 @@ end function hipblasZgetrsBatched ! getrs_strided_batched interface - function hipblasSgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A, ipiv,& - stride_P, B, ldb, stride_B, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgetrsStridedBatched') + function hipblasSgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A, ipiv, & + stride_P, B, ldb, stride_B, info, batch_count) & + bind(c, name='hipblasSgetrsStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrsStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -12858,13 +13061,13 @@ end function hipblasSgetrsStridedBatched end interface interface - function hipblasDgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A, ipiv,& - stride_P, B, ldb, stride_B, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgetrsStridedBatched') + function hipblasDgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A, ipiv, & + stride_P, B, ldb, stride_B, info, batch_count) & + bind(c, name='hipblasDgetrsStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrsStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -12883,13 +13086,13 @@ end function hipblasDgetrsStridedBatched end interface interface - function hipblasCgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A, ipiv,& - stride_P, B, ldb, stride_B, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgetrsStridedBatched') + function hipblasCgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A, ipiv, & + stride_P, B, ldb, stride_B, info, batch_count) & + bind(c, name='hipblasCgetrsStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrsStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -12908,13 +13111,13 @@ end function hipblasCgetrsStridedBatched end interface interface - function hipblasZgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A, ipiv,& - stride_P, B, ldb, stride_B, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgetrsStridedBatched') + function hipblasZgetrsStridedBatched(handle, trans, n, nrhs, A, lda, stride_A, ipiv, & + stride_P, B, ldb, stride_B, info, batch_count) & + bind(c, name='hipblasZgetrsStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrsStridedBatched type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: n @@ -12935,11 +13138,11 @@ end function hipblasZgetrsStridedBatched ! getri_batched interface function hipblasSgetriBatched(handle, n, A, lda, ipiv, C, ldc, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgetriBatched') + bind(c, name='hipblasSgetriBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetriBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -12954,11 +13157,11 @@ end function hipblasSgetriBatched interface function hipblasDgetriBatched(handle, n, A, lda, ipiv, C, ldc, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgetriBatched') + bind(c, name='hipblasDgetriBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetriBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -12973,11 +13176,11 @@ end function hipblasDgetriBatched interface function hipblasCgetriBatched(handle, n, A, lda, ipiv, C, ldc, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgetriBatched') + bind(c, name='hipblasCgetriBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetriBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -12992,11 +13195,11 @@ end function hipblasCgetriBatched interface function hipblasZgetriBatched(handle, n, A, lda, ipiv, C, ldc, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgetriBatched') + bind(c, name='hipblasZgetriBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetriBatched type(c_ptr), value :: handle integer(c_int), value :: n type(c_ptr), value :: A @@ -13012,11 +13215,11 @@ end function hipblasZgetriBatched ! geqrf interface function hipblasSgeqrf(handle, m, n, A, lda, tau, info) & - result(c_int) & - bind(c, name = 'hipblasSgeqrf') + bind(c, name='hipblasSgeqrf') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeqrf type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -13029,11 +13232,11 @@ end function hipblasSgeqrf interface function hipblasDgeqrf(handle, m, n, A, lda, tau, info) & - result(c_int) & - bind(c, name = 'hipblasDgeqrf') + bind(c, name='hipblasDgeqrf') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeqrf type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -13046,11 +13249,11 @@ end function hipblasDgeqrf interface function hipblasCgeqrf(handle, m, n, A, lda, tau, info) & - result(c_int) & - bind(c, name = 'hipblasCgeqrf') + bind(c, name='hipblasCgeqrf') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeqrf type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -13063,11 +13266,11 @@ end function hipblasCgeqrf interface function hipblasZgeqrf(handle, m, n, A, lda, tau, info) & - result(c_int) & - bind(c, name = 'hipblasZgeqrf') + bind(c, name='hipblasZgeqrf') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeqrf type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -13081,11 +13284,11 @@ end function hipblasZgeqrf ! geqrf_batched interface function hipblasSgeqrfBatched(handle, m, n, A, lda, tau, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgeqrfBatched') + bind(c, name='hipblasSgeqrfBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeqrfBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -13099,11 +13302,11 @@ end function hipblasSgeqrfBatched interface function hipblasDgeqrfBatched(handle, m, n, A, lda, tau, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgeqrfBatched') + bind(c, name='hipblasDgeqrfBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeqrfBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -13117,11 +13320,11 @@ end function hipblasDgeqrfBatched interface function hipblasCgeqrfBatched(handle, m, n, A, lda, tau, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgeqrfBatched') + bind(c, name='hipblasCgeqrfBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeqrfBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -13135,11 +13338,11 @@ end function hipblasCgeqrfBatched interface function hipblasZgeqrfBatched(handle, m, n, A, lda, tau, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgeqrfBatched') + bind(c, name='hipblasZgeqrfBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeqrfBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -13153,13 +13356,13 @@ end function hipblasZgeqrfBatched ! geqrf_strided_batched interface - function hipblasSgeqrfStridedBatched(handle, m, n, A, lda, stride_A,& - tau, stride_T, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasSgeqrfStridedBatched') + function hipblasSgeqrfStridedBatched(handle, m, n, A, lda, stride_A, & + tau, stride_T, info, batch_count) & + bind(c, name='hipblasSgeqrfStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeqrfStridedBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -13174,34 +13377,34 @@ end function hipblasSgeqrfStridedBatched end interface interface - function hipblasDgeqrfStridedBatched(handle, m, n, A, lda, stride_A,& - tau, stride_T, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasDgeqrfStridedBatched') - use iso_c_binding - use hipblas_enums - implicit none - type(c_ptr), value :: handle - integer(c_int), value :: m - integer(c_int), value :: n - type(c_ptr), value :: A - integer(c_int), value :: lda - integer(c_int), value :: stride_A - type(c_ptr), value :: tau - integer(c_int), value :: stride_T - type(c_ptr), value :: info - integer(c_int), value :: batch_count - end function hipblasDgeqrfStridedBatched + function hipblasDgeqrfStridedBatched(handle, m, n, A, lda, stride_A, & + tau, stride_T, info, batch_count) & + bind(c, name='hipblasDgeqrfStridedBatched') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeqrfStridedBatched + type(c_ptr), value :: handle + integer(c_int), value :: m + integer(c_int), value :: n + type(c_ptr), value :: A + integer(c_int), value :: lda + integer(c_int), value :: stride_A + type(c_ptr), value :: tau + integer(c_int), value :: stride_T + type(c_ptr), value :: info + integer(c_int), value :: batch_count + end function hipblasDgeqrfStridedBatched end interface interface - function hipblasCgeqrfStridedBatched(handle, m, n, A, lda, stride_A,& - tau, stride_T, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasCgeqrfStridedBatched') + function hipblasCgeqrfStridedBatched(handle, m, n, A, lda, stride_A, & + tau, stride_T, info, batch_count) & + bind(c, name='hipblasCgeqrfStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeqrfStridedBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -13216,13 +13419,13 @@ end function hipblasCgeqrfStridedBatched end interface interface - function hipblasZgeqrfStridedBatched(handle, m, n, A, lda, stride_A,& - tau, stride_T, info, batch_count) & - result(c_int) & - bind(c, name = 'hipblasZgeqrfStridedBatched') + function hipblasZgeqrfStridedBatched(handle, m, n, A, lda, stride_A, & + tau, stride_T, info, batch_count) & + bind(c, name='hipblasZgeqrfStridedBatched') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeqrfStridedBatched type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n @@ -13239,11 +13442,11 @@ end function hipblasZgeqrfStridedBatched ! gels interface function hipblasSgels(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo) & - result(c_int) & - bind(c, name = 'hipblasSgels') + bind(c, name='hipblasSgels') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgels type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -13260,11 +13463,11 @@ end function hipblasSgels interface function hipblasDgels(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo) & - result(c_int) & - bind(c, name = 'hipblasDgels') + bind(c, name='hipblasDgels') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgels type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -13281,11 +13484,11 @@ end function hipblasDgels interface function hipblasCgels(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo) & - result(c_int) & - bind(c, name = 'hipblasCgels') + bind(c, name='hipblasCgels') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgels type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m @@ -13302,11 +13505,11 @@ end function hipblasCgels interface function hipblasZgels(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo) & - result(c_int) & - bind(c, name = 'hipblasZgels') + bind(c, name='hipblasZgels') use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgels type(c_ptr), value :: handle integer(kind(HIPBLAS_OP_N)), value :: trans integer(c_int), value :: m From 8958d92c4de63d964f95d9eec06e7b51cc228836 Mon Sep 17 00:00:00 2001 From: Torre Zuk Date: Tue, 12 Jul 2022 14:04:28 -0600 Subject: [PATCH 05/12] missed one func --- clients/include/hipblas_fortran_solver.f90 | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/clients/include/hipblas_fortran_solver.f90 b/clients/include/hipblas_fortran_solver.f90 index 8fb37d105..ac011fc9a 100644 --- a/clients/include/hipblas_fortran_solver.f90 +++ b/clients/include/hipblas_fortran_solver.f90 @@ -795,8 +795,9 @@ function hipblasDgeqrfStridedBatchedFortran(handle, m, n, A, lda, stride_A, & integer(c_int), value :: stride_T type(c_ptr), value :: info integer(c_int), value :: batch_count - res = hipblasDgeqrfStridedBatched(handle, m, n, A, lda, stride_A, & - tau, stride_T, info, batch_count) + hipblasDgeqrfStridedBatchedFortran = & + hipblasDgeqrfStridedBatched(handle, m, n, A, lda, stride_A, & + tau, stride_T, info, batch_count) end function hipblasDgeqrfStridedBatchedFortran function hipblasCgeqrfStridedBatchedFortran(handle, m, n, A, lda, stride_A, & From 80fe3a13d763383ac1762049aafe2f95db95c194 Mon Sep 17 00:00:00 2001 From: Torre Zuk Date: Tue, 12 Jul 2022 14:47:09 -0600 Subject: [PATCH 06/12] fix stubborn function --- clients/include/hipblas_fortran_solver.f90 | 1 + 1 file changed, 1 insertion(+) diff --git a/clients/include/hipblas_fortran_solver.f90 b/clients/include/hipblas_fortran_solver.f90 index ac011fc9a..db6a522e8 100644 --- a/clients/include/hipblas_fortran_solver.f90 +++ b/clients/include/hipblas_fortran_solver.f90 @@ -785,6 +785,7 @@ function hipblasDgeqrfStridedBatchedFortran(handle, m, n, A, lda, stride_A, & use iso_c_binding use hipblas_enums implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeqrfStridedBatchedFortran type(c_ptr), value :: handle integer(c_int), value :: m integer(c_int), value :: n From 0041ac3f76167ff13ff16c13ce6d607933d11af3 Mon Sep 17 00:00:00 2001 From: daineAMD Date: Tue, 12 Jul 2022 15:21:59 -0600 Subject: [PATCH 07/12] Adding codeowners --- .github/CODEOWNERS | 1 + 1 file changed, 1 insertion(+) create mode 100644 .github/CODEOWNERS diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 000000000..b542ef64a --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1 @@ +* @amcamd @TorreZuk @mahmoodw @daineAMD @bragadeesh @NaveenElumalaiAMD @rkamd From b8909251ff6dd7d551d9f5734d1b450f98e2c9ed Mon Sep 17 00:00:00 2001 From: Daine McNiven <51674140+daineAMD@users.noreply.github.com> Date: Wed, 13 Jul 2022 18:47:24 -0700 Subject: [PATCH 08/12] Adding gelsBatched and gelsStridedBatched (#508) --- clients/benchmarks/client.cpp | 6 + .../hipblas_template_specialization.cpp | 308 ++++++++++++ clients/gtest/CMakeLists.txt | 2 + clients/gtest/gels_batched_gtest.cpp | 185 +++++++ clients/gtest/gels_strided_batched_gtest.cpp | 194 +++++++ clients/include/hipblas.hpp | 30 ++ clients/include/hipblas_fortran.hpp | 114 +++++ clients/include/hipblas_fortran_solver.f90 | 199 ++++++++ clients/include/hipblas_no_fortran.hpp | 8 + clients/include/testing_gels.hpp | 9 +- clients/include/testing_gels_batched.hpp | 195 +++++++ .../include/testing_gels_strided_batched.hpp | 213 ++++++++ library/include/hipblas.h | 272 +++++++++- library/src/hcc_detail/hipblas.cpp | 475 +++++++++++++++++- library/src/hipblas_module.f90 | 198 +++++++- library/src/nvcc_detail/hipblas.cpp | 207 ++++++++ 16 files changed, 2598 insertions(+), 17 deletions(-) create mode 100644 clients/gtest/gels_batched_gtest.cpp create mode 100644 clients/gtest/gels_strided_batched_gtest.cpp create mode 100644 clients/include/testing_gels_batched.hpp create mode 100644 clients/include/testing_gels_strided_batched.hpp diff --git a/clients/benchmarks/client.cpp b/clients/benchmarks/client.cpp index 272e3586e..dd64cf184 100644 --- a/clients/benchmarks/client.cpp +++ b/clients/benchmarks/client.cpp @@ -220,6 +220,8 @@ // solver functions #ifdef __HIP_PLATFORM_SOLVER__ #include "testing_gels.hpp" +#include "testing_gels_batched.hpp" +#include "testing_gels_strided_batched.hpp" #include "testing_geqrf.hpp" #include "testing_geqrf_batched.hpp" #include "testing_geqrf_strided_batched.hpp" @@ -514,6 +516,8 @@ struct perf_blas{} || std::is_same {"getrs_batched", testing_getrs_batched}, {"getrs_strided_batched", testing_getrs_strided_batched}, {"gels", testing_gels}, + {"gels_batched", testing_gels_batched}, + {"gels_strided_batched", testing_gels_strided_batched}, #endif // Aux @@ -735,6 +739,8 @@ struct perf_blas< {"getrs_batched", testing_getrs_batched}, {"getrs_strided_batched", testing_getrs_strided_batched}, {"gels", testing_gels}, + {"gels_batched", testing_gels_batched}, + {"gels_strided_batched", testing_gels_strided_batched}, #endif }; run_function(map, arg); diff --git a/clients/common/hipblas_template_specialization.cpp b/clients/common/hipblas_template_specialization.cpp index 79e523ec0..940d01fdb 100644 --- a/clients/common/hipblas_template_specialization.cpp +++ b/clients/common/hipblas_template_specialization.cpp @@ -10175,6 +10175,160 @@ hipblasStatus_t hipblasGels(hipblasHandle_t handle, return hipblasZgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo); } +// gelsBatched +template <> +hipblasStatus_t hipblasGelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* const A[], + const int lda, + float* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasSgelsBatched( + handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo, batchCount); +} + +template <> +hipblasStatus_t hipblasGelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* const A[], + const int lda, + double* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasDgelsBatched( + handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo, batchCount); +} + +template <> +hipblasStatus_t hipblasGelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* const A[], + const int lda, + hipblasComplex* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasCgelsBatched( + handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo, batchCount); +} + +template <> +hipblasStatus_t hipblasGelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* const A[], + const int lda, + hipblasDoubleComplex* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasZgelsBatched( + handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo, batchCount); +} + +// gelsStridedBatched +template <> +hipblasStatus_t hipblasGelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* A, + const int lda, + const hipblasStride strideA, + float* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasSgelsStridedBatched( + handle, trans, m, n, nrhs, A, lda, strideA, B, ldb, strideB, info, deviceInfo, batchCount); +} + +template <> +hipblasStatus_t hipblasGelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* A, + const int lda, + const hipblasStride strideA, + double* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasDgelsStridedBatched( + handle, trans, m, n, nrhs, A, lda, strideA, B, ldb, strideB, info, deviceInfo, batchCount); +} + +template <> +hipblasStatus_t hipblasGelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* A, + const int lda, + const hipblasStride strideA, + hipblasComplex* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasCgelsStridedBatched( + handle, trans, m, n, nrhs, A, lda, strideA, B, ldb, strideB, info, deviceInfo, batchCount); +} + +template <> +hipblasStatus_t hipblasGelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* A, + const int lda, + const hipblasStride strideA, + hipblasDoubleComplex* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasZgelsStridedBatched( + handle, trans, m, n, nrhs, A, lda, strideA, B, ldb, strideB, info, deviceInfo, batchCount); +} + #endif ///////////// @@ -20427,4 +20581,158 @@ hipblasStatus_t hipblasGels(hipblasHandle_t ha return hipblasZgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo); } +// gelsBatched +template <> +hipblasStatus_t hipblasGelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* const A[], + const int lda, + float* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasSgelsBatchedFortran( + handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo, batchCount); +} + +template <> +hipblasStatus_t hipblasGelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* const A[], + const int lda, + double* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasDgelsBatchedFortran( + handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo, batchCount); +} + +template <> +hipblasStatus_t hipblasGelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* const A[], + const int lda, + hipblasComplex* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasCgelsBatchedFortran( + handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo, batchCount); +} + +template <> +hipblasStatus_t hipblasGelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* const A[], + const int lda, + hipblasDoubleComplex* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasZgelsBatchedFortran( + handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo, batchCount); +} + +// gelsStridedBatched +template <> +hipblasStatus_t hipblasGelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* A, + const int lda, + const hipblasStride strideA, + float* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasSgelsStridedBatchedFortran( + handle, trans, m, n, nrhs, A, lda, strideA, B, ldb, strideB, info, deviceInfo, batchCount); +} + +template <> +hipblasStatus_t hipblasGelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* A, + const int lda, + const hipblasStride strideA, + double* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasDgelsStridedBatchedFortran( + handle, trans, m, n, nrhs, A, lda, strideA, B, ldb, strideB, info, deviceInfo, batchCount); +} + +template <> +hipblasStatus_t hipblasGelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* A, + const int lda, + const hipblasStride strideA, + hipblasComplex* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasCgelsStridedBatchedFortran( + handle, trans, m, n, nrhs, A, lda, strideA, B, ldb, strideB, info, deviceInfo, batchCount); +} + +template <> +hipblasStatus_t hipblasGelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* A, + const int lda, + const hipblasStride strideA, + hipblasDoubleComplex* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +{ + return hipblasZgelsStridedBatchedFortran( + handle, trans, m, n, nrhs, A, lda, strideA, B, ldb, strideB, info, deviceInfo, batchCount); +} + #endif diff --git a/clients/gtest/CMakeLists.txt b/clients/gtest/CMakeLists.txt index 4b8507d93..b202097e9 100644 --- a/clients/gtest/CMakeLists.txt +++ b/clients/gtest/CMakeLists.txt @@ -106,6 +106,8 @@ if( BUILD_WITH_SOLVER ) geqrf_batched_gtest.cpp geqrf_strided_batched_gtest.cpp gels_gtest.cpp + gels_batched_gtest.cpp + gels_strided_batched_gtest.cpp ) endif( ) diff --git a/clients/gtest/gels_batched_gtest.cpp b/clients/gtest/gels_batched_gtest.cpp new file mode 100644 index 000000000..ad2ec2dab --- /dev/null +++ b/clients/gtest/gels_batched_gtest.cpp @@ -0,0 +1,185 @@ +/* ************************************************************************ + * Copyright (C) 2016-2022 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * ************************************************************************ */ + +#include "testing_gels_batched.hpp" +#include "utility.h" +#include +#include +#include + +using std::vector; +using ::testing::Combine; +using ::testing::TestWithParam; +using ::testing::Values; +using ::testing::ValuesIn; + +typedef std::tuple, char, int, bool> gels_batched_tuple; + +// {m, n, nrhs, lda, ldb} +const vector> matrix_size_range + = {{-1, -1, -1, 1, 1}, {10, 10, 10, 10, 10}, {10, 10, 10, 20, 100}, {600, 500, 400, 600, 600}}; + +const vector trans_range = { + 'N', + // 'T', // commenting this out for now as cuBLAS only supports non-transpose +}; + +const vector batch_count_range = {-1, 0, 1, 2}; + +const vector is_fortran = {false, true}; + +Arguments setup_gels_batched_arguments(gels_batched_tuple tup) +{ + vector matrix_size = std::get<0>(tup); + char trans = std::get<1>(tup); + int batchCount = std::get<2>(tup); + bool fortran = std::get<3>(tup); + + Arguments arg; + + arg.M = matrix_size[0]; + arg.N = matrix_size[1]; + arg.K = matrix_size[2]; // nrhs + arg.lda = matrix_size[3]; + arg.ldb = matrix_size[4]; + + arg.transA_option = trans; + arg.batch_count = batchCount; + + arg.fortran = fortran; + + return arg; +} + +class gels_batched_gtest : public ::TestWithParam +{ +protected: + gels_batched_gtest() {} + virtual ~gels_batched_gtest() {} + virtual void SetUp() {} + virtual void TearDown() {} +}; + +TEST_P(gels_batched_gtest, gels_batched_gtest_float) +{ + // GetParam returns a tuple. The setup routine unpacks the tuple + // and initializes arg(Arguments), which will be passed to testing routine. + + Arguments arg = setup_gels_batched_arguments(GetParam()); + + hipblasStatus_t status = testing_gels_batched(arg); + + if(status != HIPBLAS_STATUS_SUCCESS) + { + if(arg.M < 0 || arg.N < 0 || arg.K < 0 || arg.lda < arg.M || arg.ldb < arg.M + || arg.ldb < arg.N || arg.batch_count < 0) + { + EXPECT_EQ(HIPBLAS_STATUS_INVALID_VALUE, status); + } + else + { + EXPECT_EQ(HIPBLAS_STATUS_SUCCESS, status); // fail + } + } +} + +TEST_P(gels_batched_gtest, gels_batched_gtest_double) +{ + // GetParam returns a tuple. The setup routine unpacks the tuple + // and initializes arg(Arguments), which will be passed to testing routine. + + Arguments arg = setup_gels_batched_arguments(GetParam()); + + hipblasStatus_t status = testing_gels_batched(arg); + + if(status != HIPBLAS_STATUS_SUCCESS) + { + if(arg.M < 0 || arg.N < 0 || arg.K < 0 || arg.lda < arg.M || arg.ldb < arg.M + || arg.ldb < arg.N || arg.batch_count < 0) + { + EXPECT_EQ(HIPBLAS_STATUS_INVALID_VALUE, status); + } + else + { + EXPECT_EQ(HIPBLAS_STATUS_SUCCESS, status); // fail + } + } +} + +TEST_P(gels_batched_gtest, gels_batched_gtest_float_complex) +{ + // GetParam returns a tuple. The setup routine unpacks the tuple + // and initializes arg(Arguments), which will be passed to testing routine. + + Arguments arg = setup_gels_batched_arguments(GetParam()); + + hipblasStatus_t status = testing_gels_batched(arg); + + if(status != HIPBLAS_STATUS_SUCCESS) + { + if(arg.M < 0 || arg.N < 0 || arg.K < 0 || arg.lda < arg.M || arg.ldb < arg.M + || arg.ldb < arg.N || arg.batch_count < 0) + { + EXPECT_EQ(HIPBLAS_STATUS_INVALID_VALUE, status); + } + else + { + EXPECT_EQ(HIPBLAS_STATUS_SUCCESS, status); // fail + } + } +} + +TEST_P(gels_batched_gtest, gels_batched_gtest_double_complex) +{ + // GetParam returns a tuple. The setup routine unpacks the tuple + // and initializes arg(Arguments), which will be passed to testing routine. + + Arguments arg = setup_gels_batched_arguments(GetParam()); + + hipblasStatus_t status = testing_gels_batched(arg); + + if(status != HIPBLAS_STATUS_SUCCESS) + { + if(arg.M < 0 || arg.N < 0 || arg.K < 0 || arg.lda < arg.M || arg.ldb < arg.M + || arg.ldb < arg.N || arg.batch_count < 0) + { + EXPECT_EQ(HIPBLAS_STATUS_INVALID_VALUE, status); + } + else + { + EXPECT_EQ(HIPBLAS_STATUS_SUCCESS, status); // fail + } + } +} + +// notice we are using vector of vector +// so each elment in xxx_range is a vector, +// ValuesIn takes each element (a vector), combines them, and feeds them to test_p +// The combinations are { {M, N, nrhs, lda, ldb}, trans, batchCount, fortran } + +INSTANTIATE_TEST_SUITE_P(hipblasGelsBatched, + gels_batched_gtest, + Combine(ValuesIn(matrix_size_range), + ValuesIn(trans_range), + ValuesIn(batch_count_range), + ValuesIn(is_fortran))); diff --git a/clients/gtest/gels_strided_batched_gtest.cpp b/clients/gtest/gels_strided_batched_gtest.cpp new file mode 100644 index 000000000..71259b221 --- /dev/null +++ b/clients/gtest/gels_strided_batched_gtest.cpp @@ -0,0 +1,194 @@ +/* ************************************************************************ + * Copyright (C) 2016-2022 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * ************************************************************************ */ + +#include "testing_gels_strided_batched.hpp" +#include "utility.h" +#include +#include +#include + +using std::vector; +using ::testing::Combine; +using ::testing::TestWithParam; +using ::testing::Values; +using ::testing::ValuesIn; + +typedef std::tuple, char, double, int, bool> gels_strided_batched_tuple; + +// {m, n, nrhs, lda, ldb} +const vector> matrix_size_range + = {{-1, -1, -1, 1, 1}, {10, 10, 10, 10, 10}, {10, 10, 10, 20, 100}, {600, 500, 400, 600, 600}}; + +const vector trans_range = { + 'N', + 'T', +}; + +const vector stride_scale_range = {2.5}; + +const vector batch_count_range = {-1, 0, 1, 2}; + +const vector is_fortran = {false, true}; + +Arguments setup_gels_strided_batched_arguments(gels_strided_batched_tuple tup) +{ + vector matrix_size = std::get<0>(tup); + char trans = std::get<1>(tup); + double strideScale = std::get<2>(tup); + int batchCount = std::get<3>(tup); + bool fortran = std::get<4>(tup); + + Arguments arg; + + arg.M = matrix_size[0]; + arg.N = matrix_size[1]; + arg.K = matrix_size[2]; // nrhs + arg.lda = matrix_size[3]; + arg.ldb = matrix_size[4]; + + arg.transA_option = trans; + arg.stride_scale = strideScale; + arg.batch_count = batchCount; + + arg.fortran = fortran; + + return arg; +} + +class gels_strided_batched_gtest : public ::TestWithParam +{ +protected: + gels_strided_batched_gtest() {} + virtual ~gels_strided_batched_gtest() {} + virtual void SetUp() {} + virtual void TearDown() {} +}; + +#ifndef __HIP_PLATFORM_NVCC__ + +TEST_P(gels_strided_batched_gtest, gels_strided_batched_gtest_float) +{ + // GetParam returns a tuple. The setup routine unpacks the tuple + // and initializes arg(Arguments), which will be passed to testing routine. + + Arguments arg = setup_gels_strided_batched_arguments(GetParam()); + + hipblasStatus_t status = testing_gels_strided_batched(arg); + + if(status != HIPBLAS_STATUS_SUCCESS) + { + if(arg.M < 0 || arg.N < 0 || arg.K < 0 || arg.lda < arg.M || arg.ldb < arg.M + || arg.ldb < arg.N || arg.batch_count < 0) + { + EXPECT_EQ(HIPBLAS_STATUS_INVALID_VALUE, status); + } + else + { + EXPECT_EQ(HIPBLAS_STATUS_SUCCESS, status); // fail + } + } +} + +TEST_P(gels_strided_batched_gtest, gels_strided_batched_gtest_double) +{ + // GetParam returns a tuple. The setup routine unpacks the tuple + // and initializes arg(Arguments), which will be passed to testing routine. + + Arguments arg = setup_gels_strided_batched_arguments(GetParam()); + + hipblasStatus_t status = testing_gels_strided_batched(arg); + + if(status != HIPBLAS_STATUS_SUCCESS) + { + if(arg.M < 0 || arg.N < 0 || arg.K < 0 || arg.lda < arg.M || arg.ldb < arg.M + || arg.ldb < arg.N || arg.batch_count < 0) + { + EXPECT_EQ(HIPBLAS_STATUS_INVALID_VALUE, status); + } + else + { + EXPECT_EQ(HIPBLAS_STATUS_SUCCESS, status); // fail + } + } +} + +TEST_P(gels_strided_batched_gtest, gels_strided_batched_gtest_float_complex) +{ + // GetParam returns a tuple. The setup routine unpacks the tuple + // and initializes arg(Arguments), which will be passed to testing routine. + + Arguments arg = setup_gels_strided_batched_arguments(GetParam()); + + hipblasStatus_t status = testing_gels_strided_batched(arg); + + if(status != HIPBLAS_STATUS_SUCCESS) + { + if(arg.M < 0 || arg.N < 0 || arg.K < 0 || arg.lda < arg.M || arg.ldb < arg.M + || arg.ldb < arg.N || arg.batch_count < 0) + { + EXPECT_EQ(HIPBLAS_STATUS_INVALID_VALUE, status); + } + else + { + EXPECT_EQ(HIPBLAS_STATUS_SUCCESS, status); // fail + } + } +} + +TEST_P(gels_strided_batched_gtest, gels_strided_batched_gtest_double_complex) +{ + // GetParam returns a tuple. The setup routine unpacks the tuple + // and initializes arg(Arguments), which will be passed to testing routine. + + Arguments arg = setup_gels_strided_batched_arguments(GetParam()); + + hipblasStatus_t status = testing_gels_strided_batched(arg); + + if(status != HIPBLAS_STATUS_SUCCESS) + { + if(arg.M < 0 || arg.N < 0 || arg.K < 0 || arg.lda < arg.M || arg.ldb < arg.M + || arg.ldb < arg.N || arg.batch_count < 0) + { + EXPECT_EQ(HIPBLAS_STATUS_INVALID_VALUE, status); + } + else + { + EXPECT_EQ(HIPBLAS_STATUS_SUCCESS, status); // fail + } + } +} + +// notice we are using vector of vector +// so each elment in xxx_range is a vector, +// ValuesIn takes each element (a vector), combines them, and feeds them to test_p +// The combinations are { {M, N, nrhs, lda, ldb}, trans, batchCount, fortran } + +INSTANTIATE_TEST_SUITE_P(hipblasGelsStridedBatched, + gels_strided_batched_gtest, + Combine(ValuesIn(matrix_size_range), + ValuesIn(trans_range), + ValuesIn(stride_scale_range), + ValuesIn(batch_count_range), + ValuesIn(is_fortran))); + +#endif diff --git a/clients/include/hipblas.hpp b/clients/include/hipblas.hpp index a060187fe..9cb285c1d 100644 --- a/clients/include/hipblas.hpp +++ b/clients/include/hipblas.hpp @@ -1996,6 +1996,36 @@ hipblasStatus_t hipblasGels(hipblasHandle_t handle, int* info, int* deviceInfo); +template +hipblasStatus_t hipblasGelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + T* const A[], + const int lda, + T* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount); + +template +hipblasStatus_t hipblasGelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + T* A, + const int lda, + const hipblasStride strideA, + T* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount); + // dgmm template hipblasStatus_t hipblasDgmm(hipblasHandle_t handle, diff --git a/clients/include/hipblas_fortran.hpp b/clients/include/hipblas_fortran.hpp index fff8b10fe..6f8a303cb 100644 --- a/clients/include/hipblas_fortran.hpp +++ b/clients/include/hipblas_fortran.hpp @@ -7207,6 +7207,120 @@ hipblasStatus_t hipblasZgelsFortran(hipblasHandle_t handle, const int ldb, int* info, int* deviceInfo); + +// gelsBatched +hipblasStatus_t hipblasSgelsBatchedFortran(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* const A[], + const int lda, + float* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount); + +hipblasStatus_t hipblasDgelsBatchedFortran(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* const A[], + const int lda, + double* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount); + +hipblasStatus_t hipblasCgelsBatchedFortran(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* const A[], + const int lda, + hipblasComplex* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount); + +hipblasStatus_t hipblasZgelsBatchedFortran(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* const A[], + const int lda, + hipblasDoubleComplex* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount); + +// gelsStridedBatched +hipblasStatus_t hipblasSgelsStridedBatchedFortran(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* A, + const int lda, + const hipblasStride strideA, + float* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount); + +hipblasStatus_t hipblasDgelsStridedBatchedFortran(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* A, + const int lda, + const hipblasStride strideA, + double* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount); + +hipblasStatus_t hipblasCgelsStridedBatchedFortran(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* A, + const int lda, + const hipblasStride strideA, + hipblasComplex* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount); + +hipblasStatus_t hipblasZgelsStridedBatchedFortran(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* A, + const int lda, + const hipblasStride strideA, + hipblasDoubleComplex* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount); } #endif diff --git a/clients/include/hipblas_fortran_solver.f90 b/clients/include/hipblas_fortran_solver.f90 index db6a522e8..4635a66e4 100644 --- a/clients/include/hipblas_fortran_solver.f90 +++ b/clients/include/hipblas_fortran_solver.f90 @@ -930,4 +930,203 @@ function hipblasZgelsFortran(handle, trans, m, n, nrhs, A, lda, B, ldb, info, de hipblasZgels(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo) end function hipblasZgelsFortran + ! gelsBatched + function hipblasSgelsBatchedFortran(handle, trans, m, n, nrhs, A, & + lda, B, ldb, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasSgelsBatchedFortran') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgelsBatchedFortran + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + hipblasSgelsBatchedFortran = & + hipblasSgelsBatched(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo, batchCount) + end function hipblasSgelsBatchedFortran + + function hipblasDgelsBatchedFortran(handle, trans, m, n, nrhs, A, & + lda, B, ldb, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasDgelsBatchedFortran') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgelsBatchedFortran + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + hipblasDgelsBatchedFortran = & + hipblasDgelsBatched(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo, batchCount) + end function hipblasDgelsBatchedFortran + + function hipblasCgelsBatchedFortran(handle, trans, m, n, nrhs, A, & + lda, B, ldb, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasCgelsBatchedFortran') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgelsBatchedFortran + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + hipblasCgelsBatchedFortran = & + hipblasCgelsBatched(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo, batchCount) + end function hipblasCgelsBatchedFortran + + function hipblasZgelsBatchedFortran(handle, trans, m, n, nrhs, A, & + lda, B, ldb, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasZgelsBatchedFortran') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgelsBatchedFortran + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + hipblasZgelsBatchedFortran = & + hipblasZgelsBatched(handle, trans, m, n, nrhs, A, lda, B, ldb, info, deviceInfo, batchCount) + end function hipblasZgelsBatchedFortran + + ! gelsStridedBatched + function hipblasSgelsStridedBatchedFortran(handle, trans, m, n, nrhs, A, & + lda, strideA, B, ldb, strideB, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasSgelsStridedBatchedFortran') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgelsStridedBatchedFortran + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + integer(c_int64_t), value :: strideA + type(c_ptr), value :: B + integer(c_int), value :: ldb + integer(c_int64_t), value :: strideB + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + hipblasSgelsStridedBatchedFortran = & + hipblasSgelsStridedBatched(handle, trans, m, n, nrhs, A, lda, strideA, & + B, ldb, strideB, info, deviceInfo, batchCount) + end function hipblasSgelsStridedBatchedFortran + + function hipblasDgelsStridedBatchedFortran(handle, trans, m, n, nrhs, A, & + lda, strideA, B, ldb, strideB, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasDgelsStridedBatchedFortran') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgelsStridedBatchedFortran + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + integer(c_int64_t), value :: strideA + type(c_ptr), value :: B + integer(c_int), value :: ldb + integer(c_int64_t), value :: strideB + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + hipblasDgelsStridedBatchedFortran = & + hipblasDgelsStridedBatched(handle, trans, m, n, nrhs, A, lda, strideA, & + B, ldb, strideB, info, deviceInfo, batchCount) + end function hipblasDgelsStridedBatchedFortran + + function hipblasCgelsStridedBatchedFortran(handle, trans, m, n, nrhs, A, & + lda, strideA, B, ldb, strideB, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasCgelsStridedBatchedFortran') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgelsStridedBatchedFortran + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + integer(c_int64_t), value :: strideA + type(c_ptr), value :: B + integer(c_int), value :: ldb + integer(c_int64_t), value :: strideB + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + hipblasCgelsStridedBatchedFortran = & + hipblasCgelsStridedBatched(handle, trans, m, n, nrhs, A, lda, strideA, & + B, ldb, strideB, info, deviceInfo, batchCount) + end function hipblasCgelsStridedBatchedFortran + + function hipblasZgelsStridedBatchedFortran(handle, trans, m, n, nrhs, A, & + lda, strideA, B, ldb, strideB, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasZgelsStridedBatchedFortran') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgelsStridedBatchedFortran + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + integer(c_int64_t), value :: strideA + type(c_ptr), value :: B + integer(c_int), value :: ldb + integer(c_int64_t), value :: strideB + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + hipblasZgelsStridedBatchedFortran = & + hipblasZgelsStridedBatched(handle, trans, m, n, nrhs, A, lda, strideA, & + B, ldb, strideB, info, deviceInfo, batchCount) + end function hipblasZgelsStridedBatchedFortran + + end module hipblas_interface diff --git a/clients/include/hipblas_no_fortran.hpp b/clients/include/hipblas_no_fortran.hpp index 4ee922654..7c3f2c882 100644 --- a/clients/include/hipblas_no_fortran.hpp +++ b/clients/include/hipblas_no_fortran.hpp @@ -676,6 +676,14 @@ #define hipblasDgelsFortran hipblasDgels #define hipblasCgelsFortran hipblasCgels #define hipblasZgelsFortran hipblasZgels +#define hipblasSgelsBatchedFortran hipblasSgelsBatched +#define hipblasDgelsBatchedFortran hipblasDgelsBatched +#define hipblasCgelsBatchedFortran hipblasCgelsBatched +#define hipblasZgelsBatchedFortran hipblasZgelsBatched +#define hipblasSgelsStridedBatchedFortran hipblasSgelsStridedBatched +#define hipblasDgelsStridedBatchedFortran hipblasDgelsStridedBatched +#define hipblasCgelsStridedBatchedFortran hipblasCgelsStridedBatched +#define hipblasZgelsStridedBatchedFortran hipblasZgelsStridedBatched #define hipblasSgeqrfBatchedFortran hipblasSgeqrfBatched #define hipblasDgeqrfBatchedFortran hipblasDgeqrfBatched #define hipblasCgeqrfBatchedFortran hipblasCgeqrfBatched diff --git a/clients/include/testing_gels.hpp b/clients/include/testing_gels.hpp index f5da9bc82..5130496af 100644 --- a/clients/include/testing_gels.hpp +++ b/clients/include/testing_gels.hpp @@ -115,10 +115,11 @@ hipblasStatus_t testing_gels(const Arguments& argus) hipblas_error = norm_check_general('F', std::max(M, N), nrhs, ldb, hB.data(), hB_res.data()); - if(info_input != info_res) - hipblas_error++; - if(info != 0) - hipblas_error++; + + if(info != info_res) + hipblas_error += 1.0; + if(info_input != 0) + hipblas_error += 1.0; if(argus.unit_check) { diff --git a/clients/include/testing_gels_batched.hpp b/clients/include/testing_gels_batched.hpp new file mode 100644 index 000000000..3a574cbb6 --- /dev/null +++ b/clients/include/testing_gels_batched.hpp @@ -0,0 +1,195 @@ +/* ************************************************************************ + * Copyright (C) 2016-2022 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * ************************************************************************ */ + +#include +#include +#include +#include + +#include "testing_common.hpp" + +template +hipblasStatus_t testing_gels_batched(const Arguments& argus) +{ + using U = real_t; + bool FORTRAN = argus.fortran; + auto hipblasGelsBatchedFn + = FORTRAN ? hipblasGelsBatched : hipblasGelsBatched; + + int N = argus.N; + int M = argus.M; + int nrhs = argus.K; + int lda = argus.lda; + int ldb = argus.ldb; + char transc = argus.transA_option; + int batchCount = argus.batch_count; + + if(is_complex && transc == 'T') + transc = 'C'; + else if(!is_complex && transc == 'C') + transc = 'T'; + + hipblasOperation_t trans = char2hipblas_operation(transc); + + size_t A_size = size_t(lda) * N; + size_t B_size = ldb * nrhs; + + // Check to prevent memory allocation error + if(M < 0 || N < 0 || nrhs < 0 || lda < M || ldb < M || ldb < N || batchCount < 0) + { + return HIPBLAS_STATUS_INVALID_VALUE; + } + if(batchCount == 0) + { + return HIPBLAS_STATUS_SUCCESS; + } + + // Naming: dK is in GPU (device) memory. hK is in CPU (host) memory + host_batch_vector hA(A_size, 1, batchCount); + host_batch_vector hB(B_size, 1, batchCount); + host_batch_vector hB_res(B_size, 1, batchCount); + host_vector info_res(batchCount); + host_vector info(batchCount); + int info_input(-1); + + device_batch_vector dA(A_size, 1, batchCount); + device_batch_vector dB(B_size, 1, batchCount); + device_vector dInfo(batchCount); + + double gpu_time_used, hipblas_error; + hipblasLocalHandle handle(argus); + + // Initial hA, hB, hX on CPU + hipblas_init(hA, true); + hipblas_init(hB); + hB_res.copy_from(hB); + + // scale A to avoid singularities + for(int b = 0; b < batchCount; b++) + { + for(int i = 0; i < N; i++) + { + for(int j = 0; j < N; j++) + { + if(i == j) + hA[b][i + j * lda] += 400; + else + hA[b][i + j * lda] -= 4; + } + } + } + + // Copy data from CPU to device + CHECK_HIP_ERROR(dA.transfer_from(hA)); + CHECK_HIP_ERROR(dB.transfer_from(hB)); + + if(argus.unit_check || argus.norm_check) + { + /* ===================================================================== + HIPBLAS + =================================================================== */ + CHECK_HIPBLAS_ERROR(hipblasGelsBatchedFn(handle, + trans, + M, + N, + nrhs, + dA.ptr_on_device(), + lda, + dB.ptr_on_device(), + ldb, + &info_input, + dInfo, + batchCount)); + + // copy output from device to CPU + CHECK_HIP_ERROR(hB_res.transfer_from(dB)); + CHECK_HIP_ERROR( + hipMemcpy(info_res.data(), dInfo, sizeof(int) * batchCount, hipMemcpyDeviceToHost)); + + /* ===================================================================== + CPU LAPACK + =================================================================== */ + int sizeW = std::max(1, std::min(M, N) + std::max(std::min(M, N), nrhs)); + host_vector hW(sizeW); + + for(int b = 0; b < batchCount; b++) + { + info[b] = cblas_gels(transc, M, N, nrhs, hA[b], lda, hB[b], ldb, hW.data(), sizeW); + } + + hipblas_error + = norm_check_general('F', std::max(M, N), nrhs, ldb, hB, hB_res, batchCount); + + if(info_input != 0) + hipblas_error += 1.0; + for(int b = 0; b < batchCount; b++) + { + if(info[b] != info_res[b]) + hipblas_error += 1.0; + } + + if(argus.unit_check) + { + double eps = std::numeric_limits::epsilon(); + double tolerance = N * eps * 100; + + unit_check_error(hipblas_error, tolerance); + } + } + + if(argus.timing) + { + hipStream_t stream; + CHECK_HIPBLAS_ERROR(hipblasGetStream(handle, &stream)); + + int runs = argus.cold_iters + argus.iters; + for(int iter = 0; iter < runs; iter++) + { + if(iter == argus.cold_iters) + gpu_time_used = get_time_us_sync(stream); + + CHECK_HIPBLAS_ERROR(hipblasGelsBatchedFn(handle, + trans, + M, + N, + nrhs, + dA.ptr_on_device(), + lda, + dB.ptr_on_device(), + ldb, + &info_input, + dInfo, + batchCount)); + } + gpu_time_used = get_time_us_sync(stream) - gpu_time_used; + + ArgumentModel{}.log_args(std::cout, + argus, + gpu_time_used, + ArgumentLogging::NA_value, + ArgumentLogging::NA_value, + hipblas_error); + } + + return HIPBLAS_STATUS_SUCCESS; +} diff --git a/clients/include/testing_gels_strided_batched.hpp b/clients/include/testing_gels_strided_batched.hpp new file mode 100644 index 000000000..ece35c976 --- /dev/null +++ b/clients/include/testing_gels_strided_batched.hpp @@ -0,0 +1,213 @@ +/* ************************************************************************ + * Copyright (C) 2016-2022 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * ************************************************************************ */ + +#include +#include +#include +#include + +#include "testing_common.hpp" + +template +hipblasStatus_t testing_gels_strided_batched(const Arguments& argus) +{ + using U = real_t; + bool FORTRAN = argus.fortran; + auto hipblasGelsStridedBatchedFn + = FORTRAN ? hipblasGelsStridedBatched : hipblasGelsStridedBatched; + + int N = argus.N; + int M = argus.M; + int nrhs = argus.K; + int lda = argus.lda; + int ldb = argus.ldb; + char transc = argus.transA_option; + int batchCount = argus.batch_count; + double strideScale = argus.stride_scale; + if(is_complex && transc == 'T') + transc = 'C'; + else if(!is_complex && transc == 'C') + transc = 'T'; + + hipblasOperation_t trans = char2hipblas_operation(transc); + + hipblasStride strideA = size_t(lda) * N * strideScale; + hipblasStride strideB = size_t(ldb) * nrhs * strideScale; + size_t A_size = strideA * batchCount; + size_t B_size = strideB * batchCount; + + // Check to prevent memory allocation error + if(M < 0 || N < 0 || nrhs < 0 || lda < M || ldb < M || ldb < N || batchCount < 0) + { + return HIPBLAS_STATUS_INVALID_VALUE; + } + if(batchCount == 0) + { + return HIPBLAS_STATUS_SUCCESS; + } + + // Naming: dK is in GPU (device) memory. hK is in CPU (host) memory + host_vector hA(A_size); + host_vector hB(B_size); + host_vector hB_res(B_size); + host_vector info_res(batchCount); + host_vector info(batchCount); + int info_input(-1); + + device_vector dA(A_size); + device_vector dB(B_size); + device_vector dInfo(batchCount); + + double gpu_time_used, hipblas_error; + hipblasLocalHandle handle(argus); + + // Initial hA, hB, hX on CPU + srand(1); + hipblas_init(hA, true); + hipblas_init(hB); + for(int b = 0; b < batchCount; b++) + { + T* hAb = hA.data() + b * strideA; + + // scale A to avoid singularities + for(int i = 0; i < N; i++) + { + for(int j = 0; j < N; j++) + { + if(i == j) + hAb[i + j * lda] += 400; + else + hAb[i + j * lda] -= 4; + } + } + } + + hB_res = hB; + + // Copy data from CPU to device + CHECK_HIP_ERROR(hipMemcpy(dA, hA, A_size * sizeof(T), hipMemcpyHostToDevice)); + CHECK_HIP_ERROR(hipMemcpy(dB, hB, B_size * sizeof(T), hipMemcpyHostToDevice)); + + if(argus.unit_check || argus.norm_check) + { + /* ===================================================================== + HIPBLAS + =================================================================== */ + CHECK_HIPBLAS_ERROR(hipblasGelsStridedBatchedFn(handle, + trans, + M, + N, + nrhs, + dA, + lda, + strideA, + dB, + ldb, + strideB, + &info_input, + dInfo, + batchCount)); + + // copy output from device to CPU + CHECK_HIP_ERROR(hipMemcpy(hB_res, dB, B_size * sizeof(T), hipMemcpyDeviceToHost)); + CHECK_HIP_ERROR( + hipMemcpy(info_res.data(), dInfo, sizeof(int) * batchCount, hipMemcpyDeviceToHost)); + + /* ===================================================================== + CPU LAPACK + =================================================================== */ + int sizeW = std::max(1, std::min(M, N) + std::max(std::min(M, N), nrhs)); + host_vector hW(sizeW); + + for(int b = 0; b < batchCount; b++) + { + info[b] = cblas_gels(transc, + M, + N, + nrhs, + hA.data() + b * strideA, + lda, + hB.data() + b * strideB, + ldb, + hW.data(), + sizeW); + } + + hipblas_error = norm_check_general( + 'F', std::max(M, N), nrhs, ldb, strideB, hB.data(), hB_res.data(), batchCount); + + if(info_input != 0) + hipblas_error += 1.0; + for(int b = 0; b < batchCount; b++) + { + if(info[b] != info_res[b]) + hipblas_error += 1.0; + } + + if(argus.unit_check) + { + double eps = std::numeric_limits::epsilon(); + double tolerance = N * eps * 100; + + unit_check_error(hipblas_error, tolerance); + } + } + + if(argus.timing) + { + hipStream_t stream; + CHECK_HIPBLAS_ERROR(hipblasGetStream(handle, &stream)); + + int runs = argus.cold_iters + argus.iters; + for(int iter = 0; iter < runs; iter++) + { + if(iter == argus.cold_iters) + gpu_time_used = get_time_us_sync(stream); + + CHECK_HIPBLAS_ERROR(hipblasGelsStridedBatchedFn(handle, + trans, + M, + N, + nrhs, + dA, + lda, + strideA, + dB, + ldb, + strideB, + &info_input, + dInfo, + batchCount)); + } + gpu_time_used = get_time_us_sync(stream) - gpu_time_used; + + ArgumentModel{}.log_args(std::cout, + argus, + gpu_time_used, + ArgumentLogging::NA_value, + ArgumentLogging::NA_value, + hipblas_error); + } + + return HIPBLAS_STATUS_SUCCESS; +} diff --git a/library/include/hipblas.h b/library/include/hipblas.h index f62451a31..2fc338064 100644 --- a/library/include/hipblas.h +++ b/library/include/hipblas.h @@ -16693,7 +16693,7 @@ HIPBLAS_EXPORT hipblasStatus_t hipblasZgetriBatched(hipblasHandle_t ldb int. ldb >= max(m,n).\n Specifies the leading dimension of matrix B. @param[out] - info pointer to a int on the host.\n + info pointer to an int on the host.\n If info = 0, successful exit. If info = j < 0, the j-th argument is invalid. @param[out] @@ -16752,6 +16752,276 @@ HIPBLAS_EXPORT hipblasStatus_t hipblasZgels(hipblasHandle_t handle, int* deviceInfo); ///@} +/*! @{ + \brief gelsBatched solves a batch of overdetermined (or underdetermined) linear systems + defined by a set of m-by-n matrices \f$A_j\f$, and corresponding matrices \f$B_j\f$, using the + QR factorizations computed by "GEQRF_BATCHED" (or the LQ factorizations computed by "GELQF_BATCHED"). + + \details + For each instance in the batch, depending on the value of trans, the problem solved by this function is either of the form + + \f[ + \begin{array}{cl} + A_j X_j = B_j & \: \text{not transposed, or}\\ + A_j' X_j = B_j & \: \text{transposed if real, or conjugate transposed if complex} + \end{array} + \f] + + If m >= n (or m < n in the case of transpose/conjugate transpose), the system is overdetermined + and a least-squares solution approximating X_j is found by minimizing + + \f[ + || B_j - A_j X_j || \quad \text{(or} \: || B_j - A_j' X_j ||\text{)} + \f] + + If m < n (or m >= n in the case of transpose/conjugate transpose), the system is underdetermined + and a unique solution for X_j is chosen such that \f$|| X_j ||\f$ is minimal. + + - Supported precisions in rocSOLVER : s,d,c,z + - Supported precisions in cuBLAS : s,d,c,z + Note that cuBLAS backend supports only the non-transpose operation and only solves over-determined systems (m >= n). + + @param[in] + handle hipblasHandle_t. + @param[in] + trans hipblasOperation_t.\n + Specifies the form of the system of equations. + @param[in] + m int. m >= 0.\n + The number of rows of all matrices A_j in the batch. + @param[in] + n int. n >= 0.\n + The number of columns of all matrices A_j in the batch. + @param[in] + nrhs int. nrhs >= 0.\n + The number of columns of all matrices B_j and X_j in the batch; + i.e., the columns on the right hand side. + @param[inout] + A array of pointer to type. Each pointer points to an array on the GPU of dimension lda*n.\n + On entry, the matrices A_j. + On exit, the QR (or LQ) factorizations of A_j as returned by "GEQRF_BATCHED" + (or "GELQF_BATCHED"). + @param[in] + lda int. lda >= m.\n + Specifies the leading dimension of matrices A_j. + @param[inout] + B array of pointer to type. Each pointer points to an array on the GPU of dimension ldb*nrhs.\n + On entry, the matrices B_j. + On exit, when info[j] = 0, B_j is overwritten by the solution vectors (and the residuals in + the overdetermined cases) stored as columns. + @param[in] + ldb int. ldb >= max(m,n).\n + Specifies the leading dimension of matrices B_j. + @param[out] + info pointer to an int on the host.\n + If info = 0, successful exit. + If info = j < 0, the j-th argument is invalid. + @param[out] + deviceInfo pointer to int. Array of batchCount integers on the GPU.\n + If deviceInfo[j] = 0, successful exit for solution of A_j. + If deviceInfo[j] = i > 0, the solution of A_j could not be computed because input + matrix A_j is rank deficient; the i-th diagonal element of its triangular factor is zero. + @param[in] + batchCount int. batchCount >= 0.\n + Number of matrices in the batch. + ********************************************************************/ + +HIPBLAS_EXPORT hipblasStatus_t hipblasSgelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* const A[], + const int lda, + float* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount); + +HIPBLAS_EXPORT hipblasStatus_t hipblasDgelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* const A[], + const int lda, + double* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount); + +HIPBLAS_EXPORT hipblasStatus_t hipblasCgelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* const A[], + const int lda, + hipblasComplex* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount); + +HIPBLAS_EXPORT hipblasStatus_t hipblasZgelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* const A[], + const int lda, + hipblasDoubleComplex* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount); +///@} + +/*! @{ + \brief gelsStridedBatched solves a batch of overdetermined (or underdetermined) linear + systems defined by a set of m-by-n matrices \f$A_j\f$, and corresponding matrices \f$B_j\f$, + using the QR factorizations computed by "GEQRF_STRIDED_BATCHED" + (or the LQ factorizations computed by "GELQF_STRIDED_BATCHED"). + + \details + For each instance in the batch, depending on the value of trans, the problem solved by this function is either of the form + + \f[ + \begin{array}{cl} + A_j X_j = B_j & \: \text{not transposed, or}\\ + A_j' X_j = B_j & \: \text{transposed if real, or conjugate transposed if complex} + \end{array} + \f] + + If m >= n (or m < n in the case of transpose/conjugate transpose), the system is overdetermined + and a least-squares solution approximating X_j is found by minimizing + + \f[ + || B_j - A_j X_j || \quad \text{(or} \: || B_j - A_j' X_j ||\text{)} + \f] + + If m < n (or m >= n in the case of transpose/conjugate transpose), the system is underdetermined + and a unique solution for X_j is chosen such that \f$|| X_j ||\f$ is minimal. + + - Supported precisions in rocSOLVER : s,d,c,z + - Supported precisions in cuBLAS : currently unsupported + + @param[in] + handle hipblasHandle_t. + @param[in] + trans hipblasOperation_t.\n + Specifies the form of the system of equations. + @param[in] + m int. m >= 0.\n + The number of rows of all matrices A_j in the batch. + @param[in] + n int. n >= 0.\n + The number of columns of all matrices A_j in the batch. + @param[in] + nrhs int. nrhs >= 0.\n + The number of columns of all matrices B_j and X_j in the batch; + i.e., the columns on the right hand side. + @param[inout] + A pointer to type. Array on the GPU (the size depends on the value of strideA).\n + On entry, the matrices A_j. + On exit, the QR (or LQ) factorizations of A_j as returned by "GEQRF_STRIDED_BATCHED" + (or "GELQF_STRIDED_BATCHED"). + @param[in] + lda int. lda >= m.\n + Specifies the leading dimension of matrices A_j. + @param[in] + strideA hipblasStride.\n + Stride from the start of one matrix A_j to the next one A_(j+1). + There is no restriction for the value of strideA. Normal use case is strideA >= lda*n + @param[inout] + B pointer to type. Array on the GPU (the size depends on the value of strideB).\n + On entry, the matrices B_j. + On exit, when info[j] = 0, each B_j is overwritten by the solution vectors (and the residuals in + the overdetermined cases) stored as columns. + @param[in] + ldb int. ldb >= max(m,n).\n + Specifies the leading dimension of matrices B_j. + @param[in] + strideB hipblasStride.\n + Stride from the start of one matrix B_j to the next one B_(j+1). + There is no restriction for the value of strideB. Normal use case is strideB >= ldb*nrhs + @param[out] + info pointer to an int on the host.\n + If info = 0, successful exit. + If info = j < 0, the j-th argument is invalid. + @param[out] + deviceInfo pointer to int. Array of batchCount integers on the GPU.\n + If deviceInfo[j] = 0, successful exit for solution of A_j. + If deviceInfo[j] = i > 0, the solution of A_j could not be computed because input + matrix A_j is rank deficient; the i-th diagonal element of its triangular factor is zero. + @param[in] + batchCount int. batchCount >= 0.\n + Number of matrices in the batch. + ********************************************************************/ + +HIPBLAS_EXPORT hipblasStatus_t hipblasSgelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* A, + const int lda, + const hipblasStride strideA, + float* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batch_count); + +HIPBLAS_EXPORT hipblasStatus_t hipblasDgelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* A, + const int lda, + const hipblasStride strideA, + double* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batch_count); + +HIPBLAS_EXPORT hipblasStatus_t hipblasCgelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* A, + const int lda, + const hipblasStride strideA, + hipblasComplex* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batch_count); + +HIPBLAS_EXPORT hipblasStatus_t hipblasZgelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* A, + const int lda, + const hipblasStride strideA, + hipblasDoubleComplex* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batch_count); +///@} + /*! @{ \brief SOLVER API diff --git a/library/src/hcc_detail/hipblas.cpp b/library/src/hcc_detail/hipblas.cpp index ed77cf23f..43c1d488d 100644 --- a/library/src/hcc_detail/hipblas.cpp +++ b/library/src/hcc_detail/hipblas.cpp @@ -16628,6 +16628,7 @@ catch(...) return exception_to_hipblas_status(); } +// gels hipblasStatus_t hipblasSgels(hipblasHandle_t handle, hipblasOperation_t trans, const int m, @@ -16657,8 +16658,8 @@ try *info = -7; else if(ldb < m || ldb < n) *info = -8; - else if(info == NULL) - *info = -9; + else if(deviceInfo == NULL) + *info = -10; else *info = 0; @@ -16708,8 +16709,8 @@ try *info = -7; else if(ldb < m || ldb < n) *info = -8; - else if(info == NULL) - *info = -9; + else if(deviceInfo == NULL) + *info = -10; else *info = 0; @@ -16759,8 +16760,8 @@ try *info = -7; else if(ldb < m || ldb < n) *info = -8; - else if(info == NULL) - *info = -9; + else if(deviceInfo == NULL) + *info = -10; else *info = 0; @@ -16810,8 +16811,8 @@ try *info = -7; else if(ldb < m || ldb < n) *info = -8; - else if(info == NULL) - *info = -9; + else if(deviceInfo == NULL) + *info = -10; else *info = 0; @@ -16832,6 +16833,464 @@ catch(...) return exception_to_hipblas_status(); } +// gelsBatched +hipblasStatus_t hipblasSgelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* const A[], + const int lda, + float* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +try +{ + if(info == NULL) + return HIPBLAS_STATUS_INVALID_VALUE; + else if(m < 0) + *info = -2; + else if(n < 0) + *info = -3; + else if(nrhs < 0) + *info = -4; + else if(A == NULL) + *info = -5; + else if(lda < m) + *info = -6; + else if(B == NULL) + *info = -7; + else if(ldb < m || ldb < n) + *info = -8; + else if(deviceInfo == NULL) + *info = -10; + else if(batchCount < 0) + *info = -11; + else + *info = 0; + + return HIPBLAS_DEMAND_ALLOC( + rocBLASStatusToHIPStatus(rocsolver_sgels_batched((rocblas_handle)handle, + hipOperationToHCCOperation(trans), + m, + n, + nrhs, + A, + lda, + B, + ldb, + deviceInfo, + batchCount))); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +hipblasStatus_t hipblasDgelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* const A[], + const int lda, + double* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +try +{ + if(info == NULL) + return HIPBLAS_STATUS_INVALID_VALUE; + else if(m < 0) + *info = -2; + else if(n < 0) + *info = -3; + else if(nrhs < 0) + *info = -4; + else if(A == NULL) + *info = -5; + else if(lda < m) + *info = -6; + else if(B == NULL) + *info = -7; + else if(ldb < m || ldb < n) + *info = -8; + else if(deviceInfo == NULL) + *info = -10; + else if(batchCount < 0) + *info = -11; + else + *info = 0; + + return HIPBLAS_DEMAND_ALLOC( + rocBLASStatusToHIPStatus(rocsolver_dgels_batched((rocblas_handle)handle, + hipOperationToHCCOperation(trans), + m, + n, + nrhs, + A, + lda, + B, + ldb, + deviceInfo, + batchCount))); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +hipblasStatus_t hipblasCgelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* const A[], + const int lda, + hipblasComplex* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +try +{ + if(info == NULL) + return HIPBLAS_STATUS_INVALID_VALUE; + else if(m < 0) + *info = -2; + else if(n < 0) + *info = -3; + else if(nrhs < 0) + *info = -4; + else if(A == NULL) + *info = -5; + else if(lda < m) + *info = -6; + else if(B == NULL) + *info = -7; + else if(ldb < m || ldb < n) + *info = -8; + else if(deviceInfo == NULL) + *info = -10; + else if(batchCount < 0) + *info = -11; + else + *info = 0; + + return HIPBLAS_DEMAND_ALLOC( + rocBLASStatusToHIPStatus(rocsolver_cgels_batched((rocblas_handle)handle, + hipOperationToHCCOperation(trans), + m, + n, + nrhs, + (rocblas_float_complex**)A, + lda, + (rocblas_float_complex**)B, + ldb, + deviceInfo, + batchCount))); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +hipblasStatus_t hipblasZgelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* const A[], + const int lda, + hipblasDoubleComplex* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +try +{ + if(info == NULL) + return HIPBLAS_STATUS_INVALID_VALUE; + else if(m < 0) + *info = -2; + else if(n < 0) + *info = -3; + else if(nrhs < 0) + *info = -4; + else if(A == NULL) + *info = -5; + else if(lda < m) + *info = -6; + else if(B == NULL) + *info = -7; + else if(ldb < m || ldb < n) + *info = -8; + else if(deviceInfo == NULL) + *info = -10; + else if(batchCount < 0) + *info = -11; + else + *info = 0; + + return HIPBLAS_DEMAND_ALLOC( + rocBLASStatusToHIPStatus(rocsolver_zgels_batched((rocblas_handle)handle, + hipOperationToHCCOperation(trans), + m, + n, + nrhs, + (rocblas_double_complex**)A, + lda, + (rocblas_double_complex**)B, + ldb, + deviceInfo, + batchCount))); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +// gelsStridedBatched +hipblasStatus_t hipblasSgelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* A, + const int lda, + const hipblasStride strideA, + float* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +try +{ + if(info == NULL) + return HIPBLAS_STATUS_INVALID_VALUE; + else if(m < 0) + *info = -2; + else if(n < 0) + *info = -3; + else if(nrhs < 0) + *info = -4; + else if(A == NULL) + *info = -5; + else if(lda < m) + *info = -6; + else if(B == NULL) + *info = -8; + else if(ldb < m || ldb < n) + *info = -9; + else if(deviceInfo == NULL) + *info = -12; + else if(batchCount < 0) + *info = -13; + else + *info = 0; + + return HIPBLAS_DEMAND_ALLOC( + rocBLASStatusToHIPStatus(rocsolver_sgels_strided_batched((rocblas_handle)handle, + hipOperationToHCCOperation(trans), + m, + n, + nrhs, + A, + lda, + strideA, + B, + ldb, + strideB, + deviceInfo, + batchCount))); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +hipblasStatus_t hipblasDgelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* A, + const int lda, + const hipblasStride strideA, + double* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +try +{ + if(info == NULL) + return HIPBLAS_STATUS_INVALID_VALUE; + else if(m < 0) + *info = -2; + else if(n < 0) + *info = -3; + else if(nrhs < 0) + *info = -4; + else if(A == NULL) + *info = -5; + else if(lda < m) + *info = -6; + else if(B == NULL) + *info = -8; + else if(ldb < m || ldb < n) + *info = -9; + else if(deviceInfo == NULL) + *info = -12; + else if(batchCount < 0) + *info = -13; + else + *info = 0; + + return HIPBLAS_DEMAND_ALLOC( + rocBLASStatusToHIPStatus(rocsolver_dgels_strided_batched((rocblas_handle)handle, + hipOperationToHCCOperation(trans), + m, + n, + nrhs, + A, + lda, + strideA, + B, + ldb, + strideB, + deviceInfo, + batchCount))); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +hipblasStatus_t hipblasCgelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* A, + const int lda, + const hipblasStride strideA, + hipblasComplex* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +try +{ + if(info == NULL) + return HIPBLAS_STATUS_INVALID_VALUE; + else if(m < 0) + *info = -2; + else if(n < 0) + *info = -3; + else if(nrhs < 0) + *info = -4; + else if(A == NULL) + *info = -5; + else if(lda < m) + *info = -6; + else if(B == NULL) + *info = -8; + else if(ldb < m || ldb < n) + *info = -9; + else if(deviceInfo == NULL) + *info = -12; + else if(batchCount < 0) + *info = -13; + else + *info = 0; + + return HIPBLAS_DEMAND_ALLOC( + rocBLASStatusToHIPStatus(rocsolver_cgels_strided_batched((rocblas_handle)handle, + hipOperationToHCCOperation(trans), + m, + n, + nrhs, + (rocblas_float_complex*)A, + lda, + strideA, + (rocblas_float_complex*)B, + ldb, + strideB, + deviceInfo, + batchCount))); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +hipblasStatus_t hipblasZgelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* A, + const int lda, + const hipblasStride strideA, + hipblasDoubleComplex* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +try +{ + if(info == NULL) + return HIPBLAS_STATUS_INVALID_VALUE; + else if(m < 0) + *info = -2; + else if(n < 0) + *info = -3; + else if(nrhs < 0) + *info = -4; + else if(A == NULL) + *info = -5; + else if(lda < m) + *info = -6; + else if(B == NULL) + *info = -8; + else if(ldb < m || ldb < n) + *info = -9; + else if(deviceInfo == NULL) + *info = -12; + else if(batchCount < 0) + *info = -13; + else + *info = 0; + + return HIPBLAS_DEMAND_ALLOC( + rocBLASStatusToHIPStatus(rocsolver_zgels_strided_batched((rocblas_handle)handle, + hipOperationToHCCOperation(trans), + m, + n, + nrhs, + (rocblas_double_complex*)A, + lda, + strideA, + (rocblas_double_complex*)B, + ldb, + strideB, + deviceInfo, + batchCount))); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + #endif // gemm diff --git a/library/src/hipblas_module.f90 b/library/src/hipblas_module.f90 index 94fdd2d18..72aaa3861 100644 --- a/library/src/hipblas_module.f90 +++ b/library/src/hipblas_module.f90 @@ -13442,7 +13442,7 @@ end function hipblasZgeqrfStridedBatched ! gels interface function hipblasSgels(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo) & - bind(c, name='hipblasSgels') + bind(c, name = 'hipblasSgels') use iso_c_binding use hipblas_enums implicit none @@ -13463,7 +13463,7 @@ end function hipblasSgels interface function hipblasDgels(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo) & - bind(c, name='hipblasDgels') + bind(c, name = 'hipblasDgels') use iso_c_binding use hipblas_enums implicit none @@ -13484,7 +13484,7 @@ end function hipblasDgels interface function hipblasCgels(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo) & - bind(c, name='hipblasCgels') + bind(c, name = 'hipblasCgels') use iso_c_binding use hipblas_enums implicit none @@ -13505,7 +13505,7 @@ end function hipblasCgels interface function hipblasZgels(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo) & - bind(c, name='hipblasZgels') + bind(c, name = 'hipblasZgels') use iso_c_binding use hipblas_enums implicit none @@ -13524,4 +13524,194 @@ function hipblasZgels(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInf end function hipblasZgels end interface + ! gelsBatched + interface + function hipblasSgelsBatched(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasSgelsBatched') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgelsBatched + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + end function hipblasSgelsBatched + end interface + + interface + function hipblasDgelsBatched(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasDgelsBatched') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgelsBatched + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + end function hipblasDgelsBatched + end interface + + interface + function hipblasCgelsBatched(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasCgelsBatched') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgelsBatched + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + end function hipblasCgelsBatched + end interface + + interface + function hipblasZgelsBatched(handle, m, n, nrhs, trans, A, lda, B, ldb, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasZgelsBatched') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgelsBatched + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + type(c_ptr), value :: B + integer(c_int), value :: ldb + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + end function hipblasZgelsBatched + end interface + + ! gelsStridedBatched + interface + function hipblasSgelsStridedBatched(handle, m, n, nrhs, trans, A, lda, strideA, & + B, ldb, strideB, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasSgelsStridedBatched') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgelsStridedBatched + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + integer(c_int64_t), value :: strideA + type(c_ptr), value :: B + integer(c_int), value :: ldb + integer(c_int64_t), value :: strideB + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + end function hipblasSgelsStridedBatched + end interface + + interface + function hipblasDgelsStridedBatched(handle, m, n, nrhs, trans, A, lda, strideA, & + B, ldb, strideB, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasDgelsStridedBatched') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgelsStridedBatched + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + integer(c_int64_t), value :: strideA + type(c_ptr), value :: B + integer(c_int), value :: ldb + integer(c_int64_t), value :: strideB + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + end function hipblasDgelsStridedBatched + end interface + + interface + function hipblasCgelsStridedBatched(handle, m, n, nrhs, trans, A, lda, strideA, & + B, ldb, strideB, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasCgelsStridedBatched') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgelsStridedBatched + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + integer(c_int64_t), value :: strideA + type(c_ptr), value :: B + integer(c_int), value :: ldb + integer(c_int64_t), value :: strideB + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + end function hipblasCgelsStridedBatched + end interface + + interface + function hipblasZgelsStridedBatched(handle, m, n, nrhs, trans, A, lda, strideA, & + B, ldb, strideB, info, deviceInfo, batchCount) & + bind(c, name = 'hipblasZgelsStridedBatched') + use iso_c_binding + use hipblas_enums + implicit none + integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgelsStridedBatched + type(c_ptr), value :: handle + integer(kind(HIPBLAS_OP_N)), value :: trans + integer(c_int), value :: m + integer(c_int), value :: n + integer(c_int), value :: nrhs + type(c_ptr), value :: A + integer(c_int), value :: lda + integer(c_int64_t), value :: strideA + type(c_ptr), value :: B + integer(c_int), value :: ldb + integer(c_int64_t), value :: strideB + type(c_ptr), value :: info + type(c_ptr), value :: deviceInfo + integer(c_int), value :: batchCount + end function hipblasZgelsStridedBatched + end interface + end module hipblas diff --git a/library/src/nvcc_detail/hipblas.cpp b/library/src/nvcc_detail/hipblas.cpp index e950af79d..dc493b0fe 100644 --- a/library/src/nvcc_detail/hipblas.cpp +++ b/library/src/nvcc_detail/hipblas.cpp @@ -10764,6 +10764,7 @@ hipblasStatus_t hipblasZgeqrfStridedBatched(hipblasHandle_t handle, return HIPBLAS_STATUS_NOT_SUPPORTED; } +// gels hipblasStatus_t hipblasSgels(hipblasHandle_t handle, hipblasOperation_t trans, const int m, @@ -10825,6 +10826,212 @@ hipblasStatus_t hipblasZgels(hipblasHandle_t handle, return HIPBLAS_STATUS_NOT_SUPPORTED; } +// gelsBatched +hipblasStatus_t hipblasSgelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* const A[], + const int lda, + float* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +try +{ + return hipCUBLASStatusToHIPStatus(cublasSgelsBatched((cublasHandle_t)handle, + hipOperationToCudaOperation(trans), + m, + n, + nrhs, + A, + lda, + B, + ldb, + info, + deviceInfo, + batchCount)); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +hipblasStatus_t hipblasDgelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* const A[], + const int lda, + double* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +try +{ + return hipCUBLASStatusToHIPStatus(cublasDgelsBatched((cublasHandle_t)handle, + hipOperationToCudaOperation(trans), + m, + n, + nrhs, + A, + lda, + B, + ldb, + info, + deviceInfo, + batchCount)); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +hipblasStatus_t hipblasCgelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* const A[], + const int lda, + hipblasComplex* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +try +{ + return hipCUBLASStatusToHIPStatus(cublasCgelsBatched((cublasHandle_t)handle, + hipOperationToCudaOperation(trans), + m, + n, + nrhs, + (cuComplex**)A, + lda, + (cuComplex**)B, + ldb, + info, + deviceInfo, + batchCount)); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +hipblasStatus_t hipblasZgelsBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* const A[], + const int lda, + hipblasDoubleComplex* const B[], + const int ldb, + int* info, + int* deviceInfo, + const int batchCount) +try +{ + return hipCUBLASStatusToHIPStatus(cublasZgelsBatched((cublasHandle_t)handle, + hipOperationToCudaOperation(trans), + m, + n, + nrhs, + (cuDoubleComplex**)A, + lda, + (cuDoubleComplex**)B, + ldb, + info, + deviceInfo, + batchCount)); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +// gelsStridedBatched +hipblasStatus_t hipblasSgelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + float* A, + const int lda, + const hipblasStride strideA, + float* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +{ + // only batched variants of gels are supported in cuBLAS + return HIPBLAS_STATUS_NOT_SUPPORTED; +} + +hipblasStatus_t hipblasDgelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + double* A, + const int lda, + const hipblasStride strideA, + double* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +{ + // only batched variants of gels are supported in cuBLAS + return HIPBLAS_STATUS_NOT_SUPPORTED; +} + +hipblasStatus_t hipblasCgelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasComplex* A, + const int lda, + const hipblasStride strideA, + hipblasComplex* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +{ + // only batched variants of gels are supported in cuBLAS + return HIPBLAS_STATUS_NOT_SUPPORTED; +} + +hipblasStatus_t hipblasZgelsStridedBatched(hipblasHandle_t handle, + hipblasOperation_t trans, + const int m, + const int n, + const int nrhs, + hipblasDoubleComplex* A, + const int lda, + const hipblasStride strideA, + hipblasDoubleComplex* B, + const int ldb, + const hipblasStride strideB, + int* info, + int* deviceInfo, + const int batchCount) +{ + // only batched variants of gels are supported in cuBLAS + return HIPBLAS_STATUS_NOT_SUPPORTED; +} + #endif // gemm From 9b6dce73777d7bc6e1c1234cb2a999945b4dc9e6 Mon Sep 17 00:00:00 2001 From: Cory Bloor Date: Mon, 18 Jul 2022 11:43:18 -0600 Subject: [PATCH 09/12] Remove all references to hcc (#505) - Match HIP platform naming convention: hcc -> amd nvcc -> nvidia - Remove old references to hcc and replace with hipcc as needed. --- .githooks/pre-commit | 2 +- clients/benchmarks/CMakeLists.txt | 2 +- clients/gtest/CMakeLists.txt | 2 +- clients/samples/CMakeLists.txt | 4 ++-- docs/source/install.rst | 4 ++-- docs/source/orga.rst | 4 ++-- install.sh | 2 +- library/src/CMakeLists.txt | 4 ++-- library/src/{hcc_detail => amd_detail}/hipblas.cpp | 0 library/src/{nvcc_detail => nvidia_detail}/hipblas.cpp | 0 10 files changed, 12 insertions(+), 12 deletions(-) rename library/src/{hcc_detail => amd_detail}/hipblas.cpp (100%) rename library/src/{nvcc_detail => nvidia_detail}/hipblas.cpp (100%) diff --git a/.githooks/pre-commit b/.githooks/pre-commit index 8cd64a18b..4a817c98b 100755 --- a/.githooks/pre-commit +++ b/.githooks/pre-commit @@ -4,7 +4,7 @@ # are installed, and if so, uses the installed version to format # the staged changes. -export PATH=/opt/rocm/llvm/bin:/opt/rocm/hcc/bin:/usr/bin:/bin +export PATH=/opt/rocm/llvm/bin:/usr/bin:/bin # Redirect stdout to stderr. exec >&2 diff --git a/clients/benchmarks/CMakeLists.txt b/clients/benchmarks/CMakeLists.txt index d8f237b3d..e4c3c10cf 100644 --- a/clients/benchmarks/CMakeLists.txt +++ b/clients/benchmarks/CMakeLists.txt @@ -125,7 +125,7 @@ if( NOT USE_CUDA ) target_link_libraries( hipblas-bench PRIVATE hip::${CUSTOM_TARGET} ) endif() - if( CMAKE_CXX_COMPILER MATCHES ".*/hcc$|.*/hipcc$" ) + if( CMAKE_CXX_COMPILER MATCHES ".*/hipcc$" ) # hip-clang needs specific flag to turn on pthread and m target_link_libraries( hipblas-bench PRIVATE -lpthread -lm ) diff --git a/clients/gtest/CMakeLists.txt b/clients/gtest/CMakeLists.txt index b202097e9..a3756b357 100644 --- a/clients/gtest/CMakeLists.txt +++ b/clients/gtest/CMakeLists.txt @@ -185,7 +185,7 @@ if( NOT USE_CUDA ) target_link_libraries( hipblas-test PRIVATE hip::${CUSTOM_TARGET} ) endif( ) - if( CMAKE_CXX_COMPILER MATCHES ".*/hcc$|.*/hipcc$" ) + if( CMAKE_CXX_COMPILER MATCHES ".*/hipcc$" ) # hip-clang needs specific flag to turn on pthread and m target_link_libraries( hipblas-test PRIVATE -lpthread -lm ) diff --git a/clients/samples/CMakeLists.txt b/clients/samples/CMakeLists.txt index 305ba766c..047be8609 100644 --- a/clients/samples/CMakeLists.txt +++ b/clients/samples/CMakeLists.txt @@ -27,7 +27,7 @@ add_executable( example-sgemm-strided-batched example_sgemm_strided_batched.cpp add_executable( example-c example-c.c ${hipblas_samples_common} ) add_executable( example-hip-complex-her2 example_hip_complex_her2.cpp ${hipblas_samples_common} ) -if( CMAKE_CXX_COMPILER MATCHES ".*/hcc$|.*/hipcc$" ) +if( CMAKE_CXX_COMPILER MATCHES ".*/hipcc$" ) add_executable( example-hgemm example_hgemm.cpp ${hipblas_samples_common} ) endif( ) @@ -50,7 +50,7 @@ if( NOT TARGET hipblas ) endif( ) list (APPEND example-executables example-sscal example-sgemm example-sgemm-strided-batched example-c example-hip-complex-her2) -if( CMAKE_CXX_COMPILER MATCHES ".*/hcc$|.*/hipcc$" ) +if( CMAKE_CXX_COMPILER MATCHES ".*/hipcc$" ) list (APPEND example-executables example-hgemm) endif( ) diff --git a/docs/source/install.rst b/docs/source/install.rst index 7f868e55f..11ea98af5 100644 --- a/docs/source/install.rst +++ b/docs/source/install.rst @@ -164,7 +164,7 @@ Build Library Using Individual Commands cd [HIPBLAS_BUILD_DIR]/release # Default install location is in /opt/rocm, define -DCMAKE_INSTALL_PREFIX= to specify other # Default build config is 'Release', define -DCMAKE_BUILD_TYPE= to specify other - CXX=/opt/rocm/bin/hcc ccmake [HIPBLAS_SOURCE] + CXX=/opt/rocm/bin/hipcc ccmake [HIPBLAS_SOURCE] make -j$(nproc) sudo make install # sudo required if installing into system directory such as /opt/rocm @@ -198,6 +198,6 @@ Once dependencies are available on the system, it is possible to configure the c -DCMAKE_PREFIX_PATH="" # Default install location is in /opt/rocm, use -DCMAKE_INSTALL_PREFIX= to specify other - CXX=/opt/rocm/bin/hcc ccmake -DBUILD_CLIENTS_TESTS=ON -DBUILD_CLIENTS_BENCHMARKS=ON [HIPBLAS_SOURCE] + CXX=/opt/rocm/bin/hipcc ccmake -DBUILD_CLIENTS_TESTS=ON -DBUILD_CLIENTS_BENCHMARKS=ON [HIPBLAS_SOURCE] make -j$(nproc) sudo make install # sudo required if installing into system directory such as /opt/rocm diff --git a/docs/source/orga.rst b/docs/source/orga.rst index 6156a2da9..eec1027af 100644 --- a/docs/source/orga.rst +++ b/docs/source/orga.rst @@ -16,11 +16,11 @@ library/include Contains C98 include files for the external API. These files also contain Doxygen comments that document the API. -library/src/hcc_detail +library/src/amd_detail ``````````````````````` Implementation of hipBLAS interface compatible with rocBLAS APIs. -library/src/nvcc_detail +library/src/nvidia_detail ````````````````````````` Implementation of hipBLAS interface compatible with cuBLAS-v2 APIs. diff --git a/install.sh b/install.sh index f8569f64e..09b33fdaf 100755 --- a/install.sh +++ b/install.sh @@ -724,7 +724,7 @@ pushd . # Build library if [[ "${build_relocatable}" == true ]]; then CXX=${compiler} ${cmake_executable} ${cmake_common_options[@]} ${cmake_client_options[@]} -DCPACK_SET_DESTDIR=OFF -DCMAKE_INSTALL_PREFIX="${rocm_path}" \ - -DCMAKE_PREFIX_PATH="${rocm_path};${rocm_path}/hcc;${rocm_path}/hip;$(pwd)/../deps/deps-install;${cuda_path};${cmake_prefix_path}" \ + -DCMAKE_PREFIX_PATH="${rocm_path};${rocm_path}/hip;$(pwd)/../deps/deps-install;${cuda_path};${cmake_prefix_path}" \ -DCMAKE_SHARED_LINKER_FLAGS="${rocm_rpath}" \ -DCMAKE_EXE_LINKER_FLAGS=" -Wl,--enable-new-dtags -Wl,--rpath,${rocm_path}/lib:${rocm_path}/lib64" \ -DROCM_DISABLE_LDCONFIG=ON \ diff --git a/library/src/CMakeLists.txt b/library/src/CMakeLists.txt index 08df2fbc9..94e5b6659 100755 --- a/library/src/CMakeLists.txt +++ b/library/src/CMakeLists.txt @@ -39,9 +39,9 @@ endfunction( ) prepend_path( ".." hipblas_headers_public relative_hipblas_headers_public ) if( NOT USE_CUDA ) - set( hipblas_source "${CMAKE_CURRENT_SOURCE_DIR}/hcc_detail/hipblas.cpp" ) + set( hipblas_source "${CMAKE_CURRENT_SOURCE_DIR}/amd_detail/hipblas.cpp" ) else( ) - set( hipblas_source "${CMAKE_CURRENT_SOURCE_DIR}/nvcc_detail/hipblas.cpp" ) + set( hipblas_source "${CMAKE_CURRENT_SOURCE_DIR}/nvidia_detail/hipblas.cpp" ) endif( ) set (hipblas_f90_source diff --git a/library/src/hcc_detail/hipblas.cpp b/library/src/amd_detail/hipblas.cpp similarity index 100% rename from library/src/hcc_detail/hipblas.cpp rename to library/src/amd_detail/hipblas.cpp diff --git a/library/src/nvcc_detail/hipblas.cpp b/library/src/nvidia_detail/hipblas.cpp similarity index 100% rename from library/src/nvcc_detail/hipblas.cpp rename to library/src/nvidia_detail/hipblas.cpp From e4790e93e03a3622b359545504dc75044d2fce73 Mon Sep 17 00:00:00 2001 From: amcamd Date: Thu, 7 Jul 2022 08:50:57 -0500 Subject: [PATCH 10/12] allow for selection of int8 datatype --- clients/common/utility.cpp | 28 ++- clients/include/testing_gemm_batched_ex.hpp | 4 +- clients/include/testing_gemm_ex.hpp | 228 ++++++++++-------- .../testing_gemm_strided_batched_ex.hpp | 4 +- clients/include/utility.h | 8 +- docs/source/deprecation.rst | 28 +++ docs/source/usermanual.rst | 1 + library/include/hipblas.h | 25 ++ library/src/amd_detail/hipblas.cpp | 53 ++++ library/src/hipblas_module.f90 | 8 + library/src/nvidia_detail/hipblas.cpp | 20 ++ 11 files changed, 290 insertions(+), 117 deletions(-) create mode 100644 docs/source/deprecation.rst diff --git a/clients/common/utility.cpp b/clients/common/utility.cpp index 9bcb3a987..23ebfdcab 100644 --- a/clients/common/utility.cpp +++ b/clients/common/utility.cpp @@ -282,10 +282,32 @@ int getArch() /******************************************************************************* * gemm_ex int8 layout ******************************************************************************/ -bool layout_pack_int8() +bool layout_pack_int8(hipblasHandle_t handle) { - int arch = getArch(); - return arch != 908; + // This function should match the rocBLAS function: rocblas_query_int8_layout_flag + // + // Default behavior is from when int8 was supported on gfx908 and other architectures + // used packed_int8x4. All architectures support int8 since the following two PRs + // for ROCm 4.2: + // - Tensile PR 680 + // - rocBLAS-internal PR 1328 + + hipblasInt8Datatype_t int8Type; + hipblasGetInt8Datatype(handle, &int8Type); + if(HIPBLAS_INT8_DATATYPE_DEFAULT == int8Type) + { + int arch = getArch(); + return arch != 908; + } + else if(HIPBLAS_INT8_DATATYPE_INT8 == int8Type) + { + return false; + } + else if(HIPBLAS_INT8_DATATYPE_PACK_INT8x4 == int8Type) + { + return true; + } + return false; } #ifdef __cplusplus diff --git a/clients/include/testing_gemm_batched_ex.hpp b/clients/include/testing_gemm_batched_ex.hpp index 831f6c53e..57f99fa6e 100644 --- a/clients/include/testing_gemm_batched_ex.hpp +++ b/clients/include/testing_gemm_batched_ex.hpp @@ -117,7 +117,7 @@ hipblasStatus_t testing_gemm_batched_ex_template(const Arguments& argus) CHECK_HIP_ERROR(dA.transfer_from(hA)); CHECK_HIP_ERROR(dB.transfer_from(hB)); #else - if(std::is_same{} && transA == HIPBLAS_OP_N && layout_pack_int8()) + if(std::is_same{} && transA == HIPBLAS_OP_N && layout_pack_int8(handle)) { host_batch_vector hA_packed(size_A, 1, batch_count); hA_packed.copy_from(hA); @@ -130,7 +130,7 @@ hipblasStatus_t testing_gemm_batched_ex_template(const Arguments& argus) CHECK_HIP_ERROR(dA.transfer_from(hA)); } - if(std::is_same{} && transB != HIPBLAS_OP_N && layout_pack_int8()) + if(std::is_same{} && transB != HIPBLAS_OP_N && layout_pack_int8(handle)) { host_batch_vector hB_packed(size_B, 1, batch_count); hB_packed.copy_from(hB); diff --git a/clients/include/testing_gemm_ex.hpp b/clients/include/testing_gemm_ex.hpp index d9665814e..10dde990a 100644 --- a/clients/include/testing_gemm_ex.hpp +++ b/clients/include/testing_gemm_ex.hpp @@ -98,122 +98,138 @@ hipblasStatus_t testing_gemm_ex_template(const Arguments& argus) double gpu_time_used, hipblas_error_host, hipblas_error_device; hipblasLocalHandle handle(argus); - // Initial Data on CPU - hipblas_init_matrix(hA, argus, A_row, A_col, lda, 0, 1, hipblas_client_alpha_sets_nan, true); - hipblas_init_matrix( - hB, argus, B_row, B_col, ldb, 0, 1, hipblas_client_alpha_sets_nan, false, true); - hipblas_init_matrix(hC_host, argus, M, N, ldc, 0, 1, hipblas_client_beta_sets_nan); + for(auto int8Type : {HIPBLAS_INT8_DATATYPE_DEFAULT, + HIPBLAS_INT8_DATATYPE_INT8, + HIPBLAS_INT8_DATATYPE_PACK_INT8x4}) + { + // only need to test multiple int8Type for int8_t, for other datatypes break + if(!(std::is_same{}) && HIPBLAS_INT8_DATATYPE_DEFAULT != int8Type) + break; + + hipblasSetInt8Datatype(handle, int8Type); + + // Initial Data on CPU + hipblas_init_matrix( + hA, argus, A_row, A_col, lda, 0, 1, hipblas_client_alpha_sets_nan, true); + hipblas_init_matrix( + hB, argus, B_row, B_col, ldb, 0, 1, hipblas_client_alpha_sets_nan, false, true); + hipblas_init_matrix(hC_host, argus, M, N, ldc, 0, 1, hipblas_client_beta_sets_nan); - hC_gold = hC_device = hC_host; + hC_gold = hC_device = hC_host; - // copy data from CPU to device + // copy data from CPU to device - // CUDA doesn't do packing + // CUDA doesn't do packing #ifdef __HIP_PLATFORM_NVCC__ - CHECK_HIP_ERROR(hipMemcpy(dA, hA, sizeof(Ta) * size_A, hipMemcpyHostToDevice)); - CHECK_HIP_ERROR(hipMemcpy(dB, hB, sizeof(Tb) * size_B, hipMemcpyHostToDevice)); -#else - if(std::is_same{} && transA == HIPBLAS_OP_N && layout_pack_int8()) - { - host_vector hA_packed(hA); - hipblas_packInt8(hA_packed, M, K, lda); - CHECK_HIP_ERROR(hipMemcpy(dA, hA_packed, sizeof(Ta) * size_A, hipMemcpyHostToDevice)); - } - else - { + if(HIPBLAS_INT8_DATATYPE_DEFAULT != int8Type) + break; CHECK_HIP_ERROR(hipMemcpy(dA, hA, sizeof(Ta) * size_A, hipMemcpyHostToDevice)); - } - - if(std::is_same{} && transB != HIPBLAS_OP_N && layout_pack_int8()) - { - host_vector hB_packed(hB); - hipblas_packInt8(hB_packed, N, K, ldb); - CHECK_HIP_ERROR(hipMemcpy(dB, hB_packed, sizeof(Tb) * size_B, hipMemcpyHostToDevice)); - } - else - { CHECK_HIP_ERROR(hipMemcpy(dB, hB, sizeof(Tb) * size_B, hipMemcpyHostToDevice)); - } -#endif - CHECK_HIP_ERROR(hipMemcpy(dC, hC_host, sizeof(Tc) * size_C, hipMemcpyHostToDevice)); - CHECK_HIP_ERROR(hipMemcpy(d_alpha, &h_alpha_Tc, sizeof(Tex), hipMemcpyHostToDevice)); - CHECK_HIP_ERROR(hipMemcpy(d_beta, &h_beta_Tc, sizeof(Tex), hipMemcpyHostToDevice)); +#else + if(std::is_same{} && transA == HIPBLAS_OP_N && layout_pack_int8(handle)) + { + host_vector hA_packed(hA); + hipblas_packInt8(hA_packed, M, K, lda); + CHECK_HIP_ERROR(hipMemcpy(dA, hA_packed, sizeof(Ta) * size_A, hipMemcpyHostToDevice)); + } + else + { + CHECK_HIP_ERROR(hipMemcpy(dA, hA, sizeof(Ta) * size_A, hipMemcpyHostToDevice)); + } - if(unit_check || norm_check) - { - // hipBLAS - CHECK_HIPBLAS_ERROR(hipblasSetPointerMode(handle, HIPBLAS_POINTER_MODE_HOST)); - CHECK_HIPBLAS_ERROR(hipblasGemmExFn(handle, - transA, - transB, - M, - N, - K, - &h_alpha_Tc, - dA, - a_type, - lda, - dB, - b_type, - ldb, - &h_beta_Tc, - dC, - c_type, - ldc, - compute_type, - algo)); - - CHECK_HIP_ERROR(hipMemcpy(hC_host, dC, sizeof(Tc) * size_C, hipMemcpyDeviceToHost)); - CHECK_HIP_ERROR(hipMemcpy(dC, hC_device, sizeof(Tc) * size_C, hipMemcpyHostToDevice)); - - CHECK_HIPBLAS_ERROR(hipblasSetPointerMode(handle, HIPBLAS_POINTER_MODE_DEVICE)); - CHECK_HIPBLAS_ERROR(hipblasGemmExFn(handle, - transA, - transB, - M, - N, - K, - d_alpha, - dA, - a_type, - lda, - dB, - b_type, - ldb, - d_beta, - dC, - c_type, - ldc, - compute_type, - algo)); - - CHECK_HIP_ERROR(hipMemcpy(hC_device, dC, sizeof(Tc) * size_C, hipMemcpyDeviceToHost)); - - // reference BLAS - cblas_gemm(transA, - transB, - M, - N, - K, - h_alpha_Tc, - hA.data(), - lda, - hB.data(), - ldb, - h_beta_Tc, - hC_gold.data(), - ldc); - - if(unit_check) + if(std::is_same{} && transB != HIPBLAS_OP_N && layout_pack_int8(handle)) { - unit_check_general(M, N, ldc, hC_gold, hC_host); - unit_check_general(M, N, ldc, hC_gold, hC_device); + host_vector hB_packed(hB); + hipblas_packInt8(hB_packed, N, K, ldb); + CHECK_HIP_ERROR(hipMemcpy(dB, hB_packed, sizeof(Tb) * size_B, hipMemcpyHostToDevice)); } - if(norm_check) + else { - hipblas_error_host = std::abs(norm_check_general('F', M, N, ldc, hC_gold, hC_host)); - hipblas_error_device - = std::abs(norm_check_general('F', M, N, ldc, hC_gold, hC_device)); + CHECK_HIP_ERROR(hipMemcpy(dB, hB, sizeof(Tb) * size_B, hipMemcpyHostToDevice)); + } +#endif + + CHECK_HIP_ERROR(hipMemcpy(dC, hC_host, sizeof(Tc) * size_C, hipMemcpyHostToDevice)); + CHECK_HIP_ERROR(hipMemcpy(d_alpha, &h_alpha_Tc, sizeof(Tex), hipMemcpyHostToDevice)); + CHECK_HIP_ERROR(hipMemcpy(d_beta, &h_beta_Tc, sizeof(Tex), hipMemcpyHostToDevice)); + + if(unit_check || norm_check) + { + // hipBLAS + CHECK_HIPBLAS_ERROR(hipblasSetPointerMode(handle, HIPBLAS_POINTER_MODE_HOST)); + CHECK_HIPBLAS_ERROR(hipblasGemmExFn(handle, + transA, + transB, + M, + N, + K, + &h_alpha_Tc, + dA, + a_type, + lda, + dB, + b_type, + ldb, + &h_beta_Tc, + dC, + c_type, + ldc, + compute_type, + algo)); + + CHECK_HIP_ERROR(hipMemcpy(hC_host, dC, sizeof(Tc) * size_C, hipMemcpyDeviceToHost)); + CHECK_HIP_ERROR(hipMemcpy(dC, hC_device, sizeof(Tc) * size_C, hipMemcpyHostToDevice)); + + CHECK_HIPBLAS_ERROR(hipblasSetPointerMode(handle, HIPBLAS_POINTER_MODE_DEVICE)); + CHECK_HIPBLAS_ERROR(hipblasGemmExFn(handle, + transA, + transB, + M, + N, + K, + d_alpha, + dA, + a_type, + lda, + dB, + b_type, + ldb, + d_beta, + dC, + c_type, + ldc, + compute_type, + algo)); + + CHECK_HIP_ERROR(hipMemcpy(hC_device, dC, sizeof(Tc) * size_C, hipMemcpyDeviceToHost)); + + // reference BLAS + cblas_gemm(transA, + transB, + M, + N, + K, + h_alpha_Tc, + hA.data(), + lda, + hB.data(), + ldb, + h_beta_Tc, + hC_gold.data(), + ldc); + + if(unit_check) + { + unit_check_general(M, N, ldc, hC_gold, hC_host); + unit_check_general(M, N, ldc, hC_gold, hC_device); + } + if(norm_check) + { + hipblas_error_host + = std::abs(norm_check_general('F', M, N, ldc, hC_gold, hC_host)); + hipblas_error_device + = std::abs(norm_check_general('F', M, N, ldc, hC_gold, hC_device)); + } } } diff --git a/clients/include/testing_gemm_strided_batched_ex.hpp b/clients/include/testing_gemm_strided_batched_ex.hpp index 2d3d868bb..50b0671db 100644 --- a/clients/include/testing_gemm_strided_batched_ex.hpp +++ b/clients/include/testing_gemm_strided_batched_ex.hpp @@ -125,7 +125,7 @@ hipblasStatus_t testing_gemm_strided_batched_ex_template(const Arguments& argus) CHECK_HIP_ERROR(hipMemcpy(dA, hA, sizeof(Ta) * size_A, hipMemcpyHostToDevice)); CHECK_HIP_ERROR(hipMemcpy(dB, hB, sizeof(Tb) * size_B, hipMemcpyHostToDevice)); #else - if(std::is_same{} && transA == HIPBLAS_OP_N && layout_pack_int8()) + if(std::is_same{} && transA == HIPBLAS_OP_N && layout_pack_int8(handle)) { host_vector hA_packed(hA); hipblas_packInt8(hA_packed, M, K, lda, batch_count, stride_A); @@ -136,7 +136,7 @@ hipblasStatus_t testing_gemm_strided_batched_ex_template(const Arguments& argus) CHECK_HIP_ERROR(hipMemcpy(dA, hA, sizeof(Ta) * size_A, hipMemcpyHostToDevice)); } - if(std::is_same{} && transB != HIPBLAS_OP_N && layout_pack_int8()) + if(std::is_same{} && transB != HIPBLAS_OP_N && layout_pack_int8(handle)) { host_vector hB_packed(hB); hipblas_packInt8(hB_packed, N, K, ldb, batch_count, stride_B); diff --git a/clients/include/utility.h b/clients/include/utility.h index 82fd5d7b8..63f842fbe 100644 --- a/clients/include/utility.h +++ b/clients/include/utility.h @@ -923,7 +923,7 @@ int getArch(); /* query what rocBLAS recommends for int8 layout. We are /always/ passing in the flag which * rocBLAS recommends, thus we need to know what layout to format our data in our tests. * returns true if should be packed. */ -bool layout_pack_int8(); +bool layout_pack_int8(hipblasHandle_t handle); /* ============================================================================================ */ /* timing: HIP only provides very limited timers function clock() and not general; @@ -959,10 +959,10 @@ class hipblasLocalHandle ~hipblasLocalHandle(); - hipblasLocalHandle(const hipblasLocalHandle&) = delete; - hipblasLocalHandle(hipblasLocalHandle&&) = delete; + hipblasLocalHandle(const hipblasLocalHandle&) = delete; + hipblasLocalHandle(hipblasLocalHandle&&) = delete; hipblasLocalHandle& operator=(const hipblasLocalHandle&) = delete; - hipblasLocalHandle& operator=(hipblasLocalHandle&&) = delete; + hipblasLocalHandle& operator=(hipblasLocalHandle&&) = delete; // Allow hipblasLocalHandle to be used anywhere hipblas_handle is expected operator hipblasHandle_t&() diff --git a/docs/source/deprecation.rst b/docs/source/deprecation.rst new file mode 100644 index 000000000..1b98c3ad8 --- /dev/null +++ b/docs/source/deprecation.rst @@ -0,0 +1,28 @@ +####################### +Deprecations by version +####################### + +Announced in 0.49 +***************** + +Replace inplace hipblasXtrmm with out of place hipblasXtrmm +=========================================================== + +The hipblasXtrmm API, along with batched versions, will be changing in hipBLAS 1.0 +release to allow in-place and out-of-place behavior. This change will introduce an +output matrix 'C', matching the rocblas_xtrmm_outofplace API and the cublasXtrmm API. + +Announced in 0.53 +***************** + +Remove packed_int8x4 datatype +============================= + +The packed_int8x4 datatype will be removed in hipBLAS 1.0. There are two int8 datatypes: + +* int8_t +* packed_int8x4 + +int8_t is the C99 unsigned 8 bit integer. packed_int8x4 has 4 consecutive int8_t numbers +in the k dimension packed into 32 bits. packed_int8x4 is only used in hipblasGemmEx. +int8_t will continue to be available in hipblasGemmEx. diff --git a/docs/source/usermanual.rst b/docs/source/usermanual.rst index 16e50e2a3..a9d0edf4d 100644 --- a/docs/source/usermanual.rst +++ b/docs/source/usermanual.rst @@ -11,6 +11,7 @@ User Guide disclaimer intro install + deprecation orga api functions diff --git a/library/include/hipblas.h b/library/include/hipblas.h index 2fc338064..e3ed564ec 100644 --- a/library/include/hipblas.h +++ b/library/include/hipblas.h @@ -361,6 +361,13 @@ typedef enum HIPBLAS_ATOMICS_ALLOWED = 1 /**< Algorithms will take advantage of atomics where applicable. */ } hipblasAtomicsMode_t; +typedef enum +{ + HIPBLAS_INT8_DATATYPE_DEFAULT = 0x0, + HIPBLAS_INT8_DATATYPE_INT8 = 0x1, + HIPBLAS_INT8_DATATYPE_PACK_INT8x4 = 0x2 +} hipblasInt8Datatype_t; + #ifdef __cplusplus extern "C" { #endif @@ -383,7 +390,25 @@ HIPBLAS_EXPORT hipblasStatus_t hipblasSetPointerMode(hipblasHandle_t handle /*! \brief Get hipblas pointer mode */ HIPBLAS_EXPORT hipblasStatus_t hipblasGetPointerMode(hipblasHandle_t handle, hipblasPointerMode_t* mode); +// clang-format off +HIPBLAS_DEPRECATED_MSG("The hipblasSetInt8Datatype function will be removed in a future \ +release and only int8_t datatype will be supported. packed_int8x4 datatype support \ +will be removed.") +// clang-format on + +/*! \brief Set hipblas int8 Datatype */ +HIPBLAS_EXPORT hipblasStatus_t hipblasSetInt8Datatype(hipblasHandle_t handle, + hipblasInt8Datatype_t int8Type); + +// clang-format off +HIPBLAS_DEPRECATED_MSG("The hipblasGetInt8Datatype function will be removed in a future \ +release and only int8_t datatype will be supported. packed_int8x4 datatype support \ +will be removed.") +// clang-format on +/*! \brief Get hipblas int8 Datatype*/ +HIPBLAS_EXPORT hipblasStatus_t hipblasGetInt8Datatype(hipblasHandle_t handle, + hipblasInt8Datatype_t* int8Type); /*! \brief copy vector from host to device @param[in] n [int] diff --git a/library/src/amd_detail/hipblas.cpp b/library/src/amd_detail/hipblas.cpp index 43c1d488d..3906dffb4 100644 --- a/library/src/amd_detail/hipblas.cpp +++ b/library/src/amd_detail/hipblas.cpp @@ -315,6 +315,34 @@ hipblasAtomicsMode_t RocblasAtomicsModeToHIPAtomicsMode(rocblas_atomics_mode mod throw HIPBLAS_STATUS_INVALID_ENUM; } +rocblas_int8_type_for_hipblas HIPInt8DatatypeToRocblasInt8Datatype(hipblasInt8Datatype_t flags) +{ + switch(flags) + { + case HIPBLAS_INT8_DATATYPE_DEFAULT: + return rocblas_int8_type_for_hipblas_default; + case HIPBLAS_INT8_DATATYPE_PACK_INT8x4: + return rocblas_int8_type_for_hipblas_pack_int8x4; + case HIPBLAS_INT8_DATATYPE_INT8: + return rocblas_int8_type_for_hipblas_int8; + } + throw HIPBLAS_STATUS_INVALID_ENUM; +} + +hipblasInt8Datatype_t RocblasInt8DatatypeToHIPInt8Datatype(rocblas_int8_type_for_hipblas flags) +{ + switch(flags) + { + case rocblas_int8_type_for_hipblas_default: + return HIPBLAS_INT8_DATATYPE_DEFAULT; + case rocblas_int8_type_for_hipblas_pack_int8x4: + return HIPBLAS_INT8_DATATYPE_PACK_INT8x4; + case rocblas_int8_type_for_hipblas_int8: + return HIPBLAS_INT8_DATATYPE_INT8; + } + throw HIPBLAS_STATUS_INVALID_ENUM; +} + hipblasStatus_t rocBLASStatusToHIPStatus(rocblas_status_ error) { switch(error) @@ -416,6 +444,31 @@ catch(...) return exception_to_hipblas_status(); } +hipblasStatus_t hipblasSetInt8Datatype(hipblasHandle_t handle, hipblasInt8Datatype_t int8Type) +try +{ + return rocBLASStatusToHIPStatus(rocblas_set_int8_type_for_hipblas( + (rocblas_handle)handle, HIPInt8DatatypeToRocblasInt8Datatype(int8Type))); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +hipblasStatus_t hipblasGetInt8Datatype(hipblasHandle_t handle, hipblasInt8Datatype_t* int8Type) +try +{ + rocblas_int8_type_for_hipblas rocblas_type; + rocblas_status status + = rocblas_get_int8_type_for_hipblas((rocblas_handle)handle, &rocblas_type); + *int8Type = RocblasInt8DatatypeToHIPInt8Datatype(rocblas_type); + return rocBLASStatusToHIPStatus(status); +} +catch(...) +{ + return exception_to_hipblas_status(); +} + hipblasStatus_t hipblasSetVector(int n, int elemSize, const void* x, int incx, void* y, int incy) try { diff --git a/library/src/hipblas_module.f90 b/library/src/hipblas_module.f90 index 72aaa3861..51235a29f 100644 --- a/library/src/hipblas_module.f90 +++ b/library/src/hipblas_module.f90 @@ -98,6 +98,14 @@ module hipblas_enums enumerator :: HIPBLAS_ATOMICS_ALLOWED = 1 end enum + enum, bind(c) + enumerator :: HIPBLAS_INT8_DATATYPE_DEFAULT = 0 + enumerator :: HIPBLAS_INT8_DATATYPE_INT8 = 1 + enumerator :: HIPBLAS_INT8_DATATYPE_PACK_INT8x4 = 2 + end enum + + + end module hipblas_enums module hipblas diff --git a/library/src/nvidia_detail/hipblas.cpp b/library/src/nvidia_detail/hipblas.cpp index dc493b0fe..7c82509cc 100644 --- a/library/src/nvidia_detail/hipblas.cpp +++ b/library/src/nvidia_detail/hipblas.cpp @@ -347,6 +347,26 @@ catch(...) return exception_to_hipblas_status(); } +hipblasStatus_t hipblasSetInt8Datatype(hipblasHandle_t handle, hipblasInt8Datatype_t int8Datatype) +try +{ + return HIPBLAS_STATUS_NOT_SUPPORTED; +} +catch(...) +{ + return exception_to_hipblas_status(); +} + +hipblasStatus_t hipblasGetInt8Datatype(hipblasHandle_t handle, hipblasInt8Datatype_t* int8Datatype) +try +{ + return HIPBLAS_STATUS_NOT_SUPPORTED; +} +catch(...) +{ + return exception_to_hipblas_status(); +} + // note: no handle hipblasStatus_t hipblasSetVector(int n, int elemSize, const void* x, int incx, void* y, int incy) try From 927b4da3253e954015b4150788c50aba0b152a1c Mon Sep 17 00:00:00 2001 From: amcamd Date: Wed, 27 Jul 2022 14:05:58 -0500 Subject: [PATCH 11/12] improve deprecation documentation --- docs/source/deprecation.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/source/deprecation.rst b/docs/source/deprecation.rst index 1b98c3ad8..1548bbb2a 100644 --- a/docs/source/deprecation.rst +++ b/docs/source/deprecation.rst @@ -2,8 +2,8 @@ Deprecations by version ####################### -Announced in 0.49 -***************** +Announced in hipBLAS 0.49 +************************* Replace inplace hipblasXtrmm with out of place hipblasXtrmm =========================================================== @@ -12,8 +12,8 @@ The hipblasXtrmm API, along with batched versions, will be changing in hipBLAS 1 release to allow in-place and out-of-place behavior. This change will introduce an output matrix 'C', matching the rocblas_xtrmm_outofplace API and the cublasXtrmm API. -Announced in 0.53 -***************** +Announced in hipBLAS 0.53 +************************* Remove packed_int8x4 datatype ============================= From 6a8f30e40934a4907b2e6f39b6a301b8be4abbfa Mon Sep 17 00:00:00 2001 From: amcamd Date: Fri, 29 Jul 2022 09:14:05 -0500 Subject: [PATCH 12/12] correct for clang-format --- clients/include/utility.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/clients/include/utility.h b/clients/include/utility.h index 63f842fbe..8823bfce3 100644 --- a/clients/include/utility.h +++ b/clients/include/utility.h @@ -959,10 +959,10 @@ class hipblasLocalHandle ~hipblasLocalHandle(); - hipblasLocalHandle(const hipblasLocalHandle&) = delete; - hipblasLocalHandle(hipblasLocalHandle&&) = delete; + hipblasLocalHandle(const hipblasLocalHandle&) = delete; + hipblasLocalHandle(hipblasLocalHandle&&) = delete; hipblasLocalHandle& operator=(const hipblasLocalHandle&) = delete; - hipblasLocalHandle& operator=(hipblasLocalHandle&&) = delete; + hipblasLocalHandle& operator=(hipblasLocalHandle&&) = delete; // Allow hipblasLocalHandle to be used anywhere hipblas_handle is expected operator hipblasHandle_t&()